create-byan-agent 2.58.2 → 2.59.2

package/install/node_modules/rxjs/src/internal/operators/min.ts

@@ -1,54 +0,0 @@
-import { reduce } from './reduce';
-import { MonoTypeOperatorFunction } from '../types';
-import { isFunction } from '../util/isFunction';
-
-/**
- * The `min` operator operates on an Observable that emits numbers (or items that
- * can be compared with a provided function), and when source Observable completes
- * it emits a single item: the item with the smallest value.
- *
- * ![](min.png)
- *
- * ## Examples
- *
- * Get the minimal value of a series of numbers
- *
- * ```ts
- * import { of, min } from 'rxjs';
- *
- * of(5, 4, 7, 2, 8)
- *   .pipe(min())
- *   .subscribe(x => console.log(x));
- *
- * // Outputs
- * // 2
- * ```
- *
- * Use a comparer function to get the minimal item
- *
- * ```ts
- * import { of, min } from 'rxjs';
- *
- * of(
- *   { age: 7, name: 'Foo' },
- *   { age: 5, name: 'Bar' },
- *   { age: 9, name: 'Beer' }
- * ).pipe(
- *   min((a, b) => a.age < b.age ? -1 : 1)
- * )
- * .subscribe(x => console.log(x.name));
- *
- * // Outputs
- * // 'Bar'
- * ```
- *
- * @see {@link max}
- *
- * @param comparer Optional comparer function that it will use instead of its
- * default to compare the value of two items.
- * @return A function that returns an Observable that emits item with the
- * smallest value.
- */
-export function min<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T> {
-  return reduce(isFunction(comparer) ? (x, y) => (comparer(x, y) < 0 ? x : y) : (x, y) => (x < y ? x : y));
-}

package/install/node_modules/rxjs/src/internal/operators/multicast.ts

