@controlium/utils 0.0.0

package/dist/types/stringUtils/stringUtils.d.ts

@@ -0,0 +1,129 @@
+/**
+ * General String related test-related utilities.
+ * @note
+ * Originally written as String extensions, re-written as static functions for broader compatibility.
+ */
+export declare class StringUtils {
+    /**
+     * Removes leading and trailing instances of given character from a string
+     * @param originalString
+     * String to be trimmed
+     * @param characterToTrim
+     * Character to be removed from start and end of string, if present
+     */
+    static trimChar(originalString: string, characterToTrim: string): string;
+    /**
+     * Trims single or double quotes from string if string starts AND ends in same quote character
+     * @param originalString
+     * String to be trimmed
+     */
+    static trimQuotes(originalString: string): string;
+    /**
+     * Checks if character at index is an Alpha character
+     * @param stringToCheck
+     * String containing character to check
+     * @param indexZeroBased - default 0
+     * Index of character to check
+     * @returns
+     * Boolean true is alpha, otherwise false
+     */
+    static isAlpha(stringToCheck: string, indexZeroBased?: number): boolean;
+    /**
+     * Set first character of string to Capital (if Alpha)
+     * @param originalString
+     * String to set first character
+     * @returns
+     * originalString with first character capitalised
+     */
+    static capitaliseFirstCharacter(originalString: string, searchFirstAlpha?: boolean): string;
+    /**
+     * Splits a string upto substrings a maximum number of times using the specified separator and return then as an array
+     * @param originalString
+     * String to be split
+     * @param separator
+     * Character to use as seperator.  If more than one character, function will error.
+     * @param limit
+     * A value used to limit the number of elements returned in the array. Last element contains rest of string.
+     */
+    static splitRemaining(originalString: string, separator: string, limit: number, doNotSeparateInQuotes?: boolean): string[];
+    /**
+     * Splits a string upto substrings a maximum number of times using the specified separator and return then as an array
+     * @param originalString
+     * String to be split
+     * @param separator
+     * A string that identifies character or characters to use in separating the string.
+     * @param limit
+     * A value used to limit the number of elements returned in the array. First element contains start of string.
+     */
+    static splitLeading(originalString: string, separator: string, limit: number, doNotSeparateInQuotes?: boolean): string[];
+    /**
+     * Splits a string into parts, optionally ignoring slips with quotes
+     * @param originalString
+     * String to be split
+     * @param separator
+     * Character to use as seperator.  If more than one character, function will error.
+     * @param doNotSeparateInQuotes (default true)
+     * If true, separator char is ignored within single or double quotes (matching)
+     * @returns
+     * Array of original string
+     */
+    static split(originalString: string, separator: string, doNotSeparateInQuotes?: boolean): Array<string>;
+    /**
+     * Splits a string into verb and paremeters.  Parameters are part enclosed in trailing brackets.
+     * @param rawCommand
+     * String containing command verb and, optionally, braces enclosing parameters
+     * @returns
+     * Object with verb and parameters properties
+     * @example
+     * "hello"
+     * results in verb: "hello", parameters: ''
+     * "hello(this is, good)"
+     * results in verb: "hello", parameters: 'this is, good'
+     * @throws
+     * Error if badly formed (no trailing close braces etc....)
+     */
+    static splitVerbAndParameters(rawCommand: string): {
+        verb: string;
+        parameters: string;
+    };
+    /**
+     * Removes all non-alphanumerics from string
+     * @param originalString
+     * String to remove non-alphanumerics from
+     */
+    static removeNonAlphaNumeric(originalString: string): string;
+    /**
+     * Removes all whitespace from string
+     * @param originalString
+     * String to remove whitespace from
+     */
+    static removeWhitespace(originalString: string): string;
+    /**
+     * Encode given string to enable use within HTML
+     * @param originalString
+     * Non-encoded string to be HTML encoded
+     * @returns
+     * Original string HTML encoded.
+     */
+    static encodeHTML(originalString: string): string;
+    /**
+     * Replace all matching instances with replacement
+     * @param original
+     * String to replace values in
+     * @param searchValue
+     * Value to replace
+     * @param replaceValue
+     * Value to replace mathes with
+     * @returns
+     * Original string with all matching occuranced replaced
+     */
+    static replaceAll(original: string, searchValue: string, replaceValue: string): string;
+    /**
+     * Checks if a string is blank
+     * @param text
+     * String to be verified for blank
+     * @returns
+     * Boolean true is empty or with blankspaces, otherwise false
+     */
+    static isBlank(text: string): boolean;
+}

