@cmflow/cli 3.5.0 → 3.6.0

package/dist/index.d.mts

@@ -1,6 +1,4 @@
 
-/// <reference path="operators/index.d.ts" />
-/// <reference path="testing/index.d.ts" />
 import { a as SemanticContext, c as getConfig, i as CmContext, l as PackageJson, n as CommandConstructor, o as CliConfig, r as ICommand, s as getCI, t as CmTask } from "./index-B7dZdFg6.mjs";
 import { ChildProcess } from "node:child_process";
 import { SignalConstants } from "node:os";
@@ -979,353 +977,6 @@ declare class Rebase extends Fetch implements ICommand {
   success(context: CmContext): void;
 }
 //#endregion
-//#region ../../node_modules/rxjs/dist/types/internal/Subscription.d.ts
-/**
- * Represents a disposable resource, such as the execution of an Observable. A
- * Subscription has one important method, `unsubscribe`, that takes no argument
- * and just disposes the resource held by the subscription.
- *
- * Additionally, subscriptions may be grouped together through the `add()`
- * method, which will attach a child Subscription to the current Subscription.
- * When a Subscription is unsubscribed, all its children (and its grandchildren)
- * will be unsubscribed as well.
- */
-declare class Subscription implements SubscriptionLike {
-  private initialTeardown?;
-  static EMPTY: Subscription;
-  /**
-   * A flag to indicate whether this Subscription has already been unsubscribed.
-   */
-  closed: boolean;
-  private _parentage;
-  /**
-   * The list of registered finalizers to execute upon unsubscription. Adding and removing from this
-   * list occurs in the {@link #add} and {@link #remove} methods.
-   */
-  private _finalizers;
-  /**
-   * @param initialTeardown A function executed first as part of the finalization
-   * process that is kicked off when {@link #unsubscribe} is called.
-   */
-  constructor(initialTeardown?: (() => void) | undefined);
-  /**
-   * Disposes the resources held by the subscription. May, for instance, cancel
-   * an ongoing Observable execution or cancel any other type of work that
-   * started when the Subscription was created.
-   */
-  unsubscribe(): void;
-  /**
-   * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called
-   * when this subscription is unsubscribed. If this subscription is already {@link #closed},
-   * because it has already been unsubscribed, then whatever finalizer is passed to it
-   * will automatically be executed (unless the finalizer itself is also a closed subscription).
-   *
-   * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed
-   * subscription to a any subscription will result in no operation. (A noop).
-   *
-   * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
-   * operation at all. (A noop).
-   *
-   * `Subscription` instances that are added to this instance will automatically remove themselves
-   * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
-   * will need to be removed manually with {@link #remove}
-   *
-   * @param teardown The finalization logic to add to this subscription.
-   */
-  add(teardown: TeardownLogic): void;
-  /**
-   * Checks to see if a this subscription already has a particular parent.
-   * This will signal that this subscription has already been added to the parent in question.
-   * @param parent the parent to check for
-   */
-  private _hasParent;
-  /**
-   * Adds a parent to this subscription so it can be removed from the parent if it
-   * unsubscribes on it's own.
-   *
-   * NOTE: THIS ASSUMES THAT {@link _hasParent} HAS ALREADY BEEN CHECKED.
-   * @param parent The parent subscription to add
-   */
-  private _addParent;
-  /**
-   * Called on a child when it is removed via {@link #remove}.
-   * @param parent The parent to remove
-   */
-  private _removeParent;
-  /**
-   * Removes a finalizer from this subscription that was previously added with the {@link #add} method.
-   *
-   * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
-   * from every other `Subscription` they have been added to. This means that using the `remove` method
-   * is not a common thing and should be used thoughtfully.
-   *
-   * If you add the same finalizer instance of a function or an unsubscribable object to a `Subscription` instance
-   * more than once, you will need to call `remove` the same number of times to remove all instances.
-   *
-   * All finalizer instances are removed to free up memory upon unsubscription.
-   *
-   * @param teardown The finalizer to remove from this subscription
-   */
-  remove(teardown: Exclude<TeardownLogic, void>): void;
-}
-//#endregion
-//#region ../../node_modules/rxjs/dist/types/internal/types.d.ts
-/**
- * Note: This will add Symbol.observable globally for all TypeScript users,
- * however, we are no longer polyfilling Symbol.observable
- */
-declare global {
-  interface SymbolConstructor {
-    readonly observable: symbol;
-  }
-}
-/**
- * A function type interface that describes a function that accepts one parameter `T`
- * and returns another parameter `R`.
- *
- * Usually used to describe {@link OperatorFunction} - it always takes a single
- * parameter (the source Observable) and returns another Observable.
- */
-interface UnaryFunction<T, R> {
-  (source: T): R;
-}
-interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {}
-interface Unsubscribable {
-  unsubscribe(): void;
-}
-declare type TeardownLogic = Subscription | Unsubscribable | (() => void) | void;
-interface SubscriptionLike extends Unsubscribable {
-  unsubscribe(): void;
-  readonly closed: boolean;
-}
-/** OBSERVABLE INTERFACES */
-interface Subscribable<T> {
-  subscribe(observer: Partial<Observer<T>>): Unsubscribable;
-}
-/**
- * An object interface that defines a set of callback functions a user can use to get
- * notified of any set of {@link Observable}
- * {@link guide/glossary-and-semantics#notification notification} events.
- *
- * For more info, please refer to {@link guide/observer this guide}.
- */
-interface Observer<T> {
-  /**
-   * A callback function that gets called by the producer during the subscription when
-   * the producer "has" the `value`. It won't be called if `error` or `complete` callback
-   * functions have been called, nor after the consumer has unsubscribed.
-   *
-   * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}.
-   */
-  next: (value: T) => void;
-  /**
-   * A callback function that gets called by the producer if and when it encountered a
-   * problem of any kind. The errored value will be provided through the `err` parameter.
-   * This callback can't be called more than one time, it can't be called if the
-   * `complete` callback function have been called previously, nor it can't be called if
-   * the consumer has unsubscribed.
-   *
-   * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}.
-   */
-  error: (err: any) => void;
-  /**
-   * A callback function that gets called by the producer if and when it has no more
-   * values to provide (by calling `next` callback function). This means that no error
-   * has happened. This callback can't be called more than one time, it can't be called
-   * if the `error` callback function have been called previously, nor it can't be called
-   * if the consumer has unsubscribed.
-   *
-   * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}.
-   */
-  complete: () => void;
-}
-//#endregion
-//#region ../../node_modules/rxjs/dist/types/internal/Subscriber.d.ts
-/**
- * Implements the {@link Observer} interface and extends the
- * {@link Subscription} class. While the {@link Observer} is the public API for
- * consuming the values of an {@link Observable}, all Observers get converted to
- * a Subscriber, in order to provide Subscription-like capabilities such as
- * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
- * implementing operators, but it is rarely used as a public API.
- */
-declare class Subscriber<T> extends Subscription implements Observer<T> {
-  /**
-   * A static factory for a Subscriber, given a (potentially partial) definition
-   * of an Observer.
-   * @param next The `next` callback of an Observer.
-   * @param error The `error` callback of an
-   * Observer.
-   * @param complete The `complete` callback of an
-   * Observer.
-   * @return A Subscriber wrapping the (partially defined)
-   * Observer represented by the given arguments.
-   * @deprecated Do not use. Will be removed in v8. There is no replacement for this
-   * method, and there is no reason to be creating instances of `Subscriber` directly.
-   * If you have a specific use case, please file an issue.
-   */
-  static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T>;
-  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-  protected isStopped: boolean;
-  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-  protected destination: Subscriber<any> | Observer<any>;
-  /**
-   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-   * There is no reason to directly create an instance of Subscriber. This type is exported for typings reasons.
-   */
-  constructor(destination?: Subscriber<any> | Observer<any>);
-  /**
-   * The {@link Observer} callback to receive notifications of type `next` from
-   * the Observable, with a value. The Observable may call this method 0 or more
-   * times.
-   * @param value The `next` value.
-   */
-  next(value: T): void;
-  /**
-   * The {@link Observer} callback to receive notifications of type `error` from
-   * the Observable, with an attached `Error`. Notifies the Observer that
-   * the Observable has experienced an error condition.
-   * @param err The `error` exception.
-   */
-  error(err?: any): void;
-  /**
-   * The {@link Observer} callback to receive a valueless notification of type
-   * `complete` from the Observable. Notifies the Observer that the Observable
-   * has finished sending push-based notifications.
-   */
-  complete(): void;
-  unsubscribe(): void;
-  protected _next(value: T): void;
-  protected _error(err: any): void;
-  protected _complete(): void;
-}
-//#endregion
-//#region ../../node_modules/rxjs/dist/types/internal/Operator.d.ts
-/***
- * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
- */
-interface Operator<T, R> {
-  call(subscriber: Subscriber<R>, source: any): TeardownLogic;
-}
-//#endregion
-//#region ../../node_modules/rxjs/dist/types/internal/Observable.d.ts
-/**
- * A representation of any set of values over any amount of time. This is the most basic building block
- * of RxJS.
- */
-declare class Observable<T> implements Subscribable<T> {
-  /**
-   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-   */
-  source: Observable<any> | undefined;
-  /**
-   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-   */
-  operator: Operator<any, T> | undefined;
-  /**
-   * @param subscribe The function that is called when the Observable is
-   * initially subscribed to. This function is given a Subscriber, to which new values
-   * can be `next`ed, or an `error` method can be called to raise an error, or
-   * `complete` can be called to notify of a successful completion.
-   */
-  constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
-  /**
-   * Creates a new Observable by calling the Observable constructor
-   * @param subscribe the subscriber function to be passed to the Observable constructor
-   * @return A new observable.
-   * @deprecated Use `new Observable()` instead. Will be removed in v8.
-   */
-  static create: (...args: any[]) => any;
-  /**
-   * Creates a new Observable, with this Observable instance as the source, and the passed
-   * operator defined as the new observable's operator.
-   * @param operator the operator defining the operation to take on the observable
-   * @return A new observable with the Operator applied.
-   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-   * If you have implemented an operator using `lift`, it is recommended that you create an
-   * operator by simply returning `new Observable()` directly. See "Creating new operators from
-   * scratch" section here: https://rxjs.dev/guide/operators
-   */
-  lift<R>(operator?: Operator<T, R>): Observable<R>;
-  subscribe(observerOrNext?: Partial<Observer<T>> | ((value: T) => void)): Subscription;
-  /** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
-  subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
-  /**
-   * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
-   * APIs that expect promises, like `async/await`. You cannot unsubscribe from this.
-   *
-   * **WARNING**: Only use this with observables you *know* will complete. If the source
-   * observable does not complete, you will end up with a promise that is hung up, and
-   * potentially all of the state of an async function hanging out in memory. To avoid
-   * this situation, look into adding something like {@link timeout}, {@link take},
-   * {@link takeWhile}, or {@link takeUntil} amongst others.
-   *
-   * #### Example
-   *
-   * ```ts
-   * import { interval, take } from 'rxjs';
-   *
-   * const source$ = interval(1000).pipe(take(4));
-   *
-   * async function getTotal() {
-   *   let total = 0;
-   *
-   *   await source$.forEach(value => {
-   *     total += value;
-   *     console.log('observable -> ' + value);
-   *   });
-   *
-   *   return total;
-   * }
-   *
-   * getTotal().then(
-   *   total => console.log('Total: ' + total)
-   * );
-   *
-   * // Expected:
-   * // 'observable -> 0'
-   * // 'observable -> 1'
-   * // 'observable -> 2'
-   * // 'observable -> 3'
-   * // 'Total: 6'
-   * ```
-   *
-   * @param next A handler for each value emitted by the observable.
-   * @return A promise that either resolves on observable completion or
-   * rejects with the handled error.
-   */
-  forEach(next: (value: T) => void): Promise<void>;
-  /**
-   * @param next a handler for each value emitted by the observable
-   * @param promiseCtor a constructor function used to instantiate the Promise
-   * @return a promise that either resolves on observable completion or
-   *  rejects with the handled error
-   * @deprecated Passing a Promise constructor will no longer be available
-   * in upcoming versions of RxJS. This is because it adds weight to the library, for very
-   * little benefit. If you need this functionality, it is recommended that you either
-   * polyfill Promise, or you create an adapter to convert the returned native promise
-   * to whatever promise implementation you wanted. Will be removed in v8.
-   */
-  forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
-  pipe(): Observable<T>;
-  pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
-  pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
-  pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
-  pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
-  pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
-  pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
-  pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
-  pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
-  pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
-  pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<unknown>;
-  /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
-  toPromise(): Promise<T | undefined>;
-  /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
-  toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
-  /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
-  toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
-}
-//#endregion
 //#region src/commands/tasks/push-branch.d.ts
 type PushBranchContext = CmContext<{
   origin?: string;
@@ -2986,7 +2637,6 @@ type ExecaSyncArrayShort<OptionsType extends SyncOptions> = <NewOptionsType exte
 type RunOptions = Record<string, unknown>;
 type CliSyncResult = ReturnType<typeof execaSync>;
 interface CliResult extends Promise<unknown> {
-  toObservable(opt?: RunOptions): Observable<string>;
   toStream(opt?: RunOptions): ReturnType<typeof execa>;
   cwd(cwd: string): CliResult;
   sync(opt?: RunOptions): CliSyncResult;