@naman_deep_singh/js-extensions 1.2.0 → 1.3.1

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

@@ -0,0 +1,146 @@
+"use strict";
+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 () {
+        // Create a more robust cache key using WeakMap for cycle detection
+        const cloneId = Symbol('clone');
+        // 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/dist/cjs/string/index.d.ts

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

package/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/dist/cjs/{string-extensions.js → string/string-extensions.js}

@@ -20,6 +20,9 @@ function extendString() {
             .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 () {
@@ -52,12 +55,36 @@ function extendString() {
         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 () {

package/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/dist/cjs/types/global-augmentations.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './extension-types';
+export * from './global-augmentations';

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

@@ -0,0 +1,4 @@
+import { 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/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/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/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/dist/cjs/utils/index.d.ts

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

package/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/dist/esm/{array-extensions.js → array/array-extensions.js}

@@ -12,6 +12,9 @@ export function extendArray() {
         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));
@@ -19,6 +22,9 @@ export function extendArray() {
         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])
@@ -28,19 +34,32 @@ export function extendArray() {
         }, {});
     };
     Array.prototype.sum = function () {
-        return this.reduce((sum, num) => sum + (typeof num === 'number' ? num : 0), 0);
+        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');
-        return numbers.length > 0 ? numbers.reduce((sum, num) => sum + num, 0) / numbers.length : 0;
+        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];
@@ -48,6 +67,9 @@ export function extendArray() {
         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));
@@ -60,12 +82,21 @@ export function extendArray() {
         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 () {

package/dist/esm/array/index.d.ts

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

package/dist/esm/array/index.js

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

package/dist/esm/core/index.d.ts

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

package/dist/esm/core/index.js

@@ -0,0 +1,3 @@
+// Re-export core utilities
+export * from './validation';
+export * from './performance';

package/dist/esm/{performance.d.ts → core/performance.d.ts}

@@ -5,7 +5,7 @@ export interface PerformanceConfig {
 }
 export declare function setPerformanceConfig(newConfig: Partial<PerformanceConfig>): void;
 export declare function getPerformanceConfig(): PerformanceConfig;
-declare class LRUCache<K, V> {
+export declare class LRUCache<K, V> {
     private cache;
     private maxSize;
     constructor(maxSize?: number);
@@ -13,6 +13,4 @@ declare class LRUCache<K, V> {
     set(key: K, value: V): void;
     clear(): void;
 }
-export declare const cache: LRUCache<unknown, unknown>;
 export declare function withCache<T>(key: string, fn: () => T): T;
-export {};

package/dist/esm/{performance.js → core/performance.js}

@@ -5,13 +5,18 @@ const defaultConfig = {
 };
 let config = { ...defaultConfig };
 export 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);
+    }
 }
 export function getPerformanceConfig() {
     return { ...config };
 }
 // Simple LRU cache for expensive operations
-class LRUCache {
+export class LRUCache {
     constructor(maxSize = 100) {
         this.cache = new Map();
         this.maxSize = maxSize;
@@ -42,16 +47,23 @@ class LRUCache {
         this.cache.clear();
     }
 }
-export const cache = new LRUCache(config.maxCacheSize);
+let cache = null;
+function getOrCreateCache() {
+    if (!cache) {
+        cache = new LRUCache(config.maxCacheSize);
+    }
+    return cache;
+}
 export function withCache(key, fn) {
     if (!config.enableCaching) {
         return fn();
     }
-    const cached = cache.get(key);
+    const currentCache = getOrCreateCache();
+    const cached = currentCache.get(key);
     if (cached !== undefined) {
         return cached;
     }
     const result = fn();
-    cache.set(key, result);
+    currentCache.set(key, result);
     return result;
 }

package/dist/esm/extensions/index.d.ts

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

package/dist/esm/extensions/index.js

@@ -0,0 +1,5 @@
+// Re-export all extensions
+export * from '../string';
+export * from '../array';
+export * from '../object';
+export * from '../number';

package/dist/esm/index.d.ts

@@ -1,26 +1,22 @@
-import { extendString } from './string-extensions';
-import { extendArray } from './array-extensions';
-import { extendObject } from './object-extensions';
-import { extendNumber } from './number-extensions';
-import { setPerformanceConfig, getPerformanceConfig, type PerformanceConfig, withCache } from './performance';
-import './types';
+import '../types/global-augmentations';
+import { extendString } from './string';
+import { extendArray } from './array';
+import { extendObject } from './object';
+import { extendNumber } from './number';
+import { withCache, setPerformanceConfig, getPerformanceConfig } from './core/performance';
+import { ExtensionOptions, PerformanceConfig } from './types/extension-types';
+export { ExtensionOptions, PerformanceConfig };
 export { withCache };
-export interface ExtensionOptions {
-    string?: boolean;
-    array?: boolean;
-    object?: boolean;
-    number?: boolean;
-    performance?: PerformanceConfig;
-}
+import { extendAll } from './init/initializer';
 /**
  * Initialize JavaScript prototype extensions
  * @param options - Configure which extensions to enable (default: all enabled)
  */
-export declare function initExtensions(options?: ExtensionOptions): void;
+export declare function initializeExtensions(options?: ExtensionOptions): void;
 /**
  * Initialize all extensions (convenience function)
  */
-export declare function extendAll(): void;
+export { extendAll };
 /**
  * Initialize only specific extensions
  */
@@ -30,9 +26,9 @@ export declare const extend: {
     object: typeof extendObject;
     number: typeof extendNumber;
 };
-export { setPerformanceConfig, getPerformanceConfig, type PerformanceConfig };
+export { setPerformanceConfig, getPerformanceConfig };
 declare const _default: {
-    initExtensions: typeof initExtensions;
+    initializeExtensions: typeof initializeExtensions;
     extendAll: typeof extendAll;
     extend: {
         string: typeof extendString;

package/dist/esm/index.js

@@ -1,35 +1,27 @@
-import { extendString } from './string-extensions';
-import { extendArray } from './array-extensions';
-import { extendObject } from './object-extensions';
-import { extendNumber } from './number-extensions';
-import { setPerformanceConfig, getPerformanceConfig, withCache } from './performance';
-import './types';
+// Import types first
+import '../types/global-augmentations';
+// Import extension modules
+import { extendString } from './string';
+import { extendArray } from './array';
+import { extendObject } from './object';
+import { extendNumber } from './number';
+// Import core utilities
+import { withCache, setPerformanceConfig, getPerformanceConfig } from './core/performance';
 // Export withCache for use in extensions
 export { withCache };
+// Import initialization functions
+import { initExtensions, extendAll } from './init/initializer';
 /**
  * Initialize JavaScript prototype extensions
  * @param options - Configure which extensions to enable (default: all enabled)
  */
-export function initExtensions(options = {}) {
-    const { string = true, array = true, object = true, number = true, performance } = options;
-    if (performance) {
-        setPerformanceConfig(performance);
-    }
-    if (string)
-        extendString();
-    if (array)
-        extendArray();
-    if (object)
-        extendObject();
-    if (number)
-        extendNumber();
+export function initializeExtensions(options = {}) {
+    initExtensions(options);
 }
 /**
  * Initialize all extensions (convenience function)
  */
-export function extendAll() {
-    initExtensions();
-}
+export { extendAll };
 /**
  * Initialize only specific extensions
  */
@@ -41,8 +33,9 @@ export const extend = {
 };
 // Export performance utilities
 export { setPerformanceConfig, getPerformanceConfig };
+// Default export
 export default {
-    initExtensions,
+    initializeExtensions,
     extendAll,
     extend,
     setPerformanceConfig,

package/dist/esm/init/index.d.ts

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

package/dist/esm/init/index.js

@@ -0,0 +1,3 @@
+// Re-export initialization logic
+export * from './initializer';
+export * from './options';

package/dist/esm/init/initializer.d.ts

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