@chainlink/external-adapter-framework 2.11.1 → 2.11.3

package/generator-adapter/node_modules/@inquirer/core/dist/index.js

@@ -0,0 +1,12 @@
+export { isUpKey, isDownKey, isSpaceKey, isBackspaceKey, isTabKey, isNumberKey, isEnterKey, } from "./lib/key.js";
+export * from "./lib/errors.js";
+export { usePrefix } from "./lib/use-prefix.js";
+export { useState } from "./lib/use-state.js";
+export { useEffect } from "./lib/use-effect.js";
+export { useMemo } from "./lib/use-memo.js";
+export { useRef } from "./lib/use-ref.js";
+export { useKeypress } from "./lib/use-keypress.js";
+export { makeTheme } from "./lib/make-theme.js";
+export { usePagination } from "./lib/pagination/use-pagination.js";
+export { createPrompt } from "./lib/create-prompt.js";
+export { Separator } from "./lib/Separator.js";

package/generator-adapter/node_modules/@inquirer/core/dist/{commonjs/lib → lib}/Separator.d.ts

@@ -4,7 +4,7 @@
  */
 export declare class Separator {
     readonly separator: string;
-    readonly type = "separator";
+    readonly type: string;
     constructor(separator?: string);
     static isSeparator(choice: unknown): choice is Separator;
 }

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/Separator.js

