ts-packages 1.0.0 → 3.0.0

package/packages/js-extensions/dist/cjs/string/string-extensions.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendString = extendString;
+const utils_1 = require("src/utils");
+let stringExtended = false;
+function extendString() {
+    if (stringExtended)
+        return;
+    stringExtended = true;
+    (0, utils_1.defineExtension)(String.prototype, 'toCapitalize', function () {
+        return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toCamelCase', function () {
+        return this.replace(/[-_\s]+(.)?/g, (_, char) => (char ? char.toUpperCase() : ''));
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toKebabCase', function () {
+        return this.replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase();
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toSnakeCase', function () {
+        return this.replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/[\s-]+/g, '_')
+            .toLowerCase();
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'truncate', function (length, suffix = '...') {
+        if (!Number.isInteger(length) || length < 0) {
+            throw new TypeError(`truncate: length must be a non-negative integer, got ${length}`);
+        }
+        return this.length > length ? this.substring(0, length) + suffix : this.toString();
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'isEmail', function () {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(this.toString());
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'isUrl', function () {
+        try {
+            new URL(this.toString());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'removeWhitespace', function () {
+        return this.replace(/\s+/g, '');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'reverse', function () {
+        return this.split('').reverse().join('');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'isPalindrome', function () {
+        const cleaned = this.toLowerCase().replace(/[^a-z0-9]/g, '');
+        return cleaned === cleaned.split('').reverse().join('');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toTitleCase', function () {
+        return this.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'stripHtml', function () {
+        return this.replace(/<[^>]*>/g, '');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'padStart', function (targetLength, padString = ' ') {
+        if (!Number.isInteger(targetLength) || targetLength < 0) {
+            throw new TypeError(`padStart: targetLength must be a non-negative integer, got ${targetLength}`);
+        }
+        if (typeof padString !== 'string') {
+            throw new TypeError(`padStart: padString must be a string, got ${typeof padString}`);
+        }
+        if (padString.length === 0) {
+            throw new TypeError('padStart: padString cannot be empty');
+        }
+        return this.toString().padStart(targetLength, padString);
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'padEnd', function (targetLength, padString = ' ') {
+        if (!Number.isInteger(targetLength) || targetLength < 0) {
+            throw new TypeError(`padEnd: targetLength must be a non-negative integer, got ${targetLength}`);
+        }
+        if (typeof padString !== 'string') {
+            throw new TypeError(`padEnd: padString must be a string, got ${typeof padString}`);
+        }
+        if (padString.length === 0) {
+            throw new TypeError('padEnd: padString cannot be empty');
+        }
+        return this.toString().padEnd(targetLength, padString);
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'count', function (substring) {
+        if (typeof substring !== 'string') {
+            throw new TypeError(`count: substring must be a string, got ${typeof substring}`);
+        }
+        if (substring === '') {
+            throw new TypeError('count: substring cannot be empty');
+        }
+        const escaped = substring.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return (this.match(new RegExp(escaped, 'g')) || []).length;
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'words', function () {
+        return this.trim().split(/\s+/).filter((word) => word.length > 0);
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'lines', function () {
+        return this.split(/\r?\n/);
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'capitalizeWords', function () {
+        return this.toString().replace(/\b\w/g, (char) => char.toUpperCase());
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'reverseWords', function () {
+        return this.toString().split(/\s+/).reverse().join(' ');
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'truncateWords', function (count, suffix = '...') {
+        if (!Number.isInteger(count) || count < 0) {
+            throw new TypeError(`truncateWords: count must be a non-negative integer, got ${count}`);
+        }
+        const words = this.toString().split(/\s+/);
+        if (words.length <= count)
+            return this.toString();
+        return words.slice(0, count).join(' ') + suffix;
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'slugify', function () {
+        return this.toString()
+            .toLowerCase()
+            .replace(/[^\w\s-]/g, '')
+            .trim()
+            .replace(/[\s_-]+/g, '-');
+    });
+}

package/packages/js-extensions/dist/cjs/types/extension-types.d.ts

@@ -0,0 +1,9 @@
+import { PerformanceConfig } from '../core/performance';
+export interface ExtensionOptions {
+    string?: boolean;
+    array?: boolean;
+    object?: boolean;
+    number?: boolean;
+    performance?: PerformanceConfig;
+}
+export { PerformanceConfig };

package/packages/js-extensions/dist/cjs/types/extension-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/js-extensions/dist/cjs/types/global-augmentations.d.ts

@@ -0,0 +1,72 @@
+declare global {
+    interface String {
+        toCapitalize(): string;
+        toCamelCase(): string;
+        toKebabCase(): string;
+        toSnakeCase(): string;
+        truncate(length: number, suffix?: string): string;
+        isEmail(): boolean;
+        isUrl(): boolean;
+        removeWhitespace(): string;
+        reverse(): string;
+        isPalindrome(): boolean;
+        toTitleCase(): string;
+        stripHtml(): string;
+        padStart(targetLength: number, padString?: string): string;
+        padEnd(targetLength: number, padString?: string): string;
+        count(substring: string): number;
+        words(): string[];
+        lines(): string[];
+    }
+    interface Array<T> {
+        unique(): T[];
+        shuffle(): T[];
+        chunk(size: number): T[][];
+        groupBy<K extends string | number>(keyFn: (item: T) => K): Record<K, T[]>;
+        sum(): number;
+        average(): number;
+        compact(): T[];
+        compactTruthy(): T[];
+        pluck<K extends keyof T>(key: K): T[K][];
+        findLast(predicate: (item: T) => boolean): T | undefined;
+        partition(predicate: (item: T) => boolean): [T[], T[]];
+        flatten(depth?: number): any[];
+        deepFlatten(): any[];
+        difference(other: T[]): T[];
+        intersection(other: T[]): T[];
+        union(other: T[]): T[];
+        sample(): T | undefined;
+        take(count: number): T[];
+        drop(count: number): T[];
+    }
+    interface Object {
+        isEmpty(): boolean;
+        pick<T extends Record<string, any>, K extends keyof T>(keys: K[]): Pick<T, K>;
+        omit<T extends Record<string, any>, K extends keyof T>(keys: K[]): Omit<T, K>;
+        deepClone<T>(): T;
+        merge(other: Record<string, any>): Record<string, any>;
+        deepFreeze<T>(): T;
+        hasPath(path: string): boolean;
+        getPath(path: string, defaultValue?: any): any;
+        setPath(path: string, value: any): any;
+    }
+    interface Number {
+        toPercent(decimals?: number): string;
+        toCurrency(currency?: string, locale?: string): string;
+        clamp(min: number, max: number): number;
+        isEven(): boolean;
+        isOdd(): boolean;
+        isPrime(): boolean;
+        factorial(): number;
+        toOrdinal(): string;
+        toRoman(): string;
+        inRange(min: number, max: number): boolean;
+        round(decimals?: number): number;
+        ceil(decimals?: number): number;
+        floor(decimals?: number): number;
+        abs(): number;
+        sign(): number;
+        times(callback: (index: number) => void): void;
+    }
+}
+export {};

package/packages/js-extensions/dist/cjs/types/global-augmentations.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/js-extensions/dist/cjs/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './extension-types';
+export * from './global-augmentations';

package/packages/js-extensions/dist/cjs/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all types
+__exportStar(require("./extension-types"), exports);
+__exportStar(require("./global-augmentations"), exports);

package/packages/js-extensions/dist/cjs/utils/config.d.ts

@@ -0,0 +1,4 @@
+import type { PerformanceConfig } from '../core/performance';
+export declare function validateConfig(config: Partial<PerformanceConfig>, defaultConfig: PerformanceConfig): PerformanceConfig;
+export declare function validatePerformanceSettings(settings: Partial<PerformanceConfig>): PerformanceConfig;
+export declare function mergeConfigs<T extends Record<string, any>>(base: T, override: Partial<T>): T;

package/packages/js-extensions/dist/cjs/utils/config.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+exports.validatePerformanceSettings = validatePerformanceSettings;
+exports.mergeConfigs = mergeConfigs;
+function validateConfig(config, defaultConfig) {
+    return { ...defaultConfig, ...config };
+}
+function validatePerformanceSettings(settings) {
+    const validated = {
+        enableCaching: settings.enableCaching ?? false,
+        maxCacheSize: Math.max(1, settings.maxCacheSize ?? 100),
+        enableValidation: settings.enableValidation ?? true,
+    };
+    return validated;
+}
+function mergeConfigs(base, override) {
+    const result = { ...base };
+    for (const key in override) {
+        if (override[key] !== undefined) {
+            result[key] = override[key];
+        }
+    }
+    return result;
+}

package/packages/js-extensions/dist/cjs/utils/defineExtension.d.ts

@@ -0,0 +1 @@
+export declare function defineExtension<T extends object>(prototype: T, name: string, fn: Function): void;

package/packages/js-extensions/dist/cjs/utils/defineExtension.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineExtension = defineExtension;
+function defineExtension(prototype, name, fn) {
+    if (!Object.prototype.hasOwnProperty.call(prototype, name)) {
+        Object.defineProperty(prototype, name, {
+            value: fn,
+            writable: false,
+            configurable: false,
+            enumerable: false,
+        });
+    }
+}

package/packages/js-extensions/dist/cjs/utils/helpers.d.ts

@@ -0,0 +1,5 @@
+export declare function isValidArrayIndex(index: number): boolean;
+export declare function ensurePositiveInteger(value: number, name: string): void;
+export declare function safeClone<T>(obj: T): T;
+export declare function getPathSegments(path: string): string[];
+export declare function hasOwnProperty(obj: any, key: string): boolean;

package/packages/js-extensions/dist/cjs/utils/helpers.js

@@ -0,0 +1,37 @@
+"use strict";
+// Shared helper functions for extensions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidArrayIndex = isValidArrayIndex;
+exports.ensurePositiveInteger = ensurePositiveInteger;
+exports.safeClone = safeClone;
+exports.getPathSegments = getPathSegments;
+exports.hasOwnProperty = hasOwnProperty;
+function isValidArrayIndex(index) {
+    return Number.isInteger(index) && index >= 0;
+}
+function ensurePositiveInteger(value, name) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new TypeError(`${name} must be a positive integer`);
+    }
+}
+function safeClone(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    if (obj instanceof Date)
+        return new Date(obj.getTime());
+    if (Array.isArray(obj))
+        return obj.map((item) => safeClone(item));
+    const cloned = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            cloned[key] = safeClone(obj[key]);
+        }
+    }
+    return cloned;
+}
+function getPathSegments(path) {
+    return path.split('.').filter((segment) => segment.length > 0);
+}
+function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}

package/packages/js-extensions/dist/cjs/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './helpers';
+export * from './defineExtension';

package/packages/js-extensions/dist/cjs/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all utilities
+__exportStar(require("./config"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./defineExtension"), exports);

package/packages/js-extensions/dist/esm/array/array-extensions.d.ts

@@ -0,0 +1 @@
+export declare function extendArray(): void;

package/packages/js-extensions/dist/esm/array/array-extensions.js

@@ -0,0 +1,151 @@
+import { defineExtension } from "src/utils";
+let arrayExtended = false;
+export function extendArray() {
+    if (arrayExtended)
+        return;
+    arrayExtended = true;
+    defineExtension(Array.prototype, 'unique', function () {
+        return [...new Set(this)];
+    });
+    defineExtension(Array.prototype, 'shuffle', function () {
+        const arr = [...this];
+        for (let i = arr.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+        return arr;
+    });
+    defineExtension(Array.prototype, 'chunk', function (size) {
+        if (!Number.isInteger(size) || size <= 0) {
+            throw new TypeError(`chunk: size must be a positive integer, got ${size}`);
+        }
+        const chunks = [];
+        for (let i = 0; i < this.length; i += size) {
+            chunks.push(this.slice(i, i + size));
+        }
+        return chunks;
+    });
+    defineExtension(Array.prototype, 'groupBy', function (keyFn) {
+        if (typeof keyFn !== 'function') {
+            throw new TypeError(`groupBy: keyFn must be a function, got ${typeof keyFn}`);
+        }
+        return this.reduce((groups, item) => {
+            const key = keyFn(item);
+            if (!groups[key])
+                groups[key] = [];
+            groups[key].push(item);
+            return groups;
+        }, {});
+    });
+    defineExtension(Array.prototype, 'sum', function () {
+        if (this.length === 0) {
+            throw new TypeError('sum: array must contain at least one number');
+        }
+        return this.reduce((sum, num) => sum + num, 0);
+    });
+    defineExtension(Array.prototype, 'average', function () {
+        if (this.length === 0) {
+            throw new TypeError('average: array must contain at least one number');
+        }
+        return this.reduce((sum, num) => sum + num, 0) / this.length;
+    });
+    defineExtension(Array.prototype, 'compact', function () {
+        return this.filter((item) => item !== null && item !== undefined && item !== '');
+    });
+    defineExtension(Array.prototype, 'compactTruthy', function () {
+        return this.filter(Boolean);
+    });
+    defineExtension(Array.prototype, 'pluck', function (key) {
+        return this
+            .map((item) => item[key])
+            .filter((val) => val !== undefined);
+    });
+    defineExtension(Array.prototype, 'findLast', function (predicate) {
+        if (typeof predicate !== 'function') {
+            throw new TypeError(`findLast: predicate must be a function, got ${typeof predicate}`);
+        }
+        for (let i = this.length - 1; i >= 0; i--) {
+            if (predicate(this[i]))
+                return this[i];
+        }
+        return undefined;
+    });
+    defineExtension(Array.prototype, 'partition', function (predicate) {
+        if (typeof predicate !== 'function') {
+            throw new TypeError(`partition: predicate must be a function, got ${typeof predicate}`);
+        }
+        const truthy = [];
+        const falsy = [];
+        this.forEach((item) => predicate(item) ? truthy.push(item) : falsy.push(item));
+        return [truthy, falsy];
+    });
+    defineExtension(Array.prototype, 'flatten', function (depth = 1) {
+        return depth > 0
+            ? this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.flatten(depth - 1) : val), [])
+            : this.slice();
+    });
+    defineExtension(Array.prototype, 'deepFlatten', function () {
+        return this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
+    });
+    defineExtension(Array.prototype, 'difference', function (other) {
+        if (!Array.isArray(other)) {
+            throw new TypeError(`difference: other must be an array, got ${typeof other}`);
+        }
+        return this.filter((item) => !other.includes(item));
+    });
+    defineExtension(Array.prototype, 'intersection', function (other) {
+        if (!Array.isArray(other)) {
+            throw new TypeError(`intersection: other must be an array, got ${typeof other}`);
+        }
+        return this.filter((item) => other.includes(item));
+    });
+    defineExtension(Array.prototype, 'union', function (other) {
+        if (!Array.isArray(other)) {
+            throw new TypeError(`union: other must be an array, got ${typeof other}`);
+        }
+        return [...new Set([...this, ...other])];
+    });
+    defineExtension(Array.prototype, 'sample', function () {
+        return this.length > 0
+            ? this[Math.floor(Math.random() * this.length)]
+            : undefined;
+    });
+    defineExtension(Array.prototype, 'take', function (count) {
+        return this.slice(0, Math.max(0, count));
+    });
+    defineExtension(Array.prototype, 'drop', function (count) {
+        return this.slice(Math.max(0, count));
+    });
+    defineExtension(Array.prototype, 'uniqueBy', function (keyFn) {
+        if (typeof keyFn !== 'function') {
+            throw new TypeError(`uniqueBy: keyFn must be a function, got ${typeof keyFn}`);
+        }
+        const seen = new Set();
+        const result = [];
+        for (const item of this) {
+            const key = keyFn(item);
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(item);
+            }
+        }
+        return result;
+    });
+    defineExtension(Array.prototype, 'sortBy', function (keyFn) {
+        if (typeof keyFn !== 'function') {
+            throw new TypeError(`sortBy: keyFn must be a function, got ${typeof keyFn}`);
+        }
+        return [...this].sort((a, b) => {
+            const aVal = keyFn(a);
+            const bVal = keyFn(b);
+            if (aVal < bVal)
+                return -1;
+            if (aVal > bVal)
+                return 1;
+            return 0;
+        });
+    });
+    defineExtension(Array.prototype, 'last', function () {
+        return this.length > 0 ? this[this.length - 1] : undefined;
+    });
+}

package/packages/js-extensions/dist/esm/array/index.d.ts

@@ -0,0 +1 @@
+export { extendArray } from './array-extensions';

package/packages/js-extensions/dist/esm/array/index.js

@@ -0,0 +1 @@
+export { extendArray } from './array-extensions';

package/packages/js-extensions/dist/esm/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './validation';
+export * from './performance';

package/packages/js-extensions/dist/esm/core/index.js

@@ -0,0 +1,3 @@
+// Re-export core utilities
+export * from './validation';
+export * from './performance';

package/packages/js-extensions/dist/esm/core/performance.d.ts

@@ -0,0 +1,17 @@
+export interface PerformanceConfig {
+    enableCaching?: boolean;
+    maxCacheSize?: number;
+    enableValidation?: boolean;
+}
+export declare function setPerformanceConfig(newConfig: Partial<PerformanceConfig>): void;
+export declare function getPerformanceConfig(): PerformanceConfig;
+export declare class LRUCache<K, V> {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    clear(): void;
+}
+export declare function makeInternalCacheKey(domain: string, key: string | number): string;
+export declare function withCache<T>(key: string, fn: () => T): T;

package/packages/js-extensions/dist/esm/core/performance.js

@@ -0,0 +1,74 @@
+import { getPackageVersion } from "./version";
+const defaultConfig = {
+    enableCaching: false,
+    maxCacheSize: 100,
+    enableValidation: true,
+};
+let config = { ...defaultConfig };
+export function setPerformanceConfig(newConfig) {
+    const oldMaxSize = config.maxCacheSize;
+    config = { ...config, ...newConfig };
+    // Recreate cache if maxCacheSize changed
+    if (cache && oldMaxSize !== config.maxCacheSize) {
+        cache = new LRUCache(config.maxCacheSize);
+    }
+}
+export function getPerformanceConfig() {
+    return { ...config };
+}
+// Simple LRU cache for expensive operations
+export class LRUCache {
+    constructor(maxSize = 100) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            // Move to end (most recently used)
+            this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            // Remove least recently used (first item)
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+let cache = null;
+function getOrCreateCache() {
+    if (!cache) {
+        cache = new LRUCache(config.maxCacheSize);
+    }
+    return cache;
+}
+export function makeInternalCacheKey(domain, key) {
+    const INTERNAL_CACHE_PREFIX = '@js-ext' + getPackageVersion();
+    return `${INTERNAL_CACHE_PREFIX}:${domain}:${key}`;
+}
+export function withCache(key, fn) {
+    if (!config.enableCaching) {
+        return fn();
+    }
+    const currentCache = getOrCreateCache();
+    const cached = currentCache.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = fn();
+    currentCache.set(key, result);
+    return result;
+}

package/packages/js-extensions/dist/esm/core/validation.d.ts

@@ -0,0 +1,4 @@
+export declare function validateExtensionInput(value: any, type: string, methodName: string): void;
+export declare function validateArrayInput<T>(arr: T[], methodName: string): void;
+export declare function validateNumberRange(num: number, min: number, max: number, methodName: string): void;
+export declare function validatePositiveInteger(num: number, methodName: string): void;

package/packages/js-extensions/dist/esm/core/validation.js

@@ -0,0 +1,25 @@
+// Validation utilities for extensions
+export function validateExtensionInput(value, type, methodName) {
+    if (value == null) {
+        throw new TypeError(`Cannot call ${methodName} on ${value}`);
+    }
+    const actualType = typeof value;
+    if (actualType !== type) {
+        throw new TypeError(`${methodName} can only be called on ${type} values, got ${actualType}`);
+    }
+}
+export function validateArrayInput(arr, methodName) {
+    if (!Array.isArray(arr)) {
+        throw new TypeError(`${methodName} can only be called on arrays`);
+    }
+}
+export function validateNumberRange(num, min, max, methodName) {
+    if (num < min || num > max) {
+        throw new RangeError(`${methodName}: number must be between ${min} and ${max}, got ${num}`);
+    }
+}
+export function validatePositiveInteger(num, methodName) {
+    if (!Number.isInteger(num) || num < 0) {
+        throw new TypeError(`${methodName}: expected positive integer, got ${num}`);
+    }
+}

package/packages/js-extensions/dist/esm/core/version.d.ts

@@ -0,0 +1 @@
+export declare const getPackageVersion: () => string;

package/packages/js-extensions/dist/esm/core/version.js

@@ -0,0 +1,5 @@
+import { createRequire } from 'node:module';
+const requireFn = createRequire("../../package.json");
+export const getPackageVersion = () => {
+    return requireFn('../package.json').version;
+};