blendsdk 5.33.0

package/dist/postgresql/update-statement.js

@@ -0,0 +1,75 @@
+import { UpdateStatement } from '../dbcore/index.js';
+/**
+ * Provides PostgreSQL-specific implementation for UPDATE statement construction.
+ * Builds parameterized UPDATE queries with SET, WHERE, and RETURNING clauses.
+ * Extends the base UpdateStatement class with PostgreSQL syntax.
+ *
+ * @export
+ * @class PostgreSQLUpdateStatement
+ * @template TableType - The type representing the table structure for type-safe updates
+ * @template FilterType - The type representing the filter criteria for the WHERE clause
+ * @extends {UpdateStatement<TableType, FilterType>}
+ */
+export class PostgreSQLUpdateStatement extends UpdateStatement {
+    /**
+     * Constructs the PostgreSQL UPDATE query string with SET, WHERE, and RETURNING clauses.
+     * Generates parameterized query with named parameters for values (prefixed with 'v_')
+     * and uses expression builder for complex WHERE conditions.
+     * Supports optional RETURNING clause to retrieve updated row data.
+     *
+     * @protected
+     * @return {string} The complete UPDATE query string
+     * @memberof PostgreSQLUpdateStatement
+     */
+    buildQuery() {
+        const keys = Object.keys(this._values);
+        // Validate that values are provided — empty SET clause is invalid SQL
+        if (keys.length === 0) {
+            throw new Error(`Cannot build UPDATE statement for table "${this.tableName}": no values provided. ` +
+                'Call .values() with at least one column before executing.');
+        }
+        let queryStr = `UPDATE ${this.tableName} SET `;
+        const setClauses = [];
+        // Build SET clause from values to update
+        // Each value key becomes a parameterized assignment with 'v_' prefix (e.g., column = :v_column)
+        Object.keys(this._values).forEach(key => {
+            setClauses.push(`${key} = :v_${key}`);
+        });
+        // Append SET clause with comma-separated assignments
+        queryStr += setClauses.join(', ');
+        // Build WHERE clause from cached compiled expression
+        const compiled = this.getCompiledExpression();
+        if (compiled?.sql) {
+            queryStr += ` WHERE ${compiled.sql}`;
+        }
+        // Add RETURNING clause if specified to retrieve updated row data
+        if (this._returning.length > 0) {
+            queryStr += ` RETURNING ${this._returning.join(', ')}`;
+        }
+        return queryStr.trim();
+    }
+    /**
+     * Builds the parameter object for the UPDATE query.
+     * Combines value parameters (prefixed with 'v_') and expression parameters.
+     * Returns an object mapping parameter names to their values for query execution.
+     *
+     * @protected
+     * @return {Object} Object containing named parameters for both values and WHERE clause
+     * @memberof PostgreSQLUpdateStatement
+     */
+    buildParameters() {
+        const params = {};
+        // Add values parameters with 'v_' prefix (columns to update)
+        // This prevents conflicts with expression parameters
+        Object.keys(this._values).forEach(key => {
+            params[`v_${key}`] = this._values[key];
+        });
+        // Get parameters from cached compiled expression
+        const compiled = this.getCompiledExpression();
+        if (compiled) {
+            Object.assign(params, compiled.params);
+        }
+        return params;
+    }
+}
+//# sourceMappingURL=update-statement.js.map

