ts-packages 2.0.0 → 3.0.0

package/packages/js-extensions/src/number/number-extensions.ts

@@ -1,99 +1,70 @@
-// Number prototype extensions
-import { withCache } from '../core/performance'
+import { defineExtension } from 'src/utils'
+import { makeInternalCacheKey, withCache } from '../core/performance'
+
+let numberExtended = false
 
 export function extendNumber() {
-	Number.prototype.toPercent = function (decimals = 2): string {
-		return `${(this.valueOf() * 100).toFixed(decimals)}%`
-	}
-
-	Number.prototype.toCurrency = function (
-		currency = 'USD',
-		locale = 'en-US',
-	): string {
-		return new Intl.NumberFormat(locale, {
-			style: 'currency',
-			currency,
-		}).format(this.valueOf())
-	}
-
-	Number.prototype.clamp = function (min: number, max: number): number {
-		if (min > max) {
-			throw new RangeError(
-				`clamp: min (${min}) cannot be greater than max (${max})`,
-			)
-		}
-		return Math.min(Math.max(this.valueOf(), min), max)
-	}
+	if (numberExtended) return
+	numberExtended = true
+
+	defineExtension(Number.prototype, 'toPercent', function (this: number, decimals = 2): string {
+		return `${(this * 100).toFixed(decimals)}%`
+	})
 
-	Number.prototype.isEven = function (): boolean {
-		return this.valueOf() % 2 === 0
-	}
+	defineExtension(Number.prototype, 'toCurrency', function (this: number, currency = 'USD', locale = 'en-US'): string {
+		return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(this)
+	})
 
-	Number.prototype.isOdd = function (): boolean {
-		return this.valueOf() % 2 !== 0
-	}
+	defineExtension(Number.prototype, 'clamp', function (this: number, min: number, max: number): number {
+		if (min > max) throw new RangeError(`clamp: min (${min}) cannot be greater than max (${max})`)
+		return Math.min(Math.max(this, min), max)
+	})
 
-	Number.prototype.isPrime = function (): boolean {
-		const num = this.valueOf()
-		return withCache(`prime_${num}`, () => {
+	defineExtension(Number.prototype, 'isEven', function (this: number): boolean {
+		return this % 2 === 0
+	})
+
+	defineExtension(Number.prototype, 'isOdd', function (this: number): boolean {
+		return this % 2 !== 0
+	})
+
+	defineExtension(Number.prototype, 'isPrime', function (this: number): boolean {
+		const num = this
+		return withCache(makeInternalCacheKey('prime', num), () => {
 			if (num < 2) return false
-			for (let i = 2; i <= Math.sqrt(num); i++) {
-				if (num % i === 0) return false
-			}
+			for (let i = 2; i <= Math.sqrt(num); i++) if (num % i === 0) return false
 			return true
 		})
-	}
+	})
 
-	Number.prototype.factorial = function (): number {
-		const num = Math.floor(this.valueOf())
-		return withCache(`factorial_${num}`, () => {
-			if (num < 0) return Number.NaN
-			if (num === 0 || num === 1) return 1
+	defineExtension(Number.prototype, 'factorial', function (this: number): number {
+		const num = Math.floor(this)
+		return withCache(makeInternalCacheKey('factorial', num), () => {
+			if (num < 0) return NaN
+			if (num <= 1) return 1
 			let result = 1
-			for (let i = 2; i <= num; i++) {
-				result *= i
-			}
+			for (let i = 2; i <= num; i++) result *= i
 			return result
 		})
-	}
+	})
 
-	Number.prototype.toOrdinal = function (): string {
-		const num = Math.floor(this.valueOf())
+	defineExtension(Number.prototype, 'toOrdinal', function (this: number): string {
+		const num = Math.floor(this)
 		const suffix = ['th', 'st', 'nd', 'rd']
 		const v = num % 100
 		return num + (suffix[(v - 20) % 10] || suffix[v] || suffix[0])
-	}
-
-	Number.prototype.toRoman = function (): string {
-		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')
-		}
+	defineExtension(Number.prototype, 'toRoman', function (this: number): string {
+		const num = Math.floor(this)
+		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}`, () => {
+		return withCache(makeInternalCacheKey('roman', num), () => {
 			const values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
-			const symbols = [
-				'M',
-				'CM',
-				'D',
-				'CD',
-				'C',
-				'XC',
-				'L',
-				'XL',
-				'X',
-				'IX',
-				'V',
-				'IV',
-				'I',
-			]
-			let result = ''
+			const symbols = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
 			let n = num
+			let result = ''
 			for (let i = 0; i < values.length; i++) {
 				while (n >= values[i]) {
 					result += symbols[i]
@@ -102,61 +73,57 @@ export function extendNumber() {
 			}
 			return result
 		})
-	}
+	})
 
-	Number.prototype.inRange = function (min: number, max: number): boolean {
-		const num = this.valueOf()
-		return num >= min && num <= max
-	}
+	defineExtension(Number.prototype, 'inRange', function (this: number, min: number, max: number): boolean {
+		return this >= min && this <= max
+	})
 
-	Number.prototype.round = function (decimals = 0): number {
-		if (!Number.isInteger(decimals) || decimals < 0) {
-			throw new TypeError(
-				`round: decimals must be a non-negative integer, got ${decimals}`,
-			)
-		}
+	defineExtension(Number.prototype, 'round', function (this: number, decimals = 0): number {
+		if (!Number.isInteger(decimals) || decimals < 0) throw new TypeError('round: decimals must be non-negative integer')
 		const factor = Math.pow(10, decimals)
-		return Math.round(this.valueOf() * factor) / factor
-	}
+		return Math.round(this * factor) / factor
+	})
 
-	Number.prototype.ceil = function (decimals = 0): number {
-		if (!Number.isInteger(decimals) || decimals < 0) {
-			throw new TypeError(
-				`ceil: decimals must be a non-negative integer, got ${decimals}`,
-			)
-		}
+	defineExtension(Number.prototype, 'ceil', function (this: number, decimals = 0): number {
+		if (!Number.isInteger(decimals) || decimals < 0) throw new TypeError('ceil: decimals must be non-negative integer')
+		const factor = Math.pow(10, decimals)
+		return Math.ceil(this * factor) / factor
+	})
+
+	defineExtension(Number.prototype, 'floor', function (this: number, decimals = 0): number {
+		if (!Number.isInteger(decimals) || decimals < 0) throw new TypeError('floor: decimals must be non-negative integer')
 		const factor = Math.pow(10, decimals)
-		return Math.ceil(this.valueOf() * factor) / factor
-	}
+		return Math.floor(this * factor) / factor
+	})
 
-	Number.prototype.floor = function (decimals = 0): number {
+	defineExtension(Number.prototype, 'abs', function (this: number): number {
+		return Math.abs(this)
+	})
+
+	defineExtension(Number.prototype, 'sign', function (this: number): number {
+		return Math.sign(this)
+	})
+
+	defineExtension(Number.prototype, 'times', function (this: number, callback: (index: number) => void): void {
+		if (typeof callback !== 'function') throw new TypeError('times: callback must be a function')
+		for (let i = 0; i < Math.floor(this); i++) callback(i)
+	})
+
+	defineExtension(Number.prototype, 'toFixedNumber', function (this: number, decimals = 0): number {
 		if (!Number.isInteger(decimals) || decimals < 0) {
-			throw new TypeError(
-				`floor: decimals must be a non-negative integer, got ${decimals}`,
-			)
+			throw new TypeError(`toFixedNumber: decimals must be a non-negative integer, got ${decimals}`);
 		}
-		const factor = Math.pow(10, decimals)
-		return Math.floor(this.valueOf() * factor) / factor
-	}
-
-	Number.prototype.abs = function (): number {
-		return Math.abs(this.valueOf())
-	}
-
-	Number.prototype.sign = function (): number {
-		return Math.sign(this.valueOf())
-	}
-
-	Number.prototype.times = function (callback: (index: number) => void): void {
-		if (typeof callback !== 'function') {
-			throw new TypeError(
-				`times: callback must be a function, got ${typeof callback}`,
-			)
+		const factor = Math.pow(10, decimals);
+		return Math.round(this.valueOf() * factor) / factor;
+	});
+
+	defineExtension(Number.prototype, 'randomUpTo', function (this: number): number {
+		const max = this.valueOf();
+		if (!Number.isFinite(max)) {
+			throw new TypeError(`randomUpTo: number must be finite, got ${max}`);
 		}
+		return Math.random() * max;
+	});
 
-		const num = Math.floor(this.valueOf())
-		for (let i = 0; i < num; i++) {
-			callback(i)
-		}
-	}
 }

package/packages/js-extensions/src/object/object-extensions.ts

@@ -1,171 +1,143 @@
-// Object prototype extensions
+import { defineExtension } from "src/utils"
+
+
+let objectExtended = false
 
 export function extendObject() {
-	Object.prototype.isEmpty = function (): boolean {
+	if (objectExtended) return
+	objectExtended = true
+
+	defineExtension(Object.prototype, 'isEmpty', function (this: object): boolean {
 		return Object.keys(this).length === 0
-	}
-
-	Object.prototype.pick = function <
-		T extends Record<string, any>,
-		K extends keyof T,
-	>(keys: K[]): Pick<T, K> {
-		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')
-		}
+	})
 
+	defineExtension(Object.prototype, 'pick', function <T extends Record<string, any>, K extends keyof T>(this: T, keys: K[]): Pick<T, K> {
+		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 = {} as Pick<T, K>
-		const obj = this as T
 		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 <
-		T extends Record<string, any>,
-		K extends keyof T,
-	>(keys: K[]): Omit<T, K> {
-		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 } as T
-		keys.forEach((key) => {
-			delete result[key]
-		})
-		return result as Omit<T, K>
-	}
-
-	Object.prototype.deepClone = function <T>(): T {
-		// 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()) as unknown as T
-
-		// Handle Array objects
-		if (Array.isArray(this)) {
-			return this.map((item) => {
-				if (
-					item &&
-					typeof item === 'object' &&
-					typeof (item as any).deepClone === 'function'
-				) {
-					return (item as any).deepClone()
-				}
-				return item
-			}) as unknown as T
-		}
+	defineExtension(Object.prototype, 'omit', function <T extends Record<string, any>, K extends keyof T>(this: T, keys: K[]): Omit<T, K> {
+		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])
+		return result
+	})
 
-		// Handle regular objects with better cycle detection
+	defineExtension(Object.prototype, 'deepClone', function <T>(this: T): T {
 		const visited = new WeakSet()
-
 		function deepCloneSafe(obj: any): any {
 			if (obj === null || typeof obj !== 'object') return obj
-
-			if (visited.has(obj)) {
-				throw new Error('Circular reference detected in deepClone')
-			}
-
+			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 = {} as Record<string, unknown>
+			const cloned: Record<string, unknown> = {}
 			Object.keys(obj).forEach((key) => {
 				cloned[key] = deepCloneSafe(obj[key])
 			})
-
 			return cloned
 		}
+		return deepCloneSafe(this)
+	})
 
-		return deepCloneSafe(this) as T
-	}
-
-	Object.prototype.merge = function <T extends Record<string, unknown>>(
-		other: Partial<T>,
-	): T {
-		return { ...this, ...other } as T
-	}
+	defineExtension(Object.prototype, 'merge', function <T extends object>(this: T, other: Partial<T>): T {
+		return { ...this, ...other }
+	})
 
-	Object.prototype.deepFreeze = function <T>(): T {
-		const propNames = Object.getOwnPropertyNames(this)
-		for (const name of propNames) {
+	defineExtension(Object.prototype, 'deepFreeze', function <T>(this: T): T {
+		Object.getOwnPropertyNames(this).forEach((name) => {
 			const value = (this as any)[name]
-			if (value && typeof value === 'object') {
-				value.deepFreeze()
-			}
-		}
-		return Object.freeze(this) as T
-	}
+			if (value && typeof value === 'object') value.deepFreeze?.()
+		})
+		return Object.freeze(this)
+	})
+
+	defineExtension(Object.prototype, 'hasPath', function (this: object, path: string): boolean {
+		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
+		})
+	})
 
-	Object.prototype.hasPath = function (path: string): boolean {
-		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')
-		}
+	defineExtension(Object.prototype, 'getPath', function (this: object, path: string, defaultValue?: any): any {
+		if (!path.trim()) throw new TypeError('getPath: path cannot be empty')
+		return path.split('.').reduce((acc: any, key) => (acc && key in acc ? acc[key] : defaultValue), this as any)
+	})
 
+	defineExtension(Object.prototype, 'setPath', function (this: object, path: string, value: any): any {
+		if (!path.trim()) throw new TypeError('setPath: path cannot be empty')
 		const keys = path.split('.')
 		let current: any = 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
-	}
+		current[keys[keys.length - 1]] = value
+		return this
+	})
 
-	Object.prototype.getPath = function (path: string, defaultValue?: any): any {
-		if (typeof path !== 'string') {
-			throw new TypeError(`getPath: path must be a string, got ${typeof path}`)
+	defineExtension(Object.prototype, 'mapValues', function <T extends Record<string, any>>(this: T, fn: (value: T[keyof T], key: keyof T) => any): Record<string, any> {
+		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: Record<string, any> = {};
+		for (const key in this) {
+			if (Object.prototype.hasOwnProperty.call(this, key)) {
+				result[key] = fn((this as any)[key], key);
+			}
 		}
+		return result;
+	});
 
-		const keys = path.split('.')
-		let current: any = this
-		for (const key of keys) {
-			if (current == null || !(key in current)) return defaultValue
-			current = current[key]
+	defineExtension(Object.prototype, 'mapKeys', function <T extends Record<string, any>>(this: T, fn: (key: keyof T) => string | number | symbol): Record<string, any> {
+		if (typeof fn !== 'function') {
+			throw new TypeError(`mapKeys: fn must be a function, got ${typeof fn}`);
 		}
-		return current
-	}
+		const result: Record<string, any> = {};
+		for (const key in this) {
+			if (Object.prototype.hasOwnProperty.call(this, key)) {
+				const newKey = fn(key);
+				result[newKey as string] = (this as any)[key];
+			}
+		}
+		return result;
+	});
 
-	Object.prototype.setPath = function (path: string, value: any): any {
-		if (typeof path !== 'string') {
-			throw new TypeError(`setPath: path must be a string, got ${typeof path}`)
+	defineExtension(Object.prototype, 'filterKeys', function <T extends Record<string, any>>(this: T, keys: (keyof T)[]): Partial<T> {
+		if (!Array.isArray(keys)) {
+			throw new TypeError(`filterKeys: keys must be an array, got ${typeof keys}`);
 		}
-		if (path.trim() === '') {
-			throw new TypeError('setPath: path cannot be empty or whitespace')
+		const result: Partial<T> = {};
+		for (const key of keys) {
+			if (key in this) {
+				result[key] = (this as any)[key];
+			}
 		}
+		return result;
+	});
 
-		const keys = path.split('.')
-		let current: any = this
-		for (let i = 0; i < keys.length - 1; i++) {
-			const key = keys[i]
-			if (!(key in current) || typeof current[key] !== 'object') {
-				current[key] = {}
+	defineExtension(Object.prototype, 'filterValues', function <T extends Record<string, any>>(this: T, fn: (value: T[keyof T], key: keyof T) => boolean): Partial<T> {
+		if (typeof fn !== 'function') {
+			throw new TypeError(`filterValues: fn must be a function, got ${typeof fn}`);
+		}
+		const result: Partial<T> = {};
+		for (const key in this) {
+			if (Object.prototype.hasOwnProperty.call(this, key)) {
+				const val = (this as any)[key];
+				if (fn(val, key)) {
+					result[key] = val;
+				}
 			}
-			current = current[key]
 		}
-		current[keys[keys.length - 1]] = value
-		return this
-	}
+		return result;
+	});
 }