@naman_deep_singh/js-extensions 1.0.0 → 1.2.0

package/dist/cjs/object-extensions.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendObject = extendObject;
+// Object prototype extensions
+const performance_1 = require("./performance");
+function extendObject() {
+    Object.prototype.isEmpty = function () {
+        return Object.keys(this).length === 0;
+    };
+    Object.prototype.pick = function (keys) {
+        const result = {};
+        const obj = this;
+        keys.forEach(key => {
+            if (key in obj) {
+                result[key] = obj[key];
+            }
+        });
+        return result;
+    };
+    Object.prototype.omit = function (keys) {
+        const result = { ...this };
+        keys.forEach(key => {
+            delete result[key];
+        });
+        return result;
+    };
+    Object.prototype.deepClone = function () {
+        return (0, performance_1.withCache)(`clone_${JSON.stringify(this)}`, () => {
+            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
+            const cloned = {};
+            Object.keys(this).forEach(key => {
+                const value = this[key];
+                if (value && typeof value === 'object' && typeof value.deepClone === 'function') {
+                    cloned[key] = value.deepClone();
+                }
+                else {
+                    cloned[key] = value;
+                }
+            });
+            return cloned;
+        });
+    };
+    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) {
+        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) {
+        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) {
+        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/performance.d.ts

@@ -0,0 +1,18 @@
+export interface PerformanceConfig {
+    enableCaching?: boolean;
+    maxCacheSize?: number;
+    enableValidation?: boolean;
+}
+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/cjs/performance.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cache = void 0;
+exports.setPerformanceConfig = setPerformanceConfig;
+exports.getPerformanceConfig = getPerformanceConfig;
+exports.withCache = withCache;
+const defaultConfig = {
+    enableCaching: false,
+    maxCacheSize: 100,
+    enableValidation: true
+};
+let config = { ...defaultConfig };
+function setPerformanceConfig(newConfig) {
+    config = { ...config, ...newConfig };
+}
+function getPerformanceConfig() {
+    return { ...config };
+}
+// Simple LRU cache for expensive operations
+class LRUCache {
+    constructor(maxSize = 100) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            // Move to end (most recently used)
+            this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            // Remove least recently used (first item)
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+exports.cache = new LRUCache(config.maxCacheSize);
+function withCache(key, fn) {
+    if (!config.enableCaching) {
+        return fn();
+    }
+    const cached = exports.cache.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = fn();
+    exports.cache.set(key, result);
+    return result;
+}

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

@@ -51,4 +51,19 @@ function extendString() {
     String.prototype.stripHtml = function () {
         return this.replace(/<[^>]*>/g, '');
     };
+    String.prototype.padStart = function (targetLength, padString = ' ') {
+        return this.toString().padStart(targetLength, padString);
+    };
+    String.prototype.padEnd = function (targetLength, padString = ' ') {
+        return this.toString().padEnd(targetLength, padString);
+    };
+    String.prototype.count = function (substring) {
+        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 () {
+        return this.split(/\r?\n/);
+    };
 }

package/dist/{types.d.ts → cjs/types.d.ts}

@@ -12,6 +12,11 @@ declare global {
         isPalindrome(): boolean;
         toTitleCase(): string;
         stripHtml(): string;
+        padStart(targetLength: number, padString?: string): string;
+        padEnd(targetLength: number, padString?: string): string;
+        count(substring: string): number;
+        words(): string[];
+        lines(): string[];
     }
     interface Array<T> {
         unique(): T[];
@@ -26,6 +31,12 @@ declare global {
         partition(predicate: (item: T) => boolean): [T[], T[]];
         flatten(depth?: number): any[];
         deepFlatten(): any[];
+        difference(other: T[]): T[];
+        intersection(other: T[]): T[];
+        union(other: T[]): T[];
+        sample(): T | undefined;
+        take(count: number): T[];
+        drop(count: number): T[];
     }
     interface Object {
         isEmpty(): boolean;
@@ -34,6 +45,9 @@ declare global {
         deepClone<T>(): T;
         merge(other: Record<string, any>): Record<string, any>;
         deepFreeze<T>(): T;
+        hasPath(path: string): boolean;
+        getPath(path: string, defaultValue?: any): any;
+        setPath(path: string, value: any): any;
     }
     interface Number {
         toPercent(decimals?: number): string;
@@ -46,6 +60,12 @@ declare global {
         toOrdinal(): string;
         toRoman(): string;
         inRange(min: number, max: number): boolean;
+        round(decimals?: number): number;
+        ceil(decimals?: number): number;
+        floor(decimals?: number): number;
+        abs(): number;
+        sign(): number;
+        times(callback: (index: number) => void): void;
     }
 }
 export {};

package/dist/cjs/validation.d.ts

@@ -0,0 +1,4 @@
+export declare function validateExtensionInput(value: any, type: string, methodName: string): void;
+export declare function validateArrayInput<T>(arr: T[], methodName: string): void;
+export declare function validateNumberRange(num: number, min: number, max: number, methodName: string): void;
+export declare function validatePositiveInteger(num: number, methodName: string): void;

package/dist/cjs/validation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExtensionInput = validateExtensionInput;
+exports.validateArrayInput = validateArrayInput;
+exports.validateNumberRange = validateNumberRange;
+exports.validatePositiveInteger = validatePositiveInteger;
+// Validation utilities for extensions
+function validateExtensionInput(value, type, methodName) {
+    if (value == null) {
+        throw new TypeError(`Cannot call ${methodName} on ${value}`);
+    }
+    const actualType = typeof value;
+    if (actualType !== type) {
+        throw new TypeError(`${methodName} can only be called on ${type} values, got ${actualType}`);
+    }
+}
+function validateArrayInput(arr, methodName) {
+    if (!Array.isArray(arr)) {
+        throw new TypeError(`${methodName} can only be called on arrays`);
+    }
+}
+function validateNumberRange(num, min, max, methodName) {
+    if (num < min || num > max) {
+        throw new RangeError(`${methodName}: number must be between ${min} and ${max}, got ${num}`);
+    }
+}
+function validatePositiveInteger(num, methodName) {
+    if (!Number.isInteger(num) || num < 0) {
+        throw new TypeError(`${methodName}: expected positive integer, got ${num}`);
+    }
+}

package/dist/esm/array-extensions.d.ts

@@ -0,0 +1 @@
+export declare function extendArray(): void;

package/dist/esm/array-extensions.js

@@ -0,0 +1,80 @@
+// Array prototype extensions
+export function extendArray() {
+    Array.prototype.unique = function () {
+        return [...new Set(this)];
+    };
+    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) {
+        const chunks = [];
+        for (let i = 0; i < this.length; i += size) {
+            chunks.push(this.slice(i, i + size));
+        }
+        return chunks;
+    };
+    Array.prototype.groupBy = function (keyFn) {
+        return this.reduce((groups, item) => {
+            const key = keyFn(item);
+            if (!groups[key])
+                groups[key] = [];
+            groups[key].push(item);
+            return groups;
+        }, {});
+    };
+    Array.prototype.sum = function () {
+        return this.reduce((sum, num) => sum + (typeof num === 'number' ? num : 0), 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;
+    };
+    Array.prototype.compact = function () {
+        return this.filter(item => item != null && item !== '' && item !== false);
+    };
+    Array.prototype.pluck = function (key) {
+        return this.map(item => item && typeof item === 'object' ? item[key] : undefined).filter(val => val !== undefined);
+    };
+    Array.prototype.findLast = function (predicate) {
+        for (let i = this.length - 1; i >= 0; i--) {
+            if (predicate(this[i]))
+                return this[i];
+        }
+        return undefined;
+    };
+    Array.prototype.partition = function (predicate) {
+        const truthy = [];
+        const falsy = [];
+        this.forEach(item => predicate(item) ? truthy.push(item) : falsy.push(item));
+        return [truthy, falsy];
+    };
+    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 () {
+        return this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
+    };
+    Array.prototype.difference = function (other) {
+        return this.filter(item => !other.includes(item));
+    };
+    Array.prototype.intersection = function (other) {
+        return this.filter(item => other.includes(item));
+    };
+    Array.prototype.union = function (other) {
+        return [...new Set([...this, ...other])];
+    };
+    Array.prototype.sample = function () {
+        return this.length > 0 ? this[Math.floor(Math.random() * this.length)] : undefined;
+    };
+    Array.prototype.take = function (count) {
+        return this.slice(0, Math.max(0, count));
+    };
+    Array.prototype.drop = function (count) {
+        return this.slice(Math.max(0, count));
+    };
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,46 @@
+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';
+export { withCache };
+export interface ExtensionOptions {
+    string?: boolean;
+    array?: boolean;
+    object?: boolean;
+    number?: boolean;
+    performance?: PerformanceConfig;
+}
+/**
+ * Initialize JavaScript prototype extensions
+ * @param options - Configure which extensions to enable (default: all enabled)
+ */
+export declare function initExtensions(options?: ExtensionOptions): void;
+/**
+ * Initialize all extensions (convenience function)
+ */
+export declare function extendAll(): void;
+/**
+ * Initialize only specific extensions
+ */
+export declare const extend: {
+    string: typeof extendString;
+    array: typeof extendArray;
+    object: typeof extendObject;
+    number: typeof extendNumber;
+};
+export { setPerformanceConfig, getPerformanceConfig, type PerformanceConfig };
+declare const _default: {
+    initExtensions: typeof initExtensions;
+    extendAll: typeof extendAll;
+    extend: {
+        string: typeof extendString;
+        array: typeof extendArray;
+        object: typeof extendObject;
+        number: typeof extendNumber;
+    };
+    setPerformanceConfig: typeof setPerformanceConfig;
+    getPerformanceConfig: typeof getPerformanceConfig;
+};
+export default _default;

package/dist/esm/index.js

@@ -0,0 +1,50 @@
+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';
+// Export withCache for use in extensions
+export { withCache };
+/**
+ * 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();
+}
+/**
+ * Initialize all extensions (convenience function)
+ */
+export function extendAll() {
+    initExtensions();
+}
+/**
+ * Initialize only specific extensions
+ */
+export const extend = {
+    string: extendString,
+    array: extendArray,
+    object: extendObject,
+    number: extendNumber
+};
+// Export performance utilities
+export { setPerformanceConfig, getPerformanceConfig };
+export default {
+    initExtensions,
+    extendAll,
+    extend,
+    setPerformanceConfig,
+    getPerformanceConfig
+};

package/dist/esm/number-extensions.d.ts

@@ -0,0 +1 @@
+export declare function extendNumber(): void;

package/dist/esm/number-extensions.js

@@ -0,0 +1,100 @@
+// Number prototype extensions
+import { withCache } from './performance';
+export function extendNumber() {
+    Number.prototype.toPercent = function (decimals = 2) {
+        return (this.valueOf() * 100).toFixed(decimals) + '%';
+    };
+    Number.prototype.toCurrency = function (currency = 'USD', locale = 'en-US') {
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency: currency
+        }).format(this.valueOf());
+    };
+    Number.prototype.clamp = function (min, max) {
+        return Math.min(Math.max(this.valueOf(), min), max);
+    };
+    Number.prototype.isEven = function () {
+        return this.valueOf() % 2 === 0;
+    };
+    Number.prototype.isOdd = function () {
+        return this.valueOf() % 2 !== 0;
+    };
+    Number.prototype.isPrime = function () {
+        const num = this.valueOf();
+        return withCache(`prime_${num}`, () => {
+            if (num < 2)
+                return false;
+            for (let i = 2; i <= Math.sqrt(num); i++) {
+                if (num % i === 0)
+                    return false;
+            }
+            return true;
+        });
+    };
+    Number.prototype.factorial = function () {
+        const num = Math.floor(this.valueOf());
+        return withCache(`factorial_${num}`, () => {
+            if (num < 0)
+                return NaN;
+            if (num === 0 || num === 1)
+                return 1;
+            let result = 1;
+            for (let i = 2; i <= num; i++) {
+                result *= i;
+            }
+            return result;
+        });
+    };
+    Number.prototype.toOrdinal = function () {
+        const num = Math.floor(this.valueOf());
+        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());
+        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 = '';
+            let n = num;
+            for (let i = 0; i < values.length; i++) {
+                while (n >= values[i]) {
+                    result += symbols[i];
+                    n -= values[i];
+                }
+            }
+            return result;
+        });
+    };
+    Number.prototype.inRange = function (min, max) {
+        const num = this.valueOf();
+        return num >= min && num <= max;
+    };
+    Number.prototype.round = function (decimals = 0) {
+        const factor = Math.pow(10, decimals);
+        return Math.round(this.valueOf() * factor) / factor;
+    };
+    Number.prototype.ceil = function (decimals = 0) {
+        const factor = Math.pow(10, decimals);
+        return Math.ceil(this.valueOf() * factor) / factor;
+    };
+    Number.prototype.floor = function (decimals = 0) {
+        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) {
+        const num = Math.floor(this.valueOf());
+        for (let i = 0; i < num; i++) {
+            callback(i);
+        }
+    };
+}

package/dist/esm/object-extensions.d.ts

@@ -0,0 +1 @@
+export declare function extendObject(): void;

package/dist/esm/object-extensions.js

@@ -0,0 +1,100 @@
+// Object prototype extensions
+import { withCache } from './performance';
+export function extendObject() {
+    Object.prototype.isEmpty = function () {
+        return Object.keys(this).length === 0;
+    };
+    Object.prototype.pick = function (keys) {
+        const result = {};
+        const obj = this;
+        keys.forEach(key => {
+            if (key in obj) {
+                result[key] = obj[key];
+            }
+        });
+        return result;
+    };
+    Object.prototype.omit = function (keys) {
+        const result = { ...this };
+        keys.forEach(key => {
+            delete result[key];
+        });
+        return result;
+    };
+    Object.prototype.deepClone = function () {
+        return withCache(`clone_${JSON.stringify(this)}`, () => {
+            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
+            const cloned = {};
+            Object.keys(this).forEach(key => {
+                const value = this[key];
+                if (value && typeof value === 'object' && typeof value.deepClone === 'function') {
+                    cloned[key] = value.deepClone();
+                }
+                else {
+                    cloned[key] = value;
+                }
+            });
+            return cloned;
+        });
+    };
+    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) {
+        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) {
+        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) {
+        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;
+    };
+}