ts-packages 1.0.0 → 2.0.0

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendArray = extendArray;
+// Array prototype extensions
+function extendArray() {
+    Array.prototype.unique = function () {
+        return [...new Set(this)];
+    };
+    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;
+    };
+    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;
+    };
+    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;
+        }, {});
+    };
+    Array.prototype.sum = function () {
+        const numbers = this.filter((item) => typeof item === 'number');
+        if (numbers.length === 0) {
+            throw new TypeError('sum: array must contain at least one number');
+        }
+        return numbers.reduce((sum, num) => sum + num, 0);
+    };
+    Array.prototype.average = function () {
+        const numbers = this.filter((item) => typeof item === 'number');
+        if (numbers.length === 0) {
+            throw new TypeError('average: array must contain at least one number');
+        }
+        return numbers.reduce((sum, num) => sum + num, 0) / numbers.length;
+    };
+    Array.prototype.compact = function () {
+        return this.filter((item) => item != null && item !== '' && item !== false);
+    };
+    Array.prototype.pluck = function (key) {
+        if (typeof key !== 'string' &&
+            typeof key !== 'number' &&
+            typeof key !== 'symbol') {
+            throw new TypeError(`pluck: key must be a string, number, or symbol, got ${typeof key}`);
+        }
+        return this.map((item) => item && typeof item === 'object' ? item[key] : undefined).filter((val) => val !== undefined);
+    };
+    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;
+    };
+    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];
+    };
+    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();
+    };
+    Array.prototype.deepFlatten = function () {
+        return this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
+    };
+    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));
+    };
+    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));
+    };
+    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])];
+    };
+    Array.prototype.sample = function () {
+        return this.length > 0
+            ? this[Math.floor(Math.random() * this.length)]
+            : undefined;
+    };
+    Array.prototype.take = function (count) {
+        return this.slice(0, Math.max(0, count));
+    };
+    Array.prototype.drop = function (count) {
+        return this.slice(Math.max(0, count));
+    };
+}

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

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

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendArray = void 0;
+var array_extensions_1 = require("./array-extensions");
+Object.defineProperty(exports, "extendArray", { enumerable: true, get: function () { return array_extensions_1.extendArray; } });

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

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

package/packages/js-extensions/dist/cjs/core/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 core utilities
+__exportStar(require("./validation"), exports);
+__exportStar(require("./performance"), exports);

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

