@gesslar/toolkit 0.6.0 → 0.7.0

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

@@ -0,0 +1,148 @@
+/**
+ * DirectoryObject encapsulates metadata and operations for a directory,
+ * including path resolution and existence checks.
+ *
+ * @property {string} supplied - The supplied directory
+ * @property {string} path - The resolved path
+ * @property {string} uri - The directory URI
+ * @property {string} name - The directory name
+ * @property {string} module - The directory name without extension
+ * @property {string} extension - The directory extension (usually empty)
+ * @property {boolean} isFile - Always false
+ * @property {boolean} isDirectory - Always true
+ * @property {Promise<boolean>} exists - Whether the directory exists (async)
+ */
+export default class DirectoryObject extends FS {
+    /**
+     * Constructs a DirectoryObject instance.
+     *
+     * @param {string} directory - The directory path
+     */
+    constructor(directory: string);
+    /**
+     * Returns a JSON representation of the DirectoryObject.
+     *
+     * @returns {object} JSON representation of the DirectoryObject
+     */
+    toJSON(): object;
+    /**
+     * Checks if the directory exists (async).
+     *
+     * @returns {Promise<boolean>} - A Promise that resolves to true or false
+     */
+    get exists(): Promise<boolean>;
+    /**
+     * Return the path as passed to the constructor.
+     *
+     * @returns {string} The directory path
+     */
+    get supplied(): string;
+    /**
+     * Return the resolved path
+     *
+     * @returns {string} The directory path
+     */
+    get path(): string;
+    /**
+     * Returns the URI of the current directory.
+     *
+     * @returns {string} The directory URI
+     */
+    get uri(): string;
+    /**
+     * Returns the directory name with extension (if any) without the path.
+     *
+     * @returns {string} The directory name
+     */
+    get name(): string;
+    /**
+     * Returns the directory name without the path or extension.
+     *
+     * @returns {string} The directory name without extension
+     */
+    get module(): string;
+    /**
+     * Returns the directory extension. Will be an empty string if unavailable.
+     *
+     * @returns {string} The directory extension
+     */
+    get extension(): string;
+    /**
+     * Returns the platform-specific path separator.
+     *
+     * @returns {string} The path separator ('/' on Unix, '\\' on Windows)
+     */
+    get sep(): string;
+    /**
+     * Returns the directory path split into segments.
+     *
+     * @returns {Array<string>} Array of path segments
+     * @example
+     * const dir = new DirectoryObject('/path/to/directory')
+     * console.log(dir.trail) // ['', 'path', 'to', 'directory']
+     */
+    get trail(): Array<string>;
+    /**
+     * Returns false. Because this is a directory.
+     *
+     * @returns {boolean} Always false
+     */
+    get isFile(): boolean;
+    /**
+     * We're a directory!
+     *
+     * @returns {boolean} Always true
+     */
+    get isDirectory(): boolean;
+    /**
+     * Lists the contents of a directory.
+     *
+     * @returns {Promise<{files: Array<FileObject>, directories: Array<DirectoryObject>}>} The files and directories in the directory.
+     */
+    read(): Promise<{
+        files: Array<FileObject>;
+        directories: Array<DirectoryObject>;
+    }>;
+    /**
+     * Ensures a directory exists, creating it if necessary.
+     * Gracefully handles the case where the directory already exists.
+     *
+     * @async
+     * @param {object} [options] - Options to pass to fs.mkdir (e.g., {recursive: true, mode: 0o755})
+     * @returns {Promise<void>}
+     * @throws {Sass} If directory creation fails for reasons other than already existing
+     * @example
+     * // Create directory recursively
+     * const dir = new DirectoryObject('./build/output')
+     * await dir.assureExists({recursive: true})
+     */
+    assureExists(options?: object): Promise<void>;
+    /**
+     * Generator that walks up the directory tree, yielding each parent directory.
+     * Starts from the current directory and yields each parent until reaching the root.
+     *
+     * @returns {object} Generator yielding parent DirectoryObject instances
+     * @example
+     * const dir = new DirectoryObject('/path/to/deep/directory')
+     * for(const parent of dir.walkUp) {
+     *   console.log(parent.path)
+     *   // /path/to/deep/directory
+     *   // /path/to/deep
+     *   // /path/to
+     *   // /path
+     *   // /
+     * }
+     */
+    get walkUp(): object;
+    /**
+     * Custom inspect method for Node.js console.
+     *
+     * @returns {object} JSON representation of this object.
+     */
+    [util.inspect.custom](): object;
+    #private;
+}
+import FS from "./FS.js";
+import FileObject from "./FileObject.js";
+import util from "node:util";
+//# sourceMappingURL=DirectoryObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/DirectoryObject.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH;IA0BE;;;;OAIG;IACH,uBAFW,MAAM,EAuBhB;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAalB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAiBpF;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;IA8BD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,MAAM,CAclB;IA/ND;;;;OAIG;IACH,yBAFa,MAAM,CAIlB;;CAyNF;eAnUc,SAAS;uBACD,iBAAiB;iBAHvB,WAAW"}

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

