@wocker/utils 1.0.11 → 2.0.0-beta.0

package/lib/tools/normalizeOptions.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const normalizeOptions = (rawOptions) => {
+    if (Array.isArray(rawOptions)) {
+        return rawOptions.map((option) => {
+            if (typeof option === "string") {
+                return {
+                    label: option,
+                    value: option
+                };
+            }
+            return {
+                label: option.label || option.value || "",
+                value: option.value || ""
+            };
+        });
+    }
+    return Object.keys(rawOptions).map((value) => {
+        return {
+            label: rawOptions[value],
+            value
+        };
+    });
+};
+exports.normalizeOptions = normalizeOptions;

package/lib/{volumeFormat.js → tools/volumeFormat.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.volumeFormat = void 0;
 const volumeFormat = (volume) => {
-    const { source, destination, options } = volume;
+    const { source = "/", destination = "/", options } = volume;
     return `${source}:${destination}` + (options ? `:${options}` : "");
 };
 exports.volumeFormat = volumeFormat;

package/lib/types/KeypressEvent.d.ts

@@ -0,0 +1,5 @@
+export type KeypressEvent = {
+    name: string;
+    shift?: boolean;
+    ctrl?: boolean;
+};

package/lib/types/KeypressEvent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/PromptConfig.d.ts

@@ -0,0 +1,8 @@
+import { PartialDeep } from "@inquirer/type";
+import { Theme } from "./Theme";
+import { PromptValidationConfig } from "./PromptValidationConfig";
+export type PromptConfig<V = unknown, C = object, T extends Theme = Theme> = C & PromptValidationConfig<V> & {
+    message?: string;
+    default?: V;
+    theme?: PartialDeep<T>;
+};

package/lib/types/PromptConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/PromptValidationConfig.d.ts

@@ -0,0 +1,10 @@
+import { ValidationRule } from "./ValidationRule";
+import { Validation } from "./Validation";
+export type PromptValidationConfig<V = unknown> = {
+    required?: boolean | string;
+    min?: ValidationRule<number>;
+    max?: ValidationRule<number>;
+    minLength?: ValidationRule<number>;
+    maxLength?: ValidationRule<number>;
+    validate?: Validation<V> | Record<string, Validation<V>>;
+};

package/lib/types/PromptValidationConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/Theme.d.ts

@@ -0,0 +1,6 @@
+import { Theme as InquirerTheme, Status } from "@inquirer/core";
+export type Theme<T extends object = object> = InquirerTheme<T & {
+    style: {
+        value: (value: string, status: Status) => string;
+    };
+}>;

package/lib/types/Theme.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/Validation.d.ts

@@ -0,0 +1,2 @@
+import { ValidationResult } from "./ValidationResult";
+export type Validation<T> = (value: T) => ValidationResult | Promise<ValidationResult>;

package/lib/types/Validation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ValidationError.d.ts

@@ -0,0 +1,4 @@
+export type ValidationError = {
+    message: string;
+    type: string;
+};

package/lib/types/ValidationError.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ValidationResult.d.ts

@@ -0,0 +1 @@
+export type ValidationResult = string | string[] | boolean | undefined;

package/lib/types/ValidationResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ValidationRule.d.ts

@@ -0,0 +1,3 @@
+import { ValidationValue } from "./ValidationValue";
+import { ValidationValueMessage } from "./ValidationValueMessage";
+export type ValidationRule<T extends ValidationValue = ValidationValue> = T | ValidationValueMessage<T>;

package/lib/types/ValidationRule.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ValidationValue.d.ts

@@ -0,0 +1 @@
+export type ValidationValue = boolean | number | string | RegExp;

package/lib/types/ValidationValue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ValidationValueMessage.d.ts

@@ -0,0 +1,5 @@
+import { ValidationValue } from "./ValidationValue";
+export type ValidationValueMessage<T extends ValidationValue = ValidationValue> = {
+    message: string;
+    value: T;
+};

package/lib/types/ValidationValueMessage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/validation/normalizeRule.d.ts

@@ -0,0 +1,3 @@
+import { ValidationRule } from "../types/ValidationRule";
+import { ValidationValue } from "../types/ValidationValue";
+export declare const normalizeRule: <T extends ValidationValue = ValidationValue>(rule?: ValidationRule<T>) => [T | undefined, string | undefined];

package/lib/validation/normalizeRule.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRule = void 0;
+const normalizeRule = (rule) => {
+    if (typeof rule === "undefined") {
+        return [undefined, undefined];
+    }
+    if (typeof rule === "object" && rule !== null && !(rule instanceof RegExp)) {
+        return [rule.value, rule.message];
+    }
+    return [
+        rule,
+        undefined
+    ];
+};
+exports.normalizeRule = normalizeRule;

package/lib/validation/validatePrompt.d.ts

@@ -0,0 +1,3 @@
+import { PromptValidationConfig } from "../types/PromptValidationConfig";
+import { ValidationError } from "../types/ValidationError";
+export declare const validatePrompt: <T = unknown>(value: any, config: PromptValidationConfig<T>) => Promise<undefined | ValidationError>;

package/lib/validation/validatePrompt.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePrompt = void 0;
+const normalizeRule_1 = require("./normalizeRule");
+const messages_1 = require("../messages");
+const validatePrompt = (value, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const { required, min, max, minLength, maxLength, validate } = config;
+    const isEmpty = typeof value === "undefined" ||
+        (typeof value === "boolean" && !value) ||
+        (typeof value === "string" && value === "") ||
+        (typeof value === "object" && value === null) ||
+        (typeof value === "number" && isNaN(value)) ||
+        (Array.isArray(value) && value.length === 0);
+    const isRequired = (typeof required === "boolean" && required) ||
+        typeof required === "string";
+    if (isRequired && isEmpty) {
+        return {
+            type: "required",
+            message: typeof required === "string" ? required : messages_1.messages.required
+        };
+    }
+    const [minValue, minMessage] = (0, normalizeRule_1.normalizeRule)(min);
+    if (!isEmpty && typeof minValue !== "undefined") {
+        if (typeof value === "number" && value < minValue) {
+            return {
+                type: "min",
+                message: minMessage || messages_1.messages.min(minValue)
+            };
+        }
+    }
+    const [maxValue, maxMessage] = (0, normalizeRule_1.normalizeRule)(max);
+    if (!isEmpty && typeof maxValue !== "undefined") {
+        if (typeof value === "number" && value > maxValue) {
+            return {
+                type: "max",
+                message: maxMessage || messages_1.messages.max(maxValue)
+            };
+        }
+    }
+    const [minLengthValue, minLengthMessage] = (0, normalizeRule_1.normalizeRule)(minLength);
+    if (!isEmpty && typeof minLengthValue !== "undefined") {
+        const validateValue = typeof value === "number"
+            ? value.toString()
+            : value;
+        if (typeof validateValue === "string" && validateValue.length < minLengthValue) {
+            return {
+                type: "minLength",
+                message: minLengthMessage || messages_1.messages.minLength(minLengthValue)
+            };
+        }
+        if (Array.isArray(value) && value.length < minLengthValue) {
+            return {
+                type: "minLength",
+                message: minLengthMessage || messages_1.messages.minArrayLength(minLengthValue)
+            };
+        }
+    }
+    const [maxLengthValue, maxLengthMessage = ""] = (0, normalizeRule_1.normalizeRule)(maxLength);
+    if (!isEmpty && typeof maxLengthValue === "number") {
+        const validateValue = typeof value === "number"
+            ? value.toString()
+            : value;
+        if (typeof validateValue === "string" && validateValue.length > maxLengthValue) {
+            return {
+                type: "maxLength",
+                message: maxLengthMessage || messages_1.messages.maxLength(maxLengthValue)
+            };
+        }
+        if (Array.isArray(value) && value.length > maxLengthValue) {
+            return {
+                type: "maxLength",
+                message: maxLengthMessage || messages_1.messages.maxArrayLength(maxLengthValue)
+            };
+        }
+    }
+    if (validate) {
+        const rules = typeof validate === "function"
+            ? { validate }
+            : validate;
+        for (const name in rules) {
+            const result = yield rules[name](value);
+            if (result === false || typeof result === "string") {
+                return {
+                    message: typeof result === "string" ? result : messages_1.messages.custom,
+                    type: "custom"
+                };
+            }
+        }
+    }
+    return undefined;
+});
+exports.validatePrompt = validatePrompt;

