@naman_deep_singh/js-extensions 1.3.3 → 1.4.0

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

@@ -1,20 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendArray = extendArray;
-// Array prototype extensions
+const utils_1 = require("src/utils");
+let arrayExtended = false;
 function extendArray() {
-    Array.prototype.unique = function () {
+    if (arrayExtended)
+        return;
+    arrayExtended = true;
+    (0, utils_1.defineExtension)(Array.prototype, 'unique', function () {
         return [...new Set(this)];
-    };
-    Array.prototype.shuffle = function () {
+    });
+    (0, utils_1.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;
-    };
-    Array.prototype.chunk = function (size) {
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'chunk', function (size) {
         if (!Number.isInteger(size) || size <= 0) {
             throw new TypeError(`chunk: size must be a positive integer, got ${size}`);
         }
@@ -23,8 +27,8 @@ function extendArray() {
             chunks.push(this.slice(i, i + size));
         }
         return chunks;
-    };
-    Array.prototype.groupBy = function (keyFn) {
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'groupBy', function (keyFn) {
         if (typeof keyFn !== 'function') {
             throw new TypeError(`groupBy: keyFn must be a function, got ${typeof keyFn}`);
         }
@@ -35,33 +39,31 @@ function extendArray() {
             groups[key].push(item);
             return groups;
         }, {});
-    };
-    Array.prototype.sum = function () {
-        const numbers = this.filter((item) => typeof item === 'number');
-        if (numbers.length === 0) {
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'sum', function () {
+        if (this.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) {
+        return this.reduce((sum, num) => sum + num, 0);
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'average', function () {
+        if (this.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) {
+        return this.reduce((sum, num) => sum + num, 0) / this.length;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'compact', function () {
+        return this.filter((item) => item !== null && item !== undefined && item !== '');
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'compactTruthy', function () {
+        return this.filter(Boolean);
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'pluck', function (key) {
+        return this
+            .map((item) => item[key])
+            .filter((val) => val !== undefined);
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'findLast', function (predicate) {
         if (typeof predicate !== 'function') {
             throw new TypeError(`findLast: predicate must be a function, got ${typeof predicate}`);
         }
@@ -70,8 +72,8 @@ function extendArray() {
                 return this[i];
         }
         return undefined;
-    };
-    Array.prototype.partition = function (predicate) {
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'partition', function (predicate) {
         if (typeof predicate !== 'function') {
             throw new TypeError(`partition: predicate must be a function, got ${typeof predicate}`);
         }
@@ -79,42 +81,74 @@ function extendArray() {
         const falsy = [];
         this.forEach((item) => predicate(item) ? truthy.push(item) : falsy.push(item));
         return [truthy, falsy];
-    };
-    Array.prototype.flatten = function (depth = 1) {
+    });
+    (0, utils_1.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();
-    };
-    Array.prototype.deepFlatten = function () {
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'deepFlatten', function () {
         return this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
-    };
-    Array.prototype.difference = function (other) {
+    });
+    (0, utils_1.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));
-    };
-    Array.prototype.intersection = function (other) {
+    });
+    (0, utils_1.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));
-    };
-    Array.prototype.union = function (other) {
+    });
+    (0, utils_1.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])];
-    };
-    Array.prototype.sample = function () {
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'sample', function () {
         return this.length > 0
             ? this[Math.floor(Math.random() * this.length)]
             : undefined;
-    };
-    Array.prototype.take = function (count) {
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'take', function (count) {
         return this.slice(0, Math.max(0, count));
-    };
-    Array.prototype.drop = function (count) {
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'drop', function (count) {
         return this.slice(Math.max(0, count));
-    };
+    });
+    (0, utils_1.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;
+    });
+    (0, utils_1.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;
+        });
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'last', function () {
+        return this.length > 0 ? this[this.length - 1] : undefined;
+    });
 }

package/dist/cjs/core/performance.d.ts

@@ -13,4 +13,5 @@ export declare class LRUCache<K, V> {
     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/dist/cjs/core/performance.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LRUCache = void 0;
 exports.setPerformanceConfig = setPerformanceConfig;
 exports.getPerformanceConfig = getPerformanceConfig;
+exports.makeInternalCacheKey = makeInternalCacheKey;
 exports.withCache = withCache;
+const version_1 = require("./version");
 const defaultConfig = {
     enableCaching: false,
     maxCacheSize: 100,
@@ -61,6 +63,10 @@ function getOrCreateCache() {
     }
     return cache;
 }
+function makeInternalCacheKey(domain, key) {
+    const INTERNAL_CACHE_PREFIX = '@js-ext' + (0, version_1.getPackageVersion)();
+    return `${INTERNAL_CACHE_PREFIX}:${domain}:${key}`;
+}
 function withCache(key, fn) {
     if (!config.enableCaching) {
         return fn();

package/dist/cjs/core/version.d.ts

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

package/dist/cjs/core/version.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = void 0;
+const node_module_1 = require("node:module");
+const requireFn = (0, node_module_1.createRequire)("../../package.json");
+const getPackageVersion = () => {
+    return requireFn('../package.json').version;
+};
+exports.getPackageVersion = getPackageVersion;

package/dist/cjs/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/dist/cjs/index.js

@@ -43,6 +43,7 @@ function initializeExtensions(options = {}) {
     (0, initializer_1.initExtensions)(options);
 }
 /**
+ * Selective prototype extension helpers
  * Initialize only specific extensions
  */
 exports.extend = {

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

@@ -1,90 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendNumber = extendNumber;
-// Number prototype extensions
+const utils_1 = require("src/utils");
 const performance_1 = require("../core/performance");
+let numberExtended = false;
 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;
+    (0, utils_1.defineExtension)(Number.prototype, 'toPercent', function (decimals = 2) {
+        return `${(this * 100).toFixed(decimals)}%`;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'toCurrency', function (currency = 'USD', locale = 'en-US') {
+        return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(this);
+    });
+    (0, utils_1.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 (0, performance_1.withCache)(`prime_${num}`, () => {
+        return Math.min(Math.max(this, min), max);
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'isEven', function () {
+        return this % 2 === 0;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'isOdd', function () {
+        return this % 2 !== 0;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'isPrime', function () {
+        const num = this;
+        return (0, performance_1.withCache)((0, performance_1.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 (0, performance_1.withCache)(`factorial_${num}`, () => {
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'factorial', function () {
+        const num = Math.floor(this);
+        return (0, performance_1.withCache)((0, performance_1.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());
+    });
+    (0, utils_1.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) {
+    });
+    (0, utils_1.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 (0, performance_1.withCache)(`roman_${num}`, () => {
+        return (0, performance_1.withCache)((0, performance_1.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];
@@ -93,45 +74,52 @@ 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}`);
-        }
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'inRange', function (min, max) {
+        return this >= min && this <= max;
+    });
+    (0, utils_1.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;
+    });
+    (0, utils_1.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;
+    });
+    (0, utils_1.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;
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'abs', function () {
+        return Math.abs(this);
+    });
+    (0, utils_1.defineExtension)(Number.prototype, 'sign', function () {
+        return Math.sign(this);
+    });
+    (0, utils_1.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);
+    });
+    (0, utils_1.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;
+    });
+    (0, utils_1.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;
+    });
 }