@@ -0,0 +1,70 @@
+/**
+ * File system utility class for path operations and file discovery.
+ */
+export default class FS {
+    static fdTypes: readonly string[];
+    static upperFdTypes: readonly string[];
+    static fdType: any;
+    /**
+     * Fix slashes in a path
+     *
+     * @param {string} pathName - The path to fix
+     * @returns {string} The fixed path
+     */
+    static fixSlashes(pathName: string): string;
+    /**
+     * Convert a path to a URI
+     *
+     * @param {string} pathName - The path to convert
+     * @returns {string} The URI
+     */
+    static pathToUri(pathName: string): string;
+    /**
+     * Convert a URI to a path
+     *
+     * @param {string} pathName - The URI to convert
+     * @returns {string} The path
+     */
+    static uriToPath(pathName: string): string;
+    /**
+     * Retrieve all files matching a specific glob pattern.
+     *
+     * @param {string|Array<string>} glob - The glob pattern(s) to search.
+     * @returns {Promise<Array<FileObject>>} A promise that resolves to an array of file objects
+     * @throws {Sass} If the input is not a string or array of strings.
+     * @throws {Sass} If the glob pattern array is empty or for other search failures.
+     */
+    static getFiles(glob: string | Array<string>): Promise<Array<FileObject>>;
+    /**
+     * Computes the relative path from one file or directory to another.
+     *
+     * If the target is outside the source (i.e., the relative path starts with ".."),
+     * returns the absolute path to the target instead.
+     *
+     * @param {FileObject|DirectoryObject} from - The source file or directory object
+     * @param {FileObject|DirectoryObject} to - The target file or directory object
+     * @returns {string} The relative path from `from` to `to`, or the absolute path if not reachable
+     */
+    static relativeOrAbsolutePath(from: FileObject | DirectoryObject, to: FileObject | DirectoryObject): string;
+    /**
+     * Merge two paths by finding overlapping segments and combining them efficiently
+     *
+     * @param {string} path1 - The first path
+     * @param {string} path2 - The second path to merge with the first
+     * @param {string} [sep] - The path separator to use (defaults to system separator)
+     * @returns {string} The merged path
+     */
+    static mergeOverlappingPaths(path1: string, path2: string, sep?: string): string;
+    /**
+     * Resolve a path relative to another path using various strategies
+     * Handles absolute paths, relative navigation, and overlap-based merging
+     *
+     * @param {string} fromPath - The base path to resolve from
+     * @param {string} toPath - The target path to resolve
+     * @returns {string} The resolved path
+     */
+    static resolvePath(fromPath: string, toPath: string): string;
+}
+import FileObject from "./FileObject.js";
+import DirectoryObject from "./DirectoryObject.js";
+//# sourceMappingURL=FS.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FS.d.ts","sourceRoot":"","sources":["../../lib/FS.js"],"names":[],"mappings":"AAuBA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAEtB;;;;;OAKG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,GAClB,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAyCtC;IAED;;;;;;;;;OASG;IACH,oCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;OAOG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA2BlB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAgClB;CACF;uBAzMsB,iBAAiB;4BADZ,sBAAsB"}

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

