appiq-solution 1.0.0

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

@@ -0,0 +1,98 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/windowCount.ts

@@ -0,0 +1,129 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/windowTime.ts

@@ -0,0 +1,207 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/windowToggle.ts

@@ -0,0 +1,132 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/windowWhen.ts

@@ -0,0 +1,125 @@
+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!;
+        }
+      )
+    );
+  });
+}