appiq-solution 1.0.0

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

@@ -0,0 +1,132 @@
+import { Subscriber } from '../Subscriber';
+import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
+import { innerFrom } from '../observable/innerFrom';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/* tslint:disable:max-line-length */
+export function switchMap<T, O extends ObservableInput<any>>(
+  project: (value: T, index: number) => O
+): OperatorFunction<T, ObservedValueOf<O>>;
+/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
+export function switchMap<T, O extends ObservableInput<any>>(
+  project: (value: T, index: number) => O,
+  resultSelector: undefined
+): OperatorFunction<T, ObservedValueOf<O>>;
+/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
+export function switchMap<T, R, O extends ObservableInput<any>>(
+  project: (value: T, index: number) => O,
+  resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R
+): OperatorFunction<T, R>;
+/* tslint:enable:max-line-length */
+
+/**
+ * Projects each source value to an Observable which is merged in the output
+ * Observable, emitting values only from the most recently projected Observable.
+ *
+ * <span class="informal">Maps each value to an Observable, then flattens all of
+ * these inner Observables using {@link switchAll}.</span>
+ *
+ * ![](switchMap.png)
+ *
+ * Returns an Observable that emits items based on applying a function that you
+ * supply to each item emitted by the source Observable, where that function
+ * returns an (so-called "inner") Observable. Each time it observes one of these
+ * inner Observables, the output Observable begins emitting the items emitted by
+ * that inner Observable. When a new inner Observable is emitted, `switchMap`
+ * stops emitting items from the earlier-emitted inner Observable and begins
+ * emitting items from the new one. It continues to behave like this for
+ * subsequent inner Observables.
+ *
+ * ## Example
+ *
+ * Generate new Observable according to source Observable values
+ *
+ * ```ts
+ * import { of, switchMap } from 'rxjs';
+ *
+ * const switched = of(1, 2, 3).pipe(switchMap(x => of(x, x ** 2, x ** 3)));
+ * switched.subscribe(x => console.log(x));
+ * // outputs
+ * // 1
+ * // 1
+ * // 1
+ * // 2
+ * // 4
+ * // 8
+ * // 3
+ * // 9
+ * // 27
+ * ```
+ *
+ * Restart an interval Observable on every click event
+ *
+ * ```ts
+ * import { fromEvent, switchMap, interval } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(switchMap(() => interval(1000)));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link concatMap}
+ * @see {@link exhaustMap}
+ * @see {@link mergeMap}
+ * @see {@link switchAll}
+ * @see {@link switchMapTo}
+ *
+ * @param project A function that, when applied to an item emitted by the source
+ * Observable, returns an Observable.
+ * @return A function that returns an Observable that emits the result of
+ * applying the projection function (and the optional deprecated
+ * `resultSelector`) to each item emitted by the source Observable and taking
+ * only the values from the most recently projected inner Observable.
+ */
+export function switchMap<T, R, O extends ObservableInput<any>>(
+  project: (value: T, index: number) => O,
+  resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R
+): OperatorFunction<T, ObservedValueOf<O> | R> {
+  return operate((source, subscriber) => {
+    let innerSubscriber: Subscriber<ObservedValueOf<O>> | null = null;
+    let index = 0;
+    // Whether or not the source subscription has completed
+    let isComplete = false;
+
+    // We only complete the result if the source is complete AND we don't have an active inner subscription.
+    // This is called both when the source completes and when the inners complete.
+    const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
+
+    source.subscribe(
+      createOperatorSubscriber(
+        subscriber,
+        (value) => {
+          // Cancel the previous inner subscription if there was one
+          innerSubscriber?.unsubscribe();
+          let innerIndex = 0;
+          const outerIndex = index++;
+          // Start the next inner subscription
+          innerFrom(project(value, outerIndex)).subscribe(
+            (innerSubscriber = createOperatorSubscriber(
+              subscriber,
+              // When we get a new inner value, next it through. Note that this is
+              // handling the deprecate result selector here. This is because with this architecture
+              // it ends up being smaller than using the map operator.
+              (innerValue) => subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue),
+              () => {
+                // The inner has completed. Null out the inner subscriber to
+                // free up memory and to signal that we have no inner subscription
+                // currently.
+                innerSubscriber = null!;
+                checkComplete();
+              }
+            ))
+          );
+        },
+        () => {
+          isComplete = true;
+          checkComplete();
+        }
+      )
+    );
+  });
+}

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