@@ -1,98 +0,0 @@
-import { Subject } from '../Subject';
-import { Observable } from '../Observable';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { OperatorFunction, UnaryFunction, ObservedValueOf, ObservableInput } from '../types';
-import { isFunction } from '../util/isFunction';
-import { connect } from './connect';
-
-/**
- * An operator that creates a {@link ConnectableObservable}, that when connected,
- * with the `connect` method, will use the provided subject to multicast the values
- * from the source to all consumers.
- *
- * @param subject The subject to multicast through.
- * @return A function that returns a {@link ConnectableObservable}
- * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}.
- * If you're using {@link refCount} after `multicast`, use the {@link share} operator instead.
- * `multicast(subject), refCount()` is equivalent to
- * `share({ connector: () => subject, resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function multicast<T>(subject: Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-
-/**
- * Because this is deprecated in favor of the {@link connect} operator, and was otherwise poorly documented,
- * rather than duplicate the effort of documenting the same behavior, please see documentation for the
- * {@link connect} operator.
- *
- * @param subject The subject used to multicast.
- * @param selector A setup function to setup the multicast
- * @return A function that returns an observable that mirrors the observable returned by the selector.
- * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
- * `multicast(subject, selector)` is equivalent to
- * `connect(selector, { connector: () => subject })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function multicast<T, O extends ObservableInput<any>>(
-  subject: Subject<T>,
-  selector: (shared: Observable<T>) => O
-): OperatorFunction<T, ObservedValueOf<O>>;
-
-/**
- * An operator that creates a {@link ConnectableObservable}, that when connected,
- * with the `connect` method, will use the provided subject to multicast the values
- * from the source to all consumers.
- *
- * @param subjectFactory A factory that will be called to create the subject. Passing a function here
- * will cause the underlying subject to be "reset" on error, completion, or refCounted unsubscription of
- * the source.
- * @return A function that returns a {@link ConnectableObservable}
- * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}.
- * If you're using {@link refCount} after `multicast`, use the {@link share} operator instead.
- * `multicast(() => new BehaviorSubject('test')), refCount()` is equivalent to
- * `share({ connector: () => new BehaviorSubject('test') })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function multicast<T>(subjectFactory: () => Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-
-/**
- * Because this is deprecated in favor of the {@link connect} operator, and was otherwise poorly documented,
- * rather than duplicate the effort of documenting the same behavior, please see documentation for the
- * {@link connect} operator.
- *
- * @param subjectFactory A factory that creates the subject used to multicast.
- * @param selector A function to setup the multicast and select the output.
- * @return A function that returns an observable that mirrors the observable returned by the selector.
- * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
- * `multicast(subjectFactory, selector)` is equivalent to
- * `connect(selector, { connector: subjectFactory })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function multicast<T, O extends ObservableInput<any>>(
-  subjectFactory: () => Subject<T>,
-  selector: (shared: Observable<T>) => O
-): 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 multicast<T, R>(
-  subjectOrSubjectFactory: Subject<T> | (() => Subject<T>),
-  selector?: (source: Observable<T>) => Observable<R>
-): OperatorFunction<T, R> {
-  const subjectFactory = isFunction(subjectOrSubjectFactory) ? subjectOrSubjectFactory : () => subjectOrSubjectFactory;
-
-  if (isFunction(selector)) {
-    // If a selector function is provided, then we're a "normal" operator that isn't
-    // going to return a ConnectableObservable. We can use `connect` to do what we
-    // need to do.
-    return connect(selector, {
-      connector: subjectFactory,
-    });
-  }
-
-  return (source: Observable<T>) => new ConnectableObservable<any>(source, subjectFactory);
-}

package/install/node_modules/rxjs/src/internal/operators/observeOn.ts

@@ -1,70 +0,0 @@
-/** @prettier */
-import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
-import { executeSchedule } from '../util/executeSchedule';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Re-emits all notifications from source Observable with specified scheduler.
- *
- * <span class="informal">Ensure a specific scheduler is used, from outside of an Observable.</span>
- *
- * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule
- * notifications emitted by the source Observable. It might be useful, if you do not have control over
- * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.
- *
- * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,
- * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal
- * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits
- * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.
- * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split
- * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source
- * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a
- * little bit more, to ensure that they are emitted at expected moments.
- *
- * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications
- * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`
- * will delay all notifications - including error notifications - while `delay` will pass through error
- * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator
- * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used
- * for notification emissions in general.
- *
- * ## Example
- *
- * Ensure values in subscribe are called just before browser repaint
- *
- * ```ts
- * import { interval, observeOn, animationFrameScheduler } from 'rxjs';
- *
- * const someDiv = document.createElement('div');
- * someDiv.style.cssText = 'width: 200px;background: #09c';
- * document.body.appendChild(someDiv);
- * const intervals = interval(10);      // Intervals are scheduled
- *                                      // with async scheduler by default...
- * intervals.pipe(
- *   observeOn(animationFrameScheduler) // ...but we will observe on animationFrame
- * )                                    // scheduler to ensure smooth animation.
- * .subscribe(val => {
- *   someDiv.style.height = val + 'px';
- * });
- * ```
- *
- * @see {@link delay}
- *
- * @param scheduler Scheduler that will be used to reschedule notifications from source Observable.
- * @param delay Number of milliseconds that states with what delay every notification should be rescheduled.
- * @return A function that returns an Observable that emits the same
- * notifications as the source Observable, but with provided scheduler.
- */
-export function observeOn<T>(scheduler: SchedulerLike, delay = 0): MonoTypeOperatorFunction<T> {
-  return operate((source, subscriber) => {
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => executeSchedule(subscriber, scheduler, () => subscriber.next(value), delay),
-        () => executeSchedule(subscriber, scheduler, () => subscriber.complete(), delay),
-        (err) => executeSchedule(subscriber, scheduler, () => subscriber.error(err), delay)
-      )
-    );
-  });
-}

package/install/node_modules/rxjs/src/internal/operators/onErrorResumeNextWith.ts

@@ -1,99 +0,0 @@
-import { ObservableInputTuple, OperatorFunction } from '../types';
-import { argsOrArgArray } from '../util/argsOrArgArray';
-import { onErrorResumeNext as oERNCreate } from '../observable/onErrorResumeNext';
-
-export function onErrorResumeNextWith<T, A extends readonly unknown[]>(
-  sources: [...ObservableInputTuple<A>]
-): OperatorFunction<T, T | A[number]>;
-export function onErrorResumeNextWith<T, A extends readonly unknown[]>(
-  ...sources: [...ObservableInputTuple<A>]
-): OperatorFunction<T, T | A[number]>;
-
-/**
- * When any of the provided Observable emits an complete or error notification, it immediately subscribes to the next one
- * that was passed.
- *
- * <span class="informal">Execute series of Observables, subscribes to next one on error or complete.</span>
- *
- * ![](onErrorResumeNext.png)
- *
- * `onErrorResumeNext` is an operator that accepts a series of Observables, provided either directly as
- * arguments or as an array. If no single Observable is provided, returned Observable will simply behave the same
- * as the source.
- *
- * `onErrorResumeNext` returns an Observable that starts by subscribing and re-emitting values from the source Observable.
- * When its stream of values ends - no matter if Observable completed or emitted an error - `onErrorResumeNext`
- * will subscribe to the first Observable that was passed as an argument to the method. It will start re-emitting
- * its values as well and - again - when that stream ends, `onErrorResumeNext` will proceed to subscribing yet another
- * Observable in provided series, no matter if previous Observable completed or ended with an error. This will
- * be happening until there is no more Observables left in the series, at which point returned Observable will
- * complete - even if the last subscribed stream ended with an error.
- *
- * `onErrorResumeNext` can be therefore thought of as version of {@link concat} operator, which is more permissive
- * when it comes to the errors emitted by its input Observables. While `concat` subscribes to the next Observable
- * in series only if previous one successfully completed, `onErrorResumeNext` subscribes even if it ended with
- * an error.
- *
- * Note that you do not get any access to errors emitted by the Observables. In particular do not
- * expect these errors to appear in error callback passed to {@link Observable#subscribe}. If you want to take
- * specific actions based on what error was emitted by an Observable, you should try out {@link catchError} instead.
- *
- *
- * ## Example
- *
- * Subscribe to the next Observable after map fails
- *
- * ```ts
- * import { of, onErrorResumeNext, map } from 'rxjs';
- *
- * of(1, 2, 3, 0)
- *   .pipe(
- *     map(x => {
- *       if (x === 0) {
- *         throw Error();
- *       }
- *
- *       return 10 / x;
- *     }),
- *     onErrorResumeNext(of(1, 2, 3))
- *   )
- *   .subscribe({
- *     next: val => console.log(val),
- *     error: err => console.log(err),          // Will never be called.
- *     complete: () => console.log('that\'s it!')
- *   });
- *
- * // Logs:
- * // 10
- * // 5
- * // 3.3333333333333335
- * // 1
- * // 2
- * // 3
- * // 'that's it!'
- * ```
- *
- * @see {@link concat}
- * @see {@link catchError}
- *
- * @param sources `ObservableInput`s passed either directly or as an array.
- * @return A function that returns an Observable that emits values from source
- * Observable, but - if it errors - subscribes to the next passed Observable
- * and so on, until it completes or runs out of Observables.
- */
-export function onErrorResumeNextWith<T, A extends readonly unknown[]>(
-  ...sources: [[...ObservableInputTuple<A>]] | [...ObservableInputTuple<A>]
-): OperatorFunction<T, T | A[number]> {
-  // For some reason, TS 4.1 RC gets the inference wrong here and infers the
-  // result to be `A[number][]` - completely dropping the ObservableInput part
-  // of the type. This makes no sense whatsoever. As a workaround, the type is
-  // asserted explicitly.
-  const nextSources = argsOrArgArray(sources) as unknown as ObservableInputTuple<A>;
-
-  return (source) => oERNCreate(source, ...nextSources);
-}
-
-/**
- * @deprecated Renamed. Use {@link onErrorResumeNextWith} instead. Will be removed in v8.
- */
-export const onErrorResumeNext = onErrorResumeNextWith;

package/install/node_modules/rxjs/src/internal/operators/pairwise.ts

@@ -1,61 +0,0 @@
-import { OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Groups pairs of consecutive emissions together and emits them as an array of
- * two values.
- *
- * <span class="informal">Puts the current value and previous value together as
- * an array, and emits that.</span>
- *
- * ![](pairwise.png)
- *
- * The Nth emission from the source Observable will cause the output Observable
- * to emit an array [(N-1)th, Nth] of the previous and the current value, as a
- * pair. For this reason, `pairwise` emits on the second and subsequent
- * emissions from the source Observable, but not on the first emission, because
- * there is no previous value in that case.
- *
- * ## Example
- *
- * On every click (starting from the second), emit the relative distance to the previous click
- *
- * ```ts
- * import { fromEvent, pairwise, map } from 'rxjs';
- *
- * const clicks = fromEvent<PointerEvent>(document, 'click');
- * const pairs = clicks.pipe(pairwise());
- * const distance = pairs.pipe(
- *   map(([first, second]) => {
- *     const x0 = first.clientX;
- *     const y0 = first.clientY;
- *     const x1 = second.clientX;
- *     const y1 = second.clientY;
- *     return Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));
- *   })
- * );
- *
- * distance.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link buffer}
- * @see {@link bufferCount}
- *
- * @return A function that returns an Observable of pairs (as arrays) of
- * consecutive values from the source Observable.
- */
-export function pairwise<T>(): OperatorFunction<T, [T, T]> {
-  return operate((source, subscriber) => {
-    let prev: T;
-    let hasPrev = false;
-    source.subscribe(
-      createOperatorSubscriber(subscriber, (value) => {
-        const p = prev;
-        prev = value;
-        hasPrev && subscriber.next([p, value]);
-        hasPrev = true;
-      })
-    );
-  });
-}

