appiq-solution 1.0.0

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

@@ -0,0 +1,288 @@
+import { Observable } from '../Observable';
+import { innerFrom } from '../observable/innerFrom';
+import { Subject } from '../Subject';
+import { ObservableInput, Observer, OperatorFunction, SubjectLike } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber, OperatorSubscriber } from './OperatorSubscriber';
+
+export interface BasicGroupByOptions<K, T> {
+  element?: undefined;
+  duration?: (grouped: GroupedObservable<K, T>) => ObservableInput<any>;
+  connector?: () => SubjectLike<T>;
+}
+
+export interface GroupByOptionsWithElement<K, E, T> {
+  element: (value: T) => E;
+  duration?: (grouped: GroupedObservable<K, E>) => ObservableInput<any>;
+  connector?: () => SubjectLike<E>;
+}
+
+export function groupBy<T, K>(key: (value: T) => K, options: BasicGroupByOptions<K, T>): OperatorFunction<T, GroupedObservable<K, T>>;
+
+export function groupBy<T, K, E>(
+  key: (value: T) => K,
+  options: GroupByOptionsWithElement<K, E, T>
+): OperatorFunction<T, GroupedObservable<K, E>>;
+
+export function groupBy<T, K extends T>(
+  key: (value: T) => value is K
+): OperatorFunction<T, GroupedObservable<true, K> | GroupedObservable<false, Exclude<T, K>>>;
+
+export function groupBy<T, K>(key: (value: T) => K): OperatorFunction<T, GroupedObservable<K, T>>;
+
+/**
+ * @deprecated use the options parameter instead.
+ */
+export function groupBy<T, K>(
+  key: (value: T) => K,
+  element: void,
+  duration: (grouped: GroupedObservable<K, T>) => Observable<any>
+): OperatorFunction<T, GroupedObservable<K, T>>;
+
+/**
+ * @deprecated use the options parameter instead.
+ */
+export function groupBy<T, K, R>(
+  key: (value: T) => K,
+  element?: (value: T) => R,
+  duration?: (grouped: GroupedObservable<K, R>) => Observable<any>
+): OperatorFunction<T, GroupedObservable<K, R>>;
+
+/**
+ * Groups the items emitted by an Observable according to a specified criterion,
+ * and emits these grouped items as `GroupedObservables`, one
+ * {@link GroupedObservable} per group.
+ *
+ * ![](groupBy.png)
+ *
+ * When the Observable emits an item, a key is computed for this item with the key function.
+ *
+ * If a {@link GroupedObservable} for this key exists, this {@link GroupedObservable} emits. Otherwise, a new
+ * {@link GroupedObservable} for this key is created and emits.
+ *
+ * A {@link GroupedObservable} represents values belonging to the same group represented by a common key. The common
+ * key is available as the `key` field of a {@link GroupedObservable} instance.
+ *
+ * The elements emitted by {@link GroupedObservable}s are by default the items emitted by the Observable, or elements
+ * returned by the element function.
+ *
+ * ## Examples
+ *
+ * Group objects by `id` and return as array
+ *
+ * ```ts
+ * import { of, groupBy, mergeMap, reduce } from 'rxjs';
+ *
+ * of(
+ *   { id: 1, name: 'JavaScript' },
+ *   { id: 2, name: 'Parcel' },
+ *   { id: 2, name: 'webpack' },
+ *   { id: 1, name: 'TypeScript' },
+ *   { id: 3, name: 'TSLint' }
+ * ).pipe(
+ *   groupBy(p => p.id),
+ *   mergeMap(group$ => group$.pipe(reduce((acc, cur) => [...acc, cur], [])))
+ * )
+ * .subscribe(p => console.log(p));
+ *
+ * // displays:
+ * // [{ id: 1, name: 'JavaScript' }, { id: 1, name: 'TypeScript'}]
+ * // [{ id: 2, name: 'Parcel' }, { id: 2, name: 'webpack'}]
+ * // [{ id: 3, name: 'TSLint' }]
+ * ```
+ *
+ * Pivot data on the `id` field
+ *
+ * ```ts
+ * import { of, groupBy, mergeMap, reduce, map } from 'rxjs';
+ *
+ * of(
+ *   { id: 1, name: 'JavaScript' },
+ *   { id: 2, name: 'Parcel' },
+ *   { id: 2, name: 'webpack' },
+ *   { id: 1, name: 'TypeScript' },
+ *   { id: 3, name: 'TSLint' }
+ * ).pipe(
+ *   groupBy(p => p.id, { element: p => p.name }),
+ *   mergeMap(group$ => group$.pipe(reduce((acc, cur) => [...acc, cur], [`${ group$.key }`]))),
+ *   map(arr => ({ id: parseInt(arr[0], 10), values: arr.slice(1) }))
+ * )
+ * .subscribe(p => console.log(p));
+ *
+ * // displays:
+ * // { id: 1, values: [ 'JavaScript', 'TypeScript' ] }
+ * // { id: 2, values: [ 'Parcel', 'webpack' ] }
+ * // { id: 3, values: [ 'TSLint' ] }
+ * ```
+ *
+ * @param key A function that extracts the key
+ * for each item.
+ * @param element A function that extracts the
+ * return element for each item.
+ * @param duration
+ * A function that returns an Observable to determine how long each group should
+ * exist.
+ * @param connector Factory function to create an
+ * intermediate Subject through which grouped elements are emitted.
+ * @return A function that returns an Observable that emits GroupedObservables,
+ * each of which corresponds to a unique key value and each of which emits
+ * those items from the source Observable that share that key value.
+ *
+ * @deprecated Use the options parameter instead.
+ */
+export function groupBy<T, K, R>(
+  key: (value: T) => K,
+  element?: (value: T) => R,
+  duration?: (grouped: GroupedObservable<K, R>) => Observable<any>,
+  connector?: () => Subject<R>
+): OperatorFunction<T, GroupedObservable<K, R>>;
+
+// Impl
+export function groupBy<T, K, R>(
+  keySelector: (value: T) => K,
+  elementOrOptions?: ((value: any) => any) | void | BasicGroupByOptions<K, T> | GroupByOptionsWithElement<K, R, T>,
+  duration?: (grouped: GroupedObservable<any, any>) => ObservableInput<any>,
+  connector?: () => SubjectLike<any>
+): OperatorFunction<T, GroupedObservable<K, R>> {
+  return operate((source, subscriber) => {
+    let element: ((value: any) => any) | void;
+    if (!elementOrOptions || typeof elementOrOptions === 'function') {
+      element = elementOrOptions as ((value: any) => any);
+    } else {
+      ({ duration, element, connector } = elementOrOptions);
+    }
+
+    // A lookup for the groups that we have so far.
+    const groups = new Map<K, SubjectLike<any>>();
+
+    // Used for notifying all groups and the subscriber in the same way.
+    const notify = (cb: (group: Observer<any>) => void) => {
+      groups.forEach(cb);
+      cb(subscriber);
+    };
+
+    // Used to handle errors from the source, AND errors that occur during the
+    // next call from the source.
+    const handleError = (err: any) => notify((consumer) => consumer.error(err));
+
+    // The number of actively subscribed groups
+    let activeGroups = 0;
+
+    // Whether or not teardown was attempted on this subscription.
+    let teardownAttempted = false;
+
+    // Capturing a reference to this, because we need a handle to it
+    // in `createGroupedObservable` below. This is what we use to
+    // subscribe to our source observable. This sometimes needs to be unsubscribed
+    // out-of-band with our `subscriber` which is the downstream subscriber, or destination,
+    // in cases where a user unsubscribes from the main resulting subscription, but
+    // still has groups from this subscription subscribed and would expect values from it
+    // Consider:  `source.pipe(groupBy(fn), take(2))`.
+    const groupBySourceSubscriber = new OperatorSubscriber(
+      subscriber,
+      (value: T) => {
+        // Because we have to notify all groups of any errors that occur in here,
+        // we have to add our own try/catch to ensure that those errors are propagated.
+        // OperatorSubscriber will only send the error to the main subscriber.
+        try {
+          const key = keySelector(value);
+
+          let group = groups.get(key);
+          if (!group) {
+            // Create our group subject
+            groups.set(key, (group = connector ? connector() : new Subject<any>()));
+
+            // Emit the grouped observable. Note that we can't do a simple `asObservable()` here,
+            // because the grouped observable has special semantics around reference counting
+            // to ensure we don't sever our connection to the source prematurely.
+            const grouped = createGroupedObservable(key, group);
+            subscriber.next(grouped);
+
+            if (duration) {
+              const durationSubscriber = createOperatorSubscriber(
+                // Providing the group here ensures that it is disposed of -- via `unsubscribe` --
+                // when the duration subscription is torn down. That is important, because then
+                // if someone holds a handle to the grouped observable and tries to subscribe to it
+                // after the connection to the source has been severed, they will get an
+                // `ObjectUnsubscribedError` and know they can't possibly get any notifications.
+                group as any,
+                () => {
+                  // Our duration notified! We can complete the group.
+                  // The group will be removed from the map in the finalization phase.
+                  group!.complete();
+                  durationSubscriber?.unsubscribe();
+                },
+                // Completions are also sent to the group, but just the group.
+                undefined,
+                // Errors on the duration subscriber are sent to the group
+                // but only the group. They are not sent to the main subscription.
+                undefined,
+                // Finalization: Remove this group from our map.
+                () => groups.delete(key)
+              );
+
+              // Start our duration notifier.
+              groupBySourceSubscriber.add(innerFrom(duration(grouped)).subscribe(durationSubscriber));
+            }
+          }
+
+          // Send the value to our group.
+          group.next(element ? element(value) : value);
+        } catch (err) {
+          handleError(err);
+        }
+      },
+      // Source completes.
+      () => notify((consumer) => consumer.complete()),
+      // Error from the source.
+      handleError,
+      // Free up memory.
+      // When the source subscription is _finally_ torn down, release the subjects and keys
+      // in our groups Map, they may be quite large and we don't want to keep them around if we
+      // don't have to.
+      () => groups.clear(),
+      () => {
+        teardownAttempted = true;
+        // We only kill our subscription to the source if we have
+        // no active groups. As stated above, consider this scenario:
+        // source$.pipe(groupBy(fn), take(2)).
+        return activeGroups === 0;
+      }
+    );
+
+    // Subscribe to the source
+    source.subscribe(groupBySourceSubscriber);
+
+    /**
+     * Creates the actual grouped observable returned.
+     * @param key The key of the group
+     * @param groupSubject The subject that fuels the group
+     */
+    function createGroupedObservable(key: K, groupSubject: SubjectLike<any>) {
+      const result: any = new Observable<T>((groupSubscriber) => {
+        activeGroups++;
+        const innerSub = groupSubject.subscribe(groupSubscriber);
+        return () => {
+          innerSub.unsubscribe();
+          // We can kill the subscription to our source if we now have no more
+          // active groups subscribed, and a finalization was already attempted on
+          // the source.
+          --activeGroups === 0 && teardownAttempted && groupBySourceSubscriber.unsubscribe();
+        };
+      });
+      result.key = key;
+      return result;
+    }
+  });
+}
+
+/**
+ * An observable of values that is the emitted by the result of a {@link groupBy} operator,
+ * contains a `key` property for the grouping.
+ */
+export interface GroupedObservable<K, T> extends Observable<T> {
+  /**
+   * The key value for the grouped notifications.
+   */
+  readonly key: K;
+}

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

