@gesslar/toolkit 3.12.3 → 3.14.0

package/src/types/lib/Term.d.ts

@@ -1,127 +0,0 @@
-export default class Term {
-    /**
-     * Log an informational message.
-     *
-     * @param {...unknown} [arg] - Values to log.
-     */
-    static log(...arg?: unknown[]): void;
-    /**
-     * Log an informational message.
-     *
-     * @param {...unknown} [arg] - Values to log.
-     */
-    static info(...arg?: unknown[]): void;
-    /**
-     * Log a warning message.
-     *
-     * @param {...unknown} [arg] - Warning text / object.
-     */
-    static warn(...arg?: unknown[]): void;
-    /**
-     * Log an error message (plus optional details).
-     *
-     * @param {...unknown} [arg] - Values to log.
-     */
-    static error(...arg?: unknown[]): void;
-    /**
-     * Log a debug message (no-op unless console.debug provided/visible by env).
-     *
-     * @param {...unknown} [arg] - Values to log.
-     */
-    static debug(...arg?: unknown[]): void;
-    /**
-     * Start a console group for indented output.
-     *
-     * @param {...unknown} [arg] - Optional group label.
-     */
-    static group(...arg?: unknown[]): void;
-    /**
-     * End the current console group.
-     */
-    static groupEnd(): void;
-    /**
-     * Display tabular data as a table.
-     *
-     * @param {object | Array} tabularData - Object or array to display.
-     * @param {object} [options] - Table options.
-     * @param {Array<string>} [options.properties] - Optional column properties to display.
-     * @param {boolean} [options.showHeader=false] - Whether to show the header row with column names.
-     * @param {boolean} [options.quotedStrings=false] - Whether to show quotes around strings.
-     */
-    static table(tabularData: object | any[], options?: {
-        properties?: Array<string>;
-        showHeader?: boolean;
-        quotedStrings?: boolean;
-    }): void;
-    /**
-     * Emit a status line to the terminal.
-     *
-     * Accepts either a plain string or an array of message segments (see
-     * `terminalMessage()` for formatting options). If `silent` is true, output
-     * is suppressed.
-     *
-     * This is a convenient shortcut for logging status updates, with optional
-     * formatting and easy suppression.
-     *
-     * @param {string | Array<string | [string, string]>} args - Message or segments.
-     * @param {object} [options] - Behaviour flags.
-     * @param {boolean} options.silent - When true, suppress output.
-     * @returns {void}
-     */
-    static status(args: string | Array<string | [string, string]>, { silent }?: {
-        silent: boolean;
-    }): void;
-    /**
-     * Constructs a formatted status line.
-     *
-     * Input forms:
-     *  - string: printed as-is
-     *  - array: each element is either:
-     *    - a plain string (emitted unchanged), or
-     *    - a tuple: [level, text] where `level` maps to an ansiColors alias
-     *        (e.g. success, info, warn, error, modified).
-     *    - a tuple: [level, text, [openBracket,closeBracket]] where `level` maps to an ansiColors alias
-     *        (e.g. success, info, warn, error, modified). These are rendered as
-     *        colourised bracketed segments: [TEXT].
-     *
-     * The function performs a shallow validation: tuple elements must both be
-     * strings; otherwise a TypeError is thrown. Nested arrays beyond depth 1 are
-     * not supported.
-     *
-     * Recursion: array input is normalised into a single string then re-dispatched
-     * through `status` to leverage the string branch (keeps logic DRY).
-     *
-     * @param {string | Array<string | [string, string] | [string, string, string]>} argList - Message spec.
-     * @returns {void}
-     */
-    static terminalMessage(argList: string | Array<string | [string, string] | [string, string, string]>): void;
-    /**
-     * Construct a single coloured bracketed segment from a tuple specifying
-     * the style level and the text. The first element ("level") maps to an
-     * `ansiColors` alias (e.g. success, info, warn, error, modified) and is
-     * used both for the inner text colour and to locate its matching
-     * "-bracket" alias for the surrounding square brackets. The second
-     * element is the raw text to display.
-     *
-     * Input validation: every element of `parts` must be a string; otherwise
-     * an `Sass` error is thrown. (Additional elements beyond the first two are
-     * ignored – the method destructures only the first pair.)
-     *
-     * Example:
-     *  terminalBracket(["success", "COMPILED"]) → "[COMPILED]" with coloured
-     *  brackets + inner text (assuming colour support is available in the
-     *  terminal).
-     *
-     * This method does not append trailing spaces; callers are responsible for
-     * joining multiple segments with appropriate separators.
-     *
-     * @param {Array<string>} parts - Tuple: [level, text]. Additional entries ignored.
-     * @returns {string} Colourised bracketed segment (e.g. "[TEXT]").
-     * @throws {Sass} If any element of `parts` is not a string.
-     */
-    static terminalBracket([level, text, brackets]: Array<string>): string;
-    static resetTerminal(): Promise<void>;
-    static clearLines(num: any): Promise<void>;
-    static directWrite(output: any): Promise<any>;
-}
-//# sourceMappingURL=Term.d.ts.map