package/dist/postgresql/update-statement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-statement.js","sourceRoot":"","sources":["../src/update-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;;;GAUG;AACH,MAAM,OAAO,yBAAiD,SAAQ,eAGrE;IACC;;;;;;;;;OASG;IACO,UAAU;QAClB,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEvC,sEAAsE;QACtE,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CACb,4CAA4C,IAAI,CAAC,SAAS,yBAAyB;gBACjF,2DAA2D,CAC9D,CAAC;QACJ,CAAC;QAED,IAAI,QAAQ,GAAG,UAAU,IAAI,CAAC,SAAS,OAAO,CAAC;QAC/C,MAAM,UAAU,GAAa,EAAE,CAAC;QAEhC,yCAAyC;QACzC,gGAAgG;QAChG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACtC,UAAU,CAAC,IAAI,CAAC,GAAG,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QAEH,qDAAqD;QACrD,QAAQ,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAElC,qDAAqD;QACrD,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC9C,IAAI,QAAQ,EAAE,GAAG,EAAE,CAAC;YAClB,QAAQ,IAAI,UAAU,QAAQ,CAAC,GAAG,EAAE,CAAC;QACvC,CAAC;QAED,iEAAiE;QACjE,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,QAAQ,IAAI,cAAc,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACzD,CAAC;QAED,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC;IACzB,CAAC;IAED;;;;;;;;OAQG;IACO,eAAe;QACvB,MAAM,MAAM,GAA2B,EAAE,CAAC;QAE1C,6DAA6D;QAC7D,qDAAqD;QACrD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACtC,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC,GAAI,IAAI,CAAC,OAAe,CAAC,GAAG,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;QAEH,iDAAiD;QACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC9C,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;QACzC,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF"}

package/dist/stdlib/formatString.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Format a string by replacing ${...} placeholders with values from a params object.
+ *
+ * Supported placeholder syntax:
+ * - `${name}` — Simple substitution from params.name
+ * - `${name|default}` — Use "default" if params.name is undefined/null/empty
+ * - `${user.name}` — Dot-notation for nested object access
+ * - `${user.name|Anonymous}` — Dot-notation with default value
+ *
+ * Behavior:
+ * - If a key is found in params and is not null/undefined/empty-string, its string value is used
+ * - If a key is not found and a default is provided, the default is used
+ * - If a key is not found and no default is provided, the raw placeholder is kept
+ *   (e.g., "${unknown}" stays as "${unknown}")
+ * - Zero (0) and false are valid values — they are converted to string
+ * - Empty string ("") is treated as missing — falls through to default
+ *
+ * @param template - The template string containing ${...} placeholders
+ * @param params - Object with values to substitute (supports nested objects)
+ * @returns The formatted string with placeholders replaced
+ *
+ * @example
+ * // Simple substitution
+ * formatString("Hello ${name}", { name: "John" })
+ * // → "Hello John"
+ *
+ * // Default value
+ * formatString("Hello ${name|Guest}")
+ * // → "Hello Guest"
+ *
+ * // With provided value (default ignored)
+ * formatString("Hello ${name|Guest}", { name: "John" })
+ * // → "Hello John"
+ *
+ * // Dot-notation
+ * formatString("${user.name} lives in ${user.city}", { user: { name: "Alice", city: "Amsterdam" } })
+ * // → "Alice lives in Amsterdam"
+ *
+ * // Missing key (no default) — placeholder kept
+ * formatString("Hello ${unknown}")
+ * // → "Hello ${unknown}"
+ *
+ * // Numeric values
+ * formatString("Found ${count} items", { count: 42 })
+ * // → "Found 42 items"
+ *
+ * // Empty string with default
+ * formatString("Hello ${name|Guest}", { name: "" })
+ * // → "Hello Guest"
+ */
+export declare function formatString(template: string, params?: Record<string, unknown>): string;
+//# sourceMappingURL=formatString.d.ts.map

package/dist/stdlib/formatString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatString.d.ts","sourceRoot":"","sources":["../src/formatString.ts"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CA+BvF"}

package/dist/stdlib/formatString.js

