ts-packages 2.0.0 → 3.0.0

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

@@ -1,3 +1,4 @@
+import { getPackageVersion } from "./version";
 const defaultConfig = {
     enableCaching: false,
     maxCacheSize: 100,
@@ -54,6 +55,10 @@ function getOrCreateCache() {
     }
     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();

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;
+};

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

@@ -21,6 +21,7 @@ export declare function initializeExtensions(options?: ExtensionOptions): void;
  */
 export { extendAll };
 /**
+ * Selective prototype extension helpers
  * Initialize only specific extensions
  */
 export declare const extend: {

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

@@ -28,6 +28,7 @@ export function initializeExtensions(options = {}) {
  */
 export { extendAll };
 /**
+ * Selective prototype extension helpers
  * Initialize only specific extensions
  */
 export const extend = {

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

@@ -1,87 +1,68 @@
-// Number prototype extensions
-import { withCache } from '../core/performance';
+import { defineExtension } from 'src/utils';
+import { makeInternalCacheKey, withCache } from '../core/performance';
+let numberExtended = false;
 export 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) {
+    if (numberExtended)
+        return;
+    numberExtended = true;
+    defineExtension(Number.prototype, 'toPercent', function (decimals = 2) {
+        return `${(this * 100).toFixed(decimals)}%`;
+    });
+    defineExtension(Number.prototype, 'toCurrency', function (currency = 'USD', locale = 'en-US') {
+        return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(this);
+    });
+    defineExtension(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 withCache(`prime_${num}`, () => {
+        return Math.min(Math.max(this, min), max);
+    });
+    defineExtension(Number.prototype, 'isEven', function () {
+        return this % 2 === 0;
+    });
+    defineExtension(Number.prototype, 'isOdd', function () {
+        return this % 2 !== 0;
+    });
+    defineExtension(Number.prototype, 'isPrime', function () {
+        const num = this;
+        return withCache(makeInternalCacheKey('prime', num), () => {
             if (num < 2)
                 return false;
-            for (let i = 2; i <= Math.sqrt(num); i++) {
+            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 withCache(`factorial_${num}`, () => {
+    });
+    defineExtension(Number.prototype, 'factorial', function () {
+        const num = Math.floor(this);
+        return withCache(makeInternalCacheKey('factorial', num), () => {
             if (num < 0)
-                return Number.NaN;
-            if (num === 0 || num === 1)
+                return NaN;
+            if (num <= 1)
                 return 1;
             let result = 1;
-            for (let i = 2; i <= num; i++) {
+            for (let i = 2; i <= num; i++)
                 result *= i;
-            }
             return result;
         });
-    };
-    Number.prototype.toOrdinal = function () {
-        const num = Math.floor(this.valueOf());
+    });
+    defineExtension(Number.prototype, 'toOrdinal', function () {
+        const num = Math.floor(this);
         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) {
+    });
+    defineExtension(Number.prototype, 'toRoman', function () {
+        const num = Math.floor(this);
+        if (num <= 0)
             throw new RangeError('toRoman: number must be positive');
-        }
-        if (num >= 4000) {
+        if (num >= 4000)
             throw new RangeError('toRoman: number must be less than 4000');
-        }
-        return withCache(`roman_${num}`, () => {
+        return withCache(makeInternalCacheKey('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 = '';
+            const symbols = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'];
             let n = num;
+            let result = '';
             for (let i = 0; i < values.length; i++) {
                 while (n >= values[i]) {
                     result += symbols[i];
@@ -90,45 +71,52 @@ export function extendNumber() {
             }
             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}`);
-        }
+    });
+    defineExtension(Number.prototype, 'inRange', function (min, max) {
+        return this >= min && this <= max;
+    });
+    defineExtension(Number.prototype, 'round', function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0)
+            throw new TypeError('round: decimals must be non-negative integer');
         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}`);
-        }
+        return Math.round(this * factor) / factor;
+    });
+    defineExtension(Number.prototype, 'ceil', function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0)
+            throw new TypeError('ceil: decimals must be non-negative integer');
+        const factor = Math.pow(10, decimals);
+        return Math.ceil(this * factor) / factor;
+    });
+    defineExtension(Number.prototype, 'floor', function (decimals = 0) {
+        if (!Number.isInteger(decimals) || decimals < 0)
+            throw new TypeError('floor: decimals must be non-negative integer');
         const factor = Math.pow(10, decimals);
-        return Math.ceil(this.valueOf() * factor) / factor;
-    };
-    Number.prototype.floor = function (decimals = 0) {
+        return Math.floor(this * factor) / factor;
+    });
+    defineExtension(Number.prototype, 'abs', function () {
+        return Math.abs(this);
+    });
+    defineExtension(Number.prototype, 'sign', function () {
+        return Math.sign(this);
+    });
+    defineExtension(Number.prototype, 'times', function (callback) {
+        if (typeof callback !== 'function')
+            throw new TypeError('times: callback must be a function');
+        for (let i = 0; i < Math.floor(this); i++)
+            callback(i);
+    });
+    defineExtension(Number.prototype, 'toFixedNumber', function (decimals = 0) {
         if (!Number.isInteger(decimals) || decimals < 0) {
-            throw new TypeError(`floor: decimals must be a non-negative integer, got ${decimals}`);
+            throw new TypeError(`toFixedNumber: 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);
+        return Math.round(this.valueOf() * factor) / factor;
+    });
+    defineExtension(Number.prototype, 'randomUpTo', function () {
+        const max = this.valueOf();
+        if (!Number.isFinite(max)) {
+            throw new TypeError(`randomUpTo: number must be finite, got ${max}`);
         }
-    };
+        return Math.random() * max;
+    });
 }

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

@@ -1,69 +1,40 @@
-// Object prototype extensions
+import { defineExtension } from "src/utils";
+let objectExtended = false;
 export function extendObject() {
-    Object.prototype.isEmpty = function () {
+    if (objectExtended)
+        return;
+    objectExtended = true;
+    defineExtension(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) {
+    });
+    defineExtension(Object.prototype, 'pick', function (keys) {
+        if (!Array.isArray(keys))
+            throw new TypeError('pick: keys must be an array');
+        if (!keys.length)
             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];
-            }
+            if (key in this)
+                result[key] = this[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) {
+    });
+    defineExtension(Object.prototype, 'omit', function (keys) {
+        if (!Array.isArray(keys))
+            throw new TypeError('omit: keys must be an array');
+        if (!keys.length)
             throw new TypeError('omit: keys array cannot be empty');
-        }
         const result = { ...this };
-        keys.forEach((key) => {
-            delete result[key];
-        });
+        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
+    });
+    defineExtension(Object.prototype, 'deepClone', function () {
         const visited = new WeakSet();
         function deepCloneSafe(obj) {
             if (obj === null || typeof obj !== 'object')
                 return obj;
-            if (visited.has(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());
@@ -76,69 +47,97 @@ export function extendObject() {
             return cloned;
         }
         return deepCloneSafe(this);
-    };
-    Object.prototype.merge = function (other) {
+    });
+    defineExtension(Object.prototype, 'merge', function (other) {
         return { ...this, ...other };
-    };
-    Object.prototype.deepFreeze = function () {
-        const propNames = Object.getOwnPropertyNames(this);
-        for (const name of propNames) {
+    });
+    defineExtension(Object.prototype, 'deepFreeze', function () {
+        Object.getOwnPropertyNames(this).forEach((name) => {
             const value = this[name];
-            if (value && typeof value === 'object') {
-                value.deepFreeze();
-            }
-        }
+            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');
-        }
+    });
+    defineExtension(Object.prototype, 'hasPath', function (path) {
+        if (!path.trim())
+            throw new TypeError('hasPath: path cannot be empty');
+        return path.split('.').every((key) => {
+            if (this == null || !(key in this))
+                return false;
+            // @ts-ignore
+            this = this[key];
+            return true;
+        });
+    });
+    defineExtension(Object.prototype, 'getPath', function (path, defaultValue) {
+        if (!path.trim())
+            throw new TypeError('getPath: path cannot be empty');
+        return path.split('.').reduce((acc, key) => (acc && key in acc ? acc[key] : defaultValue), this);
+    });
+    defineExtension(Object.prototype, 'setPath', function (path, value) {
+        if (!path.trim())
+            throw new TypeError('setPath: path cannot be empty');
         const keys = path.split('.');
         let current = this;
-        for (const key of keys) {
-            if (current == null || !(key in current))
-                return false;
-            current = current[key];
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!(keys[i] in current) || typeof current[keys[i]] !== 'object')
+                current[keys[i]] = {};
+            current = current[keys[i]];
         }
-        return true;
-    };
-    Object.prototype.getPath = function (path, defaultValue) {
-        if (typeof path !== 'string') {
-            throw new TypeError(`getPath: path must be a string, got ${typeof path}`);
+        current[keys[keys.length - 1]] = value;
+        return this;
+    });
+    defineExtension(Object.prototype, 'mapValues', function (fn) {
+        if (typeof fn !== 'function') {
+            throw new TypeError(`mapValues: fn must be a function, got ${typeof fn}`);
         }
-        if (path.trim() === '') {
-            throw new TypeError('getPath: path cannot be empty or whitespace');
+        const result = {};
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                result[key] = fn(this[key], key);
+            }
         }
-        const keys = path.split('.');
-        let current = this;
-        for (const key of keys) {
-            if (current == null || !(key in current))
-                return defaultValue;
-            current = current[key];
+        return result;
+    });
+    defineExtension(Object.prototype, 'mapKeys', function (fn) {
+        if (typeof fn !== 'function') {
+            throw new TypeError(`mapKeys: fn must be a function, got ${typeof fn}`);
         }
-        return current;
-    };
-    Object.prototype.setPath = function (path, value) {
-        if (typeof path !== 'string') {
-            throw new TypeError(`setPath: path must be a string, got ${typeof path}`);
+        const result = {};
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const newKey = fn(key);
+                result[newKey] = this[key];
+            }
         }
-        if (path.trim() === '') {
-            throw new TypeError('setPath: path cannot be empty or whitespace');
+        return result;
+    });
+    defineExtension(Object.prototype, 'filterKeys', function (keys) {
+        if (!Array.isArray(keys)) {
+            throw new TypeError(`filterKeys: keys must be an array, got ${typeof keys}`);
         }
-        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] = {};
+        const result = {};
+        for (const key of keys) {
+            if (key in this) {
+                result[key] = this[key];
             }
-            current = current[key];
         }
-        current[keys[keys.length - 1]] = value;
-        return this;
-    };
+        return result;
+    });
+    defineExtension(Object.prototype, 'filterValues', function (fn) {
+        if (typeof fn !== 'function') {
+            throw new TypeError(`filterValues: fn must be a function, got ${typeof fn}`);
+        }
+        const result = {};
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const val = this[key];
+                if (fn(val, key)) {
+                    result[key] = val;
+                }
+            }
+        }
+        return result;
+    });
 }