taskninja 1.1.4 → 1.1.6

package/src/node_modules/rxjs/src/internal/operators/window.ts

@@ -1,98 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction, ObservableInput } from '../types';
-import { Subject } from '../Subject';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { noop } from '../util/noop';
-import { innerFrom } from '../observable/innerFrom';
-
-/**
- * Branch out the source Observable values as a nested Observable whenever
- * `windowBoundaries` emits.
- *
- * <span class="informal">It's like {@link buffer}, but emits a nested Observable
- * instead of an array.</span>
- *
- * ![](window.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits connected, non-overlapping
- * windows. It emits the current window and opens a new one whenever the
- * `windowBoundaries` emits an item. `windowBoundaries` can be any type that
- * `ObservableInput` accepts. It internally gets converted to an Observable.
- * Because each window is an Observable, the output is a higher-order Observable.
- *
- * ## Example
- *
- * In every window of 1 second each, emit at most 2 click events
- *
- * ```ts
- * import { fromEvent, interval, window, map, take, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const sec = interval(1000);
- * const result = clicks.pipe(
- *   window(sec),
- *   map(win => win.pipe(take(2))), // take at most 2 emissions from each window
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link windowCount}
- * @see {@link windowTime}
- * @see {@link windowToggle}
- * @see {@link windowWhen}
- * @see {@link buffer}
- *
- * @param windowBoundaries An `ObservableInput` that completes the
- * previous window and starts a new window.
- * @return A function that returns an Observable of windows, which are
- * Observables emitting values of the source Observable.
- */
-export function window<T>(windowBoundaries: ObservableInput<any>): OperatorFunction<T, Observable<T>> {
-  return operate((source, subscriber) => {
-    let windowSubject: Subject<T> = new Subject<T>();
-
-    subscriber.next(windowSubject.asObservable());
-
-    const errorHandler = (err: any) => {
-      windowSubject.error(err);
-      subscriber.error(err);
-    };
-
-    // Subscribe to our source
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => windowSubject?.next(value),
-        () => {
-          windowSubject.complete();
-          subscriber.complete();
-        },
-        errorHandler
-      )
-    );
-
-    // Subscribe to the window boundaries.
-    innerFrom(windowBoundaries).subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        () => {
-          windowSubject.complete();
-          subscriber.next((windowSubject = new Subject()));
-        },
-        noop,
-        errorHandler
-      )
-    );
-
-    return () => {
-      // Unsubscribing the subject ensures that anyone who has captured
-      // a reference to this window that tries to use it after it can
-      // no longer get values from the source will get an ObjectUnsubscribedError.
-      windowSubject?.unsubscribe();
-      windowSubject = null!;
-    };
-  });
-}

package/src/node_modules/rxjs/src/internal/operators/windowCount.ts

