new license file version [CI SKIP]
This commit is contained in:
@@ -0,0 +1 @@
|
||||
module.exports={A:{D:{"1":"XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB FC","2":"0 1 2 3 4 5 6 7 8 9 I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB"},L:{"1":"D"},B:{"1":"P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t","2":"C K L H M N O"},C:{"1":"0 1 2 3 4 5 6 7 8 9 J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB","2":"CC tB I u DC EC"},M:{"1":"D"},A:{"2":"J E F G A B BC"},F:{"1":"KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d","2":"0 1 2 3 4 5 6 7 8 9 G B C H M N O v w x y z AB BB CB DB EB FB GB HB IB JB OC PC QC RC qB 9B SC rB"},K:{"1":"e","2":"A B C qB 9B rB"},E:{"2":"I u J E GC zB HC IC JC NC","33":"F G A B C K L H KC 0B qB rB 1B LC MC 2B 3B 4B 5B sB 6B 7B 8B"},G:{"2":"zB TC AC UC VC WC","33":"F XC YC ZC aC bC cC dC eC fC gC hC iC jC kC lC mC 2B 3B 4B 5B sB 6B 7B 8B"},P:{"1":"xC yC zC 0B 0C 1C 2C 3C 4C sB 5C 6C 7C","2":"I vC wC"},I:{"1":"D","2":"tB I oC pC qC rC AC sC tC"}},B:6,C:"text-decoration shorthand property"};
|
||||
@@ -0,0 +1 @@
|
||||
import 'rxjs-compat/add/operator/count';
|
||||
@@ -0,0 +1,21 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2014 Mathias Buus
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
@@ -0,0 +1 @@
|
||||
console.log('API usage not implemented yet...');
|
||||
@@ -0,0 +1,7 @@
|
||||
"use strict";
|
||||
function __export(m) {
|
||||
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
||||
}
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
__export(require("rxjs-compat/operator/zip"));
|
||||
//# sourceMappingURL=zip.js.map
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"webSocket.js","sources":["../../src/observable/dom/webSocket.ts"],"names":[],"mappings":";;;;;AAAA,0DAAqD"}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"defaultIfEmpty.js","sources":["../src/operators/defaultIfEmpty.ts"],"names":[],"mappings":";;;;;AAAA,0DAAqD"}
|
||||
@@ -0,0 +1,12 @@
|
||||
# These are supported funding model platforms
|
||||
|
||||
github: [ljharb]
|
||||
patreon: # Replace with a single Patreon username
|
||||
open_collective: # Replace with a single Open Collective username
|
||||
ko_fi: # Replace with a single Ko-fi username
|
||||
tidelift: npm/qs
|
||||
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
|
||||
liberapay: # Replace with a single Liberapay username
|
||||
issuehunt: # Replace with a single IssueHunt username
|
||||
otechie: # Replace with a single Otechie username
|
||||
custom: # Replace with a single custom sponsorship URL
|
||||
@@ -0,0 +1,41 @@
|
||||
{
|
||||
"name": "is-unicode-supported",
|
||||
"version": "0.1.0",
|
||||
"description": "Detect whether the terminal supports Unicode",
|
||||
"license": "MIT",
|
||||
"repository": "sindresorhus/is-unicode-supported",
|
||||
"funding": "https://github.com/sponsors/sindresorhus",
|
||||
"author": {
|
||||
"name": "Sindre Sorhus",
|
||||
"email": "sindresorhus@gmail.com",
|
||||
"url": "https://sindresorhus.com"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=10"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "xo && ava && tsd"
|
||||
},
|
||||
"files": [
|
||||
"index.js",
|
||||
"index.d.ts"
|
||||
],
|
||||
"keywords": [
|
||||
"terminal",
|
||||
"unicode",
|
||||
"detect",
|
||||
"utf8",
|
||||
"console",
|
||||
"shell",
|
||||
"support",
|
||||
"supports",
|
||||
"supported",
|
||||
"check",
|
||||
"detection"
|
||||
],
|
||||
"devDependencies": {
|
||||
"ava": "^2.4.0",
|
||||
"tsd": "^0.14.0",
|
||||
"xo": "^0.38.2"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
"use strict";
|
||||
function __export(m) {
|
||||
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
||||
}
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
__export(require("rxjs-compat/operator/toPromise"));
|
||||
//# sourceMappingURL=toPromise.js.map
|
||||
@@ -0,0 +1,31 @@
|
||||
import { innerSubscribe, SimpleInnerSubscriber, SimpleOuterSubscriber } from '../innerSubscribe';
|
||||
export function takeUntil(notifier) {
|
||||
return (source) => source.lift(new TakeUntilOperator(notifier));
|
||||
}
|
||||
class TakeUntilOperator {
|
||||
constructor(notifier) {
|
||||
this.notifier = notifier;
|
||||
}
|
||||
call(subscriber, source) {
|
||||
const takeUntilSubscriber = new TakeUntilSubscriber(subscriber);
|
||||
const notifierSubscription = innerSubscribe(this.notifier, new SimpleInnerSubscriber(takeUntilSubscriber));
|
||||
if (notifierSubscription && !takeUntilSubscriber.seenValue) {
|
||||
takeUntilSubscriber.add(notifierSubscription);
|
||||
return source.subscribe(takeUntilSubscriber);
|
||||
}
|
||||
return takeUntilSubscriber;
|
||||
}
|
||||
}
|
||||
class TakeUntilSubscriber extends SimpleOuterSubscriber {
|
||||
constructor(destination) {
|
||||
super(destination);
|
||||
this.seenValue = false;
|
||||
}
|
||||
notifyNext() {
|
||||
this.seenValue = true;
|
||||
this.complete();
|
||||
}
|
||||
notifyComplete() {
|
||||
}
|
||||
}
|
||||
//# sourceMappingURL=takeUntil.js.map
|
||||
@@ -0,0 +1,31 @@
|
||||
declare const resolveFrom: {
|
||||
/**
|
||||
Resolve the path of a module like [`require.resolve()`](https://nodejs.org/api/globals.html#globals_require_resolve) but from a given path.
|
||||
|
||||
@param fromDirectory - Directory to resolve from.
|
||||
@param moduleId - What you would use in `require()`.
|
||||
@returns Resolved module path. Throws when the module can't be found.
|
||||
|
||||
@example
|
||||
```
|
||||
import resolveFrom = require('resolve-from');
|
||||
|
||||
// There is a file at `./foo/bar.js`
|
||||
|
||||
resolveFrom('foo', './bar');
|
||||
//=> '/Users/sindresorhus/dev/test/foo/bar.js'
|
||||
```
|
||||
*/
|
||||
(fromDirectory: string, moduleId: string): string;
|
||||
|
||||
/**
|
||||
Resolve the path of a module like [`require.resolve()`](https://nodejs.org/api/globals.html#globals_require_resolve) but from a given path.
|
||||
|
||||
@param fromDirectory - Directory to resolve from.
|
||||
@param moduleId - What you would use in `require()`.
|
||||
@returns Resolved module path or `undefined` when the module can't be found.
|
||||
*/
|
||||
silent(fromDirectory: string, moduleId: string): string | undefined;
|
||||
};
|
||||
|
||||
export = resolveFrom;
|
||||
@@ -0,0 +1,127 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var Observable_1 = require("../Observable");
|
||||
var identity_1 = require("../util/identity");
|
||||
var isScheduler_1 = require("../util/isScheduler");
|
||||
function generate(initialStateOrOptions, condition, iterate, resultSelectorOrObservable, scheduler) {
|
||||
var resultSelector;
|
||||
var initialState;
|
||||
if (arguments.length == 1) {
|
||||
var options = initialStateOrOptions;
|
||||
initialState = options.initialState;
|
||||
condition = options.condition;
|
||||
iterate = options.iterate;
|
||||
resultSelector = options.resultSelector || identity_1.identity;
|
||||
scheduler = options.scheduler;
|
||||
}
|
||||
else if (resultSelectorOrObservable === undefined || isScheduler_1.isScheduler(resultSelectorOrObservable)) {
|
||||
initialState = initialStateOrOptions;
|
||||
resultSelector = identity_1.identity;
|
||||
scheduler = resultSelectorOrObservable;
|
||||
}
|
||||
else {
|
||||
initialState = initialStateOrOptions;
|
||||
resultSelector = resultSelectorOrObservable;
|
||||
}
|
||||
return new Observable_1.Observable(function (subscriber) {
|
||||
var state = initialState;
|
||||
if (scheduler) {
|
||||
return scheduler.schedule(dispatch, 0, {
|
||||
subscriber: subscriber,
|
||||
iterate: iterate,
|
||||
condition: condition,
|
||||
resultSelector: resultSelector,
|
||||
state: state
|
||||
});
|
||||
}
|
||||
do {
|
||||
if (condition) {
|
||||
var conditionResult = void 0;
|
||||
try {
|
||||
conditionResult = condition(state);
|
||||
}
|
||||
catch (err) {
|
||||
subscriber.error(err);
|
||||
return undefined;
|
||||
}
|
||||
if (!conditionResult) {
|
||||
subscriber.complete();
|
||||
break;
|
||||
}
|
||||
}
|
||||
var value = void 0;
|
||||
try {
|
||||
value = resultSelector(state);
|
||||
}
|
||||
catch (err) {
|
||||
subscriber.error(err);
|
||||
return undefined;
|
||||
}
|
||||
subscriber.next(value);
|
||||
if (subscriber.closed) {
|
||||
break;
|
||||
}
|
||||
try {
|
||||
state = iterate(state);
|
||||
}
|
||||
catch (err) {
|
||||
subscriber.error(err);
|
||||
return undefined;
|
||||
}
|
||||
} while (true);
|
||||
return undefined;
|
||||
});
|
||||
}
|
||||
exports.generate = generate;
|
||||
function dispatch(state) {
|
||||
var subscriber = state.subscriber, condition = state.condition;
|
||||
if (subscriber.closed) {
|
||||
return undefined;
|
||||
}
|
||||
if (state.needIterate) {
|
||||
try {
|
||||
state.state = state.iterate(state.state);
|
||||
}
|
||||
catch (err) {
|
||||
subscriber.error(err);
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
else {
|
||||
state.needIterate = true;
|
||||
}
|
||||
if (condition) {
|
||||
var conditionResult = void 0;
|
||||
try {
|
||||
conditionResult = condition(state.state);
|
||||
}
|
||||
catch (err) {
|
||||
subscriber.error(err);
|
||||
return undefined;
|
||||
}
|
||||
if (!conditionResult) {
|
||||
subscriber.complete();
|
||||
return undefined;
|
||||
}
|
||||
if (subscriber.closed) {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
var value;
|
||||
try {
|
||||
value = state.resultSelector(state.state);
|
||||
}
|
||||
catch (err) {
|
||||
subscriber.error(err);
|
||||
return undefined;
|
||||
}
|
||||
if (subscriber.closed) {
|
||||
return undefined;
|
||||
}
|
||||
subscriber.next(value);
|
||||
if (subscriber.closed) {
|
||||
return undefined;
|
||||
}
|
||||
return this.schedule(state);
|
||||
}
|
||||
//# sourceMappingURL=generate.js.map
|
||||
@@ -0,0 +1,80 @@
|
||||
import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
|
||||
/**
|
||||
*
|
||||
* Errors if Observable does not emit a value in given time span.
|
||||
*
|
||||
* <span class="informal">Timeouts on Observable that doesn't emit values fast enough.</span>
|
||||
*
|
||||
* 
|
||||
*
|
||||
* `timeout` operator accepts as an argument either a number or a Date.
|
||||
*
|
||||
* If number was provided, it returns an Observable that behaves like a source
|
||||
* Observable, unless there is a period of time where there is no value emitted.
|
||||
* So if you provide `100` as argument and first value comes after 50ms from
|
||||
* the moment of subscription, this value will be simply re-emitted by the resulting
|
||||
* Observable. If however after that 100ms passes without a second value being emitted,
|
||||
* stream will end with an error and source Observable will be unsubscribed.
|
||||
* These checks are performed throughout whole lifecycle of Observable - from the moment
|
||||
* it was subscribed to, until it completes or errors itself. Thus every value must be
|
||||
* emitted within specified period since previous value.
|
||||
*
|
||||
* If provided argument was Date, returned Observable behaves differently. It throws
|
||||
* if Observable did not complete before provided Date. This means that periods between
|
||||
* emission of particular values do not matter in this case. If Observable did not complete
|
||||
* before provided Date, source Observable will be unsubscribed. Other than that, resulting
|
||||
* stream behaves just as source Observable.
|
||||
*
|
||||
* `timeout` accepts also a Scheduler as a second parameter. It is used to schedule moment (or moments)
|
||||
* when returned Observable will check if source stream emitted value or completed.
|
||||
*
|
||||
* ## Examples
|
||||
* Check if ticks are emitted within certain timespan
|
||||
* ```ts
|
||||
* import { interval } from 'rxjs';
|
||||
* import { timeout } from 'rxjs/operators';
|
||||
*
|
||||
* const seconds = interval(1000);
|
||||
*
|
||||
* seconds.pipe(timeout(1100)) // Let's use bigger timespan to be safe,
|
||||
* // since `interval` might fire a bit later then scheduled.
|
||||
* .subscribe(
|
||||
* value => console.log(value), // Will emit numbers just as regular `interval` would.
|
||||
* err => console.log(err), // Will never be called.
|
||||
* );
|
||||
*
|
||||
* seconds.pipe(timeout(900))
|
||||
* .subscribe(
|
||||
* value => console.log(value), // Will never be called.
|
||||
* err => console.log(err), // Will emit error before even first value is emitted,
|
||||
* // since it did not arrive within 900ms period.
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* Use Date to check if Observable completed
|
||||
* ```ts
|
||||
* import { interval } from 'rxjs';
|
||||
* import { timeout } from 'rxjs/operators';
|
||||
*
|
||||
* const seconds = interval(1000);
|
||||
*
|
||||
* seconds.pipe(
|
||||
* timeout(new Date("December 17, 2020 03:24:00")),
|
||||
* )
|
||||
* .subscribe(
|
||||
* value => console.log(value), // Will emit values as regular `interval` would
|
||||
* // until December 17, 2020 at 03:24:00.
|
||||
* err => console.log(err) // On December 17, 2020 at 03:24:00 it will emit an error,
|
||||
* // since Observable did not complete by then.
|
||||
* );
|
||||
* ```
|
||||
* @see {@link timeoutWith}
|
||||
*
|
||||
* @param {number|Date} due Number specifying period within which Observable must emit values
|
||||
* or Date specifying before when Observable should complete
|
||||
* @param {SchedulerLike} [scheduler] Scheduler controlling when timeout checks occur.
|
||||
* @return {Observable<T>} Observable that mirrors behaviour of source, unless timeout checks fail.
|
||||
* @method timeout
|
||||
* @owner Observable
|
||||
*/
|
||||
export declare function timeout<T>(due: number | Date, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
|
||||
@@ -0,0 +1,24 @@
|
||||
var common = require('../common');
|
||||
var assert = common.assert;
|
||||
var retry = require(common.dir.lib + '/retry');
|
||||
|
||||
(function testForeverUsesFirstTimeout() {
|
||||
var operation = retry.operation({
|
||||
retries: 0,
|
||||
minTimeout: 100,
|
||||
maxTimeout: 100,
|
||||
forever: true
|
||||
});
|
||||
|
||||
operation.attempt(function(numAttempt) {
|
||||
console.log('>numAttempt', numAttempt);
|
||||
var err = new Error("foo");
|
||||
if (numAttempt == 10) {
|
||||
operation.stop();
|
||||
}
|
||||
|
||||
if (operation.retry(err)) {
|
||||
return;
|
||||
}
|
||||
});
|
||||
})();
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"errorObject.js","sources":["../../../src/internal/util/errorObject.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,IAAM,WAAW,GAAQ,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC"}
|
||||
@@ -0,0 +1,146 @@
|
||||
import { Operator } from '../Operator';
|
||||
import { Observable } from '../Observable';
|
||||
import { Subscriber } from '../Subscriber';
|
||||
import { Subscription } from '../Subscription';
|
||||
import { ObservableInput, OperatorFunction } from '../types';
|
||||
import { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';
|
||||
|
||||
/**
|
||||
* Applies an accumulator function over the source Observable where the
|
||||
* accumulator function itself returns an Observable, then each intermediate
|
||||
* Observable returned is merged into the output Observable.
|
||||
*
|
||||
* <span class="informal">It's like {@link scan}, but the Observables returned
|
||||
* by the accumulator are merged into the outer Observable.</span>
|
||||
*
|
||||
* ## Example
|
||||
* Count the number of click events
|
||||
* ```ts
|
||||
* import { fromEvent, of } from 'rxjs';
|
||||
* import { mapTo, mergeScan } from 'rxjs/operators';
|
||||
*
|
||||
* const click$ = fromEvent(document, 'click');
|
||||
* const one$ = click$.pipe(mapTo(1));
|
||||
* const seed = 0;
|
||||
* const count$ = one$.pipe(
|
||||
* mergeScan((acc, one) => of(acc + one), seed),
|
||||
* );
|
||||
* count$.subscribe(x => console.log(x));
|
||||
*
|
||||
* // Results:
|
||||
* // 1
|
||||
* // 2
|
||||
* // 3
|
||||
* // 4
|
||||
* // ...and so on for each click
|
||||
* ```
|
||||
*
|
||||
* @param {function(acc: R, value: T): Observable<R>} accumulator
|
||||
* The accumulator function called on each source value.
|
||||
* @param seed The initial accumulation value.
|
||||
* @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of
|
||||
* input Observables being subscribed to concurrently.
|
||||
* @return {Observable<R>} An observable of the accumulated values.
|
||||
* @method mergeScan
|
||||
* @owner Observable
|
||||
*/
|
||||
export function mergeScan<T, R>(accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,
|
||||
seed: R,
|
||||
concurrent: number = Number.POSITIVE_INFINITY): OperatorFunction<T, R> {
|
||||
return (source: Observable<T>) => source.lift(new MergeScanOperator(accumulator, seed, concurrent));
|
||||
}
|
||||
|
||||
export class MergeScanOperator<T, R> implements Operator<T, R> {
|
||||
constructor(private accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,
|
||||
private seed: R,
|
||||
private concurrent: number) {
|
||||
}
|
||||
|
||||
call(subscriber: Subscriber<R>, source: any): any {
|
||||
return source.subscribe(new MergeScanSubscriber(
|
||||
subscriber, this.accumulator, this.seed, this.concurrent
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* We need this JSDoc comment for affecting ESDoc.
|
||||
* @ignore
|
||||
* @extends {Ignored}
|
||||
*/
|
||||
export class MergeScanSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {
|
||||
private hasValue: boolean = false;
|
||||
private hasCompleted: boolean = false;
|
||||
private buffer: Observable<any>[] = [];
|
||||
private active: number = 0;
|
||||
protected index: number = 0;
|
||||
|
||||
constructor(destination: Subscriber<R>,
|
||||
private accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,
|
||||
private acc: R,
|
||||
private concurrent: number) {
|
||||
super(destination);
|
||||
}
|
||||
|
||||
protected _next(value: any): void {
|
||||
if (this.active < this.concurrent) {
|
||||
const index = this.index++;
|
||||
const destination = this.destination;
|
||||
let ish;
|
||||
try {
|
||||
const { accumulator } = this;
|
||||
ish = accumulator(this.acc, value, index);
|
||||
} catch (e) {
|
||||
return destination.error!(e);
|
||||
}
|
||||
this.active++;
|
||||
this._innerSub(ish);
|
||||
} else {
|
||||
this.buffer.push(value);
|
||||
}
|
||||
}
|
||||
|
||||
private _innerSub(ish: any): void {
|
||||
const innerSubscriber = new SimpleInnerSubscriber(this);
|
||||
const destination = this.destination as Subscription;
|
||||
destination.add(innerSubscriber);
|
||||
const innerSubscription = innerSubscribe(ish, innerSubscriber);
|
||||
// The returned subscription will usually be the subscriber that was
|
||||
// passed. However, interop subscribers will be wrapped and for
|
||||
// unsubscriptions to chain correctly, the wrapper needs to be added, too.
|
||||
if (innerSubscription !== innerSubscriber) {
|
||||
destination.add(innerSubscription);
|
||||
}
|
||||
}
|
||||
|
||||
protected _complete(): void {
|
||||
this.hasCompleted = true;
|
||||
if (this.active === 0 && this.buffer.length === 0) {
|
||||
if (this.hasValue === false) {
|
||||
this.destination.next!(this.acc);
|
||||
}
|
||||
this.destination.complete!();
|
||||
}
|
||||
this.unsubscribe();
|
||||
}
|
||||
|
||||
notifyNext(innerValue: R): void {
|
||||
const { destination } = this;
|
||||
this.acc = innerValue;
|
||||
this.hasValue = true;
|
||||
destination.next!(innerValue);
|
||||
}
|
||||
|
||||
notifyComplete(): void {
|
||||
const buffer = this.buffer;
|
||||
this.active--;
|
||||
if (buffer.length > 0) {
|
||||
this._next(buffer.shift());
|
||||
} else if (this.active === 0 && this.hasCompleted) {
|
||||
if (this.hasValue === false) {
|
||||
this.destination.next!(this.acc);
|
||||
}
|
||||
this.destination.complete!();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"QueueScheduler.js","sources":["../../../src/internal/scheduler/QueueScheduler.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;IAAoC,0CAAc;IAAlD;;IACA,CAAC;IAAD,qBAAC;AAAD,CAAC,AADD,CAAoC,cAAc,GACjD"}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"auditTime.js","sources":["../src/operators/auditTime.ts"],"names":[],"mappings":";;;;;AAAA,qDAAgD"}
|
||||
Reference in New Issue
Block a user