ts-packages 1.0.0 → 2.0.0

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendNumber = extendNumber;
+// Number prototype extensions
+const performance_1 = require("../core/performance");
+function extendNumber() {
+    Number.prototype.toPercent = function (decimals = 2) {
+        return `${(this.valueOf() * 100).toFixed(decimals)}%`;
+    };
+    Number.prototype.toCurrency = function (currency = 'USD', locale = 'en-US') {
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency,
+        }).format(this.valueOf());
+    };
+    Number.prototype.clamp = function (min, max) {
+        if (min > max) {
+            throw new RangeError(`clamp: min (${min}) cannot be greater than max (${max})`);
+        }
+        return Math.min(Math.max(this.valueOf(), min), max);
+    };
+    Number.prototype.isEven = function () {
+        return this.valueOf() % 2 === 0;
+    };
+    Number.prototype.isOdd = function () {
+        return this.valueOf() % 2 !== 0;
+    };
+    Number.prototype.isPrime = function () {
+        const num = this.valueOf();
+        return (0, performance_1.withCache)(`prime_${num}`, () => {
+            if (num < 2)
+                return false;
+            for (let i = 2; i <= Math.sqrt(num); i++) {
+                if (num % i === 0)
+                    return false;
+            }
+            return true;
+        });
+    };
+    Number.prototype.factorial = function () {
+        const num = Math.floor(this.valueOf());
+        return (0, performance_1.withCache)(`factorial_${num}`, () => {
+            if (num < 0)
+                return Number.NaN;
+            if (num === 0 || num === 1)
+                return 1;
+            let result = 1;
+            for (let i = 2; i <= num; i++) {
+                result *= i;
+            }
+            return result;
+        });
+    };
+    Number.prototype.toOrdinal = function () {
+        const num = Math.floor(this.valueOf());
+        const suffix = ['th', 'st', 'nd', 'rd'];
+        const v = num % 100;
+        return num + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
+    };
+    Number.prototype.toRoman = function () {
+        const num = Math.floor(this.valueOf());
+        // Better validation for roman numerals
+        if (num <= 0) {
+            throw new RangeError('toRoman: number must be positive');
+        }
+        if (num >= 4000) {
+            throw new RangeError('toRoman: number must be less than 4000');
+        }
+        return (0, performance_1.withCache)(`roman_${num}`, () => {
+            const values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
+            const symbols = [
+                'M',
+                'CM',
+                'D',
+                'CD',
+                'C',
+                'XC',
+                'L',
+                'XL',
+                'X',
+                'IX',
+                'V',
+                'IV',
+                'I',
+            ];
+            let result = '';
+            let n = num;
+            for (let i = 0; i < values.length; i++) {
+                while (n >= values[i]) {
+                    result += symbols[i];
+                    n -= values[i];
+                }
+            }
+            return result;
+        });
+    };
+    Number.prototype.inRange = function (min, max) {
+        const num = this.valueOf();
+        return num >= min && num <= max;
+    };
+    Number.prototype.round = function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0) {
+            throw new TypeError(`round: decimals must be a non-negative integer, got ${decimals}`);
+        }
+        const factor = Math.pow(10, decimals);
+        return Math.round(this.valueOf() * factor) / factor;
+    };
+    Number.prototype.ceil = function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0) {
+            throw new TypeError(`ceil: decimals must be a non-negative integer, got ${decimals}`);
+        }
+        const factor = Math.pow(10, decimals);
+        return Math.ceil(this.valueOf() * factor) / factor;
+    };
+    Number.prototype.floor = function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0) {
+            throw new TypeError(`floor: decimals must be a non-negative integer, got ${decimals}`);
+        }
+        const factor = Math.pow(10, decimals);
+        return Math.floor(this.valueOf() * factor) / factor;
+    };
+    Number.prototype.abs = function () {
+        return Math.abs(this.valueOf());
+    };
+    Number.prototype.sign = function () {
+        return Math.sign(this.valueOf());
+    };
+    Number.prototype.times = function (callback) {
+        if (typeof callback !== 'function') {
+            throw new TypeError(`times: callback must be a function, got ${typeof callback}`);
+        }
+        const num = Math.floor(this.valueOf());
+        for (let i = 0; i < num; i++) {
+            callback(i);
+        }
+    };
+}

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

@@ -0,0 +1 @@
+export { extendObject } from './object-extensions';

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

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

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

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

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

