appiq-solution 1.0.9 → 1.2.0

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

@@ -1,76 +0,0 @@
-import { Observable } from '../Observable';
-import { AsyncSubject } from '../AsyncSubject';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { UnaryFunction } from '../types';
-
-/**
- * Returns a connectable observable sequence that shares a single subscription to the
- * underlying sequence containing only the last notification.
- *
- * ![](publishLast.png)
- *
- * Similar to {@link publish}, but it waits until the source observable completes and stores
- * the last emitted value.
- * Similarly to {@link publishReplay} and {@link publishBehavior}, this keeps storing the last
- * value even if it has no more subscribers. If subsequent subscriptions happen, they will
- * immediately get that last stored value and complete.
- *
- * ## Example
- *
- * ```ts
- * import { ConnectableObservable, interval, publishLast, tap, take } from 'rxjs';
- *
- * const connectable = <ConnectableObservable<number>>interval(1000)
- *   .pipe(
- *     tap(x => console.log('side effect', x)),
- *     take(3),
- *     publishLast()
- *   );
- *
- * connectable.subscribe({
- *   next: x => console.log('Sub. A', x),
- *   error: err => console.log('Sub. A Error', err),
- *   complete: () => console.log('Sub. A Complete')
- * });
- *
- * connectable.subscribe({
- *   next: x => console.log('Sub. B', x),
- *   error: err => console.log('Sub. B Error', err),
- *   complete: () => console.log('Sub. B Complete')
- * });
- *
- * connectable.connect();
- *
- * // Results:
- * // 'side effect 0'   - after one second
- * // 'side effect 1'   - after two seconds
- * // 'side effect 2'   - after three seconds
- * // 'Sub. A 2'        - immediately after 'side effect 2'
- * // 'Sub. B 2'
- * // 'Sub. A Complete'
- * // 'Sub. B Complete'
- * ```
- *
- * @see {@link ConnectableObservable}
- * @see {@link publish}
- * @see {@link publishReplay}
- * @see {@link publishBehavior}
- *
- * @return A function that returns an Observable that emits elements of a
- * sequence produced by multicasting the source sequence.
- * @deprecated Will be removed in v8. To create a connectable observable with an
- * {@link AsyncSubject} under the hood, use {@link connectable}.
- * `source.pipe(publishLast())` is equivalent to
- * `connectable(source, { connector: () => new AsyncSubject(), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishLast`, use the {@link share} operator instead.
- * `source.pipe(publishLast(), refCount())` is equivalent to
- * `source.pipe(share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function publishLast<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>> {
-  // Note that this has *never* supported a selector function like `publish` and `publishReplay`.
-  return (source) => {
-    const subject = new AsyncSubject<T>();
-    return new ConnectableObservable(source, () => subject);
-  };
-}

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

@@ -1,96 +0,0 @@
-import { Observable } from '../Observable';
-import { ReplaySubject } from '../ReplaySubject';
-import { multicast } from './multicast';
-import { MonoTypeOperatorFunction, OperatorFunction, TimestampProvider, ObservableInput, ObservedValueOf } from '../types';
-import { isFunction } from '../util/isFunction';
-
-/**
- * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject}
- * internally.
- *
- * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
- * @param windowTime The window time for the underlying {@link ReplaySubject}.
- * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
- * @deprecated Will be removed in v8. To create a connectable observable that uses a
- * {@link ReplaySubject} under the hood, use {@link connectable}.
- * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to
- * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead.
- * `publishReplay(size, time, scheduler), refCount()` is equivalent to
- * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function publishReplay<T>(
-  bufferSize?: number,
-  windowTime?: number,
-  timestampProvider?: TimestampProvider
-): MonoTypeOperatorFunction<T>;
-
-/**
- * Creates an observable, that when subscribed to, will create a {@link ReplaySubject},
- * and pass an observable from it (using [asObservable](api/index/class/Subject#asObservable)) to
- * the `selector` function, which then returns an observable that is subscribed to before
- * "connecting" the source to the internal `ReplaySubject`.
- *
- * Since this is deprecated, for additional details see the documentation for {@link connect}.
- *
- * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
- * @param windowTime The window time for the underlying {@link ReplaySubject}.
- * @param selector A function used to setup the multicast.
- * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
- * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
- * `source.pipe(publishReplay(size, window, selector, scheduler))` is equivalent to
- * `source.pipe(connect(selector, { connector: () => new ReplaySubject(size, window, scheduler) }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function publishReplay<T, O extends ObservableInput<any>>(
-  bufferSize: number | undefined,
-  windowTime: number | undefined,
-  selector: (shared: Observable<T>) => O,
-  timestampProvider?: TimestampProvider
-): OperatorFunction<T, ObservedValueOf<O>>;
-
-/**
- * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject}
- * internally.
- *
- * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
- * @param windowTime The window time for the underlying {@link ReplaySubject}.
- * @param selector Passing `undefined` here determines that this operator will return a {@link ConnectableObservable}.
- * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
- * @deprecated Will be removed in v8. To create a connectable observable that uses a
- * {@link ReplaySubject} under the hood, use {@link connectable}.
- * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to
- * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead.
- * `publishReplay(size, time, scheduler), refCount()` is equivalent to
- * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function publishReplay<T, O extends ObservableInput<any>>(
-  bufferSize: number | undefined,
-  windowTime: number | undefined,
-  selector: undefined,
-  timestampProvider: TimestampProvider
-): OperatorFunction<T, ObservedValueOf<O>>;
-
-/**
- * @deprecated Will be removed in v8. Use the {@link connectable} observable, the {@link connect} operator or the
- * {@link share} operator instead. See the overloads below for equivalent replacement examples of this operator's
- * behaviors.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function publishReplay<T, R>(
-  bufferSize?: number,
-  windowTime?: number,
-  selectorOrScheduler?: TimestampProvider | OperatorFunction<T, R>,
-  timestampProvider?: TimestampProvider
-) {
-  if (selectorOrScheduler && !isFunction(selectorOrScheduler)) {
-    timestampProvider = selectorOrScheduler;
-  }
-  const selector = isFunction(selectorOrScheduler) ? selectorOrScheduler : undefined;
-  // Note, we're passing `selector!` here, because at runtime, `undefined` is an acceptable argument
-  // but it makes our TypeScript signature for `multicast` unhappy (as it should, because it's gross).
-  return (source: Observable<T>) => multicast(new ReplaySubject<T>(bufferSize, windowTime, timestampProvider), selector!)(source);
-}

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

@@ -1,20 +0,0 @@
-import { ObservableInputTuple, OperatorFunction } from '../types';
-import { argsOrArgArray } from '../util/argsOrArgArray';
-import { raceWith } from './raceWith';
-
-/** @deprecated Replaced with {@link raceWith}. Will be removed in v8. */
-export function race<T, A extends readonly unknown[]>(otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-/** @deprecated Replaced with {@link raceWith}. Will be removed in v8. */
-export function race<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-
-/**
- * Returns an Observable that mirrors the first source Observable to emit a next,
- * error or complete notification from the combination of this Observable and supplied Observables.
- * @param args Sources used to race for which Observable emits first.
- * @return A function that returns an Observable that mirrors the output of the
- * first Observable to emit an item.
- * @deprecated Replaced with {@link raceWith}. Will be removed in v8.
- */
-export function race<T>(...args: any[]): OperatorFunction<T, unknown> {
-  return raceWith(...argsOrArgArray(args));
-}

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

@@ -1,40 +0,0 @@
-import { OperatorFunction, ObservableInputTuple } from '../types';
-import { raceInit } from '../observable/race';
-import { operate } from '../util/lift';
-import { identity } from '../util/identity';
-
-/**
- * Creates an Observable that mirrors the first source Observable to emit a next,
- * error or complete notification from the combination of the Observable to which
- * the operator is applied and supplied Observables.
- *
- * ## Example
- *
- * ```ts
- * import { interval, map, raceWith } from 'rxjs';
- *
- * const obs1 = interval(7000).pipe(map(() => 'slow one'));
- * const obs2 = interval(3000).pipe(map(() => 'fast one'));
- * const obs3 = interval(5000).pipe(map(() => 'medium one'));
- *
- * obs1
- *   .pipe(raceWith(obs2, obs3))
- *   .subscribe(winner => console.log(winner));
- *
- * // Outputs
- * // a series of 'fast one'
- * ```
- *
- * @param otherSources Sources used to race for which Observable emits first.
- * @return A function that returns an Observable that mirrors the output of the
- * first Observable to emit an item.
- */
-export function raceWith<T, A extends readonly unknown[]>(
-  ...otherSources: [...ObservableInputTuple<A>]
-): OperatorFunction<T, T | A[number]> {
-  return !otherSources.length
-    ? identity
-    : operate((source, subscriber) => {
-        raceInit<T | A[number]>([source, ...otherSources])(subscriber);
-      });
-}

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

@@ -1,61 +0,0 @@
-import { scanInternals } from './scanInternals';
-import { OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-
-export function reduce<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>;
-export function reduce<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
-export function reduce<V, A, S = A>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
-
-/**
- * Applies an accumulator function over the source Observable, and returns the
- * accumulated result when the source completes, given an optional seed value.
- *
- * <span class="informal">Combines together all values emitted on the source,
- * using an accumulator function that knows how to join a new source value into
- * the accumulation from the past.</span>
- *
- * ![](reduce.png)
- *
- * Like
- * [Array.prototype.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce),
- * `reduce` applies an `accumulator` function against an accumulation and each
- * value of the source Observable (from the past) to reduce it to a single
- * value, emitted on the output Observable. Note that `reduce` will only emit
- * one value, only when the source Observable completes. It is equivalent to
- * applying operator {@link scan} followed by operator {@link last}.
- *
- * Returns an Observable that applies a specified `accumulator` function to each
- * item emitted by the source Observable. If a `seed` value is specified, then
- * that value will be used as the initial value for the accumulator. If no seed
- * value is specified, the first item of the source is used as the seed.
- *
- * ## Example
- *
- * Count the number of click events that happened in 5 seconds
- *
- * ```ts
- * import { fromEvent, takeUntil, interval, map, reduce } from 'rxjs';
- *
- * const clicksInFiveSeconds = fromEvent(document, 'click')
- *   .pipe(takeUntil(interval(5000)));
- *
- * const ones = clicksInFiveSeconds.pipe(map(() => 1));
- * const seed = 0;
- * const count = ones.pipe(reduce((acc, one) => acc + one, seed));
- *
- * count.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link count}
- * @see {@link expand}
- * @see {@link mergeScan}
- * @see {@link scan}
- *
- * @param accumulator The accumulator function called on each source value.
- * @param seed The initial accumulation value.
- * @return A function that returns an Observable that emits a single value that
- * is the result of accumulating the values emitted by the source Observable.
- */
-export function reduce<V, A>(accumulator: (acc: V | A, value: V, index: number) => A, seed?: any): OperatorFunction<V, V | A> {
-  return operate(scanInternals(accumulator, seed, arguments.length >= 2, false, true));
-}

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

@@ -1,119 +0,0 @@
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { Subscription } from '../Subscription';
-import { MonoTypeOperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Make a {@link ConnectableObservable} behave like a ordinary observable and automates the way
- * you can connect to it.
- *
- * Internally it counts the subscriptions to the observable and subscribes (only once) to the source if
- * the number of subscriptions is larger than 0. If the number of subscriptions is smaller than 1, it
- * unsubscribes from the source. This way you can make sure that everything before the *published*
- * refCount has only a single subscription independently of the number of subscribers to the target
- * observable.
- *
- * Note that using the {@link share} operator is exactly the same as using the `multicast(() => new Subject())` operator
- * (making the observable hot) and the *refCount* operator in a sequence.
- *
- * ![](refCount.png)
- *
- * ## Example
- *
- * In the following example there are two intervals turned into connectable observables
- * by using the *publish* operator. The first one uses the *refCount* operator, the
- * second one does not use it. You will notice that a connectable observable does nothing
- * until you call its connect function.
- *
- * ```ts
- * import { interval, tap, publish, refCount } from 'rxjs';
- *
- * // Turn the interval observable into a ConnectableObservable (hot)
- * const refCountInterval = interval(400).pipe(
- *   tap(num => console.log(`refCount ${ num }`)),
- *   publish(),
- *   refCount()
- * );
- *
- * const publishedInterval = interval(400).pipe(
- *   tap(num => console.log(`publish ${ num }`)),
- *   publish()
- * );
- *
- * refCountInterval.subscribe();
- * refCountInterval.subscribe();
- * // 'refCount 0' -----> 'refCount 1' -----> etc
- * // All subscriptions will receive the same value and the tap (and
- * // every other operator) before the `publish` operator will be executed
- * // only once per event independently of the number of subscriptions.
- *
- * publishedInterval.subscribe();
- * // Nothing happens until you call .connect() on the observable.
- * ```
- *
- * @return A function that returns an Observable that automates the connection
- * to ConnectableObservable.
- * @see {@link ConnectableObservable}
- * @see {@link share}
- * @see {@link publish}
- * @deprecated Replaced with the {@link share} operator. How `share` is used
- * will depend on the connectable observable you created just prior to the
- * `refCount` operator.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function refCount<T>(): MonoTypeOperatorFunction<T> {
-  return operate((source, subscriber) => {
-    let connection: Subscription | null = null;
-
-    (source as any)._refCount++;
-
-    const refCounter = createOperatorSubscriber(subscriber, undefined, undefined, undefined, () => {
-      if (!source || (source as any)._refCount <= 0 || 0 < --(source as any)._refCount) {
-        connection = null;
-        return;
-      }
-
-      ///
-      // Compare the local RefCountSubscriber's connection Subscription to the
-      // connection Subscription on the shared ConnectableObservable. In cases
-      // where the ConnectableObservable source synchronously emits values, and
-      // the RefCountSubscriber's downstream Observers synchronously unsubscribe,
-      // execution continues to here before the RefCountOperator has a chance to
-      // supply the RefCountSubscriber with the shared connection Subscription.
-      // For example:
-      // ```
-      // range(0, 10).pipe(
-      //   publish(),
-      //   refCount(),
-      //   take(5),
-      // )
-      // .subscribe();
-      // ```
-      // In order to account for this case, RefCountSubscriber should only dispose
-      // the ConnectableObservable's shared connection Subscription if the
-      // connection Subscription exists, *and* either:
-      //   a. RefCountSubscriber doesn't have a reference to the shared connection
-      //      Subscription yet, or,
-      //   b. RefCountSubscriber's connection Subscription reference is identical
-      //      to the shared connection Subscription
-      ///
-
-      const sharedConnection = (source as any)._connection;
-      const conn = connection;
-      connection = null;
-
-      if (sharedConnection && (!conn || sharedConnection === conn)) {
-        sharedConnection.unsubscribe();
-      }
-
-      subscriber.unsubscribe();
-    });
-
-    source.subscribe(refCounter);
-
-    if (!refCounter.closed) {
-      connection = (source as ConnectableObservable<T>).connect();
-    }
-  });
-}

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

@@ -1,172 +0,0 @@
-import { Subscription } from '../Subscription';
-import { EMPTY } from '../observable/empty';
-import { operate } from '../util/lift';
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { innerFrom } from '../observable/innerFrom';
-import { timer } from '../observable/timer';
-
-export interface RepeatConfig {
-  /**
-   * The number of times to repeat the source. Defaults to `Infinity`.
-   */
-  count?: number;
-
-  /**
-   * If a `number`, will delay the repeat of the source by that number of milliseconds.
-   * If a function, it will provide the number of times the source has been subscribed to,
-   * and the return value should be a valid observable input that will notify when the source
-   * should be repeated. If the notifier observable is empty, the result will complete.
-   */
-  delay?: number | ((count: number) => ObservableInput<any>);
-}
-
-/**
- * Returns an Observable that will resubscribe to the source stream when the source stream completes.
- *
- * <span class="informal">Repeats all values emitted on the source. It's like {@link retry}, but for non error cases.</span>
- *
- * ![](repeat.png)
- *
- * Repeat will output values from a source until the source completes, then it will resubscribe to the
- * source a specified number of times, with a specified delay. Repeat can be particularly useful in
- * combination with closing operators like {@link take}, {@link takeUntil}, {@link first}, or {@link takeWhile},
- * as it can be used to restart a source again from scratch.
- *
- * Repeat is very similar to {@link retry}, where {@link retry} will resubscribe to the source in the error case, but
- * `repeat` will resubscribe if the source completes.
- *
- * Note that `repeat` will _not_ catch errors. Use {@link retry} for that.
- *
- * - `repeat(0)` returns an empty observable
- * - `repeat()` will repeat forever
- * - `repeat({ delay: 200 })` will repeat forever, with a delay of 200ms between repetitions.
- * - `repeat({ count: 2, delay: 400 })` will repeat twice, with a delay of 400ms between repetitions.
- * - `repeat({ delay: (count) => timer(count * 1000) })` will repeat forever, but will have a delay that grows by one second for each repetition.
- *
- * ## Example
- *
- * Repeat a message stream
- *
- * ```ts
- * import { of, repeat } from 'rxjs';
- *
- * const source = of('Repeat message');
- * const result = source.pipe(repeat(3));
- *
- * result.subscribe(x => console.log(x));
- *
- * // Results
- * // 'Repeat message'
- * // 'Repeat message'
- * // 'Repeat message'
- * ```
- *
- * Repeat 3 values, 2 times
- *
- * ```ts
- * import { interval, take, repeat } from 'rxjs';
- *
- * const source = interval(1000);
- * const result = source.pipe(take(3), repeat(2));
- *
- * result.subscribe(x => console.log(x));
- *
- * // Results every second
- * // 0
- * // 1
- * // 2
- * // 0
- * // 1
- * // 2
- * ```
- *
- * Defining two complex repeats with delays on the same source.
- * Note that the second repeat cannot be called until the first
- * repeat as exhausted it's count.
- *
- * ```ts
- * import { defer, of, repeat } from 'rxjs';
- *
- * const source = defer(() => {
- *    return of(`Hello, it is ${new Date()}`)
- * });
- *
- * source.pipe(
- *    // Repeat 3 times with a delay of 1 second between repetitions
- *    repeat({
- *      count: 3,
- *      delay: 1000,
- *    }),
- *
- *    // *Then* repeat forever, but with an exponential step-back
- *    // maxing out at 1 minute.
- *    repeat({
- *      delay: (count) => timer(Math.min(60000, 2 ^ count * 1000))
- *    })
- * )
- * ```
- *
- * @see {@link repeatWhen}
- * @see {@link retry}
- *
- * @param countOrConfig Either the number of times the source Observable items are repeated
- * (a count of 0 will yield an empty Observable) or a {@link RepeatConfig} object.
- */
-export function repeat<T>(countOrConfig?: number | RepeatConfig): MonoTypeOperatorFunction<T> {
-  let count = Infinity;
-  let delay: RepeatConfig['delay'];
-
-  if (countOrConfig != null) {
-    if (typeof countOrConfig === 'object') {
-      ({ count = Infinity, delay } = countOrConfig);
-    } else {
-      count = countOrConfig;
-    }
-  }
-
-  return count <= 0
-    ? () => EMPTY
-    : operate((source, subscriber) => {
-        let soFar = 0;
-        let sourceSub: Subscription | null;
-
-        const resubscribe = () => {
-          sourceSub?.unsubscribe();
-          sourceSub = null;
-          if (delay != null) {
-            const notifier = typeof delay === 'number' ? timer(delay) : innerFrom(delay(soFar));
-            const notifierSubscriber = createOperatorSubscriber(subscriber, () => {
-              notifierSubscriber.unsubscribe();
-              subscribeToSource();
-            });
-            notifier.subscribe(notifierSubscriber);
-          } else {
-            subscribeToSource();
-          }
-        };
-
-        const subscribeToSource = () => {
-          let syncUnsub = false;
-          sourceSub = source.subscribe(
-            createOperatorSubscriber(subscriber, undefined, () => {
-              if (++soFar < count) {
-                if (sourceSub) {
-                  resubscribe();
-                } else {
-                  syncUnsub = true;
-                }
-              } else {
-                subscriber.complete();
-              }
-            })
-          );
-
-          if (syncUnsub) {
-            resubscribe();
-          }
-        };
-
-        subscribeToSource();
-      });
-}