@@ -0,0 +1,16 @@
+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 withCache<T>(key: string, fn: () => T): T;

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCache = void 0;
+exports.setPerformanceConfig = setPerformanceConfig;
+exports.getPerformanceConfig = getPerformanceConfig;
+exports.withCache = withCache;
+const defaultConfig = {
+    enableCaching: false,
+    maxCacheSize: 100,
+    enableValidation: true,
+};
+let config = { ...defaultConfig };
+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);
+    }
+}
+function getPerformanceConfig() {
+    return { ...config };
+}
+// Simple LRU cache for expensive operations
+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();
+    }
+}
+exports.LRUCache = LRUCache;
+let cache = null;
+function getOrCreateCache() {
+    if (!cache) {
+        cache = new LRUCache(config.maxCacheSize);
+    }
+    return cache;
+}
+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/cjs/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/cjs/core/validation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExtensionInput = validateExtensionInput;
+exports.validateArrayInput = validateArrayInput;
+exports.validateNumberRange = validateNumberRange;
+exports.validatePositiveInteger = validatePositiveInteger;
+// Validation utilities for extensions
+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}`);
+    }
+}
+function validateArrayInput(arr, methodName) {
+    if (!Array.isArray(arr)) {
+        throw new TypeError(`${methodName} can only be called on arrays`);
+    }
+}
+function validateNumberRange(num, min, max, methodName) {
+    if (num < min || num > max) {
+        throw new RangeError(`${methodName}: number must be between ${min} and ${max}, got ${num}`);
+    }
+}
+function validatePositiveInteger(num, methodName) {
+    if (!Number.isInteger(num) || num < 0) {
+        throw new TypeError(`${methodName}: expected positive integer, got ${num}`);
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from '../string';
+export * from '../array';
+export * from '../object';
+export * from '../number';

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

@@ -0,0 +1,21 @@
+"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 extensions
+__exportStar(require("../string"), exports);
+__exportStar(require("../array"), exports);
+__exportStar(require("../object"), exports);
+__exportStar(require("../number"), exports);

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

@@ -0,0 +1,60 @@
+import '../types/global-augmentations';
+import { extendArray } from './array';
+import { extendNumber } from './number';
+import { extendObject } from './object';
+import { extendString } from './string';
+import { LRUCache, getPerformanceConfig, setPerformanceConfig, withCache } from './core/performance';
+import { validateArrayInput, validateExtensionInput, validateNumberRange, validatePositiveInteger } from './core/validation';
+import { mergeConfigs, validateConfig, validatePerformanceSettings } from './utils/config';
+import { ensurePositiveInteger, getPathSegments, hasOwnProperty, isValidArrayIndex, safeClone } from './utils/helpers';
+import { ExtensionOptions, PerformanceConfig } from './types/extension-types';
+export { ExtensionOptions, PerformanceConfig };
+export { withCache };
+import { extendAll } from './init/initializer';
+/**
+ * Initialize JavaScript prototype extensions
+ * @param options - Configure which extensions to enable (default: all enabled)
+ */
+export declare function initializeExtensions(options?: ExtensionOptions): void;
+/**
+ * Initialize all extensions (convenience function)
+ */
+export { extendAll };
+/**
+ * Initialize only specific extensions
+ */
+export declare const extend: {
+    string: typeof extendString;
+    array: typeof extendArray;
+    object: typeof extendObject;
+    number: typeof extendNumber;
+};
+export { validateExtensionInput, validateArrayInput, validateNumberRange, validatePositiveInteger, };
+export { validateConfig, validatePerformanceSettings, mergeConfigs, isValidArrayIndex, ensurePositiveInteger, safeClone, getPathSegments, hasOwnProperty, };
+export { LRUCache, setPerformanceConfig, getPerformanceConfig };
+declare const _default: {
+    initializeExtensions: typeof initializeExtensions;
+    extendAll: typeof extendAll;
+    extend: {
+        string: typeof extendString;
+        array: typeof extendArray;
+        object: typeof extendObject;
+        number: typeof extendNumber;
+    };
+    LRUCache: typeof LRUCache;
+    setPerformanceConfig: typeof setPerformanceConfig;
+    getPerformanceConfig: typeof getPerformanceConfig;
+    validateExtensionInput: typeof validateExtensionInput;
+    validateArrayInput: typeof validateArrayInput;
+    validateNumberRange: typeof validateNumberRange;
+    validatePositiveInteger: typeof validatePositiveInteger;
+    validateConfig: typeof validateConfig;
+    validatePerformanceSettings: typeof validatePerformanceSettings;
+    mergeConfigs: typeof mergeConfigs;
+    isValidArrayIndex: typeof isValidArrayIndex;
+    ensurePositiveInteger: typeof ensurePositiveInteger;
+    safeClone: typeof safeClone;
+    getPathSegments: typeof getPathSegments;
+    hasOwnProperty: typeof hasOwnProperty;
+};
+export default _default;

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPerformanceConfig = exports.setPerformanceConfig = exports.LRUCache = exports.hasOwnProperty = exports.getPathSegments = exports.safeClone = exports.ensurePositiveInteger = exports.isValidArrayIndex = exports.mergeConfigs = exports.validatePerformanceSettings = exports.validateConfig = exports.validatePositiveInteger = exports.validateNumberRange = exports.validateArrayInput = exports.validateExtensionInput = exports.extend = exports.extendAll = exports.withCache = void 0;
+exports.initializeExtensions = initializeExtensions;
+// Import types first
+require("../types/global-augmentations");
+const array_1 = require("./array");
+const number_1 = require("./number");
+const object_1 = require("./object");
+// Import extension modules
+const string_1 = require("./string");
+// Import core utilities
+const performance_1 = require("./core/performance");
+Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function () { return performance_1.LRUCache; } });
+Object.defineProperty(exports, "getPerformanceConfig", { enumerable: true, get: function () { return performance_1.getPerformanceConfig; } });
+Object.defineProperty(exports, "setPerformanceConfig", { enumerable: true, get: function () { return performance_1.setPerformanceConfig; } });
+Object.defineProperty(exports, "withCache", { enumerable: true, get: function () { return performance_1.withCache; } });
+// Import validation utilities
+const validation_1 = require("./core/validation");
+Object.defineProperty(exports, "validateArrayInput", { enumerable: true, get: function () { return validation_1.validateArrayInput; } });
+Object.defineProperty(exports, "validateExtensionInput", { enumerable: true, get: function () { return validation_1.validateExtensionInput; } });
+Object.defineProperty(exports, "validateNumberRange", { enumerable: true, get: function () { return validation_1.validateNumberRange; } });
+Object.defineProperty(exports, "validatePositiveInteger", { enumerable: true, get: function () { return validation_1.validatePositiveInteger; } });
+// Import utility functions
+const config_1 = require("./utils/config");
+Object.defineProperty(exports, "mergeConfigs", { enumerable: true, get: function () { return config_1.mergeConfigs; } });
+Object.defineProperty(exports, "validateConfig", { enumerable: true, get: function () { return config_1.validateConfig; } });
+Object.defineProperty(exports, "validatePerformanceSettings", { enumerable: true, get: function () { return config_1.validatePerformanceSettings; } });
+const helpers_1 = require("./utils/helpers");
+Object.defineProperty(exports, "ensurePositiveInteger", { enumerable: true, get: function () { return helpers_1.ensurePositiveInteger; } });
+Object.defineProperty(exports, "getPathSegments", { enumerable: true, get: function () { return helpers_1.getPathSegments; } });
+Object.defineProperty(exports, "hasOwnProperty", { enumerable: true, get: function () { return helpers_1.hasOwnProperty; } });
+Object.defineProperty(exports, "isValidArrayIndex", { enumerable: true, get: function () { return helpers_1.isValidArrayIndex; } });
+Object.defineProperty(exports, "safeClone", { enumerable: true, get: function () { return helpers_1.safeClone; } });
+// Import initialization functions
+const initializer_1 = require("./init/initializer");
+Object.defineProperty(exports, "extendAll", { enumerable: true, get: function () { return initializer_1.extendAll; } });
+/**
+ * Initialize JavaScript prototype extensions
+ * @param options - Configure which extensions to enable (default: all enabled)
+ */
+function initializeExtensions(options = {}) {
+    (0, initializer_1.initExtensions)(options);
+}
+/**
+ * Initialize only specific extensions
+ */
+exports.extend = {
+    string: string_1.extendString,
+    array: array_1.extendArray,
+    object: object_1.extendObject,
+    number: number_1.extendNumber,
+};
+// Default export
+exports.default = {
+    initializeExtensions,
+    extendAll: initializer_1.extendAll,
+    extend: exports.extend,
+    LRUCache: performance_1.LRUCache,
+    setPerformanceConfig: performance_1.setPerformanceConfig,
+    getPerformanceConfig: performance_1.getPerformanceConfig,
+    // Validation utilities
+    validateExtensionInput: validation_1.validateExtensionInput,
+    validateArrayInput: validation_1.validateArrayInput,
+    validateNumberRange: validation_1.validateNumberRange,
+    validatePositiveInteger: validation_1.validatePositiveInteger,
+    // Utility functions
+    validateConfig: config_1.validateConfig,
+    validatePerformanceSettings: config_1.validatePerformanceSettings,
+    mergeConfigs: config_1.mergeConfigs,
+    isValidArrayIndex: helpers_1.isValidArrayIndex,
+    ensurePositiveInteger: helpers_1.ensurePositiveInteger,
+    safeClone: helpers_1.safeClone,
+    getPathSegments: helpers_1.getPathSegments,
+    hasOwnProperty: helpers_1.hasOwnProperty,
+};

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

@@ -0,0 +1,2 @@
+export * from './initializer';
+export * from './options';

package/packages/js-extensions/dist/cjs/init/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 initialization logic
+__exportStar(require("./initializer"), exports);
+__exportStar(require("./options"), exports);

package/packages/js-extensions/dist/cjs/init/initializer.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionOptions } from '../types/extension-types';
+export declare function initExtensions(options?: ExtensionOptions): void;
+export declare function extendAll(): void;

package/packages/js-extensions/dist/cjs/init/initializer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initExtensions = initExtensions;
+exports.extendAll = extendAll;
+// Extension initialization logic
+const array_1 = require("../array");
+const performance_1 = require("../core/performance");
+const number_1 = require("../number");
+const object_1 = require("../object");
+const string_1 = require("../string");
+function initExtensions(options = {}) {
+    const { string = true, array = true, object = true, number = true, performance, } = options;
+    if (performance) {
+        // Set performance config if provided
+        (0, performance_1.setPerformanceConfig)(performance);
+    }
+    if (string)
+        (0, string_1.extendString)();
+    if (array)
+        (0, array_1.extendArray)();
+    if (object)
+        (0, object_1.extendObject)();
+    if (number)
+        (0, number_1.extendNumber)();
+}
+function extendAll() {
+    initExtensions();
+}

package/packages/js-extensions/dist/cjs/init/options.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionOptions } from '../types/extension-types';
+export declare function validateExtensionOptions(options: Partial<ExtensionOptions>): ExtensionOptions;
+export declare function createExtensionOptions(enableString?: boolean, enableArray?: boolean, enableObject?: boolean, enableNumber?: boolean, performanceConfig?: any): ExtensionOptions;

package/packages/js-extensions/dist/cjs/init/options.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExtensionOptions = validateExtensionOptions;
+exports.createExtensionOptions = createExtensionOptions;
+function validateExtensionOptions(options) {
+    const validated = {
+        string: options.string !== false,
+        array: options.array !== false,
+        object: options.object !== false,
+        number: options.number !== false,
+        performance: options.performance,
+    };
+    return validated;
+}
+function createExtensionOptions(enableString = true, enableArray = true, enableObject = true, enableNumber = true, performanceConfig) {
+    return {
+        string: enableString,
+        array: enableArray,
+        object: enableObject,
+        number: enableNumber,
+        performance: performanceConfig,
+    };
+}

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

@@ -0,0 +1 @@
+export { extendNumber } from './number-extensions';

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendNumber = void 0;
+var number_extensions_1 = require("./number-extensions");
+Object.defineProperty(exports, "extendNumber", { enumerable: true, get: function () { return number_extensions_1.extendNumber; } });

package/packages/js-extensions/dist/cjs/number/number-extensions.d.ts

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