mutts 1.0.7 → 1.0.9

package/src/reactive/{interface.ts → watch.ts}

@@ -1,22 +1,18 @@
 import { decorator, type GenericClassDecorator } from '../decorator'
 import { deepWatch } from './deep-watch'
-import { effect, untracked } from './effects'
+import { effect } from './effects'
 import { isNonReactive, nonReactiveClass, nonReactiveObjects } from './non-reactive-state'
 import { unwrap } from './proxy-state'
 import { markWithRoot } from './registry'
 import { dependant } from './tracking'
 import {
-	type DependencyAccess,
+	type EffectAccess,
+	type EffectCleanup,
 	nonReactiveMark,
-	type ScopedCallback,
+	stopped,
 	unreactiveProperties,
 } from './types'
 
-/**
- * Symbol for accessing the cleanup function on cleaned objects
- */
-export const cleanup = Symbol('cleanup')
-
 //#region watch
 
 const unsetYet = Symbol('unset-yet')
@@ -38,10 +34,10 @@ export interface WatchOptions {
  * @returns Cleanup function to stop watching
  */
 export function watch<T>(
-	value: (dep: DependencyAccess) => T,
+	value: (dep: EffectAccess) => T,
 	changed: (value: T, oldValue?: T) => void,
 	options?: Omit<WatchOptions, 'deep'> & { deep?: false }
-): ScopedCallback
+): EffectCleanup
 /**
  * Watches a reactive value with deep watching enabled
  * @param value - Function that returns the value to watch
@@ -50,10 +46,10 @@ export function watch<T>(
  * @returns Cleanup function to stop watching
  */
 export function watch<T extends object | any[]>(
-	value: (dep: DependencyAccess) => T,
+	value: (dep: EffectAccess) => T,
 	changed: (value: T, oldValue?: T) => void,
 	options?: Omit<WatchOptions, 'deep'> & { deep: true }
-): ScopedCallback
+): EffectCleanup
 /**
  * Watches a reactive object directly
  * @param value - The reactive object to watch
@@ -65,7 +61,7 @@ export function watch<T extends object | any[]>(
 	value: T,
 	changed: (value: T) => void,
 	options?: WatchOptions
-): ScopedCallback
+): EffectCleanup
 
 export function watch(
 	value: any, //object | ((dep: DependencyAccess) => object),
@@ -85,7 +81,7 @@ function watchObject(
 	value: object,
 	changed: (value: object) => void,
 	{ immediate = false, deep = false } = {}
-): ScopedCallback {
+): EffectCleanup {
 	if (deep) return deepWatch(value, changed, { immediate })!
 	return effect(function watchObjectEffect() {
 		dependant(value)
@@ -95,12 +91,12 @@ function watchObject(
 }
 
 function watchCallBack<T>(
-	value: (dep: DependencyAccess) => T,
+	value: (dep: EffectAccess) => T,
 	changed: (value: T, oldValue?: T) => void,
 	{ immediate = false, deep = false } = {}
-): ScopedCallback {
+): EffectCleanup {
 	let oldValue: T | typeof unsetYet = unsetYet
-	let deepCleanup: ScopedCallback | undefined
+	let deepCleanup: EffectCleanup | undefined
 	const cbCleanup = effect(
 		markWithRoot(function watchCallBackEffect(access) {
 			const newValue = value(access)
@@ -108,17 +104,22 @@ function watchCallBack<T>(
 				if (oldValue === unsetYet) {
 					if (immediate) changed(newValue)
 				} else changed(newValue, oldValue)
-				oldValue = newValue
-				if (deep) {
-					if (deepCleanup) deepCleanup()
-					deepCleanup = deepWatch(newValue as object, (value) => changed(value as T, value as T))
-				}
+			oldValue = newValue
+			if (deep) {
+				if (deepCleanup) deepCleanup()
+				deepCleanup = deepWatch(newValue as object, (value) => changed(value as T, value as T))
+			}
 		}, value)
 	)
-	return () => {
-		cbCleanup()
-		if (deepCleanup) deepCleanup()
-	}
+	return Object.defineProperties(
+		() => {
+			cbCleanup()
+			if (deepCleanup) deepCleanup()
+		},
+		{
+			[stopped]: { get: () => cbCleanup[stopped] },
+		}
+	) as EffectCleanup
 }
 
 //#endregion
@@ -129,7 +130,7 @@ function watchCallBack<T>(
  * Mark an object as non-reactive. This object and all its properties will never be made reactive.
  * @param obj - The object to mark as non-reactive
  */
