ts-packages 2.0.0 → 3.0.0

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

@@ -1,174 +1,292 @@
-// Array prototype extensions
+import { defineExtension } from "src/utils"
+
+let arrayExtended = false
+
 export function extendArray() {
-	Array.prototype.unique = function <T>(): T[] {
-		return [...new Set(this)]
-	}
-
-	Array.prototype.shuffle = function <T>(): T[] {
-		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
-	}
+	if (arrayExtended) return
+	arrayExtended = true
 
-	Array.prototype.chunk = function <T>(size: number): T[][] {
-		if (!Number.isInteger(size) || size <= 0) {
-			throw new TypeError(`chunk: size must be a positive integer, got ${size}`)
-		}
-		const chunks: T[][] = []
-		for (let i = 0; i < this.length; i += size) {
-			chunks.push(this.slice(i, i + size))
-		}
-		return chunks
-	}
+	defineExtension(
+		Array.prototype,
+		'unique',
+		function <T>(this: readonly T[]): T[] {
+			return [...new Set(this)]
+		},
+	)
 
-	Array.prototype.groupBy = function <T>(
-		keyFn: (item: T) => string | number,
-	): Record<string | number, T[]> {
-		if (typeof keyFn !== 'function') {
-			throw new TypeError(
-				`groupBy: keyFn must be a function, got ${typeof keyFn}`,
-			)
-		}
+	defineExtension(
+		Array.prototype,
+		'shuffle',
+		function <T>(this: readonly T[]): T[] {
+			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
+		},
+	)
 
-		return this.reduce(
-			(groups, item) => {
-				const key = keyFn(item)
-				if (!groups[key]) groups[key] = []
-				groups[key].push(item)
-				return groups
-			},
-			{} as Record<string | number, T[]>,
-		)
-	}
-
-	Array.prototype.sum = function (): number {
-		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)
-	}
+	defineExtension(
+		Array.prototype,
+		'chunk',
+		function <T>(this: readonly T[], size: number): T[][] {
+			if (!Number.isInteger(size) || size <= 0) {
+				throw new TypeError(`chunk: size must be a positive integer, got ${size}`)
+			}
+			const chunks: T[][] = []
+			for (let i = 0; i < this.length; i += size) {
+				chunks.push(this.slice(i, i + size))
+			}
+			return chunks
+		},
+	)
 
