@bquery/bquery 1.2.0 → 1.4.0

package/dist/core/utils/function.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Function-focused utility helpers.
+ *
+ * @module bquery/core/utils/function
+ */
+/** A debounced function with a cancel method to clear the pending timeout. */
+export interface DebouncedFn<TArgs extends unknown[]> {
+    (...args: TArgs): void;
+    /** Cancels the pending debounced invocation. */
+    cancel(): void;
+}
+/** A throttled function with a cancel method to reset the throttle timer. */
+export interface ThrottledFn<TArgs extends unknown[]> {
+    (...args: TArgs): void;
+    /** Resets the throttle timer, allowing the next call to execute immediately. */
+    cancel(): void;
+}
+/**
+ * Creates a debounced function that delays execution until after
+ * the specified delay has elapsed since the last call.
+ *
+ * @template TArgs - The argument types of the function
+ * @param fn - The function to debounce
+ * @param delayMs - Delay in milliseconds
+ * @returns A debounced version of the function with a `cancel()` method
+ *
+ * @example
+ * ```ts
+ * const search = debounce((query: string) => {
+ *   console.log('Searching:', query);
+ * }, 300);
+ *
+ * search('h');
+ * search('he');
+ * search('hello'); // Only this call executes after 300ms
+ *
+ * search('cancel me');
+ * search.cancel(); // Cancels the pending invocation
+ * ```
+ */
+export declare function debounce<TArgs extends unknown[]>(fn: (...args: TArgs) => void, delayMs: number): DebouncedFn<TArgs>;
+/**
+ * Creates a throttled function that runs at most once per interval.
+ *
+ * @template TArgs - The argument types of the function
+ * @param fn - The function to throttle
+ * @param intervalMs - Minimum interval between calls in milliseconds
+ * @returns A throttled version of the function with a `cancel()` method
+ *
+ * @example
+ * ```ts
+ * const handleScroll = throttle(() => {
+ *   console.log('Scroll position:', window.scrollY);
+ * }, 100);
+ *
+ * window.addEventListener('scroll', handleScroll);
+ *
+ * handleScroll.cancel(); // Resets throttle, next call executes immediately
+ * ```
+ */
+export declare function throttle<TArgs extends unknown[]>(fn: (...args: TArgs) => void, intervalMs: number): ThrottledFn<TArgs>;
+/**
+ * Ensures a function only runs once. Subsequent calls return the first result.
+ *
+ * @template TArgs - The argument types of the function
+ * @template TResult - The return type of the function
+ * @param fn - The function to wrap
+ * @returns A function that only runs once
+ *
+ * @example
+ * ```ts
+ * const init = once(() => ({ ready: true }));
+ * init();
+ * init(); // only runs once
+ * ```
+ */
+export declare function once<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => TResult): (...args: TArgs) => TResult;
+/**
+ * A no-operation function.
+ *
+ * @example
+ * ```ts
+ * noop();
+ * ```
+ */
+export declare function noop(): void;
+//# sourceMappingURL=function.d.ts.map

package/dist/core/utils/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../src/core/utils/function.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,8EAA8E;AAC9E,MAAM,WAAW,WAAW,CAAC,KAAK,SAAS,OAAO,EAAE;IAClD,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACvB,gDAAgD;IAChD,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,6EAA6E;AAC7E,MAAM,WAAW,WAAW,CAAC,KAAK,SAAS,OAAO,EAAE;IAClD,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACvB,gFAAgF;IAChF,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,SAAS,OAAO,EAAE,EAC9C,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,IAAI,EAC5B,OAAO,EAAE,MAAM,GACd,WAAW,CAAC,KAAK,CAAC,CAsBpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,SAAS,OAAO,EAAE,EAC9C,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,IAAI,EAC5B,UAAU,EAAE,MAAM,GACjB,WAAW,CAAC,KAAK,CAAC,CAiBpB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACnD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,GAC9B,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAU7B;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,IAAI,IAAI,CAE3B"}