@@ -0,0 +1,118 @@
+/**
+ * Global regex for matching all ${...} placeholders in a template.
+ * Uses the 'g' flag to match all occurrences.
+ *
+ * Pattern breakdown:
+ * \$\{        — literal ${
+ * \s*         — optional whitespace inside braces
+ * (           — capture group 1: the full expression
+ *   [\w.]+   — one or more word chars or dots (the key path)
+ *   (?:\s*\|[^}]*)? — optional: pipe + default value (anything except })
+ * )
+ * \s*         — optional trailing whitespace
+ * \}          — literal }
+ *
+ * Capture groups:
+ * - Group 1: The full expression inside ${ } (e.g., "name|default")
+ */
+const PLACEHOLDER_REGEX_G = /\$\{\s*([\w.]+(?:\s*\|[^}]*)?)\s*\}/g;
+/**
+ * Resolve a dot-notation path against a nested object.
+ *
+ * Walks each segment of the dot-separated path, returning `undefined`
+ * if any intermediate segment is null or undefined.
+ *
+ * @param obj - The root object to resolve against
+ * @param path - Dot-separated path (e.g., "user.name", "address.city")
+ * @returns The resolved value, or undefined if any segment is missing
+ *
+ * @example
+ * resolveNestedKey({ user: { name: "Alice" } }, "user.name") // → "Alice"
+ * resolveNestedKey({ user: { name: "Alice" } }, "user.age")  // → undefined
+ * resolveNestedKey({ name: "Bob" }, "name")                   // → "Bob"
+ */
+function resolveNestedKey(obj, path) {
+    return path.split(".").reduce((current, segment) => {
+        // Bail out early if we hit a null/undefined intermediate
+        if (current === null || current === undefined)
+            return undefined;
+        return current[segment];
+    }, obj);
+}
+/**
+ * Format a string by replacing ${...} placeholders with values from a params object.
+ *
+ * Supported placeholder syntax:
+ * - `${name}` — Simple substitution from params.name
+ * - `${name|default}` — Use "default" if params.name is undefined/null/empty
+ * - `${user.name}` — Dot-notation for nested object access
+ * - `${user.name|Anonymous}` — Dot-notation with default value
+ *
+ * Behavior:
+ * - If a key is found in params and is not null/undefined/empty-string, its string value is used
+ * - If a key is not found and a default is provided, the default is used
+ * - If a key is not found and no default is provided, the raw placeholder is kept
+ *   (e.g., "${unknown}" stays as "${unknown}")
+ * - Zero (0) and false are valid values — they are converted to string
+ * - Empty string ("") is treated as missing — falls through to default
+ *
+ * @param template - The template string containing ${...} placeholders
+ * @param params - Object with values to substitute (supports nested objects)
+ * @returns The formatted string with placeholders replaced
+ *
+ * @example
+ * // Simple substitution
+ * formatString("Hello ${name}", { name: "John" })
+ * // → "Hello John"
+ *
+ * // Default value
+ * formatString("Hello ${name|Guest}")
+ * // → "Hello Guest"
+ *
+ * // With provided value (default ignored)
+ * formatString("Hello ${name|Guest}", { name: "John" })
+ * // → "Hello John"
+ *
+ * // Dot-notation
+ * formatString("${user.name} lives in ${user.city}", { user: { name: "Alice", city: "Amsterdam" } })
+ * // → "Alice lives in Amsterdam"
+ *
+ * // Missing key (no default) — placeholder kept
+ * formatString("Hello ${unknown}")
+ * // → "Hello ${unknown}"
+ *
+ * // Numeric values
+ * formatString("Found ${count} items", { count: 42 })
+ * // → "Found 42 items"
+ *
+ * // Empty string with default
+ * formatString("Hello ${name|Guest}", { name: "" })
+ * // → "Hello Guest"
+ */
+export function formatString(template, params) {
+    // Fast path: no placeholders in template at all
+    if (!template.includes("${")) {
+        return template;
+    }
+    // Use empty object when no params provided — defaults still need to be resolved
+    const resolvedParams = params ?? {};
+    return template.replace(PLACEHOLDER_REGEX_G, (match, expression) => {
+        // Split on first pipe to separate key from default value
+        const pipeIndex = expression.indexOf("|");
+        const key = (pipeIndex >= 0 ? expression.slice(0, pipeIndex) : expression).trim();
+        const defaultValue = pipeIndex >= 0 ? expression.slice(pipeIndex + 1) : undefined;
+        // Resolve the value from params (supports dot-notation paths)
+        const value = resolveNestedKey(resolvedParams, key);
+        // Use the value if it's defined, not null, and not empty string
+        if (value !== undefined && value !== null && value !== "") {
+            return String(value);
+        }
+        // Fall back to default value if provided (pipe was present)
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        // No value and no default — keep the raw placeholder unchanged
+        return match;
+    });
+}
+//# sourceMappingURL=formatString.js.map