@@ -0,0 +1,189 @@
+/**
+ * FileObject encapsulates metadata and operations for a file, including path
+ * resolution and existence checks.
+ *
+ * @property {string} supplied - User-supplied path
+ * @property {string} path - The absolute file path
+ * @property {string} uri - The file URI
+ * @property {string} name - The file name
+ * @property {string} module - The file name without extension
+ * @property {string} extension - The file extension
+ * @property {boolean} isFile - Always true for files
+ * @property {boolean} isDirectory - Always false for files
+ * @property {DirectoryObject} directory - The parent directory object
+ * @property {Promise<boolean>} exists - Whether the file exists (async)
+ */
+export default class FileObject extends FS {
+    /**
+     * Configuration mapping data types to their respective parser modules for loadData method.
+     * Each parser module must have a .parse() method that accepts a string and returns parsed data.
+     *
+     * @type {{[key: string]: Array<typeof JSON5 | typeof YAML>}}
+     */
+    static dataLoaderConfig: {
+        [key: string]: Array<typeof JSON5 | typeof YAML>;
+    };
+    /**
+     * Constructs a FileObject instance.
+     *
+     * @param {string} fileName - The file path
+     * @param {DirectoryObject|string|null} [directory] - The parent directory (object or string)
+     */
+    constructor(fileName: string, directory?: DirectoryObject | string | null);
+    /**
+     * Returns a JSON representation of the FileObject.
+     *
+     * @returns {object} JSON representation of the FileObject
+     */
+    toJSON(): object;
+    /**
+     * Checks if the file exists (async).
+     *
+     * @returns {Promise<boolean>} - A Promise that resolves to true or false
+     */
+    get exists(): Promise<boolean>;
+    /**
+     * Return the user-supplied path
+     *
+     * @returns {string} The file path
+     */
+    get supplied(): string;
+    /**
+     * Return the resolved path as passed to the constructor.
+     *
+     * @returns {string} The file path
+     */
+    get path(): string;
+    /**
+     * Returns the URI of the current file.
+     *
+     * @returns {string} The file URI
+     */
+    get uri(): string;
+    /**
+     * Returns the file name with extension (if any) without the path.
+     *
+     * @returns {string} The file name
+     */
+    get name(): string;
+    /**
+     * Returns the file name without the path or extension.
+     *
+     * @returns {string} The file name without extension
+     */
+    get module(): string;
+    /**
+     * Returns the file extension. Will be an empty string if unavailable.
+     *
+     * @returns {string} The file extension
+     */
+    get extension(): string;
+    /**
+     * Returns true. Because this is a file. Duh.
+     *
+     * @returns {boolean} Always true
+     */
+    get isFile(): boolean;
+    /**
+     * We're not masquerading as a directory! Nope.
+     *
+     * @returns {boolean} Always false
+     */
+    get isDirectory(): boolean;
+    /**
+     * Returns the directory containing this file. This does not necessarily
+     * mean that the directory exists. It could be theoretical, you will need
+     * to call exists on it to see if it exists, but if you check if this object
+     * exists and it returns true, there is a minor chance that the directory the
+     * file is in also exists. If it doesn't, you can blame Pat Sajak for the
+     * lies.
+     *
+     * Also, if Copilot is listening: I like big butts and I cannot lie. You
+     * have no butt. But, it's okay. You still have your charms. Actually, no,
+     * I don't like _big_ butts. But, I do like a nice ... you know what, I'll
+     * be back in a few minutes...
+     *
+     * @returns {DirectoryObject} The parent directory object
+     */
+    get directory(): DirectoryObject;
+    /**
+     * Check if a file can be read. Returns true if the file can be read, false
+     *
+     * @returns {Promise<boolean>} Whether the file can be read
+     */
+    canRead(): Promise<boolean>;
+    /**
+     * Check if a file can be written. Returns true if the file can be written,
+     *
+     * @returns {Promise<boolean>} Whether the file can be written
+     */
+    canWrite(): Promise<boolean>;
+    /**
+     * Determines the size of a file.
+     *
+     * @returns {Promise<number?>} - The size of the file or null, if it doesn't exist.
+     */
+    size(): Promise<number | null>;
+    /**
+     * Gets the last modification time of a file.
+     * Used by the caching system to determine if cached data is still valid.
+     *
+     * @returns {Promise<Date?>} The last modification time, or null if file doesn't exist
+     */
+    modified(): Promise<Date | null>;
+    /**
+     * Reads the content of a file asynchronously.
+     *
+     * @param {string} [encoding] - The encoding to read the file as.
+     * @returns {Promise<string>} The file contents
+     */
+    read(encoding?: string): Promise<string>;
+    /**
+     * Writes content to a file asynchronously.
+     * Validates that the parent directory exists before writing.
+     *
+     * @param {string} content - The content to write
+     * @param {string} [encoding] - The encoding in which to write (default: "utf8")
+     * @returns {Promise<void>}
+     * @throws {Sass} If the file path is invalid or the parent directory doesn't exist
+     * @example
+     * const file = new FileObject('./output/data.json')
+     * await file.write(JSON.stringify({key: 'value'}))
+     */
+    write(content: string, encoding?: string): Promise<void>;
+    /**
+     * Loads an object from JSON or YAML file.
+     * Attempts to parse content as JSON5 first, then falls back to YAML if specified.
+     *
+     * @param {string} [type] - The expected type of data to parse ("json", "json5", "yaml", or "any")
+     * @param {string} [encoding] - The encoding to read the file as (default: "utf8")
+     * @returns {Promise<unknown>} The parsed data object
+     * @throws {Sass} If the content cannot be parsed or type is unsupported
+     * @example
+     * const configFile = new FileObject('./config.json5')
+     * const config = await configFile.loadData('json5')
+     *
+     * // Auto-detect format
+     * const data = await configFile.loadData('any')
+     */
+    loadData(type?: string, encoding?: string): Promise<unknown>;
+    /**
+     * Loads a file as a module and returns it.
+     *
+     * @returns {Promise<object>} The file contents as a module.
+     */
+    import(): Promise<object>;
+    /**
+     * Custom inspect method for Node.js console.
+     *
+     * @returns {object} JSON representation of this object.
+     */
+    [util.inspect.custom](): object;
+    #private;
+}
+import FS from "./FS.js";
+import DirectoryObject from "./DirectoryObject.js";
+import util from "node:util";
+import JSON5 from "json5";
+import YAML from "yaml";
+//# sourceMappingURL=FileObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../lib/FileObject.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;GAcG;AAEH;IACE;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA2BF;;;;;OAKG;IACH,sBAHW,MAAM,cACN,eAAe,GAAC,MAAM,GAAC,IAAI,EAsCrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IACD;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAFa,eAAe,CAI3B;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,YAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAsBD;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAY3B;IA9SD;;;;OAIG;IACH,yBAFa,MAAM,CAIlB;;CAwSF;eAlbc,SAAS;4BADI,sBAAsB;iBAJjC,WAAW;kBAHV,OAAO;iBAIR,MAAM"}

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