-	Array.prototype.average = function (): number {
-		const numbers = this.filter((item) => typeof item === 'number')
-		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 <T>(): T[] {
-		return this.filter((item) => item != null && item !== '' && item !== false)
-	}
-
-	Array.prototype.pluck = function <T, K extends keyof T>(key: K): T[K][] {
-		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}`,
+	defineExtension(
+		Array.prototype,
+		'groupBy',
+		function <T>(
+			this: readonly T[],
+			keyFn: (item: T) => string | number,
+		): Record<string | number, T[]> {
+			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]) groups[key] = []
+					groups[key].push(item)
+					return groups
+				},
+				{} as Record<string | number, T[]>,
 			)
-		}
+		},
+	)
+
+	defineExtension(
+		Array.prototype,
+		'sum',
+		function (this: readonly number[]): number {
+			if (this.length === 0) {
+				throw new TypeError('sum: array must contain at least one number')
+			}
+			return this.reduce((sum, num) => sum + num, 0)
+		},
+	)
 
-		return this.map((item) =>
-			item && typeof item === 'object' ? item[key] : undefined,
-		).filter((val) => val !== undefined)
-	}
-
-	Array.prototype.findLast = function <T>(
-		predicate: (item: T) => boolean,
-	): T | undefined {
-		if (typeof predicate !== 'function') {
-			throw new TypeError(
-				`findLast: predicate must be a function, got ${typeof predicate}`,
+	defineExtension(
+		Array.prototype,
+		'average',
+		function (this: readonly number[]): number {
+			if (this.length === 0) {
+				throw new TypeError('average: array must contain at least one number')
+			}
+			return this.reduce((sum, num) => sum + num, 0) / this.length
+		},
+	)
+
+	defineExtension(
+		Array.prototype,
+		'compact',
+		function <T>(this: readonly T[]): T[] {
+			return this.filter(
+				(item) => item !== null && item !== undefined && item !== '',
 			)
-		}
+		},
+	)
 
-		for (let i = this.length - 1; i >= 0; i--) {
-			if (predicate(this[i])) return this[i]
-		}
-		return undefined
-	}
-
-	Array.prototype.partition = function <T>(
-		predicate: (item: T) => boolean,
-	): [T[], T[]] {
-		if (typeof predicate !== 'function') {
-			throw new TypeError(
-				`partition: predicate must be a function, got ${typeof predicate}`,
+	defineExtension(
+		Array.prototype,
+		'compactTruthy',
+		function <T>(this: readonly T[]): T[] {
+			return this.filter(Boolean)
+		},
+	)
+
+	defineExtension(
+		Array.prototype,
+		'pluck',
+		function <T extends Record<PropertyKey, any>, K extends keyof T>(
+			this: readonly T[],
+			key: K,
+		): T[K][] {
+			return this
+				.map((item) => item[key])
+				.filter((val): val is T[K] => val !== undefined)
+		},
+	)
+
+
+	defineExtension(
+		Array.prototype,
+		'findLast',
+		function <T>(
+			this: readonly T[],
+			predicate: (item: T) => boolean,
+		): T | undefined {
+			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]
+			}
+			return undefined
+		},
+	)
+
+	defineExtension(
+		Array.prototype,
+		'partition',
+		function <T>(
+			this: readonly T[],
+			predicate: (item: T) => boolean,
+		): [T[], T[]] {
+			if (typeof predicate !== 'function') {
+				throw new TypeError(
+					`partition: predicate must be a function, got ${typeof predicate}`,
+				)
+			}
+
+			const truthy: T[] = []
+			const falsy: T[] = []
+
+			this.forEach((item) =>
+				predicate(item) ? truthy.push(item) : falsy.push(item),
 			)
-		}
 
-		const truthy: T[] = []
-		const falsy: T[] = []
-		this.forEach((item) =>
-			predicate(item) ? truthy.push(item) : falsy.push(item),
-		)
-		return [truthy, falsy]
-	}
-
-	Array.prototype.flatten = function (depth = 1): any[] {
-		return depth > 0
-			? this.reduce(
+			return [truthy, falsy]
+		},
+	)
+
+	defineExtension(
+		Array.prototype,
+		'flatten',
+		function (this: readonly any[], depth = 1): any[] {
+			return depth > 0
+				? this.reduce(
 					(acc: any[], val) =>
-						acc.concat(Array.isArray(val) ? val.flatten(depth - 1) : val),
+						acc.concat(
+							Array.isArray(val) ? val.flatten(depth - 1) : val,
+						),
 					[],
 				)
-			: this.slice()
-	}
-
-	Array.prototype.deepFlatten = function (): any[] {
-		return this.reduce(
-			(acc: any[], val) =>
-				acc.concat(Array.isArray(val) ? val.deepFlatten() : val),
-			[],
-		)
-	}
-
-	Array.prototype.difference = function <T>(other: T[]): T[] {
-		if (!Array.isArray(other)) {
-			throw new TypeError(
-				`difference: other must be an array, got ${typeof other}`,
+				: this.slice()
+		},
+	)
+
+	defineExtension(
+		Array.prototype,
+		'deepFlatten',
+		function (this: readonly any[]): any[] {
+			return this.reduce(
+				(acc: any[], val) =>
+					acc.concat(Array.isArray(val) ? val.deepFlatten() : val),
+				[],
 			)
-		}
+		},
+	)
 
-		return this.filter((item) => !other.includes(item))
-	}
+	defineExtension(
+		Array.prototype,
+		'difference',
+		function <T>(this: readonly T[], other: T[]): T[] {
+			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 <T>(other: T[]): T[] {
-		if (!Array.isArray(other)) {
-			throw new TypeError(
-				`intersection: other must be an array, got ${typeof other}`,
-			)
-		}
+	defineExtension(
+		Array.prototype,
+		'intersection',
+		function <T>(this: readonly T[], other: T[]): T[] {
+			if (!Array.isArray(other)) {
+				throw new TypeError(
+					`intersection: other must be an array, got ${typeof other}`,
+				)
+			}
+			return this.filter((item) => other.includes(item))
+		},
+	)
 
-		return this.filter((item) => other.includes(item))
-	}
+	defineExtension(
+		Array.prototype,
+		'union',
+		function <T>(this: readonly T[], other: T[]): T[] {
+			if (!Array.isArray(other)) {
+				throw new TypeError(`union: other must be an array, got ${typeof other}`)
+			}
+			return [...new Set([...this, ...other])]
+		},
+	)
 
-	Array.prototype.union = function <T>(other: T[]): T[] {
-		if (!Array.isArray(other)) {
-			throw new TypeError(`union: other must be an array, got ${typeof other}`)
-		}
+	defineExtension(
+		Array.prototype,
+		'sample',
+		function <T>(this: readonly T[]): T | undefined {
+			return this.length > 0
+				? this[Math.floor(Math.random() * this.length)]
+				: undefined
+		},
+	)
+
+	defineExtension(
+		Array.prototype,
+		'take',
+		function <T>(this: readonly T[], count: number): T[] {
+			return this.slice(0, Math.max(0, count))
+		},
+	)
+
+	defineExtension(
+		Array.prototype,
+		'drop',
+		function <T>(this: readonly T[], count: number): T[] {
+			return this.slice(Math.max(0, count))
+		},
+	)
 
-		return [...new Set([...this, ...other])]
-	}
+	defineExtension(Array.prototype, 'uniqueBy', function <T, K>(this: readonly T[], keyFn: (item: T) => K): T[] {
+		if (typeof keyFn !== 'function') {
+			throw new TypeError(`uniqueBy: keyFn must be a function, got ${typeof keyFn}`);
+		}
+		const seen = new Set<K>();
+		const result: T[] = [];
+		for (const item of this) {
+			const key = keyFn(item);
+			if (!seen.has(key)) {
+				seen.add(key);
+				result.push(item);
+			}
+		}
+		return result;
+	});
 
-	Array.prototype.sample = function <T>(): T | undefined {
-		return this.length > 0
-			? this[Math.floor(Math.random() * this.length)]
-			: undefined
-	}
+	defineExtension(Array.prototype, 'sortBy', function <T>(this: readonly T[], keyFn: (item: T) => any): T[] {
+		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;
+		});
+	});
 
-	Array.prototype.take = function <T>(count: number): T[] {
-		return this.slice(0, Math.max(0, count))
-	}
+	defineExtension(Array.prototype, 'last', function <T>(this: readonly T[]): T | undefined {
+		return this.length > 0 ? this[this.length - 1] : undefined;
+	});
 
-	Array.prototype.drop = function <T>(count: number): T[] {
-		return this.slice(Math.max(0, count))
-	}
 }

package/packages/js-extensions/src/core/performance.ts

@@ -1,3 +1,5 @@
+import { getPackageVersion } from "./version"
+
 // Performance optimization utilities
 export interface PerformanceConfig {
 	enableCaching?: boolean
@@ -75,6 +77,15 @@ function getOrCreateCache(): LRUCache<string, any> {
 	return cache
 }
 
+
+export function makeInternalCacheKey(
+	domain: string,
+	key: string | number,
+): string {
+	const INTERNAL_CACHE_PREFIX = '@js-ext' + getPackageVersion();
+	return `${INTERNAL_CACHE_PREFIX}:${domain}:${key}`;
+}
+
 export function withCache<T>(key: string, fn: () => T): T {
 	if (!config.enableCaching) {
 		return fn()

package/packages/js-extensions/src/core/version.ts

@@ -0,0 +1,7 @@
+import { createRequire } from 'node:module';
+
+const requireFn = createRequire("../../package.json");
+
+export const getPackageVersion = (): string => {
+    return requireFn('../package.json').version as string;
+}

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

@@ -12,6 +12,7 @@ import { extendString } from './string'
 import {
 	LRUCache,
 	getPerformanceConfig,
+	makeInternalCacheKey,
 	setPerformanceConfig,
 	withCache,
 } from './core/performance'
@@ -63,6 +64,7 @@ export function initializeExtensions(options: ExtensionOptions = {}): void {
 export { extendAll }
 
 /**
+ * Selective prototype extension helpers
  * Initialize only specific extensions
  */
 export const extend = {