mutts 1.0.0 → 1.0.2

package/src/std-decorators.ts

@@ -1,182 +0,0 @@
-import { decorator, GenericClassDecorator } from './decorator'
-
-// In order to avoid async re-entrance, we could use zone.js or something like that.
-const syncCalculating: { object: object; prop: PropertyKey }[] = []
-export const cached = decorator({
-	getter(original, propertyKey) {
-		return function (this: any) {
-			const alreadyCalculating = syncCalculating.findIndex(
-				(c) => c.object === this && c.prop === propertyKey
-			)
-			if (alreadyCalculating > -1)
-				throw new Error(
-					`Circular dependency detected: ${syncCalculating
-						.slice(alreadyCalculating)
-						.map((c) => `${c.object.constructor.name}.${String(c.prop)}`)
-						.join(' -> ')} -> again`
-				)
-			syncCalculating.push({ object: this, prop: propertyKey })
-			try {
-				const rv = original.call(this)
-				cache(this, propertyKey, rv)
-				return rv
-			} finally {
-				syncCalculating.pop()
-			}
-		}
-	},
-})
-
-export function isCached(object: Object, propertyKey: PropertyKey) {
-	return !!Object.getOwnPropertyDescriptor(object, propertyKey)
-}
-
-export function cache(object: Object, propertyKey: PropertyKey, value: any) {
-	Object.defineProperty(object, propertyKey, { value })
-}
-
-export function describe(descriptor: {
-	enumerable?: boolean
-	configurable?: boolean // Not modifiable once the property has been defined ?
-	writable?: boolean
-}) {
-	return <T>(...properties: (keyof T)[]): GenericClassDecorator<T> =>
-		(Base) => {
-			return class extends Base {
-				constructor(...args: any[]) {
-					super(...args)
-					for (const key of properties) {
-						Object.defineProperty(this, key, {
-							...Object.getOwnPropertyDescriptor(this, key),
-							...descriptor,
-						})
-					}
-				}
-			}
-		}
-}
-
-export const deprecated = Object.assign(
-	decorator({
-		method(original, propertyKey) {
-			return function (this: any, ...args: any[]) {
-				deprecated.warn(this, propertyKey)
-				return original.apply(this, args)
-			}
-		},
-		getter(original, propertyKey) {
-			return function (this: any) {
-				deprecated.warn(this, propertyKey)
-				return original.call(this)
-			}
-		},
-		setter(original, propertyKey) {
-			return function (this: any, value: any) {
-				deprecated.warn(this, propertyKey)
-				return original.call(this, value)
-			}
-		},
-		class(original) {
-			return class extends original {
-				constructor(...args: any[]) {
-					super(...args)
-					deprecated.warn(this, 'constructor')
-				}
-			}
-		},
-		default(message: string) {
-			return decorator({
-				method(original, propertyKey) {
-					return function (this: any, ...args: any[]) {
-						deprecated.warn(this, propertyKey, message)
-						return original.apply(this, args)
-					}
-				},
-				getter(original, propertyKey) {
-					return function (this: any) {
-						deprecated.warn(this, propertyKey, message)
-						return original.call(this)
-					}
-				},
-				setter(original, propertyKey) {
-					return function (this: any, value: any) {
-						deprecated.warn(this, propertyKey, message)
-						return original.call(this, value)
-					}
-				},
-				class(original) {
-					return class extends original {
-						constructor(...args: any[]) {
-							super(...args)
-							deprecated.warn(this, 'constructor', message)
-						}
-					}
-				},
-			})
-		},
-	}),
-	{
-		warn: (target: any, propertyKey: PropertyKey, message?: string) => {
-			// biome-ignore lint/suspicious/noConsole: To be overridden
-			console.warn(
-				`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`
-			)
-		},
-	}
-)
-
-export function debounce(delay: number) {
-	return decorator({
-		method(original, _propertyKey) {
-			let timeoutId: ReturnType<typeof setTimeout> | null = null
-
-			return function (this: any, ...args: any[]) {
-				// Clear existing timeout
-				if (timeoutId) {
-					clearTimeout(timeoutId)
-				}
-
-				// Set new timeout
-				timeoutId = setTimeout(() => {
-					original.apply(this, args)
-					timeoutId = null
-				}, delay)
-			}
-		},
-	})
-}
-
-export function throttle(delay: number) {
-	return decorator({
-		method(original, _propertyKey) {
-			let lastCallTime = 0
-			let timeoutId: ReturnType<typeof setTimeout> | null = null
-
-			return function (this: any, ...args: any[]) {
-				const now = Date.now()
-
-				// If enough time has passed since last call, execute immediately
-				if (now - lastCallTime >= delay) {
-					// Clear any pending timeout since we're executing now
-					if (timeoutId) {
-						clearTimeout(timeoutId)
-						timeoutId = null
-					}
-					lastCallTime = now
-					return original.apply(this, args)
-				}
-
-				// Otherwise, schedule execution for when the delay period ends
-				if (!timeoutId) {
-					const remainingTime = delay - (now - lastCallTime)
-					const scheduledArgs = [...args] // Capture args at scheduling time
-					timeoutId = setTimeout(() => {
-						lastCallTime = Date.now()
-						original.apply(this, scheduledArgs)
-						timeoutId = null
-					}, remainingTime)
-				}
-			}
-		},
-	})
-}

package/src/utils.ts

@@ -1,52 +0,0 @@
-type ElementTypes<T extends readonly unknown[]> = {
-	[K in keyof T]: T[K] extends readonly (infer U)[] ? U : T[K]
-}
-
-export function zip<T extends (readonly unknown[])[]>(...args: T): ElementTypes<T>[] {
-	if (!args.length) return []
-	const minLength = Math.min(...args.map((arr) => arr.length))
-	const result: ElementTypes<T>[] = []
-
-	for (let i = 0; i < minLength; i++) {
-		const tuple = args.map((arr) => arr[i]) as ElementTypes<T>
-		result.push(tuple)
-	}
-
-	return result
-}
-
-const nativeConstructors = new Set<Function>([
-	Object,
-	Array,
-	Date,
-	Function,
-	Set,
-	Map,
-	WeakMap,
-	WeakSet,
-	Promise,
-	Error,
-	TypeError,
-	ReferenceError,
-	SyntaxError,
-	RangeError,
-	URIError,
-	EvalError,
-	Reflect,
-	Proxy,
-	RegExp,
-	String,
-	Number,
-	Boolean,
-] as Function[])
-export function isConstructor(fn: Function): boolean {
-	return fn && (nativeConstructors.has(fn) || fn.toString().startsWith('class '))
-}
-
-export function renamed<F extends Function>(fct: F, name: string): F {
-	return Object.defineProperties(fct, {
-		name: {
-			value: name,
-		},
-	})
-}