package/lib/validators/index.d.ts

@@ -0,0 +1 @@
+export * from "./validateVolume";

package/lib/validators/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./validateVolume"), exports);

package/lib/validators/validateVolume.d.ts

@@ -0,0 +1,2 @@
+import { Validation } from "../types/Validation";
+export declare const validateVolume: Validation<unknown>;

package/lib/validators/validateVolume.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateVolume = void 0;
+const messages_1 = require("../messages");
+const validateVolume = (value) => {
+    if (typeof value === "undefined" || value === null || value === "") {
+        return true;
+    }
+    if (typeof value !== "string") {
+        return messages_1.messages.volume.notAString;
+    }
+    if (value.length > 255) {
+        return messages_1.messages.volume.tooLong;
+    }
+    if (!/^[A-Za-z0-9]+(?:[-_]+[A-Za-z0-9]+)*$/.test(value)) {
+        return messages_1.messages.volume.invalidCharacters;
+    }
+    return true;
+};
+exports.validateVolume = validateVolume;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/utils",
-    "version": "1.0.11",
+    "version": "2.0.0-beta.0",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Utils for @wocker",
     "license": "MIT",
@@ -20,16 +20,27 @@
         "url": "https://github.com/kearisp/wocker-utils/issues"
     },
     "scripts": {
-        "prepare": "npm run build",
-        "watch": "tsc -w",
-        "build": "tsc",
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "prepublishOnly": "npm run build",
+        "build": "tsc --project tsconfig.build.json",
+        "watch": "tsc -w --project tsconfig.build.json",
+        "test": "jest",
+        "posttest": "jest-coverage-badges --output ./coverage/badges",
+        "test-watch": "jest --watchAll"
     },
     "dependencies": {
-        "inquirer": "^7.3.3"
+        "@inquirer/core": "^10.1.10"
     },
     "devDependencies": {
-        "@types/inquirer": "^7.3.3",
+        "@inquirer/testing": "^2.1.46",
+        "@inquirer/type": "^3.0.6",
+        "@types/jest": "^29.5.14",
+        "@types/mute-stream": "^0.0.4",
+        "@types/node": "^22.14.1",
+        "jest": "^29.7.0",
+        "jest-coverage-badges": "^1.1.2",
+        "mute-stream": "^2.0.0",
+        "ts-jest": "^29.3.2",
+        "ts-node": "^10.9.2",
         "typescript": "^5.8.3"
     }
 }