@@ -0,0 +1,45 @@
+import { OperatorFunction } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+import { noop } from '../util/noop';
+
+/**
+ * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`.
+ *
+ * ![](ignoreElements.png)
+ *
+ * The `ignoreElements` operator suppresses all items emitted by the source Observable,
+ * but allows its termination notification (either `error` or `complete`) to pass through unchanged.
+ *
+ * If you do not care about the items being emitted by an Observable, but you do want to be notified
+ * when it completes or when it terminates with an error, you can apply the `ignoreElements` operator
+ * to the Observable, which will ensure that it will never call its observers’ `next` handlers.
+ *
+ * ## Example
+ *
+ * Ignore all `next` emissions from the source
+ *
+ * ```ts
+ * import { of, ignoreElements } from 'rxjs';
+ *
+ * of('you', 'talking', 'to', 'me')
+ *   .pipe(ignoreElements())
+ *   .subscribe({
+ *     next: word => console.log(word),
+ *     error: err => console.log('error:', err),
+ *     complete: () => console.log('the end'),
+ *   });
+ *
+ * // result:
+ * // 'the end'
+ * ```
+ *
+ * @return A function that returns an empty Observable that only calls
+ * `complete` or `error`, based on which one is called by the source
+ * Observable.
+ */
+export function ignoreElements(): OperatorFunction<unknown, never> {
+  return operate((source, subscriber) => {
+    source.subscribe(createOperatorSubscriber(subscriber, noop));
+  });
+}

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

