mutts 1.0.0

package/src/std-decorators.ts

@@ -0,0 +1,182 @@
+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

@@ -0,0 +1,52 @@
+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,
+		},
+	})
+}