package/install/node_modules/rxjs/src/internal/operators/partition.ts

@@ -1,62 +0,0 @@
-import { not } from '../util/not';
-import { filter } from './filter';
-import { Observable } from '../Observable';
-import { UnaryFunction } from '../types';
-
-/**
- * Splits the source Observable into two, one with values that satisfy a
- * predicate, and another with values that don't satisfy the predicate.
- *
- * <span class="informal">It's like {@link filter}, but returns two Observables:
- * one like the output of {@link filter}, and the other with values that did not
- * pass the condition.</span>
- *
- * ![](partition.png)
- *
- * `partition` outputs an array with two Observables that partition the values
- * from the source Observable through the given `predicate` function. The first
- * Observable in that array emits source values for which the predicate argument
- * returns true. The second Observable emits source values for which the
- * predicate returns false. The first behaves like {@link filter} and the second
- * behaves like {@link filter} with the predicate negated.
- *
- * ## Example
- *
- * Partition click events into those on DIV elements and those elsewhere
- *
- * ```ts
- * import { fromEvent } from 'rxjs';
- * import { partition } from 'rxjs/operators';
- *
- * const div = document.createElement('div');
- * div.style.cssText = 'width: 200px; height: 200px; background: #09c;';
- * document.body.appendChild(div);
- *
- * const clicks = fromEvent(document, 'click');
- * const [clicksOnDivs, clicksElsewhere] = clicks.pipe(partition(ev => (<HTMLElement>ev.target).tagName === 'DIV'));
- *
- * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));
- * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));
- * ```
- *
- * @see {@link filter}
- *
- * @param predicate A function that evaluates each value emitted by the source
- * Observable. If it returns `true`, the value is emitted on the first Observable
- * in the returned array, if `false` the value is emitted on the second Observable
- * in the array. The `index` parameter is the number `i` for the i-th source
- * emission that has happened since the subscription, starting from the number `0`.
- * @param thisArg An optional argument to determine the value of `this` in the
- * `predicate` function.
- * @return A function that returns an array with two Observables: one with
- * values that passed the predicate, and another with values that did not pass
- * the predicate.
- * @deprecated Replaced with the {@link partition} static creation function. Will be removed in v8.
- */
-export function partition<T>(
-  predicate: (value: T, index: number) => boolean,
-  thisArg?: any
-): UnaryFunction<Observable<T>, [Observable<T>, Observable<T>]> {
-  return (source: Observable<T>) =>
-    [filter(predicate, thisArg)(source), filter(not(predicate, thisArg))(source)] as [Observable<T>, Observable<T>];
-}