@@ -1,129 +0,0 @@
-import { Observable } from '../Observable';
-import { Subject } from '../Subject';
-import { OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Branch out the source Observable values as a nested Observable with each
- * nested Observable emitting at most `windowSize` values.
- *
- * <span class="informal">It's like {@link bufferCount}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowCount.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits windows every `startWindowEvery`
- * items, each containing no more than `windowSize` items. When the source
- * Observable completes or encounters an error, the output Observable emits
- * the current window and propagates the notification from the source
- * Observable. If `startWindowEvery` is not provided, then new windows are
- * started immediately at the start of the source and when each window completes
- * with size `windowSize`.
- *
- * ## Examples
- *
- * Ignore every 3rd click event, starting from the first one
- *
- * ```ts
- * import { fromEvent, windowCount, map, skip, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowCount(3),
- *   map(win => win.pipe(skip(1))), // skip first of every 3 clicks
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * Ignore every 3rd click event, starting from the third one
- *
- * ```ts
- * import { fromEvent, windowCount, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowCount(2, 3),
- *   mergeAll() // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowTime}
- * @see {@link windowToggle}
- * @see {@link windowWhen}
- * @see {@link bufferCount}
- *
- * @param windowSize The maximum number of values emitted by each window.
- * @param startWindowEvery Interval at which to start a new window. For example
- * if `startWindowEvery` is `2`, then a new window will be started on every
- * other value from the source. A new window is started at the beginning of the
- * source by default.
- * @return A function that returns an Observable of windows, which in turn are
- * Observable of values.
- */
-export function windowCount<T>(windowSize: number, startWindowEvery: number = 0): OperatorFunction<T, Observable<T>> {
-  const startEvery = startWindowEvery > 0 ? startWindowEvery : windowSize;
-
-  return operate((source, subscriber) => {
-    let windows = [new Subject<T>()];
-    let starts: number[] = [];
-    let count = 0;
-
-    // Open the first window.
-    subscriber.next(windows[0].asObservable());
-
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value: T) => {
-          // Emit the value through all current windows.
-          // We don't need to create a new window yet, we
-          // do that as soon as we close one.
-          for (const window of windows) {
-            window.next(value);
-          }
-          // Here we're using the size of the window array to figure
-          // out if the oldest window has emitted enough values. We can do this
-          // because the size of the window array is a function of the values
-          // seen by the subscription. If it's time to close it, we complete
-          // it and remove it.
-          const c = count - windowSize + 1;
-          if (c >= 0 && c % startEvery === 0) {
-            windows.shift()!.complete();
-          }
-
-          // Look to see if the next count tells us it's time to open a new window.
-          // TODO: We need to figure out if this really makes sense. We're technically
-          // emitting windows *before* we have a value to emit them for. It's probably
-          // more expected that we should be emitting the window when the start
-          // count is reached -- not before.
-          if (++count % startEvery === 0) {
-            const window = new Subject<T>();
-            windows.push(window);
-            subscriber.next(window.asObservable());
-          }
-        },
-        () => {
-          while (windows.length > 0) {
-            windows.shift()!.complete();
-          }
-          subscriber.complete();
-        },
-        (err) => {
-          while (windows.length > 0) {
-            windows.shift()!.error(err);
-          }
-          subscriber.error(err);
-        },
-        () => {
-          starts = null!;
-          windows = null!;
-        }
-      )
-    );
-  });
-}

package/src/node_modules/rxjs/src/internal/operators/windowTime.ts

