appiq-solution 1.0.0

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

@@ -0,0 +1,403 @@
+import { asyncScheduler } from '../scheduler/async';
+import { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
+import { isValidDate } from '../util/isDate';
+import { Subscription } from '../Subscription';
+import { operate } from '../util/lift';
+import { Observable } from '../Observable';
+import { innerFrom } from '../observable/innerFrom';
+import { createErrorClass } from '../util/createErrorClass';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+import { executeSchedule } from '../util/executeSchedule';
+
+export interface TimeoutConfig<T, O extends ObservableInput<unknown> = ObservableInput<T>, M = unknown> {
+  /**
+   * The time allowed between values from the source before timeout is triggered.
+   */
+  each?: number;
+
+  /**
+   * The relative time as a `number` in milliseconds, or a specific time as a `Date` object,
+   * by which the first value must arrive from the source before timeout is triggered.
+   */
+  first?: number | Date;
+
+  /**
+   * The scheduler to use with time-related operations within this operator. Defaults to {@link asyncScheduler}
+   */
+  scheduler?: SchedulerLike;
+
+  /**
+   * A factory used to create observable to switch to when timeout occurs. Provides
+   * a {@link TimeoutInfo} about the source observable's emissions and what delay or
+   * exact time triggered the timeout.
+   */
+  with?: (info: TimeoutInfo<T, M>) => O;
+
+  /**
+   * Optional additional metadata you can provide to code that handles
+   * the timeout, will be provided through the {@link TimeoutError}.
+   * This can be used to help identify the source of a timeout or pass along
+   * other information related to the timeout.
+   */
+  meta?: M;
+}
+
+export interface TimeoutInfo<T, M = unknown> {
+  /** Optional metadata that was provided to the timeout configuration. */
+  readonly meta: M;
+  /** The number of messages seen before the timeout */
+  readonly seen: number;
+  /** The last message seen */
+  readonly lastValue: T | null;
+}
+
+/**
+ * An error emitted when a timeout occurs.
+ */
+export interface TimeoutError<T = unknown, M = unknown> extends Error {
+  /**
+   * The information provided to the error by the timeout
+   * operation that created the error. Will be `null` if
+   * used directly in non-RxJS code with an empty constructor.
+   * (Note that using this constructor directly is not recommended,
+   * you should create your own errors)
+   */
+  info: TimeoutInfo<T, M> | null;
+}
+
+export interface TimeoutErrorCtor {
+  /**
+   * @deprecated Internal implementation detail. Do not construct error instances.
+   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+   */
+  new <T = unknown, M = unknown>(info?: TimeoutInfo<T, M>): TimeoutError<T, M>;
+}
+
+/**
+ * An error thrown by the {@link timeout} operator.
+ *
+ * Provided so users can use as a type and do quality comparisons.
+ * We recommend you do not subclass this or create instances of this class directly.
+ * If you have need of a error representing a timeout, you should
+ * create your own error class and use that.
+ *
+ * @see {@link timeout}
+ */
+export const TimeoutError: TimeoutErrorCtor = createErrorClass(
+  (_super) =>
+    function TimeoutErrorImpl(this: any, info: TimeoutInfo<any> | null = null) {
+      _super(this);
+      this.message = 'Timeout has occurred';
+      this.name = 'TimeoutError';
+      this.info = info;
+    }
+);
+
+/**
+ * If `with` is provided, this will return an observable that will switch to a different observable if the source
+ * does not push values within the specified time parameters.
+ *
+ * <span class="informal">The most flexible option for creating a timeout behavior.</span>
+ *
+ * The first thing to know about the configuration is if you do not provide a `with` property to the configuration,
+ * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory
+ * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by
+ * the settings in `first` and `each`.
+ *
+ * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the
+ * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of
+ * the first value from the source _only_. The timings of all subsequent values  from the source will be checked
+ * against the time period provided by `each`, if it was provided.
+ *
+ * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of
+ * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if
+ * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first
+ * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first.
+ *
+ * ## Examples
+ *
+ * Emit a custom error if there is too much time between values
+ *
+ * ```ts
+ * import { interval, timeout, throwError } from 'rxjs';
+ *
+ * class CustomTimeoutError extends Error {
+ *   constructor() {
+ *     super('It was too slow');
+ *     this.name = 'CustomTimeoutError';
+ *   }
+ * }
+ *
+ * const slow$ = interval(900);
+ *
+ * slow$.pipe(
+ *   timeout({
+ *     each: 1000,
+ *     with: () => throwError(() => new CustomTimeoutError())
+ *   })
+ * )
+ * .subscribe({
+ *   error: console.error
+ * });
+ * ```
+ *
+ * Switch to a faster observable if your source is slow.
+ *
+ * ```ts
+ * import { interval, timeout } from 'rxjs';
+ *
+ * const slow$ = interval(900);
+ * const fast$ = interval(500);
+ *
+ * slow$.pipe(
+ *   timeout({
+ *     each: 1000,
+ *     with: () => fast$,
+ *   })
+ * )
+ * .subscribe(console.log);
+ * ```
+ * @param config The configuration for the timeout.
+ */
+export function timeout<T, O extends ObservableInput<unknown>, M = unknown>(
+  config: TimeoutConfig<T, O, M> & { with: (info: TimeoutInfo<T, M>) => O }
+): OperatorFunction<T, T | ObservedValueOf<O>>;
+
+/**
+ * Returns an observable that will error or switch to a different observable if the source does not push values
+ * within the specified time parameters.
+ *
+ * <span class="informal">The most flexible option for creating a timeout behavior.</span>
+ *
+ * The first thing to know about the configuration is if you do not provide a `with` property to the configuration,
+ * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory
+ * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by
+ * the settings in `first` and `each`.
+ *
+ * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the
+ * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of
+ * the first value from the source _only_. The timings of all subsequent values  from the source will be checked
+ * against the time period provided by `each`, if it was provided.
+ *
+ * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of
+ * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if
+ * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first
+ * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first.
+ *
+ * ### Handling TimeoutErrors
+ *
+ * If no `with` property was provided, subscriptions to the resulting observable may emit an error of {@link TimeoutError}.
+ * The timeout error provides useful information you can examine when you're handling the error. The most common way to handle
+ * the error would be with {@link catchError}, although you could use {@link tap} or just the error handler in your `subscribe` call
+ * directly, if your error handling is only a side effect (such as notifying the user, or logging).
+ *
+ * In this case, you would check the error for `instanceof TimeoutError` to validate that the error was indeed from `timeout`, and
+ * not from some other source. If it's not from `timeout`, you should probably rethrow it if you're in a `catchError`.
+ *
+ * ## Examples
+ *
+ * Emit a {@link TimeoutError} if the first value, and _only_ the first value, does not arrive within 5 seconds
+ *
+ * ```ts
+ * import { interval, timeout } from 'rxjs';
+ *
+ * // A random interval that lasts between 0 and 10 seconds per tick
+ * const source$ = interval(Math.round(Math.random() * 10_000));
+ *
+ * source$.pipe(
+ *   timeout({ first: 5_000 })
+ * )
+ * .subscribe({
+ *   next: console.log,
+ *   error: console.error
+ * });
+ * ```
+ *
+ * Emit a {@link TimeoutError} if the source waits longer than 5 seconds between any two values or the first value
+ * and subscription.
+ *
+ * ```ts
+ * import { timer, timeout, expand } from 'rxjs';
+ *
+ * const getRandomTime = () => Math.round(Math.random() * 10_000);
+ *
+ * // An observable that waits a random amount of time between each delivered value
+ * const source$ = timer(getRandomTime())
+ *   .pipe(expand(() => timer(getRandomTime())));
+ *
+ * source$
+ *   .pipe(timeout({ each: 5_000 }))
+ *   .subscribe({
+ *     next: console.log,
+ *     error: console.error
+ *   });
+ * ```
+ *
+ * Emit a {@link TimeoutError} if the source does not emit before 7 seconds, _or_ if the source waits longer than
+ * 5 seconds between any two values after the first.
+ *
+ * ```ts
+ * import { timer, timeout, expand } from 'rxjs';
+ *
+ * const getRandomTime = () => Math.round(Math.random() * 10_000);
+ *
+ * // An observable that waits a random amount of time between each delivered value
+ * const source$ = timer(getRandomTime())
+ *   .pipe(expand(() => timer(getRandomTime())));
+ *
+ * source$
+ *   .pipe(timeout({ first: 7_000, each: 5_000 }))
+ *   .subscribe({
+ *     next: console.log,
+ *     error: console.error
+ *   });
+ * ```
+ */
+export function timeout<T, M = unknown>(config: Omit<TimeoutConfig<T, any, M>, 'with'>): OperatorFunction<T, T>;
+
+/**
+ * Returns an observable that will error if the source does not push its first value before the specified time passed as a `Date`.
+ * This is functionally the same as `timeout({ first: someDate })`.
+ *
+ * <span class="informal">Errors if the first value doesn't show up before the given date and time</span>
+ *
+ * ![](timeout.png)
+ *
+ * @param first The date to at which the resulting observable will timeout if the source observable
+ * does not emit at least one value.
+ * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}.
+ */
+export function timeout<T>(first: Date, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+
+/**
+ * Returns an observable that will error if the source does not push a value within the specified time in milliseconds.
+ * This is functionally the same as `timeout({ each: milliseconds })`.
+ *
+ * <span class="informal">Errors if it waits too long between any value</span>
+ *
+ * ![](timeout.png)
+ *
+ * @param each The time allowed between each pushed value from the source before the resulting observable
+ * will timeout.
+ * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}.
+ */
+export function timeout<T>(each: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+
+/**
+ *
+ * Errors if Observable does not emit a value in given time span.
+ *
+ * <span class="informal">Timeouts on Observable that doesn't emit values fast enough.</span>
+ *
+ * ![](timeout.png)
+ *
+ * @see {@link timeoutWith}
+ *
+ * @return A function that returns an Observable that mirrors behaviour of the
+ * source Observable, unless timeout happens when it throws an error.
+ */
+export function timeout<T, O extends ObservableInput<any>, M>(
+  config: number | Date | TimeoutConfig<T, O, M>,
+  schedulerArg?: SchedulerLike
+): OperatorFunction<T, T | ObservedValueOf<O>> {
+  // Intentionally terse code.
+  // If the first argument is a valid `Date`, then we use it as the `first` config.
+  // Otherwise, if the first argument is a `number`, then we use it as the `each` config.
+  // Otherwise, it can be assumed the first argument is the configuration object itself, and
+  // we destructure that into what we're going to use, setting important defaults as we do.
+  // NOTE: The default for `scheduler` will be the `scheduler` argument if it exists, or
+  // it will default to the `asyncScheduler`.
+  const {
+    first,
+    each,
+    with: _with = timeoutErrorFactory,
+    scheduler = schedulerArg ?? asyncScheduler,
+    meta = null!,
+  } = (isValidDate(config) ? { first: config } : typeof config === 'number' ? { each: config } : config) as TimeoutConfig<T, O, M>;
+
+  if (first == null && each == null) {
+    // Ensure timeout was provided at runtime.
+    throw new TypeError('No timeout provided.');
+  }
+
+  return operate((source, subscriber) => {
+    // This subscription encapsulates our subscription to the
+    // source for this operator. We're capturing it separately,
+    // because if there is a `with` observable to fail over to,
+    // we want to unsubscribe from our original subscription, and
+    // hand of the subscription to that one.
+    let originalSourceSubscription: Subscription;
+    // The subscription for our timeout timer. This changes
+    // every time we get a new value.
+    let timerSubscription: Subscription;
+    // A bit of state we pass to our with and error factories to
+    // tell what the last value we saw was.
+    let lastValue: T | null = null;
+    // A bit of state we pass to the with and error factories to
+    // tell how many values we have seen so far.
+    let seen = 0;
+    const startTimer = (delay: number) => {
+      timerSubscription = executeSchedule(
+        subscriber,
+        scheduler,
+        () => {
+          try {
+            originalSourceSubscription.unsubscribe();
+            innerFrom(
+              _with!({
+                meta,
+                lastValue,
+                seen,
+              })
+            ).subscribe(subscriber);
+          } catch (err) {
+            subscriber.error(err);
+          }
+        },
+        delay
+      );
+    };
+
+    originalSourceSubscription = source.subscribe(
+      createOperatorSubscriber(
+        subscriber,
+        (value: T) => {
+          // clear the timer so we can emit and start another one.
+          timerSubscription?.unsubscribe();
+          seen++;
+          // Emit
+          subscriber.next((lastValue = value));
+          // null | undefined are both < 0. Thanks, JavaScript.
+          each! > 0 && startTimer(each!);
+        },
+        undefined,
+        undefined,
+        () => {
+          if (!timerSubscription?.closed) {
+            timerSubscription?.unsubscribe();
+          }
+          // Be sure not to hold the last value in memory after unsubscription
+          // it could be quite large.
+          lastValue = null;
+        }
+      )
+    );
+
+    // Intentionally terse code.
+    // If we've `seen` a value, that means the "first" clause was met already, if it existed.
+    //   it also means that a timer was already started for "each" (in the next handler above).
+    // If `first` was provided, and it's a number, then use it.
+    // If `first` was provided and it's not a number, it's a Date, and we get the difference between it and "now".
+    // If `first` was not provided at all, then our first timer will be the value from `each`.
+    !seen && startTimer(first != null ? (typeof first === 'number' ? first : +first - scheduler!.now()) : each!);
+  });
+}
+
+/**
+ * The default function to use to emit an error when timeout occurs and a `with` function
+ * is not specified.
+ * @param info The information about the timeout to pass along to the error
+ */
+function timeoutErrorFactory(info: TimeoutInfo<any>): Observable<never> {
+  throw new TimeoutError(info);
+}

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

@@ -0,0 +1,116 @@
+import { async } from '../scheduler/async';
+import { isValidDate } from '../util/isDate';
+import { ObservableInput, OperatorFunction, SchedulerLike } from '../types';
+import { timeout } from './timeout';
+
+/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(someDate, a$, scheduler)`, use the configuration object
+ * `timeout({ first: someDate, with: () => a$, scheduler })`. Will be removed in v8. */
+export function timeoutWith<T, R>(dueBy: Date, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>;
+/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(100, a$, scheduler)`, use the configuration object
+ *  `timeout({ each: 100, with: () => a$, scheduler })`. Will be removed in v8. */
+export function timeoutWith<T, R>(waitFor: number, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>;
+
+/**
+ * When the passed timespan elapses before the source emits any given value, it will unsubscribe from the source,
+ * and switch the subscription to another observable.
+ *
+ * <span class="informal">Used to switch to a different observable if your source is being slow.</span>
+ *
+ * Useful in cases where:
+ *
+ * - You want to switch to a different source that may be faster.
+ * - You want to notify a user that the data stream is slow.
+ * - You want to emit a custom error rather than the {@link TimeoutError} emitted
+ *   by the default usage of {@link timeout}.
+ *
+ * If the first parameter is passed as Date and the time of the Date arrives before the first value arrives from the source,
+ * it will unsubscribe from the source and switch the subscription to another observable.
+ *
+ * <span class="informal">Use Date object to switch to a different observable if the first value doesn't arrive by a specific time.</span>
+ *
+ * Can be used to set a timeout only for the first value, however it's recommended to use the {@link timeout} operator with
+ * the `first` configuration to get the same effect.
+ *
+ * ## Examples
+ *
+ * Fallback to a faster observable
+ *
+ * ```ts
+ * import { interval, timeoutWith } from 'rxjs';
+ *
+ * const slow$ = interval(1000);
+ * const faster$ = interval(500);
+ *
+ * slow$
+ *   .pipe(timeoutWith(900, faster$))
+ *   .subscribe(console.log);
+ * ```
+ *
+ * Emit your own custom timeout error
+ *
+ * ```ts
+ * import { interval, timeoutWith, throwError } from 'rxjs';
+ *
+ * class CustomTimeoutError extends Error {
+ *   constructor() {
+ *     super('It was too slow');
+ *     this.name = 'CustomTimeoutError';
+ *   }
+ * }
+ *
+ * const slow$ = interval(1000);
+ *
+ * slow$
+ *   .pipe(timeoutWith(900, throwError(() => new CustomTimeoutError())))
+ *   .subscribe({
+ *     error: err => console.error(err.message)
+ *   });
+ * ```
+ *
+ * @see {@link timeout}
+ *
+ * @param due When passed a number, used as the time (in milliseconds) allowed between each value from the source before timeout
+ * is triggered. When passed a Date, used as the exact time at which the timeout will be triggered if the first value does not arrive.
+ * @param withObservable The observable to switch to when timeout occurs.
+ * @param scheduler The scheduler to use with time-related operations within this operator. Defaults to {@link asyncScheduler}
+ * @return A function that returns an Observable that mirrors behaviour of the
+ * source Observable, unless timeout happens when it starts emitting values
+ * from the `ObservableInput` passed as a second parameter.
+ * @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(100, a$, scheduler)`, use {@link timeout} with the configuration
+ * object: `timeout({ each: 100, with: () => a$, scheduler })`. Instead of `timeoutWith(someDate, a$, scheduler)`, use {@link timeout}
+ * with the configuration object: `timeout({ first: someDate, with: () => a$, scheduler })`. Will be removed in v8.
+ */
+export function timeoutWith<T, R>(
+  due: number | Date,
+  withObservable: ObservableInput<R>,
+  scheduler?: SchedulerLike
+): OperatorFunction<T, T | R> {
+  let first: number | Date | undefined;
+  let each: number | undefined;
+  let _with: () => ObservableInput<R>;
+  scheduler = scheduler ?? async;
+
+  if (isValidDate(due)) {
+    first = due;
+  } else if (typeof due === 'number') {
+    each = due;
+  }
+
+  if (withObservable) {
+    _with = () => withObservable;
+  } else {
+    throw new TypeError('No observable provided to switch to');
+  }
+
+  if (first == null && each == null) {
+    // Ensure timeout was provided at runtime.
+    throw new TypeError('No timeout provided.');
+  }
+
+  return timeout<T, ObservableInput<R>>({
+    first,
+    each,
+    scheduler,
+    with: _with,
+  });
+}

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

@@ -0,0 +1,39 @@
+import { OperatorFunction, TimestampProvider, Timestamp } from '../types';
+import { dateTimestampProvider } from '../scheduler/dateTimestampProvider';
+import { map } from './map';
+
+/**
+ * Attaches a timestamp to each item emitted by an observable indicating when it was emitted
+ *
+ * The `timestamp` operator maps the *source* observable stream to an object of type
+ * `{value: T, timestamp: R}`. The properties are generically typed. The `value` property contains the value
+ * and type of the *source* observable. The `timestamp` is generated by the schedulers `now` function. By
+ * default, it uses the `asyncScheduler` which simply returns `Date.now()` (milliseconds since 1970/01/01
+ * 00:00:00:000) and therefore is of type `number`.
+ *
+ * ![](timestamp.png)
+ *
+ * ## Example
+ *
+ * In this example there is a timestamp attached to the document's click events
+ *
+ * ```ts
+ * import { fromEvent, timestamp } from 'rxjs';
+ *
+ * const clickWithTimestamp = fromEvent(document, 'click').pipe(
+ *   timestamp()
+ * );
+ *
+ * // Emits data of type { value: PointerEvent, timestamp: number }
+ * clickWithTimestamp.subscribe(data => {
+ *   console.log(data);
+ * });
+ * ```
+ *
+ * @param timestampProvider An object with a `now()` method used to get the current timestamp.
+ * @return A function that returns an Observable that attaches a timestamp to
+ * each item emitted by the source Observable indicating when it was emitted.
+ */
+export function timestamp<T>(timestampProvider: TimestampProvider = dateTimestampProvider): OperatorFunction<T, Timestamp<T>> {
+  return map((value: T) => ({ value, timestamp: timestampProvider.now() }));
+}

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

@@ -0,0 +1,44 @@
+import { reduce } from './reduce';
+import { OperatorFunction } from '../types';
+import { operate } from '../util/lift';
+
+const arrReducer = (arr: any[], value: any) => (arr.push(value), arr);
+
+/**
+ * Collects all source emissions and emits them as an array when the source completes.
+ *
+ * <span class="informal">Get all values inside an array when the source completes</span>
+ *
+ * ![](toArray.png)
+ *
+ * `toArray` will wait until the source Observable completes before emitting
+ * the array containing all emissions. When the source Observable errors no
+ * array will be emitted.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { interval, take, toArray } from 'rxjs';
+ *
+ * const source = interval(1000);
+ * const example = source.pipe(
+ *   take(10),
+ *   toArray()
+ * );
+ *
+ * example.subscribe(value => console.log(value));
+ *
+ * // output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * ```
+ *
+ * @return A function that returns an Observable that emits an array of items
+ * emitted by the source Observable when source completes.
+ */
+export function toArray<T>(): OperatorFunction<T, T[]> {
+  // Because arrays are mutable, and we're mutating the array in this
+  // reducer process, we have to encapsulate the creation of the initial
+  // array within this `operate` function.
+  return operate((source, subscriber) => {
+    reduce(arrReducer, [] as T[])(source).subscribe(subscriber);
+  });
+}