appiq-solution 1.0.0

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/errors.d.ts

@@ -0,0 +1,20 @@
+export declare class AbortPromptError extends Error {
+    name: string;
+    message: string;
+    constructor(options?: {
+        cause?: unknown;
+    });
+}
+export declare class CancelPromptError extends Error {
+    name: string;
+    message: string;
+}
+export declare class ExitPromptError extends Error {
+    name: string;
+}
+export declare class HookError extends Error {
+    name: string;
+}
+export declare class ValidationError extends Error {
+    name: string;
+}

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/errors.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.HookError = exports.ExitPromptError = exports.CancelPromptError = exports.AbortPromptError = void 0;
+class AbortPromptError extends Error {
+    name = 'AbortPromptError';
+    message = 'Prompt was aborted';
+    constructor(options) {
+        super();
+        this.cause = options?.cause;
+    }
+}
+exports.AbortPromptError = AbortPromptError;
+class CancelPromptError extends Error {
+    name = 'CancelPromptError';
+    message = 'Prompt was canceled';
+}
+exports.CancelPromptError = CancelPromptError;
+class ExitPromptError extends Error {
+    name = 'ExitPromptError';
+}
+exports.ExitPromptError = ExitPromptError;
+class HookError extends Error {
+    name = 'HookError';
+}
+exports.HookError = HookError;
+class ValidationError extends Error {
+    name = 'ValidationError';
+}
+exports.ValidationError = ValidationError;

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/hook-engine.d.ts

@@ -0,0 +1,23 @@
+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<Args extends unknown[], R>(fn: (...args: Args) => R): (...args: Args) => R;
+type SetPointer<Value> = {
+    get(): Value;
+    set(value: Value): void;
+    initialized: true;
+};
+type UnsetPointer<Value> = {
+    get(): void;
+    set(value: Value): void;
+    initialized: false;
+};
+type Pointer<Value> = SetPointer<Value> | UnsetPointer<Value>;
+export declare function withPointer<Value, ReturnValue>(cb: (pointer: Pointer<Value>) => ReturnValue): ReturnValue;
+export declare function handleChange(): void;
+export declare const effectScheduler: {
+    queue(cb: (readline: InquirerReadline) => void | (() => void)): void;
+    run(): void;
+    clearAll(): void;
+};
+export {};

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/hook-engine.js

@@ -0,0 +1,118 @@
+"use strict";
+/* eslint @typescript-eslint/no-explicit-any: ["off"] */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectScheduler = void 0;
+exports.withHooks = withHooks;
+exports.readline = readline;
+exports.withUpdates = withUpdates;
+exports.withPointer = withPointer;
+exports.handleChange = handleChange;
+const node_async_hooks_1 = require("node:async_hooks");
+const errors_ts_1 = require("./errors.js");
+const hookStorage = new node_async_hooks_1.AsyncLocalStorage();
+function createStore(rl) {
+    const store = {
+        rl,
+        hooks: [],
+        hooksCleanup: [],
+        hooksEffect: [],
+        index: 0,
+        handleChange() { },
+    };
+    return store;
+}
+// Run callback in with the hook engine setup.
+function withHooks(rl, cb) {
+    const store = createStore(rl);
+    return hookStorage.run(store, () => {
+        function cycle(render) {
+            store.handleChange = () => {
+                store.index = 0;
+                render();
+            };
+            store.handleChange();
+        }
+        return cb(cycle);
+    });
+}
+// Safe getStore utility that'll return the store or throw if undefined.
+function getStore() {
+    const store = hookStorage.getStore();
+    if (!store) {
+        throw new errors_ts_1.HookError('[Inquirer] Hook functions can only be called from within a prompt');
+    }
+    return store;
+}
+function readline() {
+    return getStore().rl;
+}
+// Merge state updates happening within the callback function to avoid multiple renders.
+function withUpdates(fn) {
+    const wrapped = (...args) => {
+        const store = getStore();
+        let shouldUpdate = false;
+        const oldHandleChange = store.handleChange;
+        store.handleChange = () => {
+            shouldUpdate = true;
+        };
+        const returnValue = fn(...args);
+        if (shouldUpdate) {
+            oldHandleChange();
+        }
+        store.handleChange = oldHandleChange;
+        return returnValue;
+    };
+    return node_async_hooks_1.AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+    const store = getStore();
+    const { index } = store;
+    const pointer = {
+        get() {
+            return store.hooks[index];
+        },
+        set(value) {
+            store.hooks[index] = value;
+        },
+        initialized: index in store.hooks,
+    };
+    const returnValue = cb(pointer);
+    store.index++;
+    return returnValue;
+}
+function handleChange() {
+    getStore().handleChange();
+}
+exports.effectScheduler = {
+    queue(cb) {
+        const store = getStore();
+        const { index } = store;
+        store.hooksEffect.push(() => {
+            store.hooksCleanup[index]?.();
+            const cleanFn = cb(readline());
+            if (cleanFn != null && typeof cleanFn !== 'function') {
+                throw new errors_ts_1.ValidationError('useEffect return value must be a cleanup function or nothing.');
+            }
+            store.hooksCleanup[index] = cleanFn;
+        });
+    },
+    run() {
+        const store = getStore();
+        withUpdates(() => {
+            store.hooksEffect.forEach((effect) => {
+                effect();
+            });
+            // Warning: Clean the hooks before exiting the `withUpdates` block.
+            // Failure to do so means an updates would hit the same effects again.
+            store.hooksEffect.length = 0;
+        })();
+    },
+    clearAll() {
+        const store = getStore();
+        store.hooksCleanup.forEach((cleanFn) => {
+            cleanFn?.();
+        });
+        store.hooksEffect.length = 0;
+        store.hooksCleanup.length = 0;
+    },
+};

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/key.d.ts

