appiq-solution 1.0.0

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

@@ -0,0 +1,146 @@
+import { OperatorFunction, ObservableInput } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+import { innerFrom } from '../observable/innerFrom';
+
+/**
+ * Compares all values of two observables in sequence using an optional comparator function
+ * and returns an observable of a single boolean value representing whether or not the two sequences
+ * are equal.
+ *
+ * <span class="informal">Checks to see of all values emitted by both observables are equal, in order.</span>
+ *
+ * ![](sequenceEqual.png)
+ *
+ * `sequenceEqual` subscribes to source observable and `compareTo` `ObservableInput` (that internally
+ * gets converted to an observable) and buffers incoming values from each observable. Whenever either
+ * observable emits a value, the value is buffered and the buffers are shifted and compared from the bottom
+ * up; If any value pair doesn't match, the returned observable will emit `false` and complete. If one of the
+ * observables completes, the operator will wait for the other observable to complete; If the other
+ * observable emits before completing, the returned observable will emit `false` and complete. If one observable never
+ * completes or emits after the other completes, the returned observable will never complete.
+ *
+ * ## Example
+ *
+ * Figure out if the Konami code matches
+ *
+ * ```ts
+ * import { from, fromEvent, map, bufferCount, mergeMap, sequenceEqual } from 'rxjs';
+ *
+ * const codes = from([
+ *   'ArrowUp',
+ *   'ArrowUp',
+ *   'ArrowDown',
+ *   'ArrowDown',
+ *   'ArrowLeft',
+ *   'ArrowRight',
+ *   'ArrowLeft',
+ *   'ArrowRight',
+ *   'KeyB',
+ *   'KeyA',
+ *   'Enter', // no start key, clearly.
+ * ]);
+ *
+ * const keys = fromEvent<KeyboardEvent>(document, 'keyup').pipe(map(e => e.code));
+ * const matches = keys.pipe(
+ *   bufferCount(11, 1),
+ *   mergeMap(last11 => from(last11).pipe(sequenceEqual(codes)))
+ * );
+ * matches.subscribe(matched => console.log('Successful cheat at Contra? ', matched));
+ * ```
+ *
+ * @see {@link combineLatest}
+ * @see {@link zip}
+ * @see {@link withLatestFrom}
+ *
+ * @param compareTo The `ObservableInput` sequence to compare the source sequence to.
+ * @param comparator An optional function to compare each value pair.
+ *
+ * @return A function that returns an Observable that emits a single boolean
+ * value representing whether or not the values emitted by the source
+ * Observable and provided `ObservableInput` were equal in sequence.
+ */
+export function sequenceEqual<T>(
+  compareTo: ObservableInput<T>,
+  comparator: (a: T, b: T) => boolean = (a, b) => a === b
+): OperatorFunction<T, boolean> {
+  return operate((source, subscriber) => {
+    // The state for the source observable
+    const aState = createState<T>();
+    // The state for the compareTo observable;
+    const bState = createState<T>();
+
+    /** A utility to emit and complete */
+    const emit = (isEqual: boolean) => {
+      subscriber.next(isEqual);
+      subscriber.complete();
+    };
+
+    /**
+     * Creates a subscriber that subscribes to one of the sources, and compares its collected
+     * state -- `selfState` -- to the other source's collected state -- `otherState`. This
+     * is used for both streams.
+     */
+    const createSubscriber = (selfState: SequenceState<T>, otherState: SequenceState<T>) => {
+      const sequenceEqualSubscriber = createOperatorSubscriber(
+        subscriber,
+        (a: T) => {
+          const { buffer, complete } = otherState;
+          if (buffer.length === 0) {
+            // If there's no values in the other buffer
+            // and the other stream is complete, we know
+            // this isn't a match, because we got one more value.
+            // Otherwise, we push onto our buffer, so when the other
+            // stream emits, it can pull this value off our buffer and check it
+            // at the appropriate time.
+            complete ? emit(false) : selfState.buffer.push(a);
+          } else {
+            // If the other stream *does* have values in its buffer,
+            // pull the oldest one off so we can compare it to what we
+            // just got. If it wasn't a match, emit `false` and complete.
+            !comparator(a, buffer.shift()!) && emit(false);
+          }
+        },
+        () => {
+          // Or observable completed
+          selfState.complete = true;
+          const { complete, buffer } = otherState;
+          // If the other observable is also complete, and there's
+          // still stuff left in their buffer, it doesn't match, if their
+          // buffer is empty, then it does match. This is because we can't
+          // possibly get more values here anymore.
+          complete && emit(buffer.length === 0);
+          // Be sure to clean up our stream as soon as possible if we can.
+          sequenceEqualSubscriber?.unsubscribe();
+        }
+      );
+
+      return sequenceEqualSubscriber;
+    };
+
+    // Subscribe to each source.
+    source.subscribe(createSubscriber(aState, bState));
+    innerFrom(compareTo).subscribe(createSubscriber(bState, aState));
+  });
+}
+
+/**
+ * A simple structure for the data used to test each sequence
+ */
+interface SequenceState<T> {
+  /** A temporary store for arrived values before they are checked */
+  buffer: T[];
+  /** Whether or not the sequence source has completed. */
+  complete: boolean;
+}
+
+/**
+ * Creates a simple structure that is used to represent
+ * data used to test each sequence.
+ */
+function createState<T>(): SequenceState<T> {
+  return {
+    buffer: [],
+    complete: false,
+  };
+}

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