package/install/node_modules/rxjs/src/internal/operators/pluck.ts

@@ -1,106 +0,0 @@
-import { map } from './map';
-import { OperatorFunction } from '../types';
-
-/* tslint:disable:max-line-length */
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export function pluck<T, K1 extends keyof T>(k1: K1): OperatorFunction<T, T[K1]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1]>(k1: K1, k2: K2): OperatorFunction<T, T[K1][K2]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(
-  k1: K1,
-  k2: K2,
-  k3: K3
-): OperatorFunction<T, T[K1][K2][K3]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(
-  k1: K1,
-  k2: K2,
-  k3: K3,
-  k4: K4
-): OperatorFunction<T, T[K1][K2][K3][K4]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export function pluck<
-  T,
-  K1 extends keyof T,
-  K2 extends keyof T[K1],
-  K3 extends keyof T[K1][K2],
-  K4 extends keyof T[K1][K2][K3],
-  K5 extends keyof T[K1][K2][K3][K4]
->(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): OperatorFunction<T, T[K1][K2][K3][K4][K5]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export function pluck<
-  T,
-  K1 extends keyof T,
-  K2 extends keyof T[K1],
-  K3 extends keyof T[K1][K2],
-  K4 extends keyof T[K1][K2][K3],
-  K5 extends keyof T[K1][K2][K3][K4],
-  K6 extends keyof T[K1][K2][K3][K4][K5]
->(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): OperatorFunction<T, T[K1][K2][K3][K4][K5][K6]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export function pluck<
-  T,
-  K1 extends keyof T,
-  K2 extends keyof T[K1],
-  K3 extends keyof T[K1][K2],
-  K4 extends keyof T[K1][K2][K3],
-  K5 extends keyof T[K1][K2][K3][K4],
-  K6 extends keyof T[K1][K2][K3][K4][K5]
->(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6, ...rest: string[]): OperatorFunction<T, unknown>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export function pluck<T>(...properties: string[]): OperatorFunction<T, unknown>;
-/* tslint:enable:max-line-length */
-
-/**
- * Maps each source value to its specified nested property.
- *
- * <span class="informal">Like {@link map}, but meant only for picking one of
- * the nested properties of every emitted value.</span>
- *
- * ![](pluck.png)
- *
- * Given a list of strings or numbers describing a path to a property, retrieves
- * the value of a specified nested property from all values in the source
- * Observable. If a property can't be resolved, it will return `undefined` for
- * that value.
- *
- * ## Example
- *
- * Map every click to the tagName of the clicked target element
- *
- * ```ts
- * import { fromEvent, pluck } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const tagNames = clicks.pipe(pluck('target', 'tagName'));
- *
- * tagNames.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link map}
- *
- * @param properties The nested properties to pluck from each source
- * value.
- * @return A function that returns an Observable of property values from the
- * source values.
- * @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8.
- */
-export function pluck<T, R>(...properties: Array<string | number | symbol>): OperatorFunction<T, R> {
-  const length = properties.length;
-  if (length === 0) {
-    throw new Error('list of properties cannot be empty.');
-  }
-  return map((x) => {
-    let currentProp: any = x;
-    for (let i = 0; i < length; i++) {
-      const p = currentProp?.[properties[i]];
-      if (typeof p !== 'undefined') {
-        currentProp = p;
-      } else {
-        return undefined;
-      }
-    }
-    return currentProp;
-  });
-}