package/dist/types/utils/utils.d.ts

@@ -0,0 +1,450 @@
+import { ChildProcessWithoutNullStreams, SpawnOptionsWithoutStdio } from 'child_process';
+import { LogLevel } from "../index";
+/**
+ * What action to perform if a file already exists when {@link Utils.writeTextToFile} is called.
+ */
+export declare enum ExistingFileWriteActions {
+    /** Overwrite existing file */
+    Overwrite = 0,
+    /** Create a new file using an incrementing index in the file name */
+    AddIndex = 1,
+    /** Append data to the existing file contents */
+    Append = 2,
+    /** Throw an error indicating the file already exists */
+    ThrowError = 3
+}
+/**
+ * Maps `typeof` string literals to their corresponding TypeScript types.
+ * Used by {@link Utils.assertType} to provide type narrowing after assertion.
+ */
+export interface AssertTypeMap {
+    string: string;
+    number: number;
+    boolean: boolean;
+    object: object;
+    bigint: bigint;
+    symbol: symbol;
+    function: (...args: unknown[]) => unknown;
+}
+/**
+ * General testing-related utilities. All methods are static — no instantiation required.
+ */
+export declare class Utils {
+    private static _promiseCount;
+    private static _defaultPromiseTimeout;
+    /**
+     * Number of currently outstanding promises wrapped by {@link timeoutPromise}.
+     * Check this at the end of a test to verify all promises have settled.
+     * @see {@link resetPromiseCount}
+     */
+    static get promiseCount(): number;
+    /**
+     * Resets the outstanding promise count to zero.
+     * @see {@link promiseCount}
+     */
+    static resetPromiseCount(): void;
+    /**
+     * Sets the default timeout in milliseconds applied by {@link timeoutPromise}
+     * when no per-call `timeoutMS` is supplied.
+     * @param timeoutMs - Timeout in milliseconds. Must be greater than zero.
+     */
+    static set defaultPromiseTimeout(timeoutMs: number);
+    /**
+     * Asserts that a value is of the expected type, throwing a logged error if not.
+     * After a successful call, TypeScript narrows `value` to the corresponding type.
+     *
+     * @param value - Value to check.
+     * @param expectedType - Expected `typeof` string (e.g. `"string"`, `"number"`).
+     * @param funcName - Name of the calling function, used in the error message.
+     * @param paramName - Name of the parameter being checked, used in the error message.
+     * @throws {Error} If `typeof value` does not match `expectedType`.
+     *
+     * @example
+     * Utils.assertType(name, "string", "greet", "name");
+     * // name is now narrowed to string
+     */
+    static assertType<K extends keyof AssertTypeMap>(value: unknown, expectedType: K, funcName: string, paramName: string): asserts value is AssertTypeMap[K];
+    /**
+     * Safely checks if a value is `null` or `undefined`.
+     *
+     * @param obj - Value to check.
+     * @returns `true` if `null` or `undefined`, otherwise `false`.
+     */
+    static isNullOrUndefined(obj?: unknown): boolean;
+    /**
+     * Safely checks if a value is `null`.
+     *
+     * @param obj - Value to check.
+     * @returns `true` if `null`, otherwise `false`.
+     */
+    static isNull(obj?: unknown): boolean;
+    /**
+     * Safely checks if a value is `undefined`.
+     *
+     * @param obj - Value to check.
+     * @returns `true` if `undefined`, otherwise `false`.
+     */
+    static isUndefined(obj?: unknown): boolean;
+    /**
+     * Checks whether a value evaluates to `true` according to common conventions.
+     *
+     * Returns `true` for:
+     * - A boolean `true`
+     * - The strings `"y"`, `"1"`, `"yes"`, `"positive"`, or `"true"` (case-insensitive, trimmed)
+     * - A number greater than zero
+     *
+     * @param valueToCheck - Value to evaluate.
+     * @returns `true` if the value is considered truthy, otherwise `false`.
+     */
+    static isTrue(valueToCheck: boolean | string | number | undefined): boolean;
+    /**
+     * Verifies whether a value is a valid `Date` object.
+     *
+     * @param dateToCheck - Value to validate.
+     * @returns `true` if the value is a `Date` instance with a valid time, otherwise `false`.
+     */
+    static isValidDate(dateToCheck: unknown): dateToCheck is Date;
+    /**
+     * Pads a number or string with leading zeros to reach a required minimum length.
+     *
+     * @param num - The number or string to pad.
+     * @param requiredMinimumLength - The minimum length of the returned string.
+     * @returns The value as a string, left-padded with `"0"` to at least `requiredMinimumLength` characters.
+     * @note If the value is already longer than `requiredMinimumLength`, no truncation occurs.
+     *
+     * @example
+     * Utils.pad(7, 3);    // => "007"
+     * Utils.pad("42", 5); // => "00042"
+     */
+    static pad(num: number | string, requiredMinimumLength: number): string;
+    /**
+     * Converts a millisecond duration to a `HH:MM:SS.t` formatted string,
+     * where `t` is tenths of a second.
+     *
+     * @param milliSeconds - Duration in milliseconds.
+     * @returns Time string formatted as `HH:MM:SS.t`.
+     * @note Durations above 359,999,000 ms (99h 59m 59s) will give unexpected results.
+     */
+    static msToHMS(milliSeconds: number): string;
+    /**
+     * Returns a random integer between `min` and `max` inclusive.
+     * If `max` is less than `min`, the values are swapped.
+     *
+     * @param min - Lower bound.
+     * @param max - Upper bound.
+     * @returns A random integer inclusively between `min` and `max`.
+     */
+    static getRandomInt(min: number, max: number): number;
+    /**
+     * Returns a random float between `min` and `max`.
+     *
+     * @param min - Lower bound.
+     * @param max - Upper bound.
+     * @returns A random float between `min` and `max`.
+     */
+    static getRandomFloat(min: number, max: number): number;
+    /**
+     * Writes data to a file, with configurable behaviour when the file already exists.
+     *
+     * Data is serialised before writing:
+     * - JSON strings are normalised (parsed then re-stringified).
+     * - Non-JSON strings are written as-is.
+     * - Objects are written as pretty-printed JSON.
+     *
+     * @param filePath - Directory path where the file should be created.
+     * @param fileName - Name of the file to write.
+     * @param data - Content to write — a string or an object.
+     * @param ifExistsAction - Action to take if the file already exists (default: `AddIndex`).
+     * @see {@link ExistingFileWriteActions}
+     * @throws {Error} If the write fails, or if `ThrowError` is specified and the file exists.
+     */
+    static writeTextToFile(filePath: string, fileName: string, data: string | object, ifExistsAction?: ExistingFileWriteActions): void;
+    /**
+     * Returns the entire contents of a file as a string.
+     *
+     * @param path - Path to the file.
+     * @param options - Optional settings:
+     *   - `encoding` — File encoding (default: `"utf-8"`).
+     *   - `detokeniseFileContents` — When `true`, passes contents through the detokeniser before returning (default: `false`).
+     * @returns Contents of the file as a string.
+     * @throws {Error} If the file cannot be read.
+     */
+    static getFileContents(filePath: string, options?: {
+        encoding?: BufferEncoding;
+        detokeniseFileContents?: boolean;
+    }): string;
+    /**
+     * Returns the entire contents of a file as a `Buffer`.
+     *
+     * @param path - Path to the file.
+     * @returns Raw file contents as a `Buffer`.
+     * @throws {Error} If the file cannot be read.
+     */
+    static getFileContentsBuffer(filePath: string): Buffer;
+    /**
+     * Resolves a setting value from, in priority order:
+     * 1. A process environment variable
+     * 2. An npm package config variable
+     * 3. A named property within `contextParameters`
+     * 4. A supplied default value
+     *
+     * @param logLevel - Log level used when reporting where the setting was found.
+     * @param settingName - Human-readable name for the setting, used in log messages.
+     * @param sources - Named sources to check:
+     *   - `processEnvName` — Environment variable name.
+     *   - `npmPackageConfigName` — npm package config key.
+     *   - `profileParameterName` — JSONPath into `contextParameters`.
+     *   - `defaultValue` — Fallback if no other source resolves.
+     * @param contextParameters - Optional context parameters used to resolve `profileParameterName`.
+     * @returns The resolved setting value, or `undefined` if no source resolved.
+     * @throws {Error} If `profileParameterName` is given but `contextParameters` is null.
+     */
+    static getSetting<returnType>(logLevel: LogLevel, settingName: string, sources: {
+        processEnvName?: string | undefined;
+        npmPackageConfigName?: string | undefined;
+        profileParameterName?: string | undefined;
+        defaultValue?: returnType | undefined;
+    }, contextParameters?: Record<string, unknown>): returnType | undefined;
+    /**
+     * Sets a process environment variable and saves its original value for later restoration.
+     *
+     * The first time a variable is set, its original value is saved under a prefixed key.
+     * Subsequent sets to the same variable do not overwrite the saved original.
+     * Call {@link resetProcessEnvs} to restore all modified variables.
+     *
+     * @param varName - Name of the environment variable to set.
+     * @param requiredValue - Value to assign.
+     * @note If the variable did not previously exist, it is stored as `"_undefined"` so that
+     *   {@link resetProcessEnvs} knows to delete it rather than restore a blank value.
+     */
+    static setProcessEnv(varName: string, requiredValue: string): void;
+    /**
+     * Restores all process environment variables that were modified by {@link setProcessEnv}
+     * back to their original values. Variables that did not previously exist are deleted.
+     *
+     * @see {@link setProcessEnv}
+     * @throws {Error} If an error occurs while resetting variables.
+     */
+    static resetProcessEnvs(): void;
+    /**
+     * Returns a deep clone of an object or JSON string.
+     * Uses JSON parse/stringify — only JSON-serialisable values are supported.
+     *
+     * @param original - The object or JSON5 string to clone.
+     * @returns A deep clone of `original`.
+     * @throws {Error} If `original` is not valid JSON (JSON5 allowed).
+     */
+    static clone(original: object | string): object;
+    /**
+     * Converts a URL glob pattern to an equivalent `RegExp`.
+     *
+     * Supported glob syntax:
+     * - `*` — matches any sequence of non-`/` characters
+     * - `**` — matches any path segment sequence (including `/`)
+     * - `?` — matches any single character
+     * - `{a,b}` — matches either `a` or `b`
+     * - `[...]` — character class, passed through as-is
+     *
+     * @param glob - The glob pattern to convert.
+     * @param options - Optional anchoring flags:
+     *   - `startOfLine` — Anchors the pattern to the start of the string (default: `true`).
+     *   - `endOfLine` — Anchors the pattern to the end of the string (default: `true`).
+     * @returns A `RegExp` equivalent to the given glob.
+     *
+     * @example
+     * Utils.globToRegex("src/**\/*.ts").test("src/foo/bar.ts"); // true
+     */
+    static globToRegex(glob: string, options?: {
+        startOfLine: boolean;
+        endOfLine: boolean;
+    }): RegExp;
+    /**
+     * Decodes HTML entities in a string back to their corresponding characters.
+     *
+     * - Named entities (e.g. `&amp;`, `&copy;`) and numeric entities (`&#169;`, `&#x1F44D;`) are decoded.
+     * - Non-breaking space characters (U+00A0) are replaced with regular spaces.
+     * - Literal apostrophes (`'`) are replaced with `&apos;` before decoding for consistent handling.
+     *
+     * @param str - The HTML-encoded string to decode.
+     * @returns The decoded string.
+     * @throws {Error} If `str` is not a string.
+     */
+    static unescapeHTML(str: string): string;
+    /**
+     * Creates a signed JWT token.
+     *
+     * @param payloadData - The JWT payload as an object or JSON string.
+     * @param signature - The signing secret or private key.
+     * @param options - Signing options: either a partial options object with an optional
+     *   `algorithm` (default `"HS256"`), or a raw JSON string for the JWT header.
+     * @returns A signed Base64 JWT token string.
+     * @throws {Error} If signing fails.
+     */
+    static createJWT(payloadData: string | object, signature: string, options?: Partial<{
+        algorithm?: string;
+    }> | string): string;
+    /**
+     * Checks whether a string is a structurally valid JWT token.
+     *
+     * @param jwtToken - The token string to validate.
+     * @returns `true` if the token can be decoded, `false` otherwise.
+     */
+    static isValidJWT(jwtToken: string): boolean;
+    /**
+     * Decodes and returns the payload of a JWT token as an object.
+     *
+     * @param jwtToken - A valid JWT token string.
+     * @returns The decoded payload as an object.
+     * @throws {Error} If the token cannot be decoded or the payload is not an object.
+     */
+    static getJWTPayload(jwtToken: string): object;
+    /**
+     * Spawns a command as a background process.
+     *
+     * @param command - The command to execute.
+     * @param args - Arguments to pass to the command.
+     * @param options - Optional settings:
+     *   - `logStdout` — Logs stdout at `TestInformation` level (default: `false`).
+     *   - `logStderr` — Logs stderr and process errors at `Error` level (default: `false`).
+     *   - `spawnOptions` — Additional options passed to `child_process.spawn`.
+     * @returns The spawned `ChildProcess`.
+     * @throws {Error} If the process fails to start (PID is `undefined`).
+     */
+    static spawnBackgroundProcess(command: string, args: string[], { logStdout, logStderr, spawnOptions }?: {
+        logStdout?: boolean;
+        logStderr?: boolean;
+        spawnOptions?: SpawnOptionsWithoutStdio;
+    }): ChildProcessWithoutNullStreams;
+    /**
+     * Spawns a command as a background process and waits for it to exit, with a timeout.
+     *
+     * @param command - The command to execute.
+     * @param args - Arguments to pass to the command.
+     * @param timeoutSeconds - Maximum time in seconds to wait before forcibly terminating the process.
+     * @param options - Optional settings (same as {@link spawnBackgroundProcess}).
+     * @returns A promise resolving to the process exit code, or `-1` on timeout or error.
+     */
+    static spawnBackgroundProcessWithTimeout(command: string, args: string[], timeoutSeconds: number, { logStdout, logStderr, spawnOptions }?: {
+        logStdout?: boolean;
+        logStderr?: boolean;
+        spawnOptions?: SpawnOptionsWithoutStdio;
+    }): Promise<number>;
+    /**
+     * Executes a shell command and returns its stdout output.
+     *
+     * @param command - The shell command to run.
+     * @returns A promise resolving to the stdout string.
+     * @throws The error or stderr string if the command fails.
+     */
+    static execCommand(command: string): Promise<string>;
+    /**
+     * Checks whether a process with the given PID is currently running.
+     *
+     * @param pid - The process ID to check.
+     * @returns `true` if the process is running (or exists but cannot be signalled), `false` if it does not exist.
+     * @throws Any unexpected error from `process.kill`.
+     */
+    static isProcessRunning(pid: number): boolean;
+    /**
+     * Sends a signal to a process and all of its descendants, leaf-first (post-order traversal).
+     *
+     * @param rootPid - PID of the root process to terminate.
+     * @param signal - Signal to send (default: `"SIGKILL"`).
+     */
+    static killProcessAndDescendants(rootPid: number, signal?: NodeJS.Signals): Promise<void>;
+    /**
+     * Terminates a background process and all its descendants, waiting for the process to close.
+     *
+     * @param backgroundProcess - The process to terminate.
+     * @param options - Optional settings:
+     *   - `signal` — Signal to use (default: `"SIGKILL"`).
+     * @returns A promise resolving to `true` once the process closes, or `false` if no valid process was provided.
+     */
+    static terminateBackgroundProcess(backgroundProcess: ChildProcessWithoutNullStreams, options?: {
+        signal?: string | number;
+    }): Promise<boolean>;
+    /**
+     * Pauses execution for the given number of milliseconds.
+     *
+     * @param periodMS - Duration to wait in milliseconds.
+     * @param logIt - When `true`, logs the sleep duration at `FrameworkDebug` level (default: `false`).
+     * @returns A promise that resolves after the given duration.
+     */
+    static sleep(periodMS: number, logIt?: boolean): Promise<unknown>;
+    /**
+     * Pauses Node.js execution until a keyboard key is pressed, while keeping the event loop running.
+     *
+     * @param logOutput - Optional message to write to the log before pausing.
+     * @returns A promise that resolves when a key is pressed.
+     * @warning This hangs indefinitely in non-TTY environments (e.g. CI pipelines).
+     *   In such cases the call is logged and returns immediately.
+     */
+    static pause(logOutput?: string): Promise<void>;
+    /**
+     * Wraps a promise with a timeout and tracks it in the outstanding promise count.
+     *
+     * The count is accessible via {@link promiseCount} and can be checked at the end of a
+     * test to verify all promises have settled. Use {@link resetPromiseCount} to clear
+     * the count between tests.
+     *
+     * @param promise - The promise to wrap.
+     * @param options - Optional settings:
+     *   - `timeoutMS` — Timeout in milliseconds. Falls back to {@link defaultPromiseTimeout} if not given.
+     *   - `friendlyName` — Name shown in the timeout error message (defaults to the caller's function name).
+     * @returns A promise that resolves/rejects with the original result, or rejects with a timeout error.
+     * @throws {Error} If no timeout is configured (neither `timeoutMS` nor `defaultPromiseTimeout` is set).
+     * @throws {Error} If `timeoutMS` is negative.
+     */
+    static timeoutPromise<T>(promise: Promise<T>, options?: {
+        timeoutMS?: number;
+        friendlyName?: string;
+    }): Promise<T>;
+    /**
+     * @deprecated Use {@link timeoutPromise} instead.
+     */
+    static withTimeoutTracked<T>(promise: Promise<T>, timeoutMs: number): Promise<T>;
+    /**
+     * Parses a raw action string into a verb and a parameter map.
+     *
+     * The expected format is `actionName(param1: value1, param2: value2)` where the
+     * parameter block is valid JSON5 without the outer braces. If no parentheses are
+     * present, `parameters` will be an empty map.
+     *
+     * @param rawAction - The raw action string to parse.
+     * @returns A {@link Utils.ActionAndParams} object with `action`, `normalizedAction`, and `parameters`.
+     * @throws {Error} If the parameter block is not valid JSON5.
+     *
+     * @example
+     * Utils.splitActionAndParameters("click(target: '#btn', force: true)");
+     * // => { action: "click", normalizedAction: "click", parameters: Map { "target" => "#btn", "force" => true } }
+     */
+    static splitActionAndParameters(rawAction: string): ActionAndParams;
+    /**
+     * Checks whether a value exists as a member of the given enum.
+     *
+     * @param enumType - The enum object to check against.
+     * @param valueToCheck - The value to look for.
+     * @returns `true` if the value is a member of the enum, `false` otherwise.
+     */
+    static checkENUMValueExists(enumType: object, valueToCheck: string): boolean;
+    /**
+     * Converts data to a string suitable for writing to a file:
+     * - JSON strings are normalised (parsed then re-stringified)
+     * - Non-JSON strings are used as-is
+     * - Objects are pretty-printed as JSON
+     */
+    private static serialiseFileData;
+    private static withTimeout;
+    private static inferCallerFunctionName;
+}
+/**
+ * The parsed result of a raw action string, as returned by {@link Utils.splitActionAndParameters}.
+ */
+export interface ActionAndParams {
+    /** Original non-normalized action verb */
+    action: string;
+    /** Lowercase and trimmed action verb */
+    normalizedAction: string;
+    /** All action parameters passed by the caller */
+    parameters: Map<string, unknown>;
+}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@controlium/utils",
+  "version": "0.0.0",
+  "description": "Shared utilities for Controlium-based projects",
+  "type": "module",
+  "author": "Team Controllium contributors",
+  "contributors": [
+    "Mat Walker <v-mwalk@alexview.com>"
+  ],
+  "license": "MIT",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist coverage",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.json",
+    "build": "npm run clean && npm run build:cjs && npm run build:esm",
+    "test": "jest --silent --runInBand",
+    "test:debug": "jest --runInBand",
+    "test:coverage": "jest --silent --coverage --runInBand",
+    "lint": "eslint 'src/**/*.ts' --fix",
+    "release": "semantic-release"
+  },
+  "keywords": [
+    "typescript",
+    "controlium",
+    "node",
+    "esm",
+    "cjs",
+    "logger",
+    "utilities"
+  ],
+  "dependencies": {
+    "@types/jsonpath-plus": "^5.0.2",
+    "@types/lodash": "^4.14.195",
+    "@types/ps-tree": "^1.1.6",
+    "date-fns": "^4.1.0",
+    "date-fns-tz": "^3.2.0",
+    "entities": "^6.0.1",
+    "jsonpath-plus": "^10.3.0",
+    "jsonpointer": "^5.0.1",
+    "jsonwebtoken": "^9.0.2",
+    "lodash": "^4.17.12",
+    "ps-tree": "^1.2.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^24.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.6.0",
+    "ts-jest": "^29.4.2",
+    "typescript": "^5.9.1",
+    "semantic-release": "^24.0.0",
+    "@semantic-release/changelog": "^6.0.0",
+    "@semantic-release/commit-analyzer": "^13.0.0",
+    "@semantic-release/git": "^10.0.0",
+    "@semantic-release/npm": "^12.0.0",
+    "@semantic-release/release-notes-generator": "^14.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "ts"
+    ],
+    "testMatch": [
+      "**/*.spec.ts"
+    ],
+    "rootDir": "src",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "transformIgnorePatterns": [],
+    "coverageDirectory": "../coverage",
+    "coverageReporters": [
+      "html",
+      "text",
+      "lcov",
+      "json-summary"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 88,
+        "functions": 90,
+        "lines": 90,
+        "statements": 90
+      }
+    },
+    "testEnvironment": "node",
+    "reporters": [
+      "default"
+    ]
+  }
+}