package/dist/stdlib/formatString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatString.js","sourceRoot":"","sources":["../src/formatString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,mBAAmB,GAAG,sCAAsC,CAAC;AAEnE;;;;;;;;;;;;;;GAcG;AACH,SAAS,gBAAgB,CAAC,GAA4B,EAAE,IAAY;IAChE,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAU,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE;QACxD,yDAAyD;QACzD,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAChE,OAAQ,OAAmC,CAAC,OAAO,CAAC,CAAC;IACzD,CAAC,EAAE,GAAG,CAAC,CAAC;AACZ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,UAAU,YAAY,CAAC,QAAgB,EAAE,MAAgC;IAC3E,gDAAgD;IAChD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3B,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED,gFAAgF;IAChF,MAAM,cAAc,GAAG,MAAM,IAAI,EAAE,CAAC;IAEpC,OAAO,QAAQ,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC,KAAK,EAAE,UAAkB,EAAE,EAAE;QACvE,yDAAyD;QACzD,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC1C,MAAM,GAAG,GAAG,CAAC,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC;QAClF,MAAM,YAAY,GAAG,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAElF,8DAA8D;QAC9D,MAAM,KAAK,GAAG,gBAAgB,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;QAEpD,gEAAgE;QAChE,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;YACxD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;QAED,4DAA4D;QAC5D,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAC7B,OAAO,YAAY,CAAC;QACxB,CAAC;QAED,+DAA+D;QAC/D,OAAO,KAAK,CAAC;IACjB,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/stdlib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './formatString.js';
+export * from './isBoolean.js';
+export * from './isNullOrUndef.js';
+export * from './isNumeric.js';
+export * from './isString.js';
+export * from './isTemplateString.js';
+export * from './wrapInArray.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/stdlib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC"}

package/dist/stdlib/index.js

@@ -0,0 +1,8 @@
+export * from './formatString.js';
+export * from './isBoolean.js';
+export * from './isNullOrUndef.js';
+export * from './isNumeric.js';
+export * from './isString.js';
+export * from './isTemplateString.js';
+export * from './wrapInArray.js';
+//# sourceMappingURL=index.js.map

package/dist/stdlib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC"}

package/dist/stdlib/isBoolean.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Tests whether the given value is a boolean primitive.
+ *
+ * Uses a type predicate so TypeScript narrows the type to `boolean`
+ * inside conditional blocks after calling this function.
+ *
+ * Note: `new Boolean(true)` creates an object wrapper, not a primitive,
+ * so this function returns `false` for Boolean object wrappers.
+ *
+ * @export
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} True if the value is a boolean primitive, false otherwise.
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+//# sourceMappingURL=isBoolean.d.ts.map

package/dist/stdlib/isBoolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBoolean.d.ts","sourceRoot":"","sources":["../src/isBoolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D"}

package/dist/stdlib/isBoolean.js

@@ -0,0 +1,17 @@
+/**
+ * Tests whether the given value is a boolean primitive.
+ *
+ * Uses a type predicate so TypeScript narrows the type to `boolean`
+ * inside conditional blocks after calling this function.
+ *
+ * Note: `new Boolean(true)` creates an object wrapper, not a primitive,
+ * so this function returns `false` for Boolean object wrappers.
+ *
+ * @export
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} True if the value is a boolean primitive, false otherwise.
+ */
+export function isBoolean(value) {
+    return typeof value === "boolean";
+}
+//# sourceMappingURL=isBoolean.js.map

package/dist/stdlib/isBoolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBoolean.js","sourceRoot":"","sources":["../src/isBoolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CAAC,KAAc;IACpC,OAAO,OAAO,KAAK,KAAK,SAAS,CAAC;AACtC,CAAC"}