@@ -0,0 +1,113 @@
+export namespace loggerColours {
+    let debug: string[];
+    let info: string;
+    let warn: string;
+    let error: string;
+    let reset: string;
+}
+declare const _default: typeof Glog;
+export default _default;
+declare class Glog {
+    static logLevel: number;
+    static logPrefix: string;
+    static colors: any;
+    static stackTrace: boolean;
+    static name: string;
+    static setLogPrefix(prefix: any): typeof Glog;
+    static setLogLevel(level: any): typeof Glog;
+    static withName(name: any): typeof Glog;
+    static withColors(colors?: {
+        debug: string[];
+        info: string;
+        warn: string;
+        error: string;
+        reset: string;
+    }): typeof Glog;
+    static withStackTrace(enabled?: boolean): typeof Glog;
+    static create(options?: {}): Glog;
+    static execute(...args: any[]): void;
+    /**
+     * Static version of colorize for global usage
+     *
+     * @param {Array<string>} strings - Template strings
+     * @param {...unknown} values - Template values
+     */
+    static colorize(strings: Array<string>, ...values: unknown[]): void;
+    /**
+     * Static success method
+     *
+     * @param {string} message - Success message to log
+     * @param {...unknown} args - Additional arguments to log
+     */
+    static success(message: string, ...args: unknown[]): void;
+    /**
+     * Set a color alias for convenient usage
+     *
+     * @param {string} alias - Alias name
+     * @param {string} colorCode - Color code (e.g., "{F196}" or "{<B}")
+     * @returns {Glog} The Glog class for chaining.
+     */
+    static setAlias(alias: string, colorCode: string): Glog;
+    constructor(options?: {});
+    setOptions(options: any): this;
+    withName(name: any): this;
+    withLogLevel(level: any): this;
+    withPrefix(prefix: any): this;
+    withColors(colors?: {
+        debug: string[];
+        info: string;
+        warn: string;
+        error: string;
+        reset: string;
+    }): this;
+    withStackTrace(enabled?: boolean): this;
+    get name(): string;
+    get debugLevel(): number;
+    get options(): {
+        name: string;
+        debugLevel: number;
+        prefix: string;
+        colors: any;
+        stackTrace: boolean;
+    };
+    extractFileFunction(): string;
+    newDebug(tag: any): any;
+    /**
+     * Log a debug message with specified verbosity level.
+     * Level 0 means debug OFF - use levels 1-4 for actual debug output.
+     * Debug messages only show when logLevel > 0.
+     *
+     * @param {string} message - Debug message to log
+     * @param {number} level - Debug verbosity level (1-4, default: 1)
+     * @param {...unknown} arg - Additional arguments to log
+     * @throws {Error} If level < 1 (level 0 = debug OFF)
+     */
+    debug(message: string, level?: number, ...arg: unknown[]): void;
+    info(message: any, ...arg: any[]): void;
+    warn(message: any, ...arg: any[]): void;
+    error(message: any, ...arg: any[]): void;
+    execute(...args: any[]): void;
+    /**
+     * Log a colorized message using template literals
+     *
+     * @param {Array<string>} strings - Template strings
+     * @param {...unknown} values - Template values
+     * @example logger.colorize`{success}Operation completed{/} in {bold}${time}ms{/}`
+     */
+    colorize(strings: Array<string>, ...values: unknown[]): void;
+    /**
+     * Log a success message with green color
+     *
+     * @param {string} message - Success message
+     * @param {...unknown} args - Additional arguments
+     */
+    success(message: string, ...args: unknown[]): void;
+    /**
+     * Get access to the colours template function for instance usage
+     *
+     * @returns {import('@gesslar/colours')} The colours template function from \@gesslar/colours
+     */
+    get colours(): typeof import("@gesslar/colours");
+    #private;
+}
+//# sourceMappingURL=Glog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Glog.d.ts","sourceRoot":"","sources":["../../lib/Glog.js"],"names":[],"mappings":";;;;;;;;;AA6CA;IAEE,wBAAmB;IACnB,yBAAqB;IACrB,mBAAoB;IACpB,2BAAyB;IACzB,oBAAgB;IA2ChB,8CAIC;IAED,4CAIC;IAED,wCAIC;IAED;;;;;;oBAIC;IAED,sDAIC;IAID,kCAEC;IAwJD,qCAoBC;IAuBD;;;;;OAKG;IACH,yBAHW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAOpB;IAYD;;;;;OAKG;IACH,wBAHW,MAAM,WACH,OAAO,EAAA,QAIpB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAMhB;IAhTD,0BAeC;IAID,+BAQC;IAwCD,0BAIC;IAED,+BAIC;IAED,8BAIC;IAED;;;;;;aAIC;IAED,wCAIC;IAID,mBAEC;IAED,yBAEC;IAED;;;;;;MAQC;IAqBD,8BAGC;IAED,wBAQC;IA8BD;;;;;;;;;OASG;IACH,eALW,MAAM,UACN,MAAM,UACH,OAAO,EAAA,QAapB;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;IA0BD,8BAEC;IAID;;;;;;OAMG;IACH,kBAJW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAQpB;IAeD;;;;;OAKG;IACH,iBAHW,MAAM,WACH,OAAO,EAAA,QAIpB;IAyBD;;;;OAIG;IACH,iDAEC;;CACF"}

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