package/src/types/lib/Term.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Term.d.ts","sourceRoot":"","sources":["../../lib/Term.js"],"names":[],"mappings":"AAOA;IACE;;;;OAIG;IACH,oBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;OAEG;IACH,wBAEC;IAED;;;;;;;;OAQG;IACH,0BANW,MAAM,QAAQ,YAEtB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QA2DA;IAED;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,eAEjD;QAAyB,MAAM,EAAvB,OAAO;KACf,GAAU,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAHW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,GAClE,IAAI,CA4BhB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,gDAJW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CASlB;IAED,sCAGC;IAED,2CAEC;IAED,8CAIC;CACF"}

package/src/types/lib/Util.d.ts

@@ -1,100 +0,0 @@
-/**
- * Utility class providing common helper functions for string manipulation,
- * timing, hashing, and option parsing.
- */
-export default class Util extends BrowserUtil {
-    /**
-     * Compute sha256 hash (hex) of the provided string.
-     *
-     * @param {string} s - Input string.
-     * @returns {string} 64-char hexadecimal digest.
-     */
-    static hashOf(s: string): string;
-    /**
-     * Extracts canonical option names from a Commander-style options object.
-     *
-     * Each key in the input object is a string containing one or more option
-     * forms, separated by commas (e.g. "-w, --watch"). This function splits each
-     * key, trims whitespace, and parses out the long option name (e.g. "watch")
-     * for each entry. If no long option ("--") is present, the short option (e.g.
-     * "v" from "-v") will be included in the result array. If both are present,
-     * the long option is preferred.
-     *
-     * Example:
-     *   generateOptionNames({"-w, --watch": "desc", "-v": "desc"})
-     *   → ["watch", "v"]
-     *
-     * Edge cases:
-     *   - If a key contains only a short option ("-v"), that short name will be
-     *     included in the result.
-     *   - If multiple long options are present, only the first is used.
-     *   - If the option string is malformed, may return undefined for that entry
-     *     (filtered out).
-     *
-     * @param {object} object - Mapping of option strings to descriptions.
-     * @returns {Array<string>} Array of canonical option names (long preferred, short if no long present).
-     */
-    static generateOptionNames(object: object): Array<string>;
-    /**
-     * Private method that performs the actual async emission logic.
-     * Handles listener execution, error aggregation, and result processing.
-     *
-     * @param {object} emitter - The emitter object (already validated)
-     * @param {string} event - The event name to emit
-     * @param {...unknown} args - Arguments to pass to event listeners
-     * @returns {Promise<void>} Resolves when all listeners have completed
-     */
-    static "__#private@#performAsyncEmit"(emitter: object, event: string, ...args: unknown[]): Promise<void>;
-    /**
-     * Emits an event asynchronously and waits for all listeners to complete.
-     * Unlike the standard EventEmitter.emit() which is synchronous, this method
-     * properly handles async event listeners by waiting for all of them to
-     * resolve or reject using Promise.allSettled().
-     *
-     * Uses strict instanceof checking to ensure the emitter is a genuine EventEmitter.
-     *
-     * @param {EventEmitter} emitter - The EventEmitter instance to emit on
-     * @param {string} event - The event name to emit
-     * @param {...unknown} args - Arguments to pass to event listeners
-     * @returns {Promise<void>} Resolves when all listeners have completed
-     */
-    static asyncEmit(emitter: EventEmitter, event: string, ...args: unknown[]): Promise<void>;
-    /**
-     * Emits an event asynchronously and waits for all listeners to complete.
-     * Like asyncEmit, but uses duck typing for more flexible emitter validation.
-     * Accepts any object that has the required EventEmitter-like methods.
-     * If it walks like an EventEmitter and quacks like an EventEmitter...
-     *
-     * @param {object} emitter - Any object with EventEmitter-like interface
-     * @param {string} event - The event name to emit
-     * @param {...unknown} args - Arguments to pass to event listeners
-     * @returns {Promise<void>} Resolves when all listeners have completed, but no grapes.
-     */
-    static asyncEmitQuack(emitter: object, event: string, ...args: unknown[]): Promise<void>;
-    /**
-     * Retrieves an environment variable and parses it as JSON5.
-     *
-     * This method fetches the value of the specified environment variable and
-     * attempts to parse it using JSON5. If the variable doesn't exist or is
-     * empty, the default value is returned. If parsing fails, an error is
-     * thrown.
-     *
-     * Example:
-     *   // export MY_CONFIG='{"debug": true, timeout: 5000}'
-     *   Util.getEnv("MY_CONFIG", {debug: false})
-     *   → {debug: true, timeout: 5000}
-     *
-     * Edge cases:
-     *   - If the environment variable doesn't exist, returns the default value
-     *   - If the value is an empty string, returns the default value
-     *   - If JSON5 parsing fails, throws a Sass error with context
-     *
-     * @param {string} ev - Name of the environment variable to retrieve
-     * @param {unknown} [def=undefined] - Default value if variable doesn't exist or is empty
-     * @returns {unknown} Parsed JSON5 value or default
-     * @throws {Sass} If JSON5 parsing fails
-     */
-    static getEnv(ev: string, def?: unknown): unknown;
-}
-import { Util as BrowserUtil } from "../browser/index.js";
-//# sourceMappingURL=Util.d.ts.map