@@ -0,0 +1,82 @@
+import { OperatorFunction } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/**
+ * Emits `false` if the input Observable emits any values, or emits `true` if the
+ * input Observable completes without emitting any values.
+ *
+ * <span class="informal">Tells whether any values are emitted by an Observable.</span>
+ *
+ * ![](isEmpty.png)
+ *
+ * `isEmpty` transforms an Observable that emits values into an Observable that
+ * emits a single boolean value representing whether or not any values were
+ * emitted by the source Observable. As soon as the source Observable emits a
+ * value, `isEmpty` will emit a `false` and complete.  If the source Observable
+ * completes having not emitted anything, `isEmpty` will emit a `true` and
+ * complete.
+ *
+ * A similar effect could be achieved with {@link count}, but `isEmpty` can emit
+ * a `false` value sooner.
+ *
+ * ## Examples
+ *
+ * Emit `false` for a non-empty Observable
+ *
+ * ```ts
+ * import { Subject, isEmpty } from 'rxjs';
+ *
+ * const source = new Subject<string>();
+ * const result = source.pipe(isEmpty());
+ *
+ * source.subscribe(x => console.log(x));
+ * result.subscribe(x => console.log(x));
+ *
+ * source.next('a');
+ * source.next('b');
+ * source.next('c');
+ * source.complete();
+ *
+ * // Outputs
+ * // 'a'
+ * // false
+ * // 'b'
+ * // 'c'
+ * ```
+ *
+ * Emit `true` for an empty Observable
+ *
+ * ```ts
+ * import { EMPTY, isEmpty } from 'rxjs';
+ *
+ * const result = EMPTY.pipe(isEmpty());
+ * result.subscribe(x => console.log(x));
+ *
+ * // Outputs
+ * // true
+ * ```
+ *
+ * @see {@link count}
+ * @see {@link EMPTY}
+ *
+ * @return A function that returns an Observable that emits boolean value
+ * indicating whether the source Observable was empty or not.
+ */
+export function isEmpty<T>(): OperatorFunction<T, boolean> {
+  return operate((source, subscriber) => {
+    source.subscribe(
+      createOperatorSubscriber(
+        subscriber,
+        () => {
+          subscriber.next(false);
+          subscriber.complete();
+        },
+        () => {
+          subscriber.next(true);
+          subscriber.complete();
+        }
+      )
+    );
+  });
+}

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

