@naman_deep_singh/js-extensions 1.3.3 → 1.4.0

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

@@ -1,72 +1,43 @@
 "use strict";
-// Object prototype extensions
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendObject = extendObject;
+const utils_1 = require("src/utils");
+let objectExtended = false;
 function extendObject() {
-    Object.prototype.isEmpty = function () {
+    if (objectExtended)
+        return;
+    objectExtended = true;
+    (0, utils_1.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) {
+    });
+    (0, utils_1.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) {
+    });
+    (0, utils_1.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
+    });
+    (0, utils_1.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());
@@ -79,69 +50,97 @@ function extendObject() {
             return cloned;
         }
         return deepCloneSafe(this);
-    };
-    Object.prototype.merge = function (other) {
+    });
+    (0, utils_1.defineExtension)(Object.prototype, 'merge', function (other) {
         return { ...this, ...other };
-    };
-    Object.prototype.deepFreeze = function () {
-        const propNames = Object.getOwnPropertyNames(this);
-        for (const name of propNames) {
+    });
+    (0, utils_1.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');
-        }
+    });
+    (0, utils_1.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;
+        });
+    });
+    (0, utils_1.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);
+    });
+    (0, utils_1.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;
+    });
+    (0, utils_1.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;
+    });
+    (0, utils_1.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;
+    });
+    (0, utils_1.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;
+    });
+    (0, utils_1.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;
+    });
 }

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

@@ -1,37 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendString = extendString;
-// String prototype extensions
+const utils_1 = require("src/utils");
+let stringExtended = false;
 function extendString() {
-    String.prototype.toCapitalize = function () {
+    if (stringExtended)
+        return;
+    stringExtended = true;
+    (0, utils_1.defineExtension)(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 () {
+    });
+    (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();
-    };
-    String.prototype.toSnakeCase = function () {
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toSnakeCase', function () {
         return this.replace(/([a-z])([A-Z])/g, '$1_$2')
             .replace(/[\s-]+/g, '_')
             .toLowerCase();
-    };
-    String.prototype.truncate = function (length, suffix = '...') {
+    });
+    (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();
-    };
-    String.prototype.isEmail = function () {
+        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());
-    };
-    String.prototype.isUrl = function () {
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'isUrl', function () {
         try {
             new URL(this.toString());
             return true;
@@ -39,24 +41,24 @@ function extendString() {
         catch {
             return false;
         }
-    };
-    String.prototype.removeWhitespace = function () {
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'removeWhitespace', function () {
         return this.replace(/\s+/g, '');
-    };
-    String.prototype.reverse = function () {
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'reverse', function () {
         return this.split('').reverse().join('');
-    };
-    String.prototype.isPalindrome = function () {
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'isPalindrome', function () {
         const cleaned = this.toLowerCase().replace(/[^a-z0-9]/g, '');
         return cleaned === cleaned.split('').reverse().join('');
-    };
-    String.prototype.toTitleCase = function () {
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'toTitleCase', function () {
         return this.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
-    };
-    String.prototype.stripHtml = function () {
+    });
+    (0, utils_1.defineExtension)(String.prototype, 'stripHtml', function () {
         return this.replace(/<[^>]*>/g, '');
-    };
-    String.prototype.padStart = function (targetLength, padString = ' ') {
+    });
+    (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}`);
         }
@@ -67,8 +69,8 @@ function extendString() {
             throw new TypeError('padStart: padString cannot be empty');
         }
         return this.toString().padStart(targetLength, padString);
-    };
-    String.prototype.padEnd = function (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}`);
         }
@@ -79,22 +81,43 @@ function extendString() {
             throw new TypeError('padEnd: padString cannot be empty');
         }
         return this.toString().padEnd(targetLength, padString);
-    };
-    String.prototype.count = function (substring) {
+    });
+    (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');
         }
-        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 () {
+        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/dist/cjs/types/global-augmentations.d.ts

@@ -26,6 +26,7 @@ declare global {
         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[]];

package/dist/cjs/utils/defineExtension.d.ts

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

package/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/dist/cjs/utils/index.d.ts

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

package/dist/cjs/utils/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // Re-export all utilities
 __exportStar(require("./config"), exports);
 __exportStar(require("./helpers"), exports);
+__exportStar(require("./defineExtension"), exports);

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

@@ -1,17 +1,21 @@
-// Array prototype extensions
+import { defineExtension } from "src/utils";
+let arrayExtended = false;
 export function extendArray() {
-    Array.prototype.unique = function () {
+    if (arrayExtended)
+        return;
+    arrayExtended = true;
+    defineExtension(Array.prototype, 'unique', function () {
         return [...new Set(this)];
-    };
-    Array.prototype.shuffle = function () {
+    });
+    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) {
+    });
+    defineExtension(Array.prototype, 'chunk', function (size) {
         if (!Number.isInteger(size) || size <= 0) {
             throw new TypeError(`chunk: size must be a positive integer, got ${size}`);
         }
@@ -20,8 +24,8 @@ export function extendArray() {
             chunks.push(this.slice(i, i + size));
         }
         return chunks;
-    };
-    Array.prototype.groupBy = function (keyFn) {
+    });
+    defineExtension(Array.prototype, 'groupBy', function (keyFn) {
         if (typeof keyFn !== 'function') {
             throw new TypeError(`groupBy: keyFn must be a function, got ${typeof keyFn}`);
         }
@@ -32,33 +36,31 @@ export function extendArray() {
             groups[key].push(item);
             return groups;
         }, {});
-    };
-    Array.prototype.sum = function () {
-        const numbers = this.filter((item) => typeof item === 'number');
-        if (numbers.length === 0) {
+    });
+    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);
+    });
+    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;
+    });
+    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}`);
         }
@@ -67,8 +69,8 @@ export function extendArray() {
                 return this[i];
         }
         return undefined;
-    };
-    Array.prototype.partition = function (predicate) {
+    });
+    defineExtension(Array.prototype, 'partition', function (predicate) {
         if (typeof predicate !== 'function') {
             throw new TypeError(`partition: predicate must be a function, got ${typeof predicate}`);
         }
@@ -76,42 +78,74 @@ export function extendArray() {
         const falsy = [];
         this.forEach((item) => predicate(item) ? truthy.push(item) : falsy.push(item));
         return [truthy, falsy];
-    };
-    Array.prototype.flatten = function (depth = 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 () {
+    });
+    defineExtension(Array.prototype, 'deepFlatten', function () {
         return this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
-    };
-    Array.prototype.difference = function (other) {
+    });
+    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) {
+    });
+    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) {
+    });
+    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 () {
+    });
+    defineExtension(Array.prototype, 'sample', function () {
         return this.length > 0
             ? this[Math.floor(Math.random() * this.length)]
             : undefined;
-    };
-    Array.prototype.take = function (count) {
+    });
+    defineExtension(Array.prototype, 'take', function (count) {
         return this.slice(0, Math.max(0, count));
-    };
-    Array.prototype.drop = function (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/dist/esm/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;