@naman_deep_singh/js-extensions 1.2.0 → 1.3.0

package/dist/esm/init/initializer.js

@@ -0,0 +1,23 @@
+import { extendString } from '../string';
+import { extendArray } from '../array';
+import { extendObject } from '../object';
+import { extendNumber } from '../number';
+import { setPerformanceConfig } from '../core/performance';
+export function initExtensions(options = {}) {
+    const { string = true, array = true, object = true, number = true, performance } = options;
+    if (performance) {
+        // Set performance config if provided
+        setPerformanceConfig(performance);
+    }
+    if (string)
+        extendString();
+    if (array)
+        extendArray();
+    if (object)
+        extendObject();
+    if (number)
+        extendNumber();
+}
+export function extendAll() {
+    initExtensions();
+}

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

@@ -0,0 +1,3 @@
+import { ExtensionOptions } from '../types/extension-types';
+export declare function validateExtensionOptions(options: Partial<ExtensionOptions>): ExtensionOptions;
+export declare function createExtensionOptions(enableString?: boolean, enableArray?: boolean, enableObject?: boolean, enableNumber?: boolean, performanceConfig?: any): ExtensionOptions;

package/dist/esm/init/options.js

@@ -0,0 +1,19 @@
+export function validateExtensionOptions(options) {
+    const validated = {
+        string: options.string !== false,
+        array: options.array !== false,
+        object: options.object !== false,
+        number: options.number !== false,
+        performance: options.performance
+    };
+    return validated;
+}
+export function createExtensionOptions(enableString = true, enableArray = true, enableObject = true, enableNumber = true, performanceConfig) {
+    return {
+        string: enableString,
+        array: enableArray,
+        object: enableObject,
+        number: enableNumber,
+        performance: performanceConfig
+    };
+}

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

@@ -0,0 +1 @@
+export { extendNumber } from './number-extensions';

package/dist/esm/number/index.js

@@ -0,0 +1 @@
+export { extendNumber } from './number-extensions';

package/dist/esm/{number-extensions.js → number/number-extensions.js}

@@ -1,5 +1,5 @@
 // Number prototype extensions
-import { withCache } from './performance';
+import { withCache } from '../core/performance';
 export function extendNumber() {
     Number.prototype.toPercent = function (decimals = 2) {
         return (this.valueOf() * 100).toFixed(decimals) + '%';
@@ -11,6 +11,9 @@ export function extendNumber() {
         }).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 () {
@@ -53,9 +56,14 @@ export function extendNumber() {
     };
     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 withCache(`roman_${num}`, () => {
-            if (num <= 0 || num >= 4000)
-                return num.toString();
             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 = '';
@@ -74,14 +82,23 @@ export function extendNumber() {
         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;
     };
@@ -92,6 +109,9 @@ export function extendNumber() {
         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/dist/esm/object/index.d.ts

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

package/dist/esm/object/index.js

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

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

@@ -0,0 +1,143 @@
+export 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/esm/string/index.d.ts

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

package/dist/esm/string/index.js

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

package/dist/esm/{string-extensions.js → string/string-extensions.js}

@@ -17,6 +17,9 @@ export 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 () {
@@ -49,12 +52,36 @@ export 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/esm/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/esm/types/global-augmentations.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/esm/types/index.js

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

package/dist/esm/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/esm/utils/config.js

@@ -0,0 +1,20 @@
+export function validateConfig(config, defaultConfig) {
+    return { ...defaultConfig, ...config };
+}
+export function validatePerformanceSettings(settings) {
+    const validated = {
+        enableCaching: settings.enableCaching ?? false,
+        maxCacheSize: Math.max(1, settings.maxCacheSize ?? 100),
+        enableValidation: settings.enableValidation ?? true
+    };
+    return validated;
+}
+export function mergeConfigs(base, override) {
+    const result = { ...base };
+    for (const key in override) {
+        if (override[key] !== undefined) {
+            result[key] = override[key];
+        }
+    }
+    return result;
+}

package/dist/esm/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/esm/utils/helpers.js

@@ -0,0 +1,30 @@
+// Shared helper functions for extensions
+export function isValidArrayIndex(index) {
+    return Number.isInteger(index) && index >= 0;
+}
+export function ensurePositiveInteger(value, name) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new TypeError(`${name} must be a positive integer`);
+    }
+}
+export 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;
+}
+export function getPathSegments(path) {
+    return path.split('.').filter(segment => segment.length > 0);
+}
+export function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}

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

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

package/dist/esm/utils/index.js

@@ -0,0 +1,3 @@
+// Re-export all utilities
+export * from './config';
+export * from './helpers';

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

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

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

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

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

@@ -5,14 +5,4 @@ export interface PerformanceConfig {
 }
 export declare function setPerformanceConfig(newConfig: Partial<PerformanceConfig>): void;
 export declare function getPerformanceConfig(): PerformanceConfig;
-declare class LRUCache<K, V> {
-    private cache;
-    private maxSize;
-    constructor(maxSize?: number);
-    get(key: K): V | undefined;
-    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/types/extensions/index.d.ts

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

package/dist/types/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/types/init/index.d.ts

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

package/dist/types/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;

package/dist/types/init/options.d.ts

@@ -0,0 +1,3 @@
+import { ExtensionOptions } from '../types/extension-types';
+export declare function validateExtensionOptions(options: Partial<ExtensionOptions>): ExtensionOptions;
+export declare function createExtensionOptions(enableString?: boolean, enableArray?: boolean, enableObject?: boolean, enableNumber?: boolean, performanceConfig?: any): ExtensionOptions;

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

@@ -0,0 +1 @@
+export { extendNumber } from './number-extensions';

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

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

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

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naman_deep_singh/js-extensions",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Universal JavaScript prototype extensions for common development utilities",
   "type": "module",
   "main": "./dist/cjs/index.js",