@@ -0,0 +1,10 @@
+export type KeypressEvent = {
+    name: string;
+    ctrl: boolean;
+};
+export declare const isUpKey: (key: KeypressEvent) => boolean;
+export declare const isDownKey: (key: KeypressEvent) => boolean;
+export declare const isSpaceKey: (key: KeypressEvent) => boolean;
+export declare const isBackspaceKey: (key: KeypressEvent) => boolean;
+export declare const isNumberKey: (key: KeypressEvent) => boolean;
+export declare const isEnterKey: (key: KeypressEvent) => boolean;

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/key.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnterKey = exports.isNumberKey = exports.isBackspaceKey = exports.isSpaceKey = exports.isDownKey = exports.isUpKey = void 0;
+const isUpKey = (key) => 
+// The up key
+key.name === 'up' ||
+    // Vim keybinding
+    key.name === 'k' ||
+    // Emacs keybinding
+    (key.ctrl && key.name === 'p');
+exports.isUpKey = isUpKey;
+const isDownKey = (key) => 
+// The down key
+key.name === 'down' ||
+    // Vim keybinding
+    key.name === 'j' ||
+    // Emacs keybinding
+    (key.ctrl && key.name === 'n');
+exports.isDownKey = isDownKey;
+const isSpaceKey = (key) => key.name === 'space';
+exports.isSpaceKey = isSpaceKey;
+const isBackspaceKey = (key) => key.name === 'backspace';
+exports.isBackspaceKey = isBackspaceKey;
+const isNumberKey = (key) => '1234567890'.includes(key.name);
+exports.isNumberKey = isNumberKey;
+const isEnterKey = (key) => key.name === 'enter' || key.name === 'return';
+exports.isEnterKey = isEnterKey;

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/make-theme.d.ts

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

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/make-theme.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTheme = makeTheme;
+const theme_ts_1 = require("./theme.js");
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    let proto = value;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(value) === proto;
+}
+function deepMerge(...objects) {
+    const output = {};
+    for (const obj of objects) {
+        for (const [key, value] of Object.entries(obj)) {
+            const prevValue = output[key];
+            output[key] =
+                isPlainObject(prevValue) && isPlainObject(value)
+                    ? deepMerge(prevValue, value)
+                    : value;
+        }
+    }
+    return output;
+}
+function makeTheme(...themes) {
+    const themesToMerge = [
+        theme_ts_1.defaultTheme,
+        ...themes.filter((theme) => theme != null),
+    ];
+    return deepMerge(...themesToMerge);
+}

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/pagination/use-pagination.d.ts