@@ -0,0 +1,267 @@
+import { innerFrom } from '../observable/innerFrom';
+import { Subject } from '../Subject';
+import { SafeSubscriber } from '../Subscriber';
+import { Subscription } from '../Subscription';
+import { MonoTypeOperatorFunction, SubjectLike, ObservableInput } from '../types';
+import { operate } from '../util/lift';
+
+export interface ShareConfig<T> {
+  /**
+   * The factory used to create the subject that will connect the source observable to
+   * multicast consumers.
+   */
+  connector?: () => SubjectLike<T>;
+  /**
+   * If `true`, the resulting observable will reset internal state on error from source and return to a "cold" state. This
+   * allows the resulting observable to be "retried" in the event of an error.
+   * If `false`, when an error comes from the source it will push the error into the connecting subject, and the subject
+   * will remain the connecting subject, meaning the resulting observable will not go "cold" again, and subsequent retries
+   * or resubscriptions will resubscribe to that same subject. In all cases, RxJS subjects will emit the same error again, however
+   * {@link ReplaySubject} will also push its buffered values before pushing the error.
+   * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained
+   * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets.
+   */
+  resetOnError?: boolean | ((error: any) => ObservableInput<any>);
+  /**
+   * If `true`, the resulting observable will reset internal state on completion from source and return to a "cold" state. This
+   * allows the resulting observable to be "repeated" after it is done.
+   * If `false`, when the source completes, it will push the completion through the connecting subject, and the subject
+   * will remain the connecting subject, meaning the resulting observable will not go "cold" again, and subsequent repeats
+   * or resubscriptions will resubscribe to that same subject.
+   * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained
+   * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets.
+   */
+  resetOnComplete?: boolean | (() => ObservableInput<any>);
+  /**
+   * If `true`, when the number of subscribers to the resulting observable reaches zero due to those subscribers unsubscribing, the
+   * internal state will be reset and the resulting observable will return to a "cold" state. This means that the next
+   * time the resulting observable is subscribed to, a new subject will be created and the source will be subscribed to
+   * again.
+   * If `false`, when the number of subscribers to the resulting observable reaches zero due to unsubscription, the subject
+   * will remain connected to the source, and new subscriptions to the result will be connected through that same subject.
+   * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained
+   * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets.
+   */
+  resetOnRefCountZero?: boolean | (() => ObservableInput<any>);
+}
+
+export function share<T>(): MonoTypeOperatorFunction<T>;
+
+export function share<T>(options: ShareConfig<T>): MonoTypeOperatorFunction<T>;
+
+/**
+ * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one
+ * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will
+ * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`.
+ * This is an alias for `multicast(() => new Subject()), refCount()`.
+ *
+ * The subscription to the underlying source Observable can be reset (unsubscribe and resubscribe for new subscribers),
+ * if the subscriber count to the shared observable drops to 0, or if the source Observable errors or completes. It is
+ * possible to use notifier factories for the resets to allow for behaviors like conditional or delayed resets. Please
+ * note that resetting on error or complete of the source Observable does not behave like a transparent retry or restart
+ * of the source because the error or complete will be forwarded to all subscribers and their subscription will be
+ * closed. Only new subscribers after a reset on error or complete happened will cause a fresh subscription to the
+ * source. To achieve transparent retries or restarts pipe the source through appropriate operators before sharing.
+ *
+ * ![](share.png)
+ *
+ * ## Example
+ *
+ * Generate new multicast Observable from the `source` Observable value
+ *
+ * ```ts
+ * import { interval, tap, map, take, share } from 'rxjs';
+ *
+ * const source = interval(1000).pipe(
+ *   tap(x => console.log('Processing: ', x)),
+ *   map(x => x * x),
+ *   take(6),
+ *   share()
+ * );
+ *
+ * source.subscribe(x => console.log('subscription 1: ', x));
+ * source.subscribe(x => console.log('subscription 2: ', x));
+ *
+ * // Logs:
+ * // Processing: 0
+ * // subscription 1: 0
+ * // subscription 2: 0
+ * // Processing: 1
+ * // subscription 1: 1
+ * // subscription 2: 1
+ * // Processing: 2
+ * // subscription 1: 4
+ * // subscription 2: 4
+ * // Processing: 3
+ * // subscription 1: 9
+ * // subscription 2: 9
+ * // Processing: 4
+ * // subscription 1: 16
+ * // subscription 2: 16
+ * // Processing: 5
+ * // subscription 1: 25
+ * // subscription 2: 25
+ * ```
+ *
+ * ## Example with notifier factory: Delayed reset
+ *
+ * ```ts
+ * import { interval, take, share, timer } from 'rxjs';
+ *
+ * const source = interval(1000).pipe(
+ *   take(3),
+ *   share({
+ *     resetOnRefCountZero: () => timer(1000)
+ *   })
+ * );
+ *
+ * const subscriptionOne = source.subscribe(x => console.log('subscription 1: ', x));
+ * setTimeout(() => subscriptionOne.unsubscribe(), 1300);
+ *
+ * setTimeout(() => source.subscribe(x => console.log('subscription 2: ', x)), 1700);
+ *
+ * setTimeout(() => source.subscribe(x => console.log('subscription 3: ', x)), 5000);
+ *
+ * // Logs:
+ * // subscription 1:  0
+ * // (subscription 1 unsubscribes here)
+ * // (subscription 2 subscribes here ~400ms later, source was not reset)
+ * // subscription 2:  1
+ * // subscription 2:  2
+ * // (subscription 2 unsubscribes here)
+ * // (subscription 3 subscribes here ~2000ms later, source did reset before)
+ * // subscription 3:  0
+ * // subscription 3:  1
+ * // subscription 3:  2
+ * ```
+ *
+ * @see {@link shareReplay}
+ *
+ * @return A function that returns an Observable that mirrors the source.
+ */
+export function share<T>(options: ShareConfig<T> = {}): MonoTypeOperatorFunction<T> {
+  const { connector = () => new Subject<T>(), resetOnError = true, resetOnComplete = true, resetOnRefCountZero = true } = options;
+  // It's necessary to use a wrapper here, as the _operator_ must be
+  // referentially transparent. Otherwise, it cannot be used in calls to the
+  // static `pipe` function - to create a partial pipeline.
+  //
+  // The _operator function_ - the function returned by the _operator_ - will
+  // not be referentially transparent - as it shares its source - but the
+  // _operator function_ is called when the complete pipeline is composed via a
+  // call to a source observable's `pipe` method - not when the static `pipe`
+  // function is called.
+  return (wrapperSource) => {
+    let connection: SafeSubscriber<T> | undefined;
+    let resetConnection: Subscription | undefined;
+    let subject: SubjectLike<T> | undefined;
+    let refCount = 0;
+    let hasCompleted = false;
+    let hasErrored = false;
+
+    const cancelReset = () => {
+      resetConnection?.unsubscribe();
+      resetConnection = undefined;
+    };
+    // Used to reset the internal state to a "cold"
+    // state, as though it had never been subscribed to.
+    const reset = () => {
+      cancelReset();
+      connection = subject = undefined;
+      hasCompleted = hasErrored = false;
+    };
+    const resetAndUnsubscribe = () => {
+      // We need to capture the connection before
+      // we reset (if we need to reset).
+      const conn = connection;
+      reset();
+      conn?.unsubscribe();
+    };
+
+    return operate<T, T>((source, subscriber) => {
+      refCount++;
+      if (!hasErrored && !hasCompleted) {
+        cancelReset();
+      }
+
+      // Create the subject if we don't have one yet. Grab a local reference to
+      // it as well, which avoids non-null assertions when using it and, if we
+      // connect to it now, then error/complete need a reference after it was
+      // reset.
+      const dest = (subject = subject ?? connector());
+
+      // Add the finalization directly to the subscriber - instead of returning it -
+      // so that the handling of the subscriber's unsubscription will be wired
+      // up _before_ the subscription to the source occurs. This is done so that
+      // the assignment to the source connection's `closed` property will be seen
+      // by synchronous firehose sources.
+      subscriber.add(() => {
+        refCount--;
+
+        // If we're resetting on refCount === 0, and it's 0, we only want to do
+        // that on "unsubscribe", really. Resetting on error or completion is a different
+        // configuration.
+        if (refCount === 0 && !hasErrored && !hasCompleted) {
+          resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
+        }
+      });
+
+      // The following line adds the subscription to the subscriber passed.
+      // Basically, `subscriber === dest.subscribe(subscriber)` is `true`.
+      dest.subscribe(subscriber);
+
+      if (
+        !connection &&
+        // Check this shareReplay is still activate - it can be reset to 0
+        // and be "unsubscribed" _before_ it actually subscribes.
+        // If we were to subscribe then, it'd leak and get stuck.
+        refCount > 0
+      ) {
+        // We need to create a subscriber here - rather than pass an observer and
+        // assign the returned subscription to connection - because it's possible
+        // for reentrant subscriptions to the shared observable to occur and in
+        // those situations we want connection to be already-assigned so that we
+        // don't create another connection to the source.
+        connection = new SafeSubscriber({
+          next: (value) => dest.next(value),
+          error: (err) => {
+            hasErrored = true;
+            cancelReset();
+            resetConnection = handleReset(reset, resetOnError, err);
+            dest.error(err);
+          },
+          complete: () => {
+            hasCompleted = true;
+            cancelReset();
+            resetConnection = handleReset(reset, resetOnComplete);
+            dest.complete();
+          },
+        });
+        innerFrom(source).subscribe(connection);
+      }
+    })(wrapperSource);
+  };
+}
+
+function handleReset<T extends unknown[] = never[]>(
+  reset: () => void,
+  on: boolean | ((...args: T) => ObservableInput<any>),
+  ...args: T
+): Subscription | undefined {
+  if (on === true) {
+    reset();
+    return;
+  }
+
+  if (on === false) {
+    return;
+  }
+
+  const onSubscriber = new SafeSubscriber({
+    next: () => {
+      onSubscriber.unsubscribe();
+      reset();
+    },
+  });
+
+  return innerFrom(on(...args)).subscribe(onSubscriber);
+}

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