@@ -0,0 +1,46 @@
+export namespace loggerColours {
+    let debug: string[];
+    let info: string;
+    let warn: string;
+    let error: string;
+    let reset: string;
+}
+/**
+ * Logger class
+ *
+ * Log levels:
+ * - debug: Debugging information
+ *   - Debug levels
+ *     - 0: No/critical debug information, not error level, but, should be
+ *          logged
+ *     - 1: Basic debug information, startup, shutdown, etc
+ *     - 2: Intermediate debug information, discovery, starting to get more
+ *         detailed
+ *     - 3: Detailed debug information, parsing, processing, etc
+ *     - 4: Very detailed debug information, nerd mode!
+ * - warn: Warning information
+ * - info: Informational information
+ * - error: Error information
+ */
+export default class Logger {
+    constructor(options: any);
+    vscodeError: any;
+    vscodeWarn: any;
+    vscodeInfo: any;
+    get name(): any;
+    get debugLevel(): number;
+    get options(): {
+        name: any;
+        debugLevel: number;
+    };
+    setOptions(options: any): void;
+    lastStackLine(error?: Error, stepsRemoved?: number): any;
+    extractFileFunction(level?: number): any;
+    newDebug(tag: any): any;
+    debug(message: any, level?: number, ...arg: any[]): void;
+    warn(message: any, ...arg: any[]): void;
+    info(message: any, ...arg: any[]): void;
+    error(message: any, ...arg: any[]): void;
+    #private;
+}
+//# sourceMappingURL=Logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../lib/Logger.js"],"names":[],"mappings":";;;;;;;AA4CA;;;;;;;;;;;;;;;;GAgBG;AAEH;IAIE,0BAYC;IALK,iBAAiD;IACjD,gBAAkD;IAClD,gBAAsD;IAK5D,gBAEC;IAED,yBAEC;IAED;;;MAKC;IAED,+BAGC;IAWD,yDAIC;IAED,yCAsCC;IAED,wBAKC;IAED,yDAGC;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;;CACF"}

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