@@ -0,0 +1,64 @@
+import { switchMap } from './switchMap';
+import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
+import { isFunction } from '../util/isFunction';
+
+/** @deprecated Will be removed in v9. Use {@link switchMap} instead: `switchMap(() => result)` */
+export function switchMapTo<O extends ObservableInput<unknown>>(observable: O): OperatorFunction<unknown, ObservedValueOf<O>>;
+/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
+export function switchMapTo<O extends ObservableInput<unknown>>(
+  observable: O,
+  resultSelector: undefined
+): OperatorFunction<unknown, ObservedValueOf<O>>;
+/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
+export function switchMapTo<T, R, O extends ObservableInput<unknown>>(
+  observable: O,
+  resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R
+): OperatorFunction<T, R>;
+
+/**
+ * Projects each source value to the same Observable which is flattened multiple
+ * times with {@link switchMap} in the output Observable.
+ *
+ * <span class="informal">It's like {@link switchMap}, but maps each value
+ * always to the same inner Observable.</span>
+ *
+ * ![](switchMapTo.png)
+ *
+ * Maps each source value to the given Observable `innerObservable` regardless
+ * of the source value, and then flattens those resulting Observables into one
+ * single Observable, which is the output Observable. The output Observables
+ * emits values only from the most recently emitted instance of
+ * `innerObservable`.
+ *
+ * ## Example
+ *
+ * Restart an interval Observable on every click event
+ *
+ * ```ts
+ * import { fromEvent, switchMapTo, interval } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(switchMapTo(interval(1000)));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link concatMapTo}
+ * @see {@link switchAll}
+ * @see {@link switchMap}
+ * @see {@link mergeMapTo}
+ *
+ * @param innerObservable An `ObservableInput` to replace each value from the
+ * source Observable.
+ * @return A function that returns an Observable that emits items from the
+ * given `innerObservable` (and optionally transformed through the deprecated
+ * `resultSelector`) every time a value is emitted on the source Observable,
+ * and taking only the values from the most recently projected inner
+ * Observable.
+ * @deprecated Will be removed in v9. Use {@link switchMap} instead: `switchMap(() => result)`
+ */
+export function switchMapTo<T, R, O extends ObservableInput<unknown>>(
+  innerObservable: O,
+  resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R
+): OperatorFunction<T, ObservedValueOf<O> | R> {
+  return isFunction(resultSelector) ? switchMap(() => innerObservable, resultSelector) : switchMap(() => innerObservable);
+}

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

@@ -0,0 +1,50 @@
+import { ObservableInput, ObservedValueOf, OperatorFunction } from '../types';
+import { switchMap } from './switchMap';
+import { operate } from '../util/lift';
+
+// TODO: Generate a marble diagram for these docs.
+
+/**
+ * Applies an accumulator function over the source Observable where the
+ * accumulator function itself returns an Observable, emitting values
+ * only from the most recently returned Observable.
+ *
+ * <span class="informal">It's like {@link mergeScan}, but only the most recent
+ * Observable returned by the accumulator is merged into the outer Observable.</span>
+ *
+ * @see {@link scan}
+ * @see {@link mergeScan}
+ * @see {@link switchMap}
+ *
+ * @param accumulator
+ * The accumulator function called on each source value.
+ * @param seed The initial accumulation value.
+ * @return A function that returns an observable of the accumulated values.
+ */
+export function switchScan<T, R, O extends ObservableInput<any>>(
+  accumulator: (acc: R, value: T, index: number) => O,
+  seed: R
+): OperatorFunction<T, ObservedValueOf<O>> {
+  return operate((source, subscriber) => {
+    // The state we will keep up to date to pass into our
+    // accumulator function at each new value from the source.
+    let state = seed;
+
+    // Use `switchMap` on our `source` to do the work of creating
+    // this operator. Note the backwards order here of `switchMap()(source)`
+    // to avoid needing to use `pipe` unnecessarily
+    switchMap(
+      // On each value from the source, call the accumulator with
+      // our previous state, the value and the index.
+      (value: T, index) => accumulator(state, value, index),
+      // Using the deprecated result selector here as a dirty trick
+      // to update our state with the flattened value.
+      (_, innerValue) => ((state = innerValue), innerValue)
+    )(source).subscribe(subscriber);
+
+    return () => {
+      // Release state on finalization
+      state = null!;
+    };
+  });
+}

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