package/dist/stdlib/isNullOrUndef.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tests whether the given value is null or undefined.
+ *
+ * Uses a type predicate to narrow the type in TypeScript conditional blocks.
+ * After calling `if (!isNullOrUndef(value))`, TypeScript knows `value` is
+ * neither `null` nor `undefined`.
+ *
+ * @export
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} True if the value is null or undefined, false otherwise.
+ */
+export declare function isNullOrUndef(value: unknown): value is null | undefined;
+/**
+ * Tests whether the given value is null or undefined and returns
+ * a default value if so.
+ *
+ * @export
+ * @template ReturnType
+ * @param {ReturnType} value - The value to test.
+ * @param {ReturnType} defaultValue - The fallback value to return when value is null/undefined.
+ * @returns {ReturnType} The original value if defined, otherwise the default value.
+ */
+export declare function isNullOrUndefDefault<ReturnType>(value: ReturnType, defaultValue: ReturnType): ReturnType;
+//# sourceMappingURL=isNullOrUndef.d.ts.map

package/dist/stdlib/isNullOrUndef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNullOrUndef.d.ts","sourceRoot":"","sources":["../src/isNullOrUndef.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,GAAG,SAAS,CAEvE;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,GAAG,UAAU,CAExG"}

package/dist/stdlib/isNullOrUndef.js

@@ -0,0 +1,28 @@
+/**
+ * Tests whether the given value is null or undefined.
+ *
+ * Uses a type predicate to narrow the type in TypeScript conditional blocks.
+ * After calling `if (!isNullOrUndef(value))`, TypeScript knows `value` is
+ * neither `null` nor `undefined`.
+ *
+ * @export
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} True if the value is null or undefined, false otherwise.
+ */
+export function isNullOrUndef(value) {
+    return value === null || value === undefined;
+}
+/**
+ * Tests whether the given value is null or undefined and returns
+ * a default value if so.
+ *
+ * @export
+ * @template ReturnType
+ * @param {ReturnType} value - The value to test.
+ * @param {ReturnType} defaultValue - The fallback value to return when value is null/undefined.
+ * @returns {ReturnType} The original value if defined, otherwise the default value.
+ */
+export function isNullOrUndefDefault(value, defaultValue) {
+    return isNullOrUndef(value) ? defaultValue : value;
+}
+//# sourceMappingURL=isNullOrUndef.js.map

package/dist/stdlib/isNullOrUndef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNullOrUndef.js","sourceRoot":"","sources":["../src/isNullOrUndef.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IACxC,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC;AACjD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAa,KAAiB,EAAE,YAAwB;IACxF,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC;AACvD,CAAC"}

package/dist/stdlib/isNumeric.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tests whether the given value is numeric.
+ *
+ * Accepts finite numbers and strings that represent valid, complete numbers.
+ * Unlike the previous implementation that used `parseFloat` (which would
+ * accept "42px" or "3.14em"), this implementation requires the entire
+ * value to be a valid number.
+ *
+ * Specifically:
+ * - Returns `true` for finite number primitives (not NaN, not Infinity).
+ * - Returns `true` for string representations of finite numbers (e.g., "42", "3.14", "-100", "1e10").
+ * - Returns `false` for NaN, Infinity, booleans, null, undefined, objects, arrays, etc.
+ * - Returns `false` for partial numeric strings like "42px", "3.14em", "100%".
+ *
+ * @export
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} True if the value is a finite number or a string that fully represents one.
+ */
+export declare function isNumeric(value: unknown): boolean;
+//# sourceMappingURL=isNumeric.d.ts.map

package/dist/stdlib/isNumeric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumeric.d.ts","sourceRoot":"","sources":["../src/isNumeric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAsBjD"}

package/dist/stdlib/isNumeric.js