package/dist/core/utils/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Utility helpers used across the framework.
+ * These are intentionally small and framework-agnostic to keep the core tiny.
+ *
+ * @module bquery/core/utils
+ */
+export * from './array';
+export * from './function';
+export * from './misc';
+export * from './number';
+export * from './object';
+export * from './string';
+export * from './type-guards';
+import { chunk, compact, ensureArray, flatten, unique } from './array';
+import { debounce, noop, once, throttle } from './function';
+import { isEmpty, parseJson, sleep, uid } from './misc';
+import { clamp, inRange, randomInt, toNumber } from './number';
+import { clone, hasOwn, isPlainObject, merge, omit, pick } from './object';
+import { capitalize, escapeRegExp, slugify, toCamelCase, toKebabCase, truncate } from './string';
+import { isArray, isBoolean, isCollection, isDate, isElement, isFunction, isNumber, isObject, isPromise, isString } from './type-guards';
+/**
+ * Utility object containing common helper functions.
+ * All utilities are designed to be tree-shakeable and have zero dependencies.
+ *
+ * Note: `isPrototypePollutionKey` is intentionally excluded from this namespace
+ * as it is an internal security helper. It remains available as a named export
+ * for internal framework use.
+ */
+export declare const utils: {
+    clone: typeof clone;
+    merge: typeof merge;
+    pick: typeof pick;
+    omit: typeof omit;
+    hasOwn: typeof hasOwn;
+    debounce: typeof debounce;
+    throttle: typeof throttle;
+    once: typeof once;
+    noop: typeof noop;
+    uid: typeof uid;
+    isElement: typeof isElement;
+    isCollection: typeof isCollection;
+    isEmpty: typeof isEmpty;
+    isPlainObject: typeof isPlainObject;
+    isFunction: typeof isFunction;
+    isString: typeof isString;
+    isNumber: typeof isNumber;
+    isBoolean: typeof isBoolean;
+    isArray: typeof isArray;
+    isDate: typeof isDate;
+    isPromise: typeof isPromise;
+    isObject: typeof isObject;
+    parseJson: typeof parseJson;
+    sleep: typeof sleep;
+    randomInt: typeof randomInt;
+    clamp: typeof clamp;
+    inRange: typeof inRange;
+    toNumber: typeof toNumber;
+    capitalize: typeof capitalize;
+    toKebabCase: typeof toKebabCase;
+    toCamelCase: typeof toCamelCase;
+    truncate: typeof truncate;
+    slugify: typeof slugify;
+    escapeRegExp: typeof escapeRegExp;
+    ensureArray: typeof ensureArray;
+    unique: typeof unique;
+    chunk: typeof chunk;
+    compact: typeof compact;
+    flatten: typeof flatten;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/core/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAE9B,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACvE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACjG,OAAO,EACL,OAAO,EACP,SAAS,EACT,YAAY,EACZ,MAAM,EACN,SAAS,EACT,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,QAAQ,EACT,MAAM,eAAe,CAAC;AAEvB;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCjB,CAAC"}

package/dist/core/utils/misc.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Miscellaneous utility helpers.
+ *
+ * @module bquery/core/utils/misc
+ */
+/**
+ * Creates a stable unique ID for DOM usage.
+ *
+ * @param prefix - Optional prefix for the ID (default: 'bQuery')
+ * @returns A unique identifier string
+ *
+ * @example
+ * ```ts
+ * const id = uid('modal'); // 'modal_x7k2m9p'
+ * ```
+ */
+export declare function uid(prefix?: string): string;
+/**
+ * Delays execution for a specified number of milliseconds.
+ *
+ * @param ms - Milliseconds to delay
+ * @returns A promise that resolves after the delay
+ *
+ * @example
+ * ```ts
+ * await sleep(1000); // Wait 1 second
+ * console.log('Done!');
+ * ```
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Safely parses a JSON string, returning a default value on error.
+ *
+ * @template T - The expected type of the parsed value
+ * @param json - The JSON string to parse
+ * @param fallback - The default value if parsing fails
+ * @returns The parsed value or the fallback
+ *
+ * @example
+ * ```ts
+ * parseJson('{"name":"bQuery"}', {}); // { name: 'bQuery' }
+ * parseJson('invalid', {}); // {}
+ * ```
+ */
+export declare function parseJson<T>(json: string, fallback: T): T;
+/**
+ * Checks for emptiness across common value types.
+ *
+ * @param value - The value to check
+ * @returns True if the value is empty (null, undefined, empty string, empty array, or empty object)
+ *
+ * @example
+ * ```ts
+ * isEmpty('');       // true
+ * isEmpty([]);       // true
+ * isEmpty({});       // true
+ * isEmpty(null);     // true
+ * isEmpty('hello');  // false
+ * isEmpty([1, 2]);   // false
+ * ```
+ */
+export declare function isEmpty(value: unknown): boolean;
+//# sourceMappingURL=misc.d.ts.map

package/dist/core/utils/misc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../../src/core/utils/misc.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,GAAG,CAAC,MAAM,SAAW,GAAG,MAAM,CAE7C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAMzD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM/C"}

package/dist/core/utils/number.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Number-focused utility helpers.
+ *
+ * @module bquery/core/utils/number
+ */
+/**
+ * Generates a random integer between min and max (inclusive).
+ *
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns A random integer in the range [min, max]
+ *
+ * @example
+ * ```ts
+ * const roll = randomInt(1, 6); // Random dice roll
+ * ```
+ */
+export declare function randomInt(min: number, max: number): number;
+/**
+ * Clamps a number between a minimum and maximum value.
+ *
+ * @param value - The value to clamp
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns The clamped value
+ *
+ * @example
+ * ```ts
+ * clamp(150, 0, 100); // 100
+ * clamp(-10, 0, 100); // 0
+ * clamp(50, 0, 100);  // 50
+ * ```
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Checks if a number is within a range.
+ *
+ * @param value - The value to check
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @param inclusive - Whether the range is inclusive (default: true)
+ * @returns True if the value is within the range
+ *
+ * @example
+ * ```ts
+ * inRange(5, 1, 10); // true
+ * inRange(10, 1, 10, false); // false
+ * ```
+ */
+export declare function inRange(value: number, min: number, max: number, inclusive?: boolean): boolean;
+/**
+ * Converts a value to a number with a fallback on NaN.
+ *
+ * @param value - The value to convert
+ * @param fallback - The fallback value if conversion fails (default: 0)
+ * @returns The parsed number or the fallback
+ *
+ * @example
+ * ```ts
+ * toNumber('42'); // 42
+ * toNumber('nope', 10); // 10
+ * ```
+ */
+export declare function toNumber(value: unknown, fallback?: number): number;
+//# sourceMappingURL=number.d.ts.map

package/dist/core/utils/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../src/core/utils/number.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,OAAO,CAG1F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,SAAI,GAAG,MAAM,CAG7D"}

package/dist/core/utils/object.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Object-focused utility helpers.
+ *
+ * @module bquery/core/utils/object
+ */
+/**
+ * Checks if a value is a plain object (not null, array, or class instance).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a plain object
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks if a key could cause prototype pollution.
+ * These keys are dangerous when used in object merging operations.
+ *
+ * @param key - The key to check
+ * @returns True if the key is a prototype pollution vector
+ *
+ * @internal
+ */
+export declare function isPrototypePollutionKey(key: string): boolean;
+/**
+ * Creates a deep clone using structuredClone if available, otherwise fallback to JSON.
+ *
+ * @template T - The type of value being cloned
+ * @param value - The value to clone
+ * @returns A deep copy of the value
+ *
+ * @remarks
+ * When `structuredClone` is available (modern browsers, Node 17+, Bun), this function
+ * provides full deep cloning including circular references, Date, Map, Set, ArrayBuffer, etc.
+ *
+ * **JSON fallback limitations** (older environments without `structuredClone`):
+ * - **Throws** on circular references
+ * - **Drops** functions, `undefined`, and Symbol properties
+ * - **Transforms** Date → ISO string, Map/Set → empty object, BigInt → throws
+ * - **Loses** prototype chains and non-enumerable properties
+ *
+ * For guaranteed safe cloning of arbitrary data, ensure your environment supports
+ * `structuredClone` or pre-validate your data structure.
+ *
+ * @example
+ * ```ts
+ * const original = { nested: { value: 1 } };
+ * const copy = clone(original);
+ * copy.nested.value = 2;
+ * console.log(original.nested.value); // 1
+ * ```
+ */
+export declare function clone<T>(value: T): T;
+/**
+ * Deep-merges plain objects into a new object.
+ * Later sources override earlier ones for primitive values.
+ * Objects are recursively merged.
+ *
+ * @param sources - Objects to merge
+ * @returns A new object with all sources merged as an intersection type
+ *
+ * @remarks
+ * This function uses overloads to provide accurate intersection types for up to 5 sources.
+ * For more than 5 sources, the return type falls back to `Record<string, unknown>`.
+ *
+ * Note that deep merging creates a shallow intersection at the type level. Nested objects
+ * are merged at runtime, but TypeScript sees them as intersected types which may not
+ * perfectly represent the merged structure for deeply nested conflicting types.
+ *
+ * @example
+ * ```ts
+ * const result = merge(
+ *   { a: 1, nested: { x: 1 } },
+ *   { b: 2, nested: { y: 2 } }
+ * );
+ * // Result: { a: 1, b: 2, nested: { x: 1, y: 2 } }
+ * // Type: { a: number; nested: { x: number } } & { b: number; nested: { y: number } }
+ * ```
+ *
+ * @security This method is protected against prototype pollution attacks.
+ * Keys like `__proto__`, `constructor`, and `prototype` are ignored.
+ */
+export declare function merge<T1 extends Record<string, unknown>>(source1: T1): T1;
+export declare function merge<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>>(source1: T1, source2: T2): T1 & T2;
+export declare function merge<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>, T3 extends Record<string, unknown>>(source1: T1, source2: T2, source3: T3): T1 & T2 & T3;
+export declare function merge<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>, T3 extends Record<string, unknown>, T4 extends Record<string, unknown>>(source1: T1, source2: T2, source3: T3, source4: T4): T1 & T2 & T3 & T4;
+export declare function merge<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>, T3 extends Record<string, unknown>, T4 extends Record<string, unknown>, T5 extends Record<string, unknown>>(source1: T1, source2: T2, source3: T3, source4: T4, source5: T5): T1 & T2 & T3 & T4 & T5;
+export declare function merge(...sources: Record<string, unknown>[]): Record<string, unknown>;
+/**
+ * Picks specified keys from an object.
+ *
+ * @template T - The object type
+ * @template K - The key type
+ * @param obj - The source object
+ * @param keys - Keys to pick
+ * @returns A new object with only the specified keys
+ *
+ * @example
+ * ```ts
+ * const user = { name: 'John', age: 30, email: 'john@example.com' };
+ * pick(user, ['name', 'email']); // { name: 'John', email: 'john@example.com' }
+ * ```
+ */
+export declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * Omits specified keys from an object.
+ *
+ * @template T - The object type
+ * @template K - The key type
+ * @param obj - The source object
+ * @param keys - Keys to omit
+ * @returns A new object without the specified keys
+ *
+ * @example
+ * ```ts
+ * const user = { name: 'John', age: 30, password: 'secret' };
+ * omit(user, ['password']); // { name: 'John', age: 30 }
+ * ```
+ */
+export declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * Checks if an object has a given own property.
+ *
+ * @template T - The object type
+ * @param obj - The object to check
+ * @param key - The property key
+ * @returns True if the property exists on the object
+ *
+ * @example
+ * ```ts
+ * hasOwn({ a: 1 }, 'a'); // true
+ * ```
+ */
+export declare function hasOwn<T extends object>(obj: T, key: PropertyKey): key is keyof T;
+//# sourceMappingURL=object.d.ts.map

package/dist/core/utils/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../src/core/utils/object.ts"],"names":[],"mappings":"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"}

package/dist/core/utils/string.d.ts

@@ -0,0 +1,80 @@
+/**
+ * String-focused utility helpers.
+ *
+ * @module bquery/core/utils/string
+ */
+/**
+ * Capitalizes the first letter of a string.
+ *
+ * @param str - The string to capitalize
+ * @returns The capitalized string
+ *
+ * @example
+ * ```ts
+ * capitalize('hello'); // 'Hello'
+ * ```
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Converts a string to kebab-case.
+ *
+ * @param str - The string to convert
+ * @returns The kebab-cased string
+ *
+ * @example
+ * ```ts
+ * toKebabCase('myVariableName'); // 'my-variable-name'
+ * ```
+ */
+export declare function toKebabCase(str: string): string;
+/**
+ * Converts a string to camelCase.
+ *
+ * @param str - The string to convert
+ * @returns The camelCased string
+ *
+ * @example
+ * ```ts
+ * toCamelCase('my-variable-name'); // 'myVariableName'
+ * ```
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * Truncates a string to a maximum length.
+ *
+ * @param str - The string to truncate
+ * @param maxLength - The maximum length
+ * @param suffix - The suffix to append when truncating (default: '…')
+ * @returns The truncated string
+ *
+ * @example
+ * ```ts
+ * truncate('Hello world', 8); // 'Hello w…'
+ * ```
+ */
+export declare function truncate(str: string, maxLength: number, suffix?: string): string;
+/**
+ * Converts a string to a URL-friendly slug.
+ *
+ * @param str - The string to slugify
+ * @returns The slugified string
+ *
+ * @example
+ * ```ts
+ * slugify('Hello, World!'); // 'hello-world'
+ * ```
+ */
+export declare function slugify(str: string): string;
+/**
+ * Escapes a string for safe usage inside a RegExp.
+ *
+ * @param str - The string to escape
+ * @returns The escaped string
+ *
+ * @example
+ * ```ts
+ * escapeRegExp('[a-z]+'); // '\\[a-z\\]+'
+ * ```
+ */
+export declare function escapeRegExp(str: string): string;
+//# sourceMappingURL=string.d.ts.map

package/dist/core/utils/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/core/utils/string.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG9C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,SAAM,GAAG,MAAM,CAK7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/core/utils/type-guards.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Type guard helpers.
+ *
+ * @module bquery/core/utils/type-guards
+ */
+/**
+ * Checks if a value is a DOM Element.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an Element
+ */
+export declare function isElement(value: unknown): value is Element;
+/**
+ * Checks if a value is a BQueryCollection-like object.
+ *
+ * @param value - The value to check
+ * @returns True if the value has an elements array property
+ */
+export declare function isCollection(value: unknown): value is {
+    elements: Element[];
+};
+/**
+ * Checks if a value is a function.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a function
+ */
+export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+/**
+ * Checks if a value is a string.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a string
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Checks if a value is a number (excluding NaN).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid number
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a value is a boolean.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a boolean
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if a value is an array.
+ *
+ * @template T - The type of array elements
+ * @param value - The value to check
+ * @returns True if the value is an array
+ */
+export declare function isArray<T = unknown>(value: unknown): value is T[];
+/**
+ * Checks if a value is a Date instance.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Date
+ */
+export declare function isDate(value: unknown): value is Date;
+/**
+ * Checks if a value is a Promise-like object.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Promise-like object
+ */
+export declare function isPromise<T = unknown>(value: unknown): value is Promise<T>;
+/**
+ * Checks if a value is a non-null object.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an object
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/core/utils/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../../src/core/utils/type-guards.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;CAAE,CAE7E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAEnF;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,EAAE,CAEjE;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAQ1E;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE"}