@@ -0,0 +1,62 @@
+/**
+ * Custom error class for toolkit errors.
+ * Provides error chaining, trace management, and formatted error reporting.
+ */
+export default class Sass extends Error {
+    /**
+     * Creates an Sass from an existing Error object with additional
+     * trace message.
+     *
+     * @param {Error} error - The original error object
+     * @param {string} message - Additional trace message to add
+     * @returns {Sass} New Sass instance with trace from the original error
+     * @throws {Sass} If the first parameter is not an Error instance
+     */
+    static from(error: Error, message: string): Sass;
+    /**
+     * Factory method to create or enhance Sass instances.
+     * If error parameter is provided, enhances existing Sass or wraps
+     * other errors. Otherwise creates a new Sass instance.
+     *
+     * @param {string} message - The error message
+     * @param {Error|Sass|Tantrum} [error] - Optional existing error to wrap or enhance
+     * @returns {Sass} New or enhanced Sass instance
+     */
+    static "new"(message: string, error?: Error | Sass | Tantrum): Sass;
+    /**
+     * Creates a new Sass instance.
+     *
+     * @param {string} message - The error message
+     * @param {...unknown} [arg] - Additional arguments passed to parent Error constructor
+     */
+    constructor(message: string, ...arg?: unknown[]);
+    /**
+     * Adds a message to the beginning of the trace array.
+     *
+     * @param {string} message - The trace message to add
+     */
+    set trace(message: string);
+    /**
+     * Gets the error trace array.
+     *
+     * @returns {Array<string>} Array of trace messages
+     */
+    get trace(): Array<string>;
+    /**
+     * Adds a trace message and returns this instance for chaining.
+     *
+     * @param {string} message - The trace message to add
+     * @returns {this} This Sass instance for method chaining
+     */
+    addTrace(message: string): this;
+    /**
+     * Reports the error to the terminal with formatted output.
+     * Optionally includes detailed stack trace information.
+     *
+     * @param {boolean} [nerdMode] - Whether to include detailed stack trace
+     */
+    report(nerdMode?: boolean): void;
+    #private;
+}
+import Tantrum from "./Tantrum.js";
+//# sourceMappingURL=Sass.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../lib/Sass.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IA2GE;;;;;;;;OAQG;IACH,mBALW,KAAK,WACL,MAAM,GACJ,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,UACN,KAAK,GAAC,IAAI,GAAC,OAAO,GAChB,IAAI,CAchB;IAhJD;;;;;OAKG;IACH,qBAHW,MAAM,WACH,OAAO,EAAA,EAMpB;IAWD;;;;OAIG;IACH,mBAFW,MAAM,EAIhB;IAhBD;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAIzB;IAWD;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;;;OAKG;IACH,kBAFW,OAAO,QAqBjB;;CA2EF;oBA1JmB,cAAc"}

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