@@ -0,0 +1,29 @@
+import { Observable } from '../Observable';
+import { ObservableInput, OperatorFunction } from '../types';
+import { identity } from '../util/identity';
+import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs';
+import { pipe } from '../util/pipe';
+import { mergeMap } from './mergeMap';
+import { toArray } from './toArray';
+
+/**
+ * Collects all of the inner sources from source observable. Then, once the
+ * source completes, joins the values using the given static.
+ *
+ * This is used for {@link combineLatestAll} and {@link zipAll} which both have the
+ * same behavior of collecting all inner observables, then operating on them.
+ *
+ * @param joinFn The type of static join to apply to the sources collected
+ * @param project The projection function to apply to the values, if any
+ */
+export function joinAllInternals<T, R>(joinFn: (sources: ObservableInput<T>[]) => Observable<T>, project?: (...args: any[]) => R) {
+  return pipe(
+    // Collect all inner sources into an array, and emit them when the
+    // source completes.
+    toArray() as OperatorFunction<ObservableInput<T>, ObservableInput<T>[]>,
+    // Run the join function on the collected array of inner sources.
+    mergeMap((sources) => joinFn(sources)),
+    // If a projection function was supplied, apply it to each result.
+    project ? mapOneOrManyArgs(project) : (identity as any)
+  );
+}

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