@@ -1,207 +0,0 @@
-import { Subject } from '../Subject';
-import { asyncScheduler } from '../scheduler/async';
-import { Observable } from '../Observable';
-import { Subscription } from '../Subscription';
-import { Observer, OperatorFunction, SchedulerLike } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { arrRemove } from '../util/arrRemove';
-import { popScheduler } from '../util/args';
-import { executeSchedule } from '../util/executeSchedule';
-
-export function windowTime<T>(windowTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;
-export function windowTime<T>(
-  windowTimeSpan: number,
-  windowCreationInterval: number,
-  scheduler?: SchedulerLike
-): OperatorFunction<T, Observable<T>>;
-export function windowTime<T>(
-  windowTimeSpan: number,
-  windowCreationInterval: number | null | void,
-  maxWindowSize: number,
-  scheduler?: SchedulerLike
-): OperatorFunction<T, Observable<T>>;
-
-/**
- * Branch out the source Observable values as a nested Observable periodically
- * in time.
- *
- * <span class="informal">It's like {@link bufferTime}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowTime.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable starts a new window periodically, as
- * determined by the `windowCreationInterval` argument. It emits each window
- * after a fixed timespan, specified by the `windowTimeSpan` argument. When the
- * source Observable completes or encounters an error, the output Observable
- * emits the current window and propagates the notification from the source
- * Observable. If `windowCreationInterval` is not provided, the output
- * Observable starts a new window when the previous window of duration
- * `windowTimeSpan` completes. If `maxWindowCount` is provided, each window
- * will emit at most fixed number of values. Window will complete immediately
- * after emitting last value and next one still will open as specified by
- * `windowTimeSpan` and `windowCreationInterval` arguments.
- *
- * ## Examples
- *
- * In every window of 1 second each, emit at most 2 click events
- *
- * ```ts
- * import { fromEvent, windowTime, map, take, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowTime(1000),
- *   map(win => win.pipe(take(2))), // take at most 2 emissions from each window
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * Every 5 seconds start a window 1 second long, and emit at most 2 click events per window
- *
- * ```ts
- * import { fromEvent, windowTime, map, take, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowTime(1000, 5000),
- *   map(win => win.pipe(take(2))), // take at most 2 emissions from each window
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * Same as example above but with `maxWindowCount` instead of `take`
- *
- * ```ts
- * import { fromEvent, windowTime, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowTime(1000, 5000, 2), // take at most 2 emissions from each window
- *   mergeAll()                 // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowCount}
- * @see {@link windowToggle}
- * @see {@link windowWhen}
- * @see {@link bufferTime}
- *
- * @param windowTimeSpan The amount of time, in milliseconds, to fill each window.
- * @param windowCreationInterval The interval at which to start new
- * windows.
- * @param maxWindowSize Max number of
- * values each window can emit before completion.
- * @param scheduler The scheduler on which to schedule the
- * intervals that determine window boundaries.
- * @return A function that returns an Observable of windows, which in turn are
- * Observables.
- */
-export function windowTime<T>(windowTimeSpan: number, ...otherArgs: any[]): OperatorFunction<T, Observable<T>> {
-  const scheduler = popScheduler(otherArgs) ?? asyncScheduler;
-  const windowCreationInterval = (otherArgs[0] as number) ?? null;
-  const maxWindowSize = (otherArgs[1] as number) || Infinity;
-
-  return operate((source, subscriber) => {
-    // The active windows, their related subscriptions, and removal functions.
-    let windowRecords: WindowRecord<T>[] | null = [];
-    // If true, it means that every time we close a window, we want to start a new window.
-    // This is only really used for when *just* the time span is passed.
-    let restartOnClose = false;
-
-    const closeWindow = (record: { window: Subject<T>; subs: Subscription }) => {
-      const { window, subs } = record;
-      window.complete();
-      subs.unsubscribe();
-      arrRemove(windowRecords, record);
-      restartOnClose && startWindow();
-    };
-
-    /**
-     * Called every time we start a new window. This also does
-     * the work of scheduling the job to close the window.
-     */
-    const startWindow = () => {
-      if (windowRecords) {
-        const subs = new Subscription();
-        subscriber.add(subs);
-        const window = new Subject<T>();
-        const record = {
-          window,
-          subs,
-          seen: 0,
-        };
-        windowRecords.push(record);
-        subscriber.next(window.asObservable());
-        executeSchedule(subs, scheduler, () => closeWindow(record), windowTimeSpan);
-      }
-    };
-
-    if (windowCreationInterval !== null && windowCreationInterval >= 0) {
-      // The user passed both a windowTimeSpan (required), and a creation interval
-      // That means we need to start new window on the interval, and those windows need
-      // to wait the required time span before completing.
-      executeSchedule(subscriber, scheduler, startWindow, windowCreationInterval, true);
-    } else {
-      restartOnClose = true;
-    }
-
-    startWindow();
-
-    /**
-     * We need to loop over a copy of the window records several times in this operator.
-     * This is to save bytes over the wire more than anything.
-     * The reason we copy the array is that reentrant code could mutate the array while
-     * we are iterating over it.
-     */
-    const loop = (cb: (record: WindowRecord<T>) => void) => windowRecords!.slice().forEach(cb);
-
-    /**
-     * Used to notify all of the windows and the subscriber in the same way
-     * in the error and complete handlers.
-     */
-    const terminate = (cb: (consumer: Observer<any>) => void) => {
-      loop(({ window }) => cb(window));
-      cb(subscriber);
-      subscriber.unsubscribe();
-    };
-
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value: T) => {
-          // Notify all windows of the value.
-          loop((record) => {
-            record.window.next(value);
-            // If the window is over the max size, we need to close it.
-            maxWindowSize <= ++record.seen && closeWindow(record);
-          });
-        },
-        // Complete the windows and the downstream subscriber and clean up.
-        () => terminate((consumer) => consumer.complete()),
-        // Notify the windows and the downstream subscriber of the error and clean up.
-        (err) => terminate((consumer) => consumer.error(err))
-      )
-    );
-
-    // Additional finalization. This will be called when the
-    // destination tears down. Other finalizations are registered implicitly
-    // above via subscription.
-    return () => {
-      // Ensure that the buffer is released.
-      windowRecords = null!;
-    };
-  });
-}
-
-interface WindowRecord<T> {
-  seen: number;
-  window: Subject<T>;
-  subs: Subscription;
-}