@@ -0,0 +1,16 @@
+import type { Prettify } from '@inquirer/type';
+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<{
+        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;
+}): string;

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/pagination/use-pagination.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePagination = usePagination;
+const use_ref_ts_1 = require("../use-ref.js");
+const utils_ts_1 = require("../utils.js");
+function usePointerPosition({ active, renderedItems, pageSize, loop, }) {
+    const state = (0, use_ref_ts_1.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;
+}
+function usePagination({ items, active, renderItem, pageSize, loop = true, }) {
+    const width = (0, utils_ts_1.readlineWidth)();
+    const bound = (num) => ((num % items.length) + items.length) % items.length;
+    const renderedItems = items.map((item, index) => {
+        if (item == null)
+            return [];
+        return (0, utils_ts_1.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/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/promise-polyfill.d.ts

@@ -0,0 +1,7 @@
+export declare class PromisePolyfill<T> extends Promise<T> {
+    static withResolver<T>(): {
+        promise: Promise<T>;
+        resolve: (value: T) => void;
+        reject: (error: unknown) => void;
+    };
+}

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/promise-polyfill.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisePolyfill = void 0;
+// TODO: Remove this class once Node 22 becomes the minimum supported version.
+class PromisePolyfill extends Promise {
+    // Available starting from Node 22
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+    static withResolver() {
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return { promise, resolve: resolve, reject: reject };
+    }
+}
+exports.PromisePolyfill = PromisePolyfill;

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/screen-manager.d.ts

@@ -0,0 +1,14 @@
+import type { InquirerReadline } from '@inquirer/type';
+export default class ScreenManager {
+    private height;
+    private extraLinesUnderPrompt;
+    private cursorPos;
+    private readonly rl;
+    constructor(rl: InquirerReadline);
+    write(content: string): void;
+    render(content: string, bottomContent?: string): void;
+    checkCursorPos(): void;
+    done({ clearContent }: {
+        clearContent: boolean;
+    }): void;
+}

package/tools/installer/node_modules/@inquirer/core/dist/commonjs/lib/screen-manager.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
+const ansi_escapes_1 = __importDefault(require("ansi-escapes"));
+const utils_ts_1 = require("./utils.js");
+const height = (content) => content.split('\n').length;
+const lastLine = (content) => content.split('\n').pop() ?? '';
+function cursorDown(n) {
+    return n > 0 ? ansi_escapes_1.default.cursorDown(n) : '';
+}
+class ScreenManager {
+    // These variables are keeping information to allow correct prompt re-rendering
+    height = 0;
+    extraLinesUnderPrompt = 0;
+    cursorPos;
+    rl;
+    constructor(rl) {
+        this.rl = rl;
+        this.cursorPos = rl.getCursorPos();
+    }
+    write(content) {
+        this.rl.output.unmute();
+        this.rl.output.write(content);
+        this.rl.output.mute();
+    }
+    render(content, bottomContent = '') {
+        // Write message to screen and setPrompt to control backspace
+        const promptLine = lastLine(content);
+        const rawPromptLine = (0, node_util_1.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.
+        let prompt = rawPromptLine;
+        if (this.rl.line.length > 0) {
+            prompt = prompt.slice(0, -this.rl.line.length);
+        }
+        this.rl.setPrompt(prompt);
+        // SetPrompt will change cursor position, now we can get correct value
+        this.cursorPos = this.rl.getCursorPos();
+        const width = (0, utils_ts_1.readlineWidth)();
+        content = (0, utils_ts_1.breakLines)(content, width);
+        bottomContent = (0, utils_ts_1.breakLines)(bottomContent, width);
+        // Manually insert an extra line if we're at the end of the line.
+        // This prevent the cursor from appearing at the beginning of the
+        // current line.
+        if (rawPromptLine.length % width === 0) {
+            content += '\n';
+        }
+        let output = content + (bottomContent ? '\n' + bottomContent : '');
+        /**
+         * Re-adjust the cursor at the correct position.
+         */
+        // We need to consider parts of the prompt under the cursor as part of the bottom
+        // content in order to correctly cleanup and re-render.
+        const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+        const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+        // Return cursor to the input position (on top of the bottomContent)
+        if (bottomContentHeight > 0)
+            output += ansi_escapes_1.default.cursorUp(bottomContentHeight);
+        // Return cursor to the initial left offset.
+        output += ansi_escapes_1.default.cursorTo(this.cursorPos.cols);
+        /**
+         * Render and store state for future re-rendering
+         */
+        this.write(cursorDown(this.extraLinesUnderPrompt) +
+            ansi_escapes_1.default.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(ansi_escapes_1.default.cursorTo(cursorPos.cols));
+            this.cursorPos = cursorPos;
+        }
+    }
+    done({ clearContent }) {
+        this.rl.setPrompt('');
+        let output = cursorDown(this.extraLinesUnderPrompt);
+        output += clearContent ? ansi_escapes_1.default.eraseLines(this.height) : '\n';
+        output += ansi_escapes_1.default.cursorShow;
+        this.write(output);
+        this.rl.close();
+    }
+}
+exports.default = ScreenManager;