@@ -0,0 +1,91 @@
+import { Observable } from '../Observable';
+import { EmptyError } from '../util/EmptyError';
+import { OperatorFunction, TruthyTypesOf } from '../types';
+import { filter } from './filter';
+import { takeLast } from './takeLast';
+import { throwIfEmpty } from './throwIfEmpty';
+import { defaultIfEmpty } from './defaultIfEmpty';
+import { identity } from '../util/identity';
+
+export function last<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
+export function last<T, D>(predicate: BooleanConstructor, defaultValue: D): OperatorFunction<T, TruthyTypesOf<T> | D>;
+export function last<T, D = T>(predicate?: null, defaultValue?: D): OperatorFunction<T, T | D>;
+export function last<T, S extends T>(
+  predicate: (value: T, index: number, source: Observable<T>) => value is S,
+  defaultValue?: S
+): OperatorFunction<T, S>;
+export function last<T, D = T>(
+  predicate: (value: T, index: number, source: Observable<T>) => boolean,
+  defaultValue?: D
+): OperatorFunction<T, T | D>;
+
+/**
+ * Returns an Observable that emits only the last item emitted by the source Observable.
+ * It optionally takes a predicate function as a parameter, in which case, rather than emitting
+ * the last item from the source Observable, the resulting Observable will emit the last item
+ * from the source Observable that satisfies the predicate.
+ *
+ * ![](last.png)
+ *
+ * It will emit an error notification if the source completes without notification or one that matches
+ * the predicate. It returns the last value or if a predicate is provided last value that matches the
+ * predicate. It returns the given default value if no notification is emitted or matches the predicate.
+ *
+ * ## Examples
+ *
+ * Last alphabet from the sequence
+ *
+ * ```ts
+ * import { from, last } from 'rxjs';
+ *
+ * const source = from(['x', 'y', 'z']);
+ * const result = source.pipe(last());
+ *
+ * result.subscribe(value => console.log(`Last alphabet: ${ value }`));
+ *
+ * // Outputs
+ * // Last alphabet: z
+ * ```
+ *
+ * Default value when the value in the predicate is not matched
+ *
+ * ```ts
+ * import { from, last } from 'rxjs';
+ *
+ * const source = from(['x', 'y', 'z']);
+ * const result = source.pipe(last(char => char === 'a', 'not found'));
+ *
+ * result.subscribe(value => console.log(`'a' is ${ value }.`));
+ *
+ * // Outputs
+ * // 'a' is not found.
+ * ```
+ *
+ * @see {@link skip}
+ * @see {@link skipUntil}
+ * @see {@link skipLast}
+ * @see {@link skipWhile}
+ * @see {@link first}
+ *
+ * @throws {EmptyError} Delivers an `EmptyError` to the Observer's `error`
+ * callback if the Observable completes before any `next` notification was sent.
+ *
+ * @param predicate The condition any source emitted item has to satisfy.
+ * @param defaultValue An optional default value to provide if last `predicate`
+ * isn't met or no values were emitted.
+ * @return A function that returns an Observable that emits only the last item
+ * satisfying the given condition from the source, or an error notification
+ * with an `EmptyError` object if no such items are emitted.
+ */
+export function last<T, D>(
+  predicate?: ((value: T, index: number, source: Observable<T>) => boolean) | null,
+  defaultValue?: D
+): OperatorFunction<T, T | D> {
+  const hasDefaultValue = arguments.length >= 2;
+  return (source: Observable<T>) =>
+    source.pipe(
+      predicate ? filter((v, i) => predicate(v, i, source)) : identity,
+      takeLast(1),
+      hasDefaultValue ? defaultIfEmpty(defaultValue!) : throwIfEmpty(() => new EmptyError())
+    );
+}

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