-function deepNonReactive<T>(obj: T): T {
+function shallowNonReactive<T>(obj: T): T {
 	obj = unwrap(obj)
 	if (isNonReactive(obj)) return obj
 	try {
@@ -152,7 +153,7 @@ function unreactiveApplication<T extends object>(
 	...args: (keyof T)[]
 ): GenericClassDecorator<T> | T {
 	return typeof arg1 === 'object'
-		? deepNonReactive(arg1)
+		? shallowNonReactive(arg1)
 		: (((original) => {
 				// Copy the parent's unreactive properties if they exist
 				original.prototype[unreactiveProperties] = new Set<PropertyKey>(
@@ -177,34 +178,3 @@ export const unreactive = decorator({
 })
 
 //#endregion
-
-export function cleanedBy<T extends object>(obj: T, cleanupFn: ScopedCallback) {
-	return Object.defineProperty(obj, cleanup, {
-		value: cleanupFn,
-		writable: false,
-		enumerable: false,
-		configurable: true,
-	}) as T & { [cleanup]: ScopedCallback }
-}
-
-//#region greedy caching
-
-/**
- * Creates a derived value that automatically recomputes when dependencies change
- * @param compute - Function that computes the derived value
- * @returns Object with value and cleanup function
- */
-export function derived<T>(compute: (dep: DependencyAccess) => T): {
-	value: T
-	[cleanup]: ScopedCallback
-} {
-	const rv = { value: undefined as unknown as T }
-	return cleanedBy(
-		rv,
-		untracked(() =>
-			effect(function derivedEffect(access) {
-				rv.value = compute(access)
-			})
-		)
-	)
-}

package/src/std-decorators.ts

@@ -1,4 +1,5 @@
 import { decorator, type GenericClassDecorator } from './decorator'
+import { flavored } from './flavored'
 
 // In order to avoid async re-entrance, we could use zone.js or something like that.
 const syncCalculating: { object: object; prop: PropertyKey }[] = []
@@ -56,26 +57,64 @@ export function cache(object: Object, propertyKey: PropertyKey, value: any) {
  * @param descriptor - The descriptor properties to apply
  * @returns A class decorator that applies the descriptor to specified properties
  */
-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 descriptor = flavored(
+	function descriptor(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) {
+							const existing = Object.getOwnPropertyDescriptor(this, key)
+							Object.defineProperty(this, key, Object.assign(existing || {}, descriptor))
+						}
 					}
 				}
 			}
-		}
-}
+	},
+	{
+		/**
+		 * enumerable: true
+		 */
+		get enumerable() {
+			return descriptor({ enumerable: true })
+		},
+		/**
+		 * enumerable: false
+		 */
+		get hidden() {
+			return descriptor({ enumerable: false })
+		},
+		/**
+		 * configurable: true
+		 */
+		get configurable() {
+			return descriptor({ configurable: true })
+		},
+		/**
+		 * configurable: false
+		 */
+		get frozen() {
+			return descriptor({ configurable: false })
+		},
+		/**
+		 * writable: true
+		 */
+		get writable() {
+			return descriptor({ writable: true })
+		},
+		/**
+		 * writable: false
+		 */
+		get readonly() {
+			return descriptor({ writable: false })
+		},
+	}
+)
 
 /**
  * Decorator that marks methods, properties, or classes as deprecated

package/src/utils.ts

@@ -260,7 +260,6 @@ export function deepCompare(a: any, b: any, cache = new Map<object, Set<object>>
 	return true
 }
 
-
 const contentRefs = new WeakMap<object, any>()
 export function contentRef(container: object) {
 	if (!contentRefs.has(container))
@@ -275,7 +274,7 @@ export function contentRef(container: object) {
 	return contentRefs.get(container)
 }
 
-export function tag<T extends object>(obj: T, name: string): T {
+export function tag<T extends object>(name: string, obj: T): T {
 	Object.defineProperties(obj, {
 		[Symbol.toStringTag]: {
 			value: name,
@@ -295,7 +294,7 @@ export function named<T extends Function>(name: string, fn: T): T {
 	Object.defineProperty(fn, 'name', {
 		value: fn.name ? `${fn.name}::${name}` : name,
 		writable: false,
-		configurable: false,
+		configurable: true,
 	})
 	return fn
-}
+}

package/src/zone.ts

@@ -1,26 +1,37 @@
-import { asyncHooks } from "./async"
-import { named, tag } from "./utils"
+import { asyncHooks } from './async'
+import { named, tag } from './utils'
 
+interface InternalZoneUse<T> {
+	enter(value?: T): unknown
+	leave(entered: unknown): void
+}
+function isu<T>(z: AZone<T> | InternalZoneUse<T>): InternalZoneUse<T> {
+	return z as InternalZoneUse<T>
+}
 export abstract class AZone<T> {
 	abstract active?: T
-	enter(value?: T): unknown {
+	protected enter(value?: T): unknown {
 		const prev = this.active
 		this.active = value
 		return prev
 	}
-	leave(entered: unknown): void {
+	protected leave(entered: unknown): void {
 		this.active = entered as T | undefined
 	}
-	with<R>(value: T, fn: () => R): R {
+	with<R>(value: T | undefined, fn: () => R): R {
 		const entered = this.enter(value)
+		let res: R
 		try {
-			return fn()
+			res = fn()
 		} finally {
 			this.leave(entered)
 		}
+		// [HACK]: Sanitization
+		// See BROWSER_ASYNC_POLYFILL.md
+		return asyncHooks.sanitizePromise(res) as R
 	}
 	root<R>(fn: () => R): R {
-		let prev = this.enter()
+		const prev = this.enter()
 		try {
 			return fn()
 		} finally {
@@ -33,48 +44,53 @@ export abstract class AZone<T> {
 	}
 }
 
-export type FunctionWrapper = <R>(fn?: () => R) => R
+export type FunctionWrapper = <R>(fn: () => R) => R
 
 export class Zone<T> extends AZone<T> {
 	active: T | undefined
 }
-type HistoryValue<T> = {present: T | undefined, history: Set<T>}
+
+type HistoryValue<T> = { present: T | undefined; history: Set<T> }
 export class ZoneHistory<T> extends AZone<HistoryValue<T>> {
-	private	history = new Set<T>()
+	private history = new Set<T>()
 	public readonly present: AZone<T>
 	public has(value: T): boolean {
 		return this.history.has(value)
 	}
 	public some(predicate: (value: T) => boolean): boolean {
-		for(const value of this.history) if(predicate(value)) return true
+		for (const value of this.history) if (predicate(value)) return true
 		return false
 	}
 	constructor(private controlled: AZone<T> = new Zone<T>()) {
 		super()
 		const self = this
-		this.present = Object.create(controlled,
+		this.present = Object.create(
+			controlled,
 			Object.getOwnPropertyDescriptors({
-				get active() { return controlled.active },
+				get active() {
+					return controlled.active
+				},
 				set active(value: T | undefined) {
 					controlled.active = value
 				},
 				enter(value?: T) {
-					if(value && self.history.has(value)) throw new Error('ZoneHistory: re-entering historical zone')
-					if(value !== undefined) self.history.add(value)
-					return { added: value, entered: controlled.enter(value) }
+					if (value && self.history.has(value))
+						throw new Error('ZoneHistory: re-entering historical zone')
+					if (value !== undefined) self.history.add(value)
+					return { added: value, entered: isu(controlled).enter(value) }
+				},
+				leave(entered: { added: T | undefined; entered: unknown }) {
+					if (entered.added !== undefined) self.history.delete(entered.added)
+					return isu(controlled).leave(entered.entered)
 				},
-				leave(entered: { added: T | undefined, entered: unknown }) {
-					if(entered.added !== undefined) self.history.delete(entered.added)
-					return controlled.leave(entered.entered)
-				}
 			})
 		)
 	}
 	get active() {
-		return {present: this.controlled.active, history: new Set(this.history)}
+		return { present: this.controlled.active, history: new Set(this.history) }
 	}
 	set active(value: HistoryValue<T> | undefined) {
-		this.history = this.history && new Set(this.history)
+		this.history = value?.history ? new Set(value.history) : new Set()
 		this.controlled.active = value?.present
 	}
 }
@@ -87,8 +103,7 @@ export class ZoneAggregator extends AZone<Map<AZone<unknown>, unknown>> {
 	}
 	get active(): Map<AZone<unknown>, unknown> | undefined {
 		const rv = new Map<AZone<unknown>, unknown>()
-		for (const z of this.#zones)
-			if (z.active !== undefined) rv.set(z, z.active)
+		for (const z of this.#zones) if (z.active !== undefined) rv.set(z, z.active)
 		return rv
 	}
 	set active(value: Map<AZone<unknown>, unknown> | undefined) {
@@ -98,12 +113,12 @@ export class ZoneAggregator extends AZone<Map<AZone<unknown>, unknown>> {
 		const entered = new Map<AZone<unknown>, unknown>()
 		for (const z of this.#zones) {
 			const v = value?.get(z)
-			entered.set(z, z.enter(v))
+			entered.set(z, isu(z).enter(v))
 		}
 		return entered
 	}
 	leave(entered: Map<AZone<unknown>, unknown>): void {
-		for (const z of this.#zones) z.leave(entered.get(z))
+		for (const z of this.#zones) isu(z).leave(entered.get(z))
 	}
 	add(z: AZone<unknown>) {
 		this.#zones.add(z)
@@ -116,12 +131,12 @@ export class ZoneAggregator extends AZone<Map<AZone<unknown>, unknown>> {
 	}
 }
 
-export const asyncZone = tag(new ZoneAggregator(), 'async')
+export const asyncZone = tag('async', new ZoneAggregator())
 asyncHooks.addHook(() => {
 	const zone = asyncZone.active
 	return () => {
 		const prev = asyncZone.active
 		asyncZone.active = zone
-		return () => asyncZone.active = prev
+		return () => (asyncZone.active = prev)
 	}
 })

package/dist/browser.js

@@ -1,161 +0,0 @@
-'use strict';
-
-var index = require('./chunks/index-BFYK02LG.js');
-
-const hooks = new Set();
-index.asyncHooks.addHook = function (hook) {
-    hooks.add(hook);
-    return () => {
-        hooks.delete(hook);
-    };
-};
-function wrap(fn) {
-    if (typeof fn !== 'function')
-        return fn;
-    const restorers = new Set();
-    for (const hook of hooks)
-        restorers.add(hook());
-    return function (...args) {
-        const undoers = new Set();
-        for (const restore of restorers)
-            undoers.add(restore());
-        try {
-            return fn.apply(this, args);
-        }
-        finally {
-            for (const undo of undoers)
-                undo();
-        }
-    };
-}
-const originals = {
-    then: Promise.prototype.then,
-    catch: Promise.prototype.catch,
-    finally: Promise.prototype.finally,
-    setTimeout: globalThis.setTimeout,
-    setInterval: globalThis.setInterval,
-    setImmediate: globalThis.setImmediate,
-    requestAnimationFrame: globalThis.requestAnimationFrame,
-    queueMicrotask: globalThis.queueMicrotask,
-};
-Promise.prototype.then = function (onFulfilled, onRejected) {
-    return originals.then.call(this, wrap(onFulfilled), wrap(onRejected));
-};
-Promise.prototype.catch = function (onRejected) {
-    return originals.catch.call(this, wrap(onRejected));
-};
-Promise.prototype.finally = function (onFinally) {
-    return originals.finally.call(this, wrap(onFinally));
-};
-globalThis.setTimeout = ((callback, ...args) => {
-    return originals.setTimeout.call(globalThis, wrap(callback), ...args);
-});
-globalThis.setInterval = ((callback, ...args) => {
-    return originals.setInterval.call(globalThis, wrap(callback), ...args);
-});
-if (originals.setImmediate) {
-    globalThis.setImmediate = ((callback, ...args) => {
-        return originals.setImmediate.call(globalThis, wrap(callback), ...args);
-    });
-}
-if (originals.requestAnimationFrame) {
-    globalThis.requestAnimationFrame = (callback) => {
-        return originals.requestAnimationFrame.call(globalThis, wrap(callback));
-    };
-}
-if (originals.queueMicrotask) {
-    globalThis.queueMicrotask = (callback) => {
-        originals.queueMicrotask.call(globalThis, wrap(callback));
-    };
-}
-
-exports.AZone = index.AZone;
-exports.ArrayReadForward = index.ArrayReadForward;
-exports.DecoratorError = index.DecoratorError;
-exports.Destroyable = index.Destroyable;
-exports.DestructionError = index.DestructionError;
-exports.Eventful = index.Eventful;
-exports.FoolProof = index.FoolProof;
-exports.Indexable = index.Indexable;
-exports.IterableWeakMap = index.IterableWeakMap;
-exports.IterableWeakSet = index.IterableWeakSet;
-exports.ReactiveBase = index.ReactiveBase;
-exports.ReactiveError = index.ReactiveError;
-Object.defineProperty(exports, "ReactiveErrorCode", {
-	enumerable: true,
-	get: function () { return index.ReactiveErrorCode; }
-});
-exports.Register = index.Register;
-exports.Zone = index.Zone;
-exports.ZoneAggregator = index.ZoneAggregator;
-exports.ZoneHistory = index.ZoneHistory;
-exports.addBatchCleanup = index.addBatchCleanup;
-exports.allocated = index.allocated;
-exports.allocatedValues = index.allocatedValues;
-exports.arrayEquals = index.arrayEquals;
-exports.asyncZone = index.asyncZone;
-exports.atomic = index.atomic;
-exports.biDi = index.biDi;
-exports.buildReactivityGraph = index.buildReactivityGraph;
-exports.cache = index.cache;
-exports.cached = index.cached;
-exports.callOnGC = index.callOnGC;
-exports.chainPromise = index.chainPromise;
-exports.cleanedBy = index.cleanedBy;
-exports.cleanup = index.cleanup;
-exports.contentRef = index.contentRef;
-exports.debounce = index.debounce;
-exports.decorator = index.decorator;
-exports.deepCompare = index.deepCompare;
-exports.deepWatch = index.deepWatch;
-exports.defer = index.defer;
-exports.deprecated = index.deprecated;
-exports.derived = index.derived;
-exports.describe = index.describe;
-exports.destructor = index.destructor;
-exports.effect = index.effect;
-exports.enableDevTools = index.enableDevTools;
-exports.forwardArray = index.forwardArray;
-exports.getActivationLog = index.getActivationLog;
-exports.getActiveProjection = index.getActiveProjection;
-exports.getAt = index.getAt;
-exports.getState = index.getState;
-exports.immutables = index.immutables;
-exports.isCached = index.isCached;
-exports.isConstructor = index.isConstructor;
-exports.isDevtoolsEnabled = index.isDevtoolsEnabled;
-exports.isNonReactive = index.isNonReactive;
-exports.isOwnAccessor = index.isOwnAccessor;
-exports.isReactive = index.isReactive;
-exports.legacyDecorator = index.legacyDecorator;
-exports.memoize = index.memoize;
-exports.mixin = index.mixin;
-exports.modernDecorator = index.modernDecorator;
-exports.named = index.named;
-exports.organize = index.organize;
-exports.organized = index.organized;
-exports.profileInfo = index.profileInfo;
-exports.project = index.project;
-exports.reactive = index.reactive;
-exports.reactiveOptions = index.options;
-exports.register = index.register;
-exports.registerEffectForDebug = index.registerEffectForDebug;
-exports.registerNativeReactivity = index.registerNativeReactivity;
-exports.registerObjectForDebug = index.registerObjectForDebug;
-exports.renamed = index.renamed;
-exports.root = index.root;
-exports.scan = index.scan;
-exports.setAt = index.setAt;
-exports.setEffectName = index.setEffectName;
-exports.setObjectName = index.setObjectName;
-exports.tag = index.tag;
-exports.throttle = index.throttle;
-exports.touched = index.touched;
-exports.touched1 = index.touched1;
-exports.trackEffect = index.trackEffect;
-exports.unreactive = index.unreactive;
-exports.untracked = index.untracked;
-exports.unwrap = index.unwrap;
-exports.watch = index.watch;
-exports.zip = index.zip;
-//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser.js","sources":["../src/async/browser.ts"],"sourcesContent":["import { Hook, Restorer, asyncHooks } from '.'\n\nconst hooks = new Set<Hook>()\n\nasyncHooks.addHook = function (hook: Hook) {\n\thooks.add(hook)\n\treturn () => {\n\t\thooks.delete(hook)\n\t}\n}\n\nexport * from '../index'\n\nfunction wrap<Args extends any[], R>(fn: ((...args: Args) => R) | null | undefined) {\n\tif (typeof fn !== 'function') return fn\n\tconst restorers = new Set<Restorer>()\n\tfor (const hook of hooks) restorers.add(hook())\n\n\treturn function (this: any, ...args: Args) {\n\t\tconst undoers = new Set<() => void>()\n\t\tfor (const restore of restorers) undoers.add(restore())\n\t\ttry {\n\t\t\treturn fn.apply(this, args)\n\t\t} finally {\n\t\t\tfor (const undo of undoers) undo()\n\t\t}\n\t}\n}\n\nconst originals = {\n\tthen: Promise.prototype.then,\n\tcatch: Promise.prototype.catch,\n\tfinally: Promise.prototype.finally,\n\tsetTimeout: globalThis.setTimeout,\n\tsetInterval: globalThis.setInterval,\n\tsetImmediate: globalThis.setImmediate,\n\trequestAnimationFrame: globalThis.requestAnimationFrame,\n\tqueueMicrotask: globalThis.queueMicrotask,\n}\n\nPromise.prototype.then = function <T, R1, R2>(\n\tthis: Promise<T>,\n\tonFulfilled?: ((value: T) => R1 | PromiseLike<R1>) | null,\n\tonRejected?: ((reason: any) => R2 | PromiseLike<R2>) | null\n): Promise<R1 | R2> {\n\treturn originals.then.call(this, wrap(onFulfilled), wrap(onRejected))\n}\n\nPromise.prototype.catch = function <T>(\n\tthis: Promise<T>,\n\tonRejected?: ((reason: any) => T | PromiseLike<T>) | null\n): Promise<T> {\n\treturn originals.catch.call(this, wrap(onRejected))\n}\n\nPromise.prototype.finally = function <T>(\n\tthis: Promise<T>,\n\tonFinally?: (() => void) | null\n): Promise<T> {\n\treturn originals.finally.call(this, wrap(onFinally))\n}\n\nglobalThis.setTimeout = ((callback: Function, ...args: any[]) => {\n\treturn originals.setTimeout.call(globalThis, wrap(callback as any), ...args)\n}) as any\n\nglobalThis.setInterval = ((callback: Function, ...args: any[]) => {\n\treturn originals.setInterval.call(globalThis, wrap(callback as any), ...args)\n}) as any\n\nif (originals.setImmediate) {\n\tglobalThis.setImmediate = ((callback: Function, ...args: any[]) => {\n\t\treturn originals.setImmediate.call(globalThis, wrap(callback as any), ...args)\n\t}) as any\n}\n\nif (originals.requestAnimationFrame) {\n\tglobalThis.requestAnimationFrame = (callback: FrameRequestCallback) => {\n\t\treturn originals.requestAnimationFrame.call(globalThis, wrap(callback))\n\t}\n}\n\nif (originals.queueMicrotask) {\n\tglobalThis.queueMicrotask = (callback: VoidFunction): void => {\n\t\toriginals.queueMicrotask.call(globalThis, wrap(callback))\n\t}\n}"],"names":["asyncHooks"],"mappings":"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"}