@@ -0,0 +1,39 @@
+/**
+ * Tests whether the given value is numeric.
+ *
+ * Accepts finite numbers and strings that represent valid, complete numbers.
+ * Unlike the previous implementation that used `parseFloat` (which would
+ * accept "42px" or "3.14em"), this implementation requires the entire
+ * value to be a valid number.
+ *
+ * Specifically:
+ * - Returns `true` for finite number primitives (not NaN, not Infinity).
+ * - Returns `true` for string representations of finite numbers (e.g., "42", "3.14", "-100", "1e10").
+ * - Returns `false` for NaN, Infinity, booleans, null, undefined, objects, arrays, etc.
+ * - Returns `false` for partial numeric strings like "42px", "3.14em", "100%".
+ *
+ * @export
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} True if the value is a finite number or a string that fully represents one.
+ */
+export function isNumeric(value) {
+    // Handle number primitives directly: must be finite (rejects NaN and Infinity)
+    if (typeof value === "number") {
+        return Number.isFinite(value);
+    }
+    // Handle string values: must fully represent a finite number
+    if (typeof value === "string") {
+        // Reject empty or whitespace-only strings
+        const trimmed = value.trim();
+        if (trimmed === "") {
+            return false;
+        }
+        // Use the unary + operator which converts the full string to a number.
+        // Unlike parseFloat, +"42px" returns NaN (not 42).
+        const num = +trimmed;
+        return Number.isFinite(num);
+    }
+    // All other types (boolean, null, undefined, objects, arrays, symbols, bigint, etc.)
+    return false;
+}
+//# sourceMappingURL=isNumeric.js.map

package/dist/stdlib/isNumeric.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumeric.js","sourceRoot":"","sources":["../src/isNumeric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,SAAS,CAAC,KAAc;IACpC,+EAA+E;IAC/E,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,6DAA6D;IAC7D,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC5B,0CAA0C;QAC1C,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;QAC7B,IAAI,OAAO,KAAK,EAAE,EAAE,CAAC;YACjB,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,uEAAuE;QACvE,mDAAmD;QACnD,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC;QACrB,OAAO,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IAED,qFAAqF;IACrF,OAAO,KAAK,CAAC;AACjB,CAAC"}

package/dist/stdlib/isString.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Tests whether the given value is a string primitive.
+ *
+ * Uses a type predicate so TypeScript narrows the type to `string`
+ * inside conditional blocks after calling this function.
+ *
+ * Note: `new String("hello")` creates an object wrapper, not a primitive,
+ * so this function returns `false` for String object wrappers.
+ *
+ * @export
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} True if the value is a string primitive, false otherwise.
+ */
+export declare function isString(value: unknown): value is string;
+//# sourceMappingURL=isString.d.ts.map

package/dist/stdlib/isString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isString.d.ts","sourceRoot":"","sources":["../src/isString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD"}

package/dist/stdlib/isString.js

@@ -0,0 +1,17 @@
+/**
+ * Tests whether the given value is a string primitive.
+ *
+ * Uses a type predicate so TypeScript narrows the type to `string`
+ * inside conditional blocks after calling this function.
+ *
+ * Note: `new String("hello")` creates an object wrapper, not a primitive,
+ * so this function returns `false` for String object wrappers.
+ *
+ * @export
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} True if the value is a string primitive, false otherwise.
+ */
+export function isString(value) {
+    return typeof value === "string";
+}
+//# sourceMappingURL=isString.js.map

package/dist/stdlib/isString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isString.js","sourceRoot":"","sources":["../src/isString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAc;IACnC,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;AACrC,CAAC"}

package/dist/stdlib/isTemplateString.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Check if a string contains ${...} template placeholders.
+ *
+ * Returns true if the string contains at least one valid placeholder
+ * matching the ${key}, ${key|default}, or ${path.to.key} syntax.
+ *
+ * @param value - The string to check
+ * @returns true if the string contains at least one ${...} placeholder
+ *
+ * @example
+ * isTemplateString("Hello ${name}")        // → true
+ * isTemplateString("Hello ${name|World}")  // → true
+ * isTemplateString("${user.name}")         // → true
+ * isTemplateString("Hello world")          // → false
+ * isTemplateString("")                     // → false
+ */
+export declare function isTemplateString(value: string): boolean;
+//# sourceMappingURL=isTemplateString.d.ts.map