package/src/types/lib/Util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../lib/Util.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mCAHW,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAazB;IAED;;;;;;;;OAQG;IACH,+CALW,MAAM,SACN,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED;;;;;;;;;;;;OAYG;IACH,0BALW,YAAY,SACZ,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAqBzB;IAED;;;;;;;;;;OAUG;IACH,+BALW,MAAM,SACN,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,kBALW,MAAM,QACN,OAAO,GACL,OAAO,CAmBnB;CACF;oCApMiC,qBAAqB"}

package/src/types/lib/Valid.d.ts

@@ -1,33 +0,0 @@
-/**
- * Validation utility class providing type checking and assertion methods.
- */
-export default class Valid {
-    static "__#private@#restrictedProto": string[];
-    /**
-     * Validates a value against a type. Uses Data.isType.
-     *
-     * @param {unknown} value - The value to validate
-     * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
-     * @param {object} [options] - Additional options for validation.
-     */
-    static type(value: unknown, type: string, options?: object): void;
-    /**
-     * Asserts a condition
-     *
-     * @param {boolean} condition - The condition to assert
-     * @param {string} message - The message to display if the condition is not
-     *                           met
-     * @param {number} [arg] - The argument to display if the condition is not
-     *                         met (optional)
-     */
-    static assert(condition: boolean, message: string, arg?: number): void;
-    /**
-     * Protects against prototype pollution by checking keys for dangerous property names.
-     * Throws if any restricted prototype properties are found in the keys array.
-     *
-     * @param {Array<string>} keys - Array of property keys to validate
-     * @throws {Sass} If any key matches restricted prototype properties (__proto__, constructor, prototype)
-     */
-    static prototypePollutionProtection(keys: Array<string>): void;
-}
-//# sourceMappingURL=Valid.d.ts.map

package/src/types/lib/Valid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Valid.d.ts","sourceRoot":"","sources":["../../lib/Valid.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IACE,+CAAmE;IAEnE;;;;;;OAMG;IACH,mBAJW,OAAO,QACP,MAAM,YACN,MAAM,QAQhB;IAED;;;;;;;;OAQG;IACH,yBANW,OAAO,WACP,MAAM,QAEN,MAAM,QAkBhB;IAED;;;;;;OAMG;IACH,0CAHW,KAAK,CAAC,MAAM,CAAC,QAYvB;CACF"}