@@ -0,0 +1,71 @@
+import { MonoTypeOperatorFunction } from '../types';
+import { EMPTY } from '../observable/empty';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/**
+ * Emits only the first `count` values emitted by the source Observable.
+ *
+ * <span class="informal">Takes the first `count` values from the source, then
+ * completes.</span>
+ *
+ * ![](take.png)
+ *
+ * `take` returns an Observable that emits only the first `count` values emitted
+ * by the source Observable. If the source emits fewer than `count` values then
+ * all of its values are emitted. After that, it completes, regardless if the
+ * source completes.
+ *
+ * ## Example
+ *
+ * Take the first 5 seconds of an infinite 1-second interval Observable
+ *
+ * ```ts
+ * import { interval, take } from 'rxjs';
+ *
+ * const intervalCount = interval(1000);
+ * const takeFive = intervalCount.pipe(take(5));
+ * takeFive.subscribe(x => console.log(x));
+ *
+ * // Logs:
+ * // 0
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * ```
+ *
+ * @see {@link takeLast}
+ * @see {@link takeUntil}
+ * @see {@link takeWhile}
+ * @see {@link skip}
+ *
+ * @param count The maximum number of `next` values to emit.
+ * @return A function that returns an Observable that emits only the first
+ * `count` values emitted by the source Observable, or all of the values from
+ * the source if the source emits fewer than `count` values.
+ */
+export function take<T>(count: number): MonoTypeOperatorFunction<T> {
+  return count <= 0
+    ? // If we are taking no values, that's empty.
+      () => EMPTY
+    : operate((source, subscriber) => {
+        let seen = 0;
+        source.subscribe(
+          createOperatorSubscriber(subscriber, (value) => {
+            // Increment the number of values we have seen,
+            // then check it against the allowed count to see
+            // if we are still letting values through.
+            if (++seen <= count) {
+              subscriber.next(value);
+              // If we have met or passed our allowed count,
+              // we need to complete. We have to do <= here,
+              // because re-entrant code will increment `seen` twice.
+              if (count <= seen) {
+                subscriber.complete();
+              }
+            }
+          })
+        );
+      });
+}

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

@@ -0,0 +1,81 @@
+import { EMPTY } from '../observable/empty';
+import { MonoTypeOperatorFunction } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/**
+ * Waits for the source to complete, then emits the last N values from the source,
+ * as specified by the `count` argument.
+ *
+ * ![](takeLast.png)
+ *
+ * `takeLast` results in an observable that will hold values up to `count` values in memory,
+ * until the source completes. It then pushes all values in memory to the consumer, in the
+ * order they were received from the source, then notifies the consumer that it is
+ * complete.
+ *
+ * If for some reason the source completes before the `count` supplied to `takeLast` is reached,
+ * all values received until that point are emitted, and then completion is notified.
+ *
+ * **Warning**: Using `takeLast` with an observable that never completes will result
+ * in an observable that never emits a value.
+ *
+ * ## Example
+ *
+ * Take the last 3 values of an Observable with many values
+ *
+ * ```ts
+ * import { range, takeLast } from 'rxjs';
+ *
+ * const many = range(1, 100);
+ * const lastThree = many.pipe(takeLast(3));
+ * lastThree.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link take}
+ * @see {@link takeUntil}
+ * @see {@link takeWhile}
+ * @see {@link skip}
+ *
+ * @param count The maximum number of values to emit from the end of
+ * the sequence of values emitted by the source Observable.
+ * @return A function that returns an Observable that emits at most the last
+ * `count` values emitted by the source Observable.
+ */
+export function takeLast<T>(count: number): MonoTypeOperatorFunction<T> {
+  return count <= 0
+    ? () => EMPTY
+    : operate((source, subscriber) => {
+        // This buffer will hold the values we are going to emit
+        // when the source completes. Since we only want to take the
+        // last N values, we can't emit until we're sure we're not getting
+        // any more values.
+        let buffer: T[] = [];
+        source.subscribe(
+          createOperatorSubscriber(
+            subscriber,
+            (value) => {
+              // Add the most recent value onto the end of our buffer.
+              buffer.push(value);
+              // If our buffer is now larger than the number of values we
+              // want to take, we remove the oldest value from the buffer.
+              count < buffer.length && buffer.shift();
+            },
+            () => {
+              // The source completed, we now know what are last values
+              // are, emit them in the order they were received.
+              for (const value of buffer) {
+                subscriber.next(value);
+              }
+              subscriber.complete();
+            },
+            // Errors are passed through to the consumer
+            undefined,
+            () => {
+              // During finalization release the values in our buffer.
+              buffer = null!;
+            }
+          )
+        );
+      });
+}

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