package/dist/stdlib/isTemplateString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTemplateString.d.ts","sourceRoot":"","sources":["../src/isTemplateString.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEvD"}

package/dist/stdlib/isTemplateString.js

@@ -0,0 +1,38 @@
+/**
+ * Regex pattern for detecting ${...} placeholders in a string.
+ *
+ * Matches: ${name}, ${name|default}, ${user.name}, ${user.name|fallback}
+ *
+ * Pattern breakdown:
+ * \$\{           — literal ${
+ * \s*            — optional whitespace
+ * [\w.]+         — one or more word chars or dots (the key path)
+ * \s*            — optional whitespace
+ * (?:\|[^}]*)?   — optional: pipe + default value (anything except })
+ * \s*            — optional whitespace
+ * \}             — literal }
+ *
+ * Does NOT use the 'g' flag — we only need to find one match to confirm
+ * the string is a template.
+ */
+const PLACEHOLDER_REGEX = /\$\{\s*[\w.]+\s*(?:\|[^}]*)?\s*\}/;
+/**
+ * Check if a string contains ${...} template placeholders.
+ *
+ * Returns true if the string contains at least one valid placeholder
+ * matching the ${key}, ${key|default}, or ${path.to.key} syntax.
+ *
+ * @param value - The string to check
+ * @returns true if the string contains at least one ${...} placeholder
+ *
+ * @example
+ * isTemplateString("Hello ${name}")        // → true
+ * isTemplateString("Hello ${name|World}")  // → true
+ * isTemplateString("${user.name}")         // → true
+ * isTemplateString("Hello world")          // → false
+ * isTemplateString("")                     // → false
+ */
+export function isTemplateString(value) {
+    return PLACEHOLDER_REGEX.test(value);
+}
+//# sourceMappingURL=isTemplateString.js.map

package/dist/stdlib/isTemplateString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTemplateString.js","sourceRoot":"","sources":["../src/isTemplateString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,iBAAiB,GAAG,mCAAmC,CAAC;AAE9D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC1C,OAAO,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACzC,CAAC"}

package/dist/stdlib/wrapInArray.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Wraps the given value in an array if it is not already an array.
+ *
+ * Returns an empty array if the value is null or undefined.
+ * Returns the value unchanged if it is already an array.
+ * Otherwise wraps the value in a single-element array.
+ *
+ * @export
+ * @template T - The type of elements in the resulting array.
+ * @param {unknown} obj - The value to wrap.
+ * @returns {Array<T>} An array containing the value, or the value itself if already an array.
+ */
+export declare function wrapInArray<T>(obj: unknown): T[];
+//# sourceMappingURL=wrapInArray.d.ts.map

package/dist/stdlib/wrapInArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapInArray.d.ts","sourceRoot":"","sources":["../src/wrapInArray.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,GAAG,CAAC,EAAE,CAEhD"}

package/dist/stdlib/wrapInArray.js

@@ -0,0 +1,17 @@
+import { isNullOrUndef } from "./isNullOrUndef.js";
+/**
+ * Wraps the given value in an array if it is not already an array.
+ *
+ * Returns an empty array if the value is null or undefined.
+ * Returns the value unchanged if it is already an array.
+ * Otherwise wraps the value in a single-element array.
+ *
+ * @export
+ * @template T - The type of elements in the resulting array.
+ * @param {unknown} obj - The value to wrap.
+ * @returns {Array<T>} An array containing the value, or the value itself if already an array.
+ */
+export function wrapInArray(obj) {
+    return Array.isArray(obj) ? obj : isNullOrUndef(obj) ? [] : [obj];
+}
+//# sourceMappingURL=wrapInArray.js.map

package/dist/stdlib/wrapInArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapInArray.js","sourceRoot":"","sources":["../src/wrapInArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,WAAW,CAAI,GAAY;IACvC,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAQ,CAAC,CAAC;AAC3E,CAAC"}