package/install/node_modules/rxjs/src/internal/operators/publish.ts

@@ -1,93 +0,0 @@
-import { Observable } from '../Observable';
-import { Subject } from '../Subject';
-import { multicast } from './multicast';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { MonoTypeOperatorFunction, OperatorFunction, UnaryFunction, ObservableInput, ObservedValueOf } from '../types';
-import { connect } from './connect';
-
-/**
- * Returns a connectable observable that, when connected, will multicast
- * all values through a single underlying {@link Subject} instance.
- *
- * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}.
- * `source.pipe(publish())` is equivalent to
- * `connectable(source, { connector: () => new Subject(), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publish`, use {@link share} operator instead.
- * `source.pipe(publish(), refCount())` is equivalent to
- * `source.pipe(share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function publish<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-
-/**
- * Returns an observable, that when subscribed to, creates an underlying {@link Subject},
- * provides an observable view of it to a `selector` function, takes the observable result of
- * that selector function and subscribes to it, sending its values to the consumer, _then_ connects
- * the subject to the original source.
- *
- * @param selector A function used to setup multicasting prior to automatic connection.
- *
- * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
- * `publish(selector)` is equivalent to `connect(selector)`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function publish<T, O extends ObservableInput<any>>(selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>;
-
-/**
- * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called
- * before it begins emitting items to those Observers that have subscribed to it.
- *
- * <span class="informal">Makes a cold Observable hot</span>
- *
- * ![](publish.png)
- *
- * ## Examples
- *
- * Make `source$` hot by applying `publish` operator, then merge each inner observable into a single one
- * and subscribe
- *
- * ```ts
- * import { zip, interval, of, map, publish, merge, tap } from 'rxjs';
- *
- * const source$ = zip(interval(2000), of(1, 2, 3, 4, 5, 6, 7, 8, 9))
- *   .pipe(map(([, number]) => number));
- *
- * source$
- *   .pipe(
- *     publish(multicasted$ =>
- *       merge(
- *         multicasted$.pipe(tap(x => console.log('Stream 1:', x))),
- *         multicasted$.pipe(tap(x => console.log('Stream 2:', x))),
- *         multicasted$.pipe(tap(x => console.log('Stream 3:', x)))
- *       )
- *     )
- *   )
- *   .subscribe();
- *
- * // Results every two seconds
- * // Stream 1: 1
- * // Stream 2: 1
- * // Stream 3: 1
- * // ...
- * // Stream 1: 9
- * // Stream 2: 9
- * // Stream 3: 9
- * ```
- *
- * @see {@link publishLast}
- * @see {@link publishReplay}
- * @see {@link publishBehavior}
- *
- * @param selector Optional selector function which can use the multicasted source sequence as many times
- * as needed, without causing multiple subscriptions to the source sequence.
- * Subscribers to the given source will receive all notifications of the source from the time of the subscription on.
- * @return A function that returns a ConnectableObservable that upon connection
- * causes the source Observable to emit items to its Observers.
- * @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 publish<T, R>(selector?: OperatorFunction<T, R>): MonoTypeOperatorFunction<T> | OperatorFunction<T, R> {
-  return selector ? (source) => connect(selector)(source) : (source) => multicast(new Subject<T>())(source);
-}

package/install/node_modules/rxjs/src/internal/operators/publishBehavior.ts

@@ -1,26 +0,0 @@
-import { Observable } from '../Observable';
-import { BehaviorSubject } from '../BehaviorSubject';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { UnaryFunction } from '../types';
-
-/**
- * Creates a {@link ConnectableObservable} that utilizes a {@link BehaviorSubject}.
- *
- * @param initialValue The initial value passed to the {@link BehaviorSubject}.
- * @return A function that returns a {@link ConnectableObservable}
- * @deprecated Will be removed in v8. To create a connectable observable that uses a
- * {@link BehaviorSubject} under the hood, use {@link connectable}.
- * `source.pipe(publishBehavior(initValue))` is equivalent to
- * `connectable(source, { connector: () => new BehaviorSubject(initValue), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishBehavior`, use the {@link share} operator instead.
- * `source.pipe(publishBehavior(initValue), refCount())` is equivalent to
- * `source.pipe(share({ connector: () => new BehaviorSubject(initValue), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false  }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export function publishBehavior<T>(initialValue: T): UnaryFunction<Observable<T>, ConnectableObservable<T>> {
-  // Note that this has *never* supported the selector function.
-  return (source) => {
-    const subject = new BehaviorSubject<T>(initialValue);
-    return new ConnectableObservable(source, () => subject);
-  };
-}