@@ -0,0 +1,50 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+import { innerFrom } from '../observable/innerFrom';
+import { noop } from '../util/noop';
+
+/**
+ * Emits the values emitted by the source Observable until a `notifier`
+ * Observable emits a value.
+ *
+ * <span class="informal">Lets values pass until a second Observable,
+ * `notifier`, emits a value. Then, it completes.</span>
+ *
+ * ![](takeUntil.png)
+ *
+ * `takeUntil` subscribes and begins mirroring the source Observable. It also
+ * monitors a second Observable, `notifier` that you provide. If the `notifier`
+ * emits a value, the output Observable stops mirroring the source Observable
+ * and completes. If the `notifier` doesn't emit any value and completes
+ * then `takeUntil` will pass all values.
+ *
+ * ## Example
+ *
+ * Tick every second until the first click happens
+ *
+ * ```ts
+ * import { interval, fromEvent, takeUntil } from 'rxjs';
+ *
+ * const source = interval(1000);
+ * const clicks = fromEvent(document, 'click');
+ * const result = source.pipe(takeUntil(clicks));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link take}
+ * @see {@link takeLast}
+ * @see {@link takeWhile}
+ * @see {@link skip}
+ *
+ * @param notifier The `ObservableInput` whose first emitted value will cause the output
+ * Observable of `takeUntil` to stop emitting values from the source Observable.
+ * @return A function that returns an Observable that emits the values from the
+ * source Observable until `notifier` emits its first value.
+ */
+export function takeUntil<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T> {
+  return operate((source, subscriber) => {
+    innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, () => subscriber.complete(), noop));
+    !subscriber.closed && source.subscribe(subscriber);
+  });
+}

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

@@ -0,0 +1,66 @@
+import { OperatorFunction, MonoTypeOperatorFunction, TruthyTypesOf } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+export function takeWhile<T>(predicate: BooleanConstructor, inclusive: true): MonoTypeOperatorFunction<T>;
+export function takeWhile<T>(predicate: BooleanConstructor, inclusive: false): OperatorFunction<T, TruthyTypesOf<T>>;
+export function takeWhile<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
+export function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S): OperatorFunction<T, S>;
+export function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S, inclusive: false): OperatorFunction<T, S>;
+export function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive?: boolean): MonoTypeOperatorFunction<T>;
+
+/**
+ * Emits values emitted by the source Observable so long as each value satisfies
+ * the given `predicate`, and then completes as soon as this `predicate` is not
+ * satisfied.
+ *
+ * <span class="informal">Takes values from the source only while they pass the
+ * condition given. When the first value does not satisfy, it completes.</span>
+ *
+ * ![](takeWhile.png)
+ *
+ * `takeWhile` subscribes and begins mirroring the source Observable. Each value
+ * emitted on the source is given to the `predicate` function which returns a
+ * boolean, representing a condition to be satisfied by the source values. The
+ * output Observable emits the source values until such time as the `predicate`
+ * returns false, at which point `takeWhile` stops mirroring the source
+ * Observable and completes the output Observable.
+ *
+ * ## Example
+ *
+ * Emit click events only while the clientX property is greater than 200
+ *
+ * ```ts
+ * import { fromEvent, takeWhile } from 'rxjs';
+ *
+ * const clicks = fromEvent<PointerEvent>(document, 'click');
+ * const result = clicks.pipe(takeWhile(ev => ev.clientX > 200));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link take}
+ * @see {@link takeLast}
+ * @see {@link takeUntil}
+ * @see {@link skip}
+ *
+ * @param predicate A function that evaluates a value emitted by the source
+ * Observable and returns a boolean. Also takes the (zero-based) index as the
+ * second argument.
+ * @param inclusive When set to `true` the value that caused `predicate` to
+ * return `false` will also be emitted.
+ * @return A function that returns an Observable that emits values from the
+ * source Observable so long as each value satisfies the condition defined by
+ * the `predicate`, then completes.
+ */
+export function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive = false): MonoTypeOperatorFunction<T> {
+  return operate((source, subscriber) => {
+    let index = 0;
+    source.subscribe(
+      createOperatorSubscriber(subscriber, (value) => {
+        const result = predicate(value, index++);
+        (result || inclusive) && subscriber.next(value);
+        !result && subscriber.complete();
+      })
+    );
+  });
+}