package/test/makes/CustomMuteStream.ts

@@ -0,0 +1,116 @@
+import MuteStream from "mute-stream";
+
+
+export class CustomMuteStream extends MuteStream {
+    protected _listeners: {
+        [event: string]: Map<any, any>;
+    } = {};
+    protected _waiters: {
+        [event: string]: {
+            completed: number;
+            resolve: (value: void | PromiseLike<void>) => void;
+        };
+    } = {};
+
+    protected getOverride(event: string, listener: any) {
+        if(!this._listeners) {
+            this._listeners = {};
+        }
+
+        if(!this._listeners[event]) {
+            this._listeners[event] = new Map();
+        }
+
+        let override = this._listeners[event].get(listener);
+
+        if(!override) {
+            override = async (...args: any[]) => {
+                const result = await listener(...args);
+
+                if(!this._waiters) {
+                    this._waiters = {};
+                }
+
+                if(this._waiters[event]) {
+                    this._waiters[event].completed++;
+
+                    if(this._waiters[event].completed === this._listeners[event].size) {
+                        this._waiters[event].resolve();
+                    }
+                }
+
+                return result;
+            };
+
+            this._listeners[event].set(listener, override);
+        }
+
+        return override;
+    }
+
+    protected hasOverride(event: string, listener: any) {
+        return this._listeners && this._listeners[event] && this._listeners[event].has(listener);
+    }
+
+    protected removeOverride(event: string, listener: any) {
+        if(!this.hasOverride(event, listener)) {
+            return;
+        }
+
+        this._listeners[event].delete(listener);
+    }
+
+    public on(event: any, listener: any): this {
+        const override = this.getOverride(event, listener);
+
+        super.on(event, override);
+
+        return this;
+    }
+
+    public addListener(event: any, listener: any): this {
+        const override = this.getOverride(event, listener);
+
+        super.addListener(event, override);
+
+        return this;
+    }
+
+    public off(event: any, listener: any): this {
+        if(this.hasOverride(event, listener)) {
+            const override = this.getOverride(event, listener);
+            super.off(event, override);
+            this.removeOverride(event, listener);
+        }
+        else {
+            super.off(event, listener);
+        }
+
+        return this;
+    }
+
+    public removeListener(event: any, listener: any): this {
+        if(this.hasOverride(event, listener)) {
+            const override = this.getOverride(event, listener);
+
+            super.removeListener(event, override);
+            this.removeOverride(event, listener);
+        }
+        else {
+            super.removeListener(event, listener);
+        }
+
+        return this;
+    }
+
+    public async wait(event: string, data: any, key: any): Promise<void> {
+        return new Promise<void>((resolve) => {
+            this._waiters[event] = {
+                resolve,
+                completed: 0
+            };
+
+            this.emit(event, data, key);
+        });
+    }
+}