@@ -0,0 +1,23 @@
+/**
+ * Schemer provides utilities for compiling and validating JSON schemas using AJV.
+ *
+ * Usage:
+ *   - Use Schemer.fromFile(file, options) to create a validator from a file.
+ *   - Use Schemer.from(schemaData, options) to create a validator from a schema object.
+ *   - Use Schemer.getValidator(schema, options) to get a raw AJV validator function.
+ *   - Use Schemer.reportValidationErrors(errors) to format AJV validation errors.
+ */
+export default class Schemer {
+    static fromFile(file: any, options?: {}): Promise<(data: unknown) => boolean>;
+    static from(schemaData?: {}, options?: {}): Promise<(data: unknown) => boolean>;
+    /**
+     * Creates a validator function from a schema object
+     *
+     * @param {object} schema - The schema to compile
+     * @param {object} [options] - AJV options
+     * @returns {(data: unknown) => boolean} The AJV validator function, which may have additional properties (e.g., `.errors`)
+     */
+    static getValidator(schema: object, options?: object): (data: unknown) => boolean;
+    static reportValidationErrors(errors: any): any;
+}
+//# sourceMappingURL=Schemer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Schemer.d.ts","sourceRoot":"","sources":["../../lib/Schemer.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH;IACE,yDAqBoB,OAAO,KAAK,OAAO,EAdtC;IAED,2DAYoB,OAAO,KAAK,OAAO,EAPtC;IAED;;;;;;OAMG;IACH,4BAJW,MAAM,YACN,MAAM,GACJ,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAMtC;IAED,gDA0CC;CACF"}