@@ -1,11 +1,11 @@
-import colors from 'yoctocolors-cjs';
+import { styleText } from 'node:util';
 import figures from '@inquirer/figures';
 /**
  * Separator object
  * Used to space/separate choices group
  */
 export class Separator {
-    separator = colors.dim(Array.from({ length: 15 }).join(figures.line));
+    separator = styleText('dim', Array.from({ length: 15 }).join(figures.line));
     type = 'separator';
     constructor(separator) {
         if (separator) {

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/create-prompt.js

@@ -2,11 +2,33 @@ import * as readline from 'node:readline';
 import { AsyncResource } from 'node:async_hooks';
 import MuteStream from 'mute-stream';
 import { onExit as onSignalExit } from 'signal-exit';
-import ScreenManager from './screen-manager.js';
-import { PromisePolyfill } from './promise-polyfill.js';
-import { withHooks, effectScheduler } from './hook-engine.js';
-import { AbortPromptError, CancelPromptError, ExitPromptError } from './errors.js';
+import ScreenManager from "./screen-manager.js";
+import { PromisePolyfill } from "./promise-polyfill.js";
+import { withHooks, effectScheduler } from "./hook-engine.js";
+import { AbortPromptError, CancelPromptError, ExitPromptError } from "./errors.js";
+function getCallSites() {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const _prepareStackTrace = Error.prepareStackTrace;
+    let result = [];
+    try {
+        Error.prepareStackTrace = (_, callSites) => {
+            const callSitesWithoutCurrent = callSites.slice(1);
+            result = callSitesWithoutCurrent;
+            return callSitesWithoutCurrent;
+        };
+        // oxlint-disable-next-line no-unused-expressions
+        new Error().stack;
+    }
+    catch {
+        // An error will occur if the Node flag --frozen-intrinsics is used.
+        // https://nodejs.org/api/cli.html#--frozen-intrinsics
+        return result;
+    }
+    Error.prepareStackTrace = _prepareStackTrace;
+    return result;
+}
 export function createPrompt(view) {
+    const callSites = getCallSites();
     const prompt = (config, context = {}) => {
         // Default `input` to stdin
         const { input = process.stdin, signal } = context;
@@ -21,7 +43,6 @@ export function createPrompt(view) {
         });
         const screen = new ScreenManager(rl);
         const { promise, resolve, reject } = PromisePolyfill.withResolver();
-        /** @deprecated pass an AbortSignal in the context options instead. See {@link https://github.com/SBoudrias/Inquirer.js#canceling-prompt} */
         const cancel = () => reject(new CancelPromptError());
         if (signal) {
             const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
@@ -35,6 +56,12 @@ export function createPrompt(view) {
         cleanups.add(onSignalExit((code, signal) => {
             reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal}`));
         }));
+        // SIGINT must be explicitly handled by the prompt so the ExitPromptError can be handled.
+        // Otherwise, the prompt will stop and in some scenarios never resolve.
+        // Ref issue #1741
+        const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
+        rl.on('SIGINT', sigint);
+        cleanups.add(() => rl.removeListener('SIGINT', sigint));
         // Re-renders only happen when the state change; but the readline cursor could change position
         // and that also requires a re-render (and a manual one because we mute the streams).
         // We set the listener after the initial workLoop to avoid a double render if render triggered
@@ -54,6 +81,12 @@ export function createPrompt(view) {
                     const nextView = view(config, (value) => {
                         setImmediate(() => resolve(value));
                     });
+                    // Typescript won't allow this, but not all users rely on typescript.
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    if (nextView === undefined) {
+                        const callerFilename = callSites[1]?.getFileName();
+                        throw new Error(`Prompt functions must return a string.\n    at ${callerFilename}`);
+                    }
                     const [content, bottomContent] = typeof nextView === 'string' ? [nextView] : nextView;
                     screen.render(content, bottomContent);
                     effectScheduler.run();

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/hook-engine.d.ts

@@ -1,7 +1,7 @@
 import type { InquirerReadline } from '@inquirer/type';
 export declare function withHooks<T>(rl: InquirerReadline, cb: (cycle: (render: () => void) => void) => T): T;
 export declare function readline(): InquirerReadline;
-export declare function withUpdates<R, T extends (...args: any[]) => R>(fn: T): (...args: Parameters<T>) => R;
+export declare function withUpdates<Args extends unknown[], R>(fn: (...args: Args) => R): (...args: Args) => R;
 type SetPointer<Value> = {
     get(): Value;
     set(value: Value): void;

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/hook-engine.js

@@ -1,6 +1,6 @@
 /* eslint @typescript-eslint/no-explicit-any: ["off"] */
 import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
-import { HookError, ValidationError } from './errors.js';
+import { HookError, ValidationError } from "./errors.js";
 const hookStorage = new AsyncLocalStorage();
 function createStore(rl) {
     const store = {

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/key.d.ts

@@ -2,9 +2,11 @@ export type KeypressEvent = {
     name: string;
     ctrl: boolean;
 };
-export declare const isUpKey: (key: KeypressEvent) => boolean;
-export declare const isDownKey: (key: KeypressEvent) => boolean;
+export type Keybinding = 'emacs' | 'vim';
+export declare const isUpKey: (key: KeypressEvent, keybindings?: ReadonlyArray<Keybinding>) => boolean;
+export declare const isDownKey: (key: KeypressEvent, keybindings?: ReadonlyArray<Keybinding>) => boolean;
 export declare const isSpaceKey: (key: KeypressEvent) => boolean;
 export declare const isBackspaceKey: (key: KeypressEvent) => boolean;
+export declare const isTabKey: (key: KeypressEvent) => boolean;
 export declare const isNumberKey: (key: KeypressEvent) => boolean;
 export declare const isEnterKey: (key: KeypressEvent) => boolean;

package/generator-adapter/node_modules/@inquirer/core/dist/lib/key.js

@@ -0,0 +1,19 @@
+export const isUpKey = (key, keybindings = []) => 
+// The up key
+key.name === 'up' ||
+    // Vim keybinding: hjkl keys map to left/down/up/right
+    (keybindings.includes('vim') && key.name === 'k') ||
+    // Emacs keybinding: Ctrl+P means "previous" in Emacs navigation conventions
+    (keybindings.includes('emacs') && key.ctrl && key.name === 'p');
+export const isDownKey = (key, keybindings = []) => 
+// The down key
+key.name === 'down' ||
+    // Vim keybinding: hjkl keys map to left/down/up/right
+    (keybindings.includes('vim') && key.name === 'j') ||
+    // Emacs keybinding: Ctrl+N means "next" in Emacs navigation conventions
+    (keybindings.includes('emacs') && key.ctrl && key.name === 'n');
+export const isSpaceKey = (key) => key.name === 'space';
+export const isBackspaceKey = (key) => key.name === 'backspace';
+export const isTabKey = (key) => key.name === 'tab';
+export const isNumberKey = (key) => '1234567890'.includes(key.name);
+export const isEnterKey = (key) => key.name === 'enter' || key.name === 'return';

package/generator-adapter/node_modules/@inquirer/core/dist/{commonjs/lib → lib}/make-theme.d.ts

@@ -1,3 +1,3 @@
 import type { Prettify, PartialDeep } from '@inquirer/type';
-import { type Theme } from './theme.js';
+import { type Theme } from './theme.ts';
 export declare function makeTheme<SpecificTheme extends object>(...themes: ReadonlyArray<undefined | PartialDeep<Theme<SpecificTheme>>>): Prettify<Theme<SpecificTheme>>;

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/make-theme.js

@@ -1,4 +1,4 @@
-import { defaultTheme } from './theme.js';
+import { defaultTheme } from "./theme.js";
 function isPlainObject(value) {
     if (typeof value !== 'object' || value === null)
         return false;

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/pagination/use-pagination.d.ts

@@ -1,15 +1,16 @@
 import type { Prettify } from '@inquirer/type';
-import { type Theme } from '../theme.js';
-import { type Layout } from './lines.js';
 export declare function usePagination<T>({ items, active, renderItem, pageSize, loop, }: {
     items: ReadonlyArray<T>;
     /** The index of the active item. */
     active: number;
     /** Renders an item as part of a page. */
-    renderItem: (layout: Prettify<Layout<T>>) => string;
+    renderItem: (layout: Prettify<{
+        item: T;
+        index: number;
+        isActive: boolean;
+    }>) => string;
     /** The size of the page. */
     pageSize: number;
     /** Allows creating an infinitely looping list. `true` if unspecified. */
     loop?: boolean;
-    theme?: Theme;
 }): string;

package/generator-adapter/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js

@@ -0,0 +1,121 @@
+import { useRef } from "../use-ref.js";
+import { readlineWidth, breakLines } from "../utils.js";
+function usePointerPosition({ active, renderedItems, pageSize, loop, }) {
+    const state = useRef({
+        lastPointer: active,
+        lastActive: undefined,
+    });
+    const { lastPointer, lastActive } = state.current;
+    const middle = Math.floor(pageSize / 2);
+    const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+    const defaultPointerPosition = renderedItems
+        .slice(0, active)
+        .reduce((acc, item) => acc + item.length, 0);
+    let pointer = defaultPointerPosition;
+    if (renderedLength > pageSize) {
+        if (loop) {
+            /**
+             * Creates the next position for the pointer considering an infinitely
+             * looping list of items to be rendered on the page.
+             *
+             * The goal is to progressively move the cursor to the middle position as the user move down, and then keep
+             * the cursor there. When the user move up, maintain the cursor position.
+             */
+            // By default, keep the cursor position as-is.
+            pointer = lastPointer;
+            if (
+            // First render, skip this logic.
+            lastActive != null &&
+                // Only move the pointer down when the user moves down.
+                lastActive < active &&
+                // Check user didn't move up across page boundary.
+                active - lastActive < pageSize) {
+                pointer = Math.min(
+                // Furthest allowed position for the pointer is the middle of the list
+                middle, Math.abs(active - lastActive) === 1
+                    ? Math.min(
+                    // Move the pointer at most the height of the last active item.
+                    lastPointer + (renderedItems[lastActive]?.length ?? 0), 
+                    // If the user moved by one item, move the pointer to the natural position of the active item as
+                    // long as it doesn't move the cursor up.
+                    Math.max(defaultPointerPosition, lastPointer))
+                    : // Otherwise, move the pointer down by the difference between the active and last active item.
+                        lastPointer + active - lastActive);
+            }
+        }
+        else {
+            /**
+             * Creates the next position for the pointer considering a finite list of
+             * items to be rendered on a page.
+             *
+             * The goal is to keep the pointer in the middle of the page whenever possible, until
+             * we reach the bounds of the list (top or bottom). In which case, the cursor moves progressively
+             * to the bottom or top of the list.
+             */
+            const spaceUnderActive = renderedItems
+                .slice(active)
+                .reduce((acc, item) => acc + item.length, 0);
+            pointer =
+                spaceUnderActive < pageSize - middle
+                    ? // If the active item is near the end of the list, progressively move the cursor towards the end.
+                        pageSize - spaceUnderActive
+                    : // Otherwise, progressively move the pointer to the middle of the list.
+                        Math.min(defaultPointerPosition, middle);
+        }
+    }
+    // Save state for the next render
+    state.current.lastPointer = pointer;
+    state.current.lastActive = active;
+    return pointer;
+}
+export function usePagination({ items, active, renderItem, pageSize, loop = true, }) {
+    const width = readlineWidth();
+    const bound = (num) => ((num % items.length) + items.length) % items.length;
+    const renderedItems = items.map((item, index) => {
+        if (item == null)
+            return [];
+        return breakLines(renderItem({ item, index, isActive: index === active }), width).split('\n');
+    });
+    const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+    const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+    const pointer = usePointerPosition({ active, renderedItems, pageSize, loop });
+    // Render the active item to decide the position.
+    // If the active item fits under the pointer, we render it there.
+    // Otherwise, we need to render it to fit at the bottom of the page; moving the pointer up.
+    const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+    const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+    // Create an array of lines for the page, and add the lines of the active item into the page
+    const pageBuffer = Array.from({ length: pageSize });
+    pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+    // Store to prevent rendering the same item twice
+    const itemVisited = new Set([active]);
+    // Fill the page under the active item
+    let bufferPointer = activeItemPosition + activeItem.length;
+    let itemPointer = bound(active + 1);
+    while (bufferPointer < pageSize &&
+        !itemVisited.has(itemPointer) &&
+        (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+        const lines = renderItemAtIndex(itemPointer);
+        const linesToAdd = lines.slice(0, pageSize - bufferPointer);
+        pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+        // Move pointers for next iteration
+        itemVisited.add(itemPointer);
+        bufferPointer += linesToAdd.length;
+        itemPointer = bound(itemPointer + 1);
+    }
+    // Fill the page over the active item
+    bufferPointer = activeItemPosition - 1;
+    itemPointer = bound(active - 1);
+    while (bufferPointer >= 0 &&
+        !itemVisited.has(itemPointer) &&
+        (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+        const lines = renderItemAtIndex(itemPointer);
+        const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+        pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+        // Move pointers for next iteration
+        itemVisited.add(itemPointer);
+        bufferPointer -= linesToAdd.length;
+        itemPointer = bound(itemPointer - 1);
+    }
+    return pageBuffer.filter((line) => typeof line === 'string').join('\n');
+}

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/screen-manager.js

@@ -1,19 +1,15 @@
-import stripAnsi from 'strip-ansi';
-import ansiEscapes from 'ansi-escapes';
-import { breakLines, readlineWidth } from './utils.js';
+import { stripVTControlCharacters } from 'node:util';
+import { breakLines, readlineWidth } from "./utils.js";
+import { cursorDown, cursorUp, cursorTo, cursorShow, eraseLines } from '@inquirer/ansi';
 const height = (content) => content.split('\n').length;
 const lastLine = (content) => content.split('\n').pop() ?? '';
-function cursorDown(n) {
-    return n > 0 ? ansiEscapes.cursorDown(n) : '';
-}
 export default class ScreenManager {
-    rl;
     // These variables are keeping information to allow correct prompt re-rendering
     height = 0;
     extraLinesUnderPrompt = 0;
     cursorPos;
+    rl;
     constructor(rl) {
-        this.rl = rl;
         this.rl = rl;
         this.cursorPos = rl.getCursorPos();
     }
@@ -25,7 +21,7 @@ export default class ScreenManager {
     render(content, bottomContent = '') {
         // Write message to screen and setPrompt to control backspace
         const promptLine = lastLine(content);
-        const rawPromptLine = stripAnsi(promptLine);
+        const rawPromptLine = stripVTControlCharacters(promptLine);
         // Remove the rl.line from our prompt. We can't rely on the content of
         // rl.line (mainly because of the password prompt), so just rely on it's
         // length.
@@ -55,30 +51,28 @@ export default class ScreenManager {
         const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
         // Return cursor to the input position (on top of the bottomContent)
         if (bottomContentHeight > 0)
-            output += ansiEscapes.cursorUp(bottomContentHeight);
+            output += cursorUp(bottomContentHeight);
         // Return cursor to the initial left offset.
-        output += ansiEscapes.cursorTo(this.cursorPos.cols);
+        output += cursorTo(this.cursorPos.cols);
         /**
          * Render and store state for future re-rendering
          */
-        this.write(cursorDown(this.extraLinesUnderPrompt) +
-            ansiEscapes.eraseLines(this.height) +
-            output);
+        this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
         this.extraLinesUnderPrompt = bottomContentHeight;
         this.height = height(output);
     }
     checkCursorPos() {
         const cursorPos = this.rl.getCursorPos();
         if (cursorPos.cols !== this.cursorPos.cols) {
-            this.write(ansiEscapes.cursorTo(cursorPos.cols));
+            this.write(cursorTo(cursorPos.cols));
             this.cursorPos = cursorPos;
         }
     }
     done({ clearContent }) {
         this.rl.setPrompt('');
         let output = cursorDown(this.extraLinesUnderPrompt);
-        output += clearContent ? ansiEscapes.eraseLines(this.height) : '\n';
-        output += ansiEscapes.cursorShow;
+        output += clearContent ? eraseLines(this.height) : '\n';
+        output += cursorShow;
         this.write(output);
         this.rl.close();
     }

package/generator-adapter/node_modules/@inquirer/core/dist/{commonjs/lib → lib}/theme.d.ts

@@ -21,8 +21,8 @@ type DefaultTheme = {
      *
      * @defaultValue
      * ```ts
-     * // import colors from 'yoctocolors-cjs';
-     * (status) => status === 'done' ? colors.green('✔') : colors.blue('?')
+     * // import { styleText } from 'node:util';
+     * (status) => status === 'done' ? styleText('green', '✔') : styleText('blue', '?')
      * ```
      */
     prefix: string | Prettify<Omit<Record<Status, string>, 'loading'>>;
@@ -64,8 +64,8 @@ type DefaultTheme = {
          *
          * @defaultValue
          * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.cyan(text)
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('cyan', text)
          * ```
          */
         answer: (text: string) => string;
@@ -78,8 +78,8 @@ type DefaultTheme = {
          *
          * @defaultValue
          * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text, status) => colors.bold(text)
+         * // import { styleText } from 'node:util';
+         * (text, status) => styleText('bold', text)
          * ```
          */
         message: (text: string, status: Status) => string;
@@ -91,8 +91,8 @@ type DefaultTheme = {
          *
          * @defaultValue
          * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.red(`> ${text}`)
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('red', `> ${text}`)
          * ```
          */
         error: (text: string) => string;
@@ -104,8 +104,8 @@ type DefaultTheme = {
          *
          * @defaultValue
          * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.dim(`(${text})`)
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('dim', `(${text})`)
          * ```
          */
         defaultAnswer: (text: string) => string;
@@ -117,8 +117,8 @@ type DefaultTheme = {
          *
          * @defaultValue
          * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.dim(text)
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('dim', text)
          * ```
          */
         help: (text: string) => string;
@@ -130,8 +130,8 @@ type DefaultTheme = {
          *
          * @defaultValue
          * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.cyan(text)
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('cyan', text)
          * ```
          */
         highlight: (text: string) => string;
@@ -143,8 +143,8 @@ type DefaultTheme = {
          *
          * @defaultValue
          * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.cyan(colors.bold(`<${text}>`))
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('cyan', styleText('bold', `<${text}>`))
          * ```
          */
         key: (text: string) => string;

package/generator-adapter/node_modules/@inquirer/core/dist/lib/theme.js

@@ -0,0 +1,21 @@
+import { styleText } from 'node:util';
+import figures from '@inquirer/figures';
+export const defaultTheme = {
+    prefix: {
+        idle: styleText('blue', '?'),
+        done: styleText('green', figures.tick),
+    },
+    spinner: {
+        interval: 80,
+        frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'].map((frame) => styleText('yellow', frame)),
+    },
+    style: {
+        answer: (text) => styleText('cyan', text),
+        message: (text) => styleText('bold', text),
+        error: (text) => styleText('red', `> ${text}`),
+        defaultAnswer: (text) => styleText('dim', `(${text})`),
+        help: (text) => styleText('dim', text),
+        highlight: (text) => styleText('cyan', text),
+        key: (text) => styleText('cyan', styleText('bold', `<${text}>`)),
+    },
+};

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/use-effect.js

@@ -1,4 +1,4 @@
-import { withPointer, effectScheduler } from './hook-engine.js';
+import { withPointer, effectScheduler } from "./hook-engine.js";
 export function useEffect(cb, depArray) {
     withPointer((pointer) => {
         const oldDeps = pointer.get();

package/generator-adapter/node_modules/@inquirer/core/dist/{commonjs/lib → lib}/use-keypress.d.ts

@@ -1,3 +1,3 @@
 import { type InquirerReadline } from '@inquirer/type';
-import { type KeypressEvent } from './key.js';
+import { type KeypressEvent } from './key.ts';
 export declare function useKeypress(userHandler: (event: KeypressEvent, rl: InquirerReadline) => void | Promise<void>): void;

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/use-keypress.js

@@ -1,6 +1,6 @@
-import { useRef } from './use-ref.js';
-import { useEffect } from './use-effect.js';
-import { withUpdates } from './hook-engine.js';
+import { useRef } from "./use-ref.js";
+import { useEffect } from "./use-effect.js";
+import { withUpdates } from "./hook-engine.js";
 export function useKeypress(userHandler) {
     const signal = useRef(userHandler);
     signal.current = userHandler;

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/use-memo.js

@@ -1,4 +1,4 @@
-import { withPointer } from './hook-engine.js';
+import { withPointer } from "./hook-engine.js";
 export function useMemo(fn, dependencies) {
     return withPointer((pointer) => {
         const prev = pointer.get();

package/generator-adapter/node_modules/@inquirer/core/dist/{commonjs/lib → lib}/use-prefix.d.ts

@@ -1,4 +1,4 @@
-import type { Theme, Status } from './theme.js';
+import type { Theme, Status } from './theme.ts';
 export declare function usePrefix({ status, theme, }: {
     status?: Status;
     theme?: Theme;

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/use-prefix.js

@@ -1,7 +1,6 @@
-import { AsyncResource } from 'node:async_hooks';
-import { useState } from './use-state.js';
-import { useEffect } from './use-effect.js';
-import { makeTheme } from './make-theme.js';
+import { useState } from "./use-state.js";
+import { useEffect } from "./use-effect.js";
+import { makeTheme } from "./make-theme.js";
 export function usePrefix({ status = 'idle', theme, }) {
     const [showLoader, setShowLoader] = useState(false);
     const [tick, setTick] = useState(0);
@@ -11,13 +10,13 @@ export function usePrefix({ status = 'idle', theme, }) {
             let tickInterval;
             let inc = -1;
             // Delay displaying spinner by 300ms, to avoid flickering
-            const delayTimeout = setTimeout(AsyncResource.bind(() => {
+            const delayTimeout = setTimeout(() => {
                 setShowLoader(true);
-                tickInterval = setInterval(AsyncResource.bind(() => {
+                tickInterval = setInterval(() => {
                     inc = inc + 1;
                     setTick(inc % spinner.frames.length);
-                }), spinner.interval);
-            }), 300);
+                }, spinner.interval);
+            }, 300);
             return () => {
                 clearTimeout(delayTimeout);
                 clearInterval(tickInterval);

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/use-ref.js

@@ -1,4 +1,4 @@
-import { useState } from './use-state.js';
+import { useState } from "./use-state.js";
 export function useRef(val) {
     return useState({ current: val })[0];
 }

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/use-state.js

@@ -1,19 +1,20 @@
-import { withPointer, handleChange } from './hook-engine.js';
+import { AsyncResource } from 'node:async_hooks';
+import { withPointer, handleChange } from "./hook-engine.js";
 export function useState(defaultValue) {
     return withPointer((pointer) => {
-        const setFn = (newValue) => {
+        const setState = AsyncResource.bind(function setState(newValue) {
             // Noop if the value is still the same.
             if (pointer.get() !== newValue) {
                 pointer.set(newValue);
                 // Trigger re-render
                 handleChange();
             }
-        };
+        });
         if (pointer.initialized) {
-            return [pointer.get(), setFn];
+            return [pointer.get(), setState];
         }
         const value = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
         pointer.set(value);
-        return [value, setFn];
+        return [value, setState];
     });
 }

package/generator-adapter/node_modules/@inquirer/core/dist/{esm/lib → lib}/utils.js

@@ -1,6 +1,6 @@
 import cliWidth from 'cli-width';
 import wrapAnsi from 'wrap-ansi';
-import { readline } from './hook-engine.js';
+import { readline } from "./hook-engine.js";
 /**
  * Force line returns at specific width. This function is ANSI code friendly and it'll
  * ignore invisible codes during width calculation.