@depup/inquirer 13.4.0-depup.0 → 14.0.2-depup.23

package/README.md

@@ -13,10 +13,16 @@ npm install @depup/inquirer
 
 | Field | Value |
 |-------|-------|
-| Original | [inquirer](https://www.npmjs.com/package/inquirer) @ 13.4.0 |
-| Processed | 2026-04-06 |
+| Original | [inquirer](https://www.npmjs.com/package/inquirer) @ 14.0.2 |
+| Processed | 2026-07-21 |
 | Smoke test | passed |
-| Deps updated | 0 |
+| Deps updated | 1 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| mute-stream | ^3.0.0 | ^4.0.0 |
 
 ---
 

package/changes.json

@@ -1,5 +1,10 @@
 {
-  "bumped": {},
-  "timestamp": "2026-04-06T20:24:20.370Z",
-  "totalUpdated": 0
+  "bumped": {
+    "mute-stream": {
+      "from": "^3.0.0",
+      "to": "^4.0.0"
+    }
+  },
+  "timestamp": "2026-07-21T17:16:42.865Z",
+  "totalUpdated": 1
 }

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { checkbox, confirm, editor, expand, input, number, password, rawlist, search, select } from '@inquirer/prompts';
 import type { Context, DistributiveMerge, Prettify } from '@inquirer/type';
-import { Observable } from 'rxjs';
+import type { Observable } from './utils/observable.ts';
 export type Answers<Key extends string = string> = Record<Key, any>;
 export type NoInfer<T> = [T][T extends any ? 0 : never];
 type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
@@ -47,7 +47,7 @@ export interface QuestionMap {
 }
 type KeyValueOrAsyncGetterFunction<T, k extends string, A extends Answers> = T extends Record<string, any> ? MaybeAsyncValue<T[k], A> : never;
 export type Question<A extends Answers = Answers, Type extends string = string> = {
-    type: Type;
+    type?: Type;
     name: string;
     message: MaybeAsyncValue<string, A>;
     default?: any;
@@ -85,7 +85,7 @@ export type QuestionDictionary<A extends Answers, Q> = {
 };
 export type DictionaryAnswers<A extends Answers, Prefilled extends Answers> = MergeAnswerObjects<NormalizeAnswers<Answers<Extract<keyof A, string>>>, WidenAnswerLiterals<Prefilled>>;
 export type PromptModulePublicQuestion<A extends Answers, Flat extends Answers = A> = {
-    type: 'input' | 'confirm' | 'editor' | 'password' | 'number' | 'rawlist' | 'expand' | 'checkbox' | 'search' | 'select';
+    type?: 'input' | 'confirm' | 'editor' | 'password' | 'number' | 'rawlist' | 'expand' | 'checkbox' | 'search' | 'select';
     name: Extract<keyof Flat, string>;
     message: MaybeAsyncValue<string, A>;
     default?: unknown;

package/dist/ui/prompt.d.ts

@@ -1,6 +1,6 @@
-import { Observable } from 'rxjs';
 import type { InquirerReadline } from '@inquirer/type';
 import type { Answers, PromptSession, StreamOptions } from '../types.ts';
+import type { InteropObservable } from '../utils/observable.ts';
 export declare const _: {
     set: (obj: Record<string, unknown>, path: string | undefined, value: unknown) => void;
     get: (obj: object, path?: string | number | symbol, defaultValue?: unknown) => any;
@@ -39,17 +39,22 @@ export type PromptFn<Value = any, Config = any> = (config: Config, context: Stre
  * Provides a set of prompt-constructors.
  */
 export type PromptCollection = Record<string, PromptFn | LegacyPromptConstructor>;
+type AnswerEvent = {
+    name: string;
+    answer: unknown;
+};
 /**
  * Base interface class other can inherits from
  */
 export default class PromptsRunner<A extends Answers> {
     private prompts;
     answers: Partial<A>;
-    process: Observable<any>;
+    process: InteropObservable<AnswerEvent>;
     private abortController;
     private opt;
     constructor(prompts: PromptCollection, opt?: StreamOptions);
     run(questions: PromptSession<A>, answers?: Partial<A>): Promise<A>;
+    private getQuestions;
     private prepareQuestion;
     private fetchAnswer;
     /**
@@ -58,3 +63,4 @@ export default class PromptsRunner<A extends Answers> {
     close: () => void;
     private shouldRun;
 }
+export {};

package/dist/ui/prompt.js

@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment */
 import readline from 'node:readline';
-import { defer, EMPTY, from, of, concatMap, filter, reduce, isObservable, lastValueFrom, } from 'rxjs';
 import runAsync from 'run-async';
 import MuteStream from 'mute-stream';
 import { AbortPromptError } from '@inquirer/core';
 import { cursorShow } from '@inquirer/ansi';
+import { EMPTY, createObservableController, isObservableLike, observableToAsyncIterable, } from "../utils/observable.js";
 export const _ = {
     set: (obj, path = '', value) => {
         let pointer = obj;
@@ -45,6 +45,13 @@ async function fetchAsyncQuestionProperty(question, prop, answers) {
     // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return propGetter;
 }
+class UnknownPromptTypeError extends Error {
+    name = 'UnknownPromptTypeError';
+    constructor(type, prompts) {
+        const availableTypes = Object.keys(prompts).toSorted().join(', ');
+        super(`Prompt type "${type}" is not registered. Available prompt types: ${availableTypes}`);
+    }
+}
 class TTYError extends Error {
     name = 'TTYError';
     isTtyError = true;
@@ -101,40 +108,53 @@ export default class PromptsRunner {
     }
     async run(questions, answers) {
         this.abortController = new AbortController();
+        const processController = createObservableController();
+        this.process = processController.observable;
         // Keep global reference to the answers
         this.answers = typeof answers === 'object' ? { ...answers } : {};
-        let obs;
+        try {
+            for await (const question of this.getQuestions(questions)) {
+                if (await this.shouldRun(question)) {
+                    const answer = await this.fetchAnswer(question);
+                    _.set(this.answers, answer.name, answer.answer);
+                    processController.next(answer);
+                }
+            }
+            processController.complete();
+            // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+            return this.answers;
+        }
+        catch (error) {
+            processController.error(error);
+            throw error;
+        }
+        finally {
+            this.close();
+        }
+    }
+    async *getQuestions(questions) {
         if (isQuestionArray(questions)) {
-            obs = from(questions);
+            yield* questions;
         }
-        else if (isObservable(questions)) {
-            obs = questions;
+        else if (isObservableLike(questions)) {
+            yield* observableToAsyncIterable(questions);
         }
         else if (isQuestionMap(questions)) {
             // Case: Called with a set of { name: question }
-            obs = from(Object.entries(questions).map(([name, question]) => {
-                return Object.assign({}, question, { name });
-            }));
+            for (const [name, question] of Object.entries(questions)) {
+                yield Object.assign({}, question, { name });
+            }
         }
         else {
             // Case: Called with a single question config
-            obs = from([questions]);
+            yield questions;
         }
-        this.process = obs.pipe(concatMap((question) => of(question).pipe(concatMap((question) => from(this.shouldRun(question).then((shouldRun) => {
-            if (shouldRun) {
-                return question;
-            }
-            return;
-        })).pipe(filter((val) => val != null))), concatMap((question) => defer(() => from(this.fetchAnswer(question)))))));
-        return (lastValueFrom(this.process.pipe(reduce((answersObj, answer) => {
-            _.set(answersObj, answer.name, answer.answer);
-            return answersObj;
-        }, this.answers)))
-            // oxlint-disable-next-line typescript/no-unsafe-type-assertion
-            .then(() => this.answers)
-            .finally(() => this.close()));
     }
     prepareQuestion = async (question) => {
+        const type = question.type ?? 'input';
+        if (!Object.hasOwn(this.prompts, type)) {
+            throw new UnknownPromptTypeError(type, this.prompts);
+        }
         const [message, defaultValue, resolvedChoices] = await Promise.all([
             fetchAsyncQuestionProperty(question, 'message', this.answers),
             fetchAsyncQuestionProperty(question, 'default', this.answers),
@@ -168,7 +188,7 @@ export default class PromptsRunner {
             message,
             default: defaultValue,
             choices,
-            type: question.type in this.prompts ? question.type : 'input',
+            type,
         });
         if (question.validate) {
             const originalValidate = question.validate;
@@ -208,6 +228,11 @@ export default class PromptsRunner {
                     rl.setPrompt('');
                     rl.output.unmute();
                     rl.output.write(cursorShow);
+                    // Reset cursor to column 0. On Windows terminals, \n moves the
+                    // cursor down without resetting the column when the rendered
+                    // prompt+answer wraps past the terminal width. Without this,
+                    // all subsequent output starts at the wrong horizontal offset.
+                    readline.cursorTo(rl.output, 0);
                     rl.output.end();
                     rl.close();
                 };

package/dist/utils/observable.d.ts

@@ -0,0 +1,39 @@
+type NextHandler<T> = (value: T) => void;
+type ErrorHandler = (error: unknown) => void;
+type CompleteHandler = () => void;
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}
+export type Observer<T> = {
+    next?: NextHandler<T>;
+    error?: ErrorHandler;
+    complete?: CompleteHandler;
+};
+export type SubscriptionLike = {
+    closed?: boolean;
+    unsubscribe: () => void;
+};
+export type Observable<T> = {
+    subscribe: {
+        (observer: Observer<T>): SubscriptionLike;
+        (next?: NextHandler<T> | null, error?: ErrorHandler | null, complete?: CompleteHandler | null): SubscriptionLike;
+    };
+};
+export type InteropObservable<T> = Observable<T> & AsyncIterable<T> & {
+    readonly [Symbol.observable]: () => Observable<T>;
+    readonly '@@observable': () => Observable<T>;
+};
+type ObservableController<T> = {
+    observable: InteropObservable<T>;
+    next: (value: T) => void;
+    error: (error: unknown) => void;
+    complete: () => void;
+};
+export declare const EMPTY: InteropObservable<never>;
+export declare function createObservableController<T>(): ObservableController<T>;
+type ObservableValue<T> = T extends Observable<infer Value> ? Value : never;
+export declare function isObservableLike<T>(value: T): value is T & Observable<ObservableValue<T>>;
+export declare function observableToAsyncIterable<T>(source: Observable<T>): AsyncIterable<T>;
+export {};

package/dist/utils/observable.js

@@ -0,0 +1,282 @@
+function getObservableSymbol() {
+    const symbolConstructor = Symbol;
+    return typeof symbolConstructor.observable === 'symbol'
+        ? symbolConstructor.observable
+        : '@@observable';
+}
+function normalizeObserver(observerOrNext, error, complete) {
+    if (typeof observerOrNext === 'function') {
+        return {
+            next: observerOrNext,
+            ...(error ? { error } : {}),
+            ...(complete ? { complete } : {}),
+        };
+    }
+    return observerOrNext ?? {};
+}
+function reportObserverError(error) {
+    queueMicrotask(() => {
+        throw error;
+    });
+}
+function callObserver(callback) {
+    try {
+        callback();
+    }
+    catch (error) {
+        reportObserverError(error);
+    }
+}
+function createClosedSubscription() {
+    return {
+        closed: true,
+        unsubscribe() { },
+    };
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function runTeardown(teardown) {
+    if (typeof teardown === 'function') {
+        teardown();
+    }
+    else {
+        teardown?.unsubscribe();
+    }
+}
+class ObservableImpl {
+    '@@observable' = () => this;
+    subscribeFn;
+    constructor(subscribeFn) {
+        this.subscribeFn = subscribeFn;
+        Object.defineProperty(this, getObservableSymbol(), {
+            configurable: true,
+            value: () => this,
+        });
+    }
+    subscribe(observerOrNext, error, complete) {
+        const observer = normalizeObserver(observerOrNext, error, complete);
+        let closed = false;
+        let teardown;
+        let teardownReady = false;
+        const subscription = {
+            get closed() {
+                return closed;
+            },
+            unsubscribe() {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                if (teardownReady) {
+                    runTeardown(teardown);
+                }
+            },
+        };
+        const safeObserver = {
+            next(value) {
+                if (!closed) {
+                    callObserver(() => observer.next?.(value));
+                }
+            },
+            error(error) {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                if (observer.error) {
+                    callObserver(() => observer.error?.(error));
+                }
+                else {
+                    reportObserverError(error);
+                }
+                if (teardownReady) {
+                    runTeardown(teardown);
+                }
+            },
+            complete() {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                callObserver(() => observer.complete?.());
+                if (teardownReady) {
+                    runTeardown(teardown);
+                }
+            },
+        };
+        try {
+            teardown = this.subscribeFn(safeObserver);
+            teardownReady = true;
+            if (subscription.closed) {
+                runTeardown(teardown);
+            }
+        }
+        catch (error) {
+            safeObserver.error?.(error);
+        }
+        return subscription;
+    }
+    [Symbol.asyncIterator]() {
+        return observableToAsyncIterable(this)[Symbol.asyncIterator]();
+    }
+}
+export const EMPTY = new ObservableImpl((observer) => {
+    observer.complete?.();
+    return createClosedSubscription();
+});
+export function createObservableController() {
+    const observers = new Set();
+    let completed = false;
+    let errored = false;
+    let thrownError;
+    const observable = new ObservableImpl((observer) => {
+        if (errored) {
+            observer.error?.(thrownError);
+            return createClosedSubscription();
+        }
+        if (completed) {
+            observer.complete?.();
+            return createClosedSubscription();
+        }
+        const entry = {
+            observer,
+            subscription: {
+                closed: false,
+                unsubscribe() {
+                    entry.subscription.closed = true;
+                    observers.delete(entry);
+                },
+            },
+        };
+        observers.add(entry);
+        return entry.subscription;
+    });
+    return {
+        observable,
+        next(value) {
+            if (completed || errored) {
+                return;
+            }
+            for (const { observer, subscription } of observers) {
+                if (!subscription.closed) {
+                    callObserver(() => observer.next?.(value));
+                }
+            }
+        },
+        error(error) {
+            if (completed || errored) {
+                return;
+            }
+            errored = true;
+            thrownError = error;
+            for (const { observer, subscription } of observers) {
+                subscription.closed = true;
+                callObserver(() => observer.error?.(error));
+            }
+            observers.clear();
+        },
+        complete() {
+            if (completed || errored) {
+                return;
+            }
+            completed = true;
+            for (const { observer, subscription } of observers) {
+                subscription.closed = true;
+                callObserver(() => observer.complete?.());
+            }
+            observers.clear();
+        },
+    };
+}
+export function isObservableLike(value) {
+    return ((typeof value === 'object' || typeof value === 'function') &&
+        value != null &&
+        'subscribe' in value &&
+        typeof value.subscribe === 'function');
+}
+export function observableToAsyncIterable(source) {
+    return {
+        [Symbol.asyncIterator]() {
+            const values = [];
+            const pending = [];
+            let completed = false;
+            let errored = false;
+            let thrownError;
+            let subscription;
+            const resolvePending = (result) => {
+                while (pending.length > 0) {
+                    pending.shift()?.resolve(result);
+                }
+            };
+            const rejectPending = (error) => {
+                while (pending.length > 0) {
+                    pending.shift()?.reject(error);
+                }
+            };
+            const iterator = {
+                next() {
+                    const item = values.shift();
+                    if (item) {
+                        return Promise.resolve({ done: false, value: item.value });
+                    }
+                    if (errored) {
+                        return Promise.reject(thrownError ?? new Error('Observable source failed'));
+                    }
+                    if (completed) {
+                        return Promise.resolve({ done: true, value: undefined });
+                    }
+                    return new Promise((resolve, reject) => {
+                        pending.push({ resolve, reject });
+                    });
+                },
+                return() {
+                    completed = true;
+                    values.length = 0;
+                    subscription?.unsubscribe();
+                    resolvePending({ done: true, value: undefined });
+                    return Promise.resolve({ done: true, value: undefined });
+                },
+            };
+            try {
+                subscription = source.subscribe({
+                    next(value) {
+                        if (completed || errored) {
+                            return;
+                        }
+                        const pendingIterator = pending.shift();
+                        if (pendingIterator) {
+                            pendingIterator.resolve({ done: false, value });
+                            return;
+                        }
+                        values.push({ value });
+                    },
+                    error(error) {
+                        if (completed || errored) {
+                            return;
+                        }
+                        values.length = 0;
+                        errored = true;
+                        thrownError = toError(error);
+                        rejectPending(thrownError);
+                        subscription?.unsubscribe();
+                    },
+                    complete() {
+                        if (completed || errored) {
+                            return;
+                        }
+                        completed = true;
+                        resolvePending({ done: true, value: undefined });
+                    },
+                });
+            }
+            catch (error) {
+                values.length = 0;
+                errored = true;
+                thrownError = toError(error);
+                rejectPending(thrownError);
+            }
+            return iterator;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/inquirer",
-  "version": "13.4.0-depup.0",
+  "version": "14.0.2-depup.23",
   "description": "A collection of common interactive command line user interfaces. (with updated dependencies)",
   "keywords": [
     "inquirer",
@@ -71,16 +71,16 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@inquirer/ansi": "^2.0.5",
-    "@inquirer/core": "^11.1.8",
-    "@inquirer/prompts": "^8.4.0",
-    "@inquirer/type": "^4.0.5",
-    "mute-stream": "^3.0.0",
-    "run-async": "^4.0.6",
-    "rxjs": "^7.8.2"
+    "@inquirer/ansi": "^2.0.7",
+    "@inquirer/core": "^11.2.1",
+    "@inquirer/prompts": "^8.5.2",
+    "@inquirer/type": "^4.0.7",
+    "mute-stream": "^4.0.0",
+    "run-async": "^4.0.6"
   },
   "devDependencies": {
     "@types/mute-stream": "^0.0.4",
+    "rxjs": "^7.8.2",
     "typescript": "^6.0.2"
   },
   "peerDependencies": {
@@ -92,17 +92,22 @@
     }
   },
   "engines": {
-    "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+    "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "gitHead": "e68fe01d65359e083581c48c4a18cd8f97d88842",
+  "gitHead": "bfd8710229e3d3c9784bef3bbfbd84c7bd09bb9e",
   "depup": {
-    "changes": {},
-    "depsUpdated": 0,
+    "changes": {
+      "mute-stream": {
+        "from": "^3.0.0",
+        "to": "^4.0.0"
+      }
+    },
+    "depsUpdated": 1,
     "originalPackage": "inquirer",
-    "originalVersion": "13.4.0",
-    "processedAt": "2026-04-06T20:24:22.833Z",
+    "originalVersion": "14.0.2",
+    "processedAt": "2026-07-21T17:16:45.498Z",
     "smokeTest": "passed"
   }
 }