package/test/makes/PromptSimulator.ts

@@ -0,0 +1,55 @@
+import {CustomMuteStream} from "./CustomMuteStream";
+import {KeypressEvent} from "../../src/types/KeypressEvent";
+import EventEmitter from "node:events";
+
+
+export class PromptSimulator {
+    protected emitter: EventEmitter;
+
+    constructor(
+        protected readonly input: CustomMuteStream
+    ) {
+        this.emitter = new EventEmitter();
+    }
+
+    public async keypress(key: string | KeypressEvent) {
+        const event = typeof key === "string" ? {
+            name: key
+        } : key;
+
+        return this.input.wait("keypress", null, event);
+    }
+
+    public async type(text: string) {
+        this.input.write(text);
+
+        for(const char of text) {
+            await this.input.wait("keypress", null, {
+                name: char
+            });
+        }
+    }
+
+    public async process(events: (string | KeypressEvent)[]): Promise<void> {
+        const typeReg = /^type:(.*)$/;
+
+        for(const event of events) {
+            if(typeof event === "string" && typeReg.test(event)) {
+                const [, text = ""] = typeReg.exec(event) || [];
+
+                await this.type(text);
+                continue;
+            }
+
+            await this.keypress(event);
+        }
+    }
+
+    public onAbort(handle: () => void) {
+        this.emitter.on("abort", handle);
+    }
+
+    public abort() {
+        this.emitter.emit("abort");
+    }
+}

package/test/tools/render.ts

@@ -0,0 +1,32 @@
+import {render} from "@inquirer/testing";
+import {Prompt, Context} from "@inquirer/type";
+import {CustomMuteStream} from "../makes/CustomMuteStream";
+import {PromptSimulator} from "../makes/PromptSimulator";
+
+
+export const customRender = async <const C, const V>(
+    prompt: Prompt<V, C>,
+    config: C,
+    options?: Omit<Context, "signal" | "input">
+) => {
+    const input = new CustomMuteStream(),
+          events = new PromptSimulator(input),
+          abortController = new AbortController();
+
+    const data = await render(prompt, config, {
+        ...options || {},
+        input,
+        signal: abortController.signal
+    });
+
+    events.onAbort(() => {
+        data.answer.catch(() => undefined);
+        abortController.abort();
+    });
+
+    return {
+        ...data,
+        input,
+        events
+    };
+};

package/lib/normalizeOptions.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeOptions = void 0;
-const normalizeOptions = (rawOptions) => {
-    return Array.isArray(rawOptions)
-        ? rawOptions.map((option) => {
-            return {
-                label: typeof option === "string"
-                    ? option
-                    : option.label || option.value || "",
-                value: typeof option === "string"
-                    ? option
-                    : option.value || ""
-            };
-        })
-        : Object.keys(rawOptions).map((value) => {
-            return {
-                label: rawOptions[value],
-                value
-            };
-        });
-};
-exports.normalizeOptions = normalizeOptions;

package/lib/promptConfig.d.ts

@@ -1,14 +0,0 @@
-import { PromptConfirmOptions } from "./promptConfirm";
-import { PromptSelectOptions } from "./promptSelect";
-import { PromptTextOptions } from "./promptText";
-type ConfirmOptions = PromptConfirmOptions & {
-    type: "boolean";
-};
-type SelectOptions = PromptSelectOptions & {
-    type: "select";
-};
-type Options = {
-    [key: string]: PromptTextOptions | ConfirmOptions | SelectOptions;
-};
-export declare const promptConfig: (options: Options, values?: any) => Promise<any>;
-export {};