@@ -0,0 +1,61 @@
+import { OperatorFunction } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+export function map<T, R>(project: (value: T, index: number) => R): OperatorFunction<T, R>;
+/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
+export function map<T, R, A>(project: (this: A, value: T, index: number) => R, thisArg: A): OperatorFunction<T, R>;
+
+/**
+ * Applies a given `project` function to each value emitted by the source
+ * Observable, and emits the resulting values as an Observable.
+ *
+ * <span class="informal">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),
+ * it passes each source value through a transformation function to get
+ * corresponding output values.</span>
+ *
+ * ![](map.png)
+ *
+ * Similar to the well known `Array.prototype.map` function, this operator
+ * applies a projection to each value and emits that projection in the output
+ * Observable.
+ *
+ * ## Example
+ *
+ * Map every click to the `clientX` position of that click
+ *
+ * ```ts
+ * import { fromEvent, map } from 'rxjs';
+ *
+ * const clicks = fromEvent<PointerEvent>(document, 'click');
+ * const positions = clicks.pipe(map(ev => ev.clientX));
+ *
+ * positions.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link mapTo}
+ * @see {@link pluck}
+ *
+ * @param project The function to apply to each `value` emitted by the source
+ * Observable. The `index` parameter is the number `i` for the i-th emission
+ * that has happened since the subscription, starting from the number `0`.
+ * @param thisArg An optional argument to define what `this` is in the
+ * `project` function.
+ * @return A function that returns an Observable that emits the values from the
+ * source Observable transformed by the given `project` function.
+ */
+export function map<T, R>(project: (value: T, index: number) => R, thisArg?: any): OperatorFunction<T, R> {
+  return operate((source, subscriber) => {
+    // The index of the value from the source. Used with projection.
+    let index = 0;
+    // Subscribe to the source, all errors and completions are sent along
+    // to the consumer.
+    source.subscribe(
+      createOperatorSubscriber(subscriber, (value: T) => {
+        // Call the projection function with the appropriate this context,
+        // and send the resulting value to the consumer.
+        subscriber.next(project.call(thisArg, value, index++));
+      })
+    );
+  });
+}

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

@@ -0,0 +1,48 @@
+import { OperatorFunction } from '../types';
+import { map } from './map';
+
+/** @deprecated To be removed in v9. Use {@link map} instead: `map(() => value)`. */
+export function mapTo<R>(value: R): OperatorFunction<unknown, R>;
+/**
+ * @deprecated Do not specify explicit type parameters. Signatures with type parameters
+ * that cannot be inferred will be removed in v8. `mapTo` itself will be removed in v9,
+ * use {@link map} instead: `map(() => value)`.
+ * */
+export function mapTo<T, R>(value: R): OperatorFunction<T, R>;
+
+/**
+ * Emits the given constant value on the output Observable every time the source
+ * Observable emits a value.
+ *
+ * <span class="informal">Like {@link map}, but it maps every source value to
+ * the same output value every time.</span>
+ *
+ * ![](mapTo.png)
+ *
+ * Takes a constant `value` as argument, and emits that whenever the source
+ * Observable emits a value. In other words, ignores the actual source value,
+ * and simply uses the emission moment to know when to emit the given `value`.
+ *
+ * ## Example
+ *
+ * Map every click to the string `'Hi'`
+ *
+ * ```ts
+ * import { fromEvent, mapTo } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const greetings = clicks.pipe(mapTo('Hi'));
+ *
+ * greetings.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link map}
+ *
+ * @param value The value to map each source value to.
+ * @return A function that returns an Observable that emits the given `value`
+ * every time the source Observable emits.
+ * @deprecated To be removed in v9. Use {@link map} instead: `map(() => value)`.
+ */
+export function mapTo<R>(value: R): OperatorFunction<unknown, R> {
+  return map(() => value);
+}