@@ -0,0 +1,147 @@
+"use strict";
+// Object prototype extensions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendObject = extendObject;
+function extendObject() {
+    Object.prototype.isEmpty = function () {
+        return Object.keys(this).length === 0;
+    };
+    Object.prototype.pick = function (keys) {
+        if (this === null || this === undefined) {
+            throw new TypeError('pick: cannot be called on null or undefined');
+        }
+        if (!Array.isArray(keys)) {
+            throw new TypeError(`pick: keys must be an array, got ${typeof keys}`);
+        }
+        if (keys.length === 0) {
+            throw new TypeError('pick: keys array cannot be empty');
+        }
+        const result = {};
+        const obj = this;
+        keys.forEach((key) => {
+            if (key in obj) {
+                result[key] = obj[key];
+            }
+        });
+        return result;
+    };
+    Object.prototype.omit = function (keys) {
+        if (this === null || this === undefined) {
+            throw new TypeError('omit: cannot be called on null or undefined');
+        }
+        if (!Array.isArray(keys)) {
+            throw new TypeError(`omit: keys must be an array, got ${typeof keys}`);
+        }
+        if (keys.length === 0) {
+            throw new TypeError('omit: keys array cannot be empty');
+        }
+        const result = { ...this };
+        keys.forEach((key) => {
+            delete result[key];
+        });
+        return result;
+    };
+    Object.prototype.deepClone = function () {
+        // Simple cycle detection without caching key generation
+        if (this === null || typeof this !== 'object')
+            return this;
+        // Handle Date objects
+        if (this instanceof Date)
+            return new Date(this.getTime());
+        // Handle Array objects
+        if (Array.isArray(this)) {
+            return this.map((item) => {
+                if (item &&
+                    typeof item === 'object' &&
+                    typeof item.deepClone === 'function') {
+                    return item.deepClone();
+                }
+                return item;
+            });
+        }
+        // Handle regular objects with better cycle detection
+        const visited = new WeakSet();
+        function deepCloneSafe(obj) {
+            if (obj === null || typeof obj !== 'object')
+                return obj;
+            if (visited.has(obj)) {
+                throw new Error('Circular reference detected in deepClone');
+            }
+            visited.add(obj);
+            if (obj instanceof Date)
+                return new Date(obj.getTime());
+            if (Array.isArray(obj))
+                return obj.map((item) => deepCloneSafe(item));
+            const cloned = {};
+            Object.keys(obj).forEach((key) => {
+                cloned[key] = deepCloneSafe(obj[key]);
+            });
+            return cloned;
+        }
+        return deepCloneSafe(this);
+    };
+    Object.prototype.merge = function (other) {
+        return { ...this, ...other };
+    };
+    Object.prototype.deepFreeze = function () {
+        const propNames = Object.getOwnPropertyNames(this);
+        for (const name of propNames) {
+            const value = this[name];
+            if (value && typeof value === 'object') {
+                value.deepFreeze();
+            }
+        }
+        return Object.freeze(this);
+    };
+    Object.prototype.hasPath = function (path) {
+        if (typeof path !== 'string') {
+            throw new TypeError(`hasPath: path must be a string, got ${typeof path}`);
+        }
+        if (path.trim() === '') {
+            throw new TypeError('hasPath: path cannot be empty or whitespace');
+        }
+        const keys = path.split('.');
+        let current = this;
+        for (const key of keys) {
+            if (current == null || !(key in current))
+                return false;
+            current = current[key];
+        }
+        return true;
+    };
+    Object.prototype.getPath = function (path, defaultValue) {
+        if (typeof path !== 'string') {
+            throw new TypeError(`getPath: path must be a string, got ${typeof path}`);
+        }
+        if (path.trim() === '') {
+            throw new TypeError('getPath: path cannot be empty or whitespace');
+        }
+        const keys = path.split('.');
+        let current = this;
+        for (const key of keys) {
+            if (current == null || !(key in current))
+                return defaultValue;
+            current = current[key];
+        }
+        return current;
+    };
+    Object.prototype.setPath = function (path, value) {
+        if (typeof path !== 'string') {
+            throw new TypeError(`setPath: path must be a string, got ${typeof path}`);
+        }
+        if (path.trim() === '') {
+            throw new TypeError('setPath: path cannot be empty or whitespace');
+        }
+        const keys = path.split('.');
+        let current = this;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const key = keys[i];
+            if (!(key in current) || typeof current[key] !== 'object') {
+                current[key] = {};
+            }
+            current = current[key];
+        }
+        current[keys[keys.length - 1]] = value;
+        return this;
+    };
+}

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

@@ -0,0 +1 @@
+export { extendString } from './string-extensions';

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

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

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

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

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendString = extendString;
+// String prototype extensions
+function extendString() {
+    String.prototype.toCapitalize = function () {
+        return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
+    };
+    String.prototype.toCamelCase = function () {
+        return this.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : '');
+    };
+    String.prototype.toKebabCase = function () {
+        return this.replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase();
+    };
+    String.prototype.toSnakeCase = function () {
+        return this.replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/[\s-]+/g, '_')
+            .toLowerCase();
+    };
+    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();
+    };
+    String.prototype.isEmail = function () {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(this.toString());
+    };
+    String.prototype.isUrl = function () {
+        try {
+            new URL(this.toString());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    String.prototype.removeWhitespace = function () {
+        return this.replace(/\s+/g, '');
+    };
+    String.prototype.reverse = function () {
+        return this.split('').reverse().join('');
+    };
+    String.prototype.isPalindrome = function () {
+        const cleaned = this.toLowerCase().replace(/[^a-z0-9]/g, '');
+        return cleaned === cleaned.split('').reverse().join('');
+    };
+    String.prototype.toTitleCase = function () {
+        return this.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+    };
+    String.prototype.stripHtml = function () {
+        return this.replace(/<[^>]*>/g, '');
+    };
+    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);
+    };
+    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);
+    };
+    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');
+        }
+        return (this.match(new RegExp(substring, 'g')) || []).length;
+    };
+    String.prototype.words = function () {
+        return this.trim()
+            .split(/\s+/)
+            .filter((word) => word.length > 0);
+    };
+    String.prototype.lines = function () {
+        return this.split(/\r?\n/);
+    };
+}

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,71 @@
+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[];
+        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/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,2 @@
+export * from './config';
+export * from './helpers';

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

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

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