@@ -0,0 +1,173 @@
+import { ReplaySubject } from '../ReplaySubject';
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+import { share } from './share';
+
+export interface ShareReplayConfig {
+  bufferSize?: number;
+  windowTime?: number;
+  refCount: boolean;
+  scheduler?: SchedulerLike;
+}
+
+export function shareReplay<T>(config: ShareReplayConfig): MonoTypeOperatorFunction<T>;
+export function shareReplay<T>(bufferSize?: number, windowTime?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+
+/**
+ * Share source and replay specified number of emissions on subscription.
+ *
+ * This operator is a specialization of `replay` that connects to a source observable
+ * and multicasts through a `ReplaySubject` constructed with the specified arguments.
+ * A successfully completed source will stay cached in the `shareReplay`ed observable forever,
+ * but an errored source can be retried.
+ *
+ * ## Why use `shareReplay`?
+ *
+ * You generally want to use `shareReplay` when you have side-effects or taxing computations
+ * that you do not wish to be executed amongst multiple subscribers.
+ * It may also be valuable in situations where you know you will have late subscribers to
+ * a stream that need access to previously emitted values.
+ * This ability to replay values on subscription is what differentiates {@link share} and `shareReplay`.
+ *
+ * ## Reference counting
+ *
+ * By default `shareReplay` will use `refCount` of false, meaning that it will _not_ unsubscribe the
+ * source when the reference counter drops to zero, i.e. the inner `ReplaySubject` will _not_ be unsubscribed
+ * (and potentially run for ever).
+ * This is the default as it is expected that `shareReplay` is often used to keep around expensive to setup
+ * observables which we want to keep running instead of having to do the expensive setup again.
+ *
+ * As of RXJS version 6.4.0 a new overload signature was added to allow for manual control over what
+ * happens when the operators internal reference counter drops to zero.
+ * If `refCount` is true, the source will be unsubscribed from once the reference count drops to zero, i.e.
+ * the inner `ReplaySubject` will be unsubscribed. All new subscribers will receive value emissions from a
+ * new `ReplaySubject` which in turn will cause a new subscription to the source observable.
+ *
+ * ## Examples
+ *
+ * Example with a third subscriber coming late to the party
+ *
+ * ```ts
+ * import { interval, take, shareReplay } from 'rxjs';
+ *
+ * const shared$ = interval(2000).pipe(
+ *   take(6),
+ *   shareReplay(3)
+ * );
+ *
+ * shared$.subscribe(x => console.log('sub A: ', x));
+ * shared$.subscribe(y => console.log('sub B: ', y));
+ *
+ * setTimeout(() => {
+ *   shared$.subscribe(y => console.log('sub C: ', y));
+ * }, 11000);
+ *
+ * // Logs:
+ * // (after ~2000 ms)
+ * // sub A: 0
+ * // sub B: 0
+ * // (after ~4000 ms)
+ * // sub A: 1
+ * // sub B: 1
+ * // (after ~6000 ms)
+ * // sub A: 2
+ * // sub B: 2
+ * // (after ~8000 ms)
+ * // sub A: 3
+ * // sub B: 3
+ * // (after ~10000 ms)
+ * // sub A: 4
+ * // sub B: 4
+ * // (after ~11000 ms, sub C gets the last 3 values)
+ * // sub C: 2
+ * // sub C: 3
+ * // sub C: 4
+ * // (after ~12000 ms)
+ * // sub A: 5
+ * // sub B: 5
+ * // sub C: 5
+ * ```
+ *
+ * Example for `refCount` usage
+ *
+ * ```ts
+ * import { Observable, tap, interval, shareReplay, take } from 'rxjs';
+ *
+ * const log = <T>(name: string, source: Observable<T>) => source.pipe(
+ *   tap({
+ *     subscribe: () => console.log(`${ name }: subscribed`),
+ *     next: value => console.log(`${ name }: ${ value }`),
+ *     complete: () => console.log(`${ name }: completed`),
+ *     finalize: () => console.log(`${ name }: unsubscribed`)
+ *   })
+ * );
+ *
+ * const obs$ = log('source', interval(1000));
+ *
+ * const shared$ = log('shared', obs$.pipe(
+ *   shareReplay({ bufferSize: 1, refCount: true }),
+ *   take(2)
+ * ));
+ *
+ * shared$.subscribe(x => console.log('sub A: ', x));
+ * shared$.subscribe(y => console.log('sub B: ', y));
+ *
+ * // PRINTS:
+ * // shared: subscribed <-- reference count = 1
+ * // source: subscribed
+ * // shared: subscribed <-- reference count = 2
+ * // source: 0
+ * // shared: 0
+ * // sub A: 0
+ * // shared: 0
+ * // sub B: 0
+ * // source: 1
+ * // shared: 1
+ * // sub A: 1
+ * // shared: completed <-- take(2) completes the subscription for sub A
+ * // shared: unsubscribed <-- reference count = 1
+ * // shared: 1
+ * // sub B: 1
+ * // shared: completed <-- take(2) completes the subscription for sub B
+ * // shared: unsubscribed <-- reference count = 0
+ * // source: unsubscribed <-- replaySubject unsubscribes from source observable because the reference count dropped to 0 and refCount is true
+ *
+ * // In case of refCount being false, the unsubscribe is never called on the source and the source would keep on emitting, even if no subscribers
+ * // are listening.
+ * // source: 2
+ * // source: 3
+ * // source: 4
+ * // ...
+ * ```
+ *
+ * @see {@link publish}
+ * @see {@link share}
+ * @see {@link publishReplay}
+ *
+ * @param configOrBufferSize Maximum element count of the replay buffer or {@link ShareReplayConfig configuration}
+ * object.
+ * @param windowTime Maximum time length of the replay buffer in milliseconds.
+ * @param scheduler Scheduler where connected observers within the selector function
+ * will be invoked on.
+ * @return A function that returns an Observable sequence that contains the
+ * elements of a sequence produced by multicasting the source sequence within a
+ * selector function.
+ */
+export function shareReplay<T>(
+  configOrBufferSize?: ShareReplayConfig | number,
+  windowTime?: number,
+  scheduler?: SchedulerLike
+): MonoTypeOperatorFunction<T> {
+  let bufferSize: number;
+  let refCount = false;
+  if (configOrBufferSize && typeof configOrBufferSize === 'object') {
+    ({ bufferSize = Infinity, windowTime = Infinity, refCount = false, scheduler } = configOrBufferSize);
+  } else {
+    bufferSize = (configOrBufferSize ?? Infinity) as number;
+  }
+  return share<T>({
+    connector: () => new ReplaySubject(bufferSize, windowTime, scheduler),
+    resetOnError: true,
+    resetOnComplete: false,
+    resetOnRefCountZero: refCount,
+  });
+}