package/src/node_modules/rxjs/src/internal/operators/windowToggle.ts

@@ -1,132 +0,0 @@
-import { Observable } from '../Observable';
-import { Subject } from '../Subject';
-import { Subscription } from '../Subscription';
-import { ObservableInput, OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { innerFrom } from '../observable/innerFrom';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { noop } from '../util/noop';
-import { arrRemove } from '../util/arrRemove';
-
-/**
- * Branch out the source Observable values as a nested Observable starting from
- * an emission from `openings` and ending when the output of `closingSelector`
- * emits.
- *
- * <span class="informal">It's like {@link bufferToggle}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowToggle.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits windows that contain those items
- * emitted by the source Observable between the time when the `openings`
- * Observable emits an item and when the Observable returned by
- * `closingSelector` emits an item.
- *
- * ## Example
- *
- * Every other second, emit the click events from the next 500ms
- *
- * ```ts
- * import { fromEvent, interval, windowToggle, EMPTY, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const openings = interval(1000);
- * const result = clicks.pipe(
- *   windowToggle(openings, i => i % 2 ? interval(500) : EMPTY),
- *   mergeAll()
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowCount}
- * @see {@link windowTime}
- * @see {@link windowWhen}
- * @see {@link bufferToggle}
- *
- * @param openings An observable of notifications to start new windows.
- * @param closingSelector A function that takes the value emitted by the
- * `openings` observable and returns an Observable, which, when it emits a next
- * notification, signals that the associated window should complete.
- * @return A function that returns an Observable of windows, which in turn are
- * Observables.
- */
-export function windowToggle<T, O>(
-  openings: ObservableInput<O>,
-  closingSelector: (openValue: O) => ObservableInput<any>
-): OperatorFunction<T, Observable<T>> {
-  return operate((source, subscriber) => {
-    const windows: Subject<T>[] = [];
-
-    const handleError = (err: any) => {
-      while (0 < windows.length) {
-        windows.shift()!.error(err);
-      }
-      subscriber.error(err);
-    };
-
-    innerFrom(openings).subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (openValue) => {
-          const window = new Subject<T>();
-          windows.push(window);
-          const closingSubscription = new Subscription();
-          const closeWindow = () => {
-            arrRemove(windows, window);
-            window.complete();
-            closingSubscription.unsubscribe();
-          };
-
-          let closingNotifier: Observable<any>;
-          try {
-            closingNotifier = innerFrom(closingSelector(openValue));
-          } catch (err) {
-            handleError(err);
-            return;
-          }
-
-          subscriber.next(window.asObservable());
-
-          closingSubscription.add(closingNotifier.subscribe(createOperatorSubscriber(subscriber, closeWindow, noop, handleError)));
-        },
-        noop
-      )
-    );
-
-    // Subscribe to the source to get things started.
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value: T) => {
-          // Copy the windows array before we emit to
-          // make sure we don't have issues with reentrant code.
-          const windowsCopy = windows.slice();
-          for (const window of windowsCopy) {
-            window.next(value);
-          }
-        },
-        () => {
-          // Complete all of our windows before we complete.
-          while (0 < windows.length) {
-            windows.shift()!.complete();
-          }
-          subscriber.complete();
-        },
-        handleError,
-        () => {
-          // Add this finalization so that all window subjects are
-          // disposed of. This way, if a user tries to subscribe
-          // to a window *after* the outer subscription has been unsubscribed,
-          // they will get an error, instead of waiting forever to
-          // see if a value arrives.
-          while (0 < windows.length) {
-            windows.shift()!.unsubscribe();
-          }
-        }
-      )
-    );
-  });
-}

package/src/node_modules/rxjs/src/internal/operators/windowWhen.ts

@@ -1,125 +0,0 @@
-import { Subscriber } from '../Subscriber';
-import { Observable } from '../Observable';
-import { Subject } from '../Subject';
-import { ObservableInput, OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { innerFrom } from '../observable/innerFrom';
-
-/**
- * Branch out the source Observable values as a nested Observable using a
- * factory function of closing Observables to determine when to start a new
- * window.
- *
- * <span class="informal">It's like {@link bufferWhen}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowWhen.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits connected, non-overlapping windows.
- * It emits the current window and opens a new one whenever the Observable
- * produced by the specified `closingSelector` function emits an item. The first
- * window is opened immediately when subscribing to the output Observable.
- *
- * ## Example
- *
- * Emit only the first two clicks events in every window of [1-5] random seconds
- *
- * ```ts
- * import { fromEvent, windowWhen, interval, map, take, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowWhen(() => interval(1000 + Math.random() * 4000)),
- *   map(win => win.pipe(take(2))), // take at most 2 emissions from each window
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowCount}
- * @see {@link windowTime}
- * @see {@link windowToggle}
- * @see {@link bufferWhen}
- *
- * @param closingSelector A function that takes no arguments and returns an
- * {@link ObservableInput} (that gets converted to Observable) that signals
- * (on either `next` or `complete`) when to close the previous window and
- * start a new one.
- * @return A function that returns an Observable of windows, which in turn are
- * Observables.
- */
-export function windowWhen<T>(closingSelector: () => ObservableInput<any>): OperatorFunction<T, Observable<T>> {
-  return operate((source, subscriber) => {
-    let window: Subject<T> | null;
-    let closingSubscriber: Subscriber<any> | undefined;
-
-    /**
-     * When we get an error, we have to notify both the
-     * destination subscriber and the window.
-     */
-    const handleError = (err: any) => {
-      window!.error(err);
-      subscriber.error(err);
-    };
-
-    /**
-     * Called every time we need to open a window.
-     * Recursive, as it will start the closing notifier, which
-     * inevitably *should* call openWindow -- but may not if
-     * it is a "never" observable.
-     */
-    const openWindow = () => {
-      // We need to clean up our closing subscription,
-      // we only cared about the first next or complete notification.
-      closingSubscriber?.unsubscribe();
-
-      // Close our window before starting a new one.
-      window?.complete();
-
-      // Start the new window.
-      window = new Subject<T>();
-      subscriber.next(window.asObservable());
-
-      // Get our closing notifier.
-      let closingNotifier: Observable<any>;
-      try {
-        closingNotifier = innerFrom(closingSelector());
-      } catch (err) {
-        handleError(err);
-        return;
-      }
-
-      // Subscribe to the closing notifier, be sure
-      // to capture the subscriber (aka Subscription)
-      // so we can clean it up when we close the window
-      // and open a new one.
-      closingNotifier.subscribe((closingSubscriber = createOperatorSubscriber(subscriber, openWindow, openWindow, handleError)));
-    };
-
-    // Start the first window.
-    openWindow();
-
-    // Subscribe to the source
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => window!.next(value),
-        () => {
-          // The source completed, close the window and complete.
-          window!.complete();
-          subscriber.complete();
-        },
-        handleError,
-        () => {
-          // Be sure to clean up our closing subscription
-          // when this tears down.
-          closingSubscriber?.unsubscribe();
-          window = null!;
-        }
-      )
-    );
-  });
-}