mutts 1.0.1 → 1.0.3

package/dist/eventful.d.ts

@@ -1,4 +1,12 @@
-declare class Eventful<Events extends Record<string, (...args: any[]) => void>> {
+/**
+ * Base type for event maps - all event handlers must be functions
+ */
+type EventsBase = Record<string, (...args: any[]) => void>;
+/**
+ * A type-safe event system that provides a clean API for event handling
+ * @template Events - The event map defining event names and their handler signatures
+ */
+declare class Eventful<Events extends EventsBase> {
     #private;
     hook(cb: <EventType extends keyof Events>(event: EventType, ...args: Parameters<Events[EventType]>) => void): () => void;
     on(events: Partial<Events>): void;
@@ -9,3 +17,4 @@ declare class Eventful<Events extends Record<string, (...args: any[]) => void>>
 }
 
 export { Eventful };
+export type { EventsBase };

package/dist/eventful.esm.js

@@ -1,32 +1,10 @@
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
+import { _ as __classPrivateFieldGet } from './chunks/_tslib-Mzh1rNsX.esm.js';
 
 var _Eventful_events, _Eventful_hooks;
+/**
+ * A type-safe event system that provides a clean API for event handling
+ * @template Events - The event map defining event names and their handler signatures
+ */
 class Eventful {
     constructor() {
         _Eventful_events.set(this, new Map());

package/dist/eventful.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"eventful.esm.js","sources":["../src/eventful.ts"],"sourcesContent":["export class Eventful<Events extends Record<string, (...args: any[]) => void>> {\n\treadonly #events = new Map<keyof Events, ((...args: any[]) => void)[]>()\n\treadonly #hooks = [] as ((...args: any[]) => void)[]\n\n\tpublic hook(\n\t\tcb: <EventType extends keyof Events>(\n\t\t\tevent: EventType,\n\t\t\t...args: Parameters<Events[EventType]>\n\t\t) => void\n\t): () => void {\n\t\tif (!this.#hooks.includes(cb)) this.#hooks.push(cb)\n\t\treturn () => {\n\t\t\tthis.#hooks.splice(this.#hooks.indexOf(cb), 1)\n\t\t}\n\t}\n\n\tpublic on(events: Partial<Events>): void\n\tpublic on<EventType extends keyof Events>(event: EventType, cb: Events[EventType]): () => void\n\tpublic on<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): () => void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.on(e, eventOrEvents[e]!)\n\t\t\t}\n\t\t} else if (cb !== undefined) {\n\t\t\tlet callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (!callbacks) {\n\t\t\t\tcallbacks = []\n\t\t\t\tthis.#events.set(eventOrEvents, callbacks)\n\t\t\t}\n\t\t\tcallbacks.push(cb)\n\t\t}\n\t\t// @ts-expect-error Generic case leads to generic case\n\t\treturn () => this.off(eventOrEvents, cb)\n\t}\n\tpublic off(events: Partial<Events>): void\n\tpublic off<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]): void\n\tpublic off<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.off(e, eventOrEvents[e])\n\t\t\t}\n\t\t} else if (cb !== null && cb !== undefined) {\n\t\t\tconst callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (callbacks) {\n\t\t\t\tthis.#events.set(\n\t\t\t\t\teventOrEvents,\n\t\t\t\t\tcallbacks.filter((c) => c !== cb)\n\t\t\t\t)\n\t\t\t}\n\t\t} else {\n\t\t\t// Remove all listeners for this event\n\t\t\tthis.#events.delete(eventOrEvents)\n\t\t}\n\t}\n\tpublic emit<EventType extends keyof Events>(\n\t\tevent: EventType,\n\t\t...args: Parameters<Events[EventType]>\n\t) {\n\t\tconst callbacks = this.#events.get(event)\n\t\tif (callbacks) for (const cb of callbacks) cb.apply(this, args)\n\t\tfor (const cb of this.#hooks) cb.call(this, event, ...args)\n\t}\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"eventful.esm.js","sources":["../src/eventful.ts"],"sourcesContent":["/**\n * Base type for event maps - all event handlers must be functions\n */\nexport type EventsBase = Record<string, (...args: any[]) => void>\n/**\n * A type-safe event system that provides a clean API for event handling\n * @template Events - The event map defining event names and their handler signatures\n */\nexport class Eventful<Events extends EventsBase> {\n\treadonly #events = new Map<keyof Events, ((...args: any[]) => void)[]>()\n\treadonly #hooks = [] as ((...args: any[]) => void)[]\n\n\tpublic hook(\n\t\tcb: <EventType extends keyof Events>(\n\t\t\tevent: EventType,\n\t\t\t...args: Parameters<Events[EventType]>\n\t\t) => void\n\t): () => void {\n\t\tif (!this.#hooks.includes(cb)) this.#hooks.push(cb)\n\t\treturn () => {\n\t\t\tthis.#hooks.splice(this.#hooks.indexOf(cb), 1)\n\t\t}\n\t}\n\n\tpublic on(events: Partial<Events>): void\n\tpublic on<EventType extends keyof Events>(event: EventType, cb: Events[EventType]): () => void\n\tpublic on<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): () => void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.on(e, eventOrEvents[e]!)\n\t\t\t}\n\t\t} else if (cb !== undefined) {\n\t\t\tlet callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (!callbacks) {\n\t\t\t\tcallbacks = []\n\t\t\t\tthis.#events.set(eventOrEvents, callbacks)\n\t\t\t}\n\t\t\tcallbacks.push(cb)\n\t\t}\n\t\t// @ts-expect-error Generic case leads to generic case\n\t\treturn () => this.off(eventOrEvents, cb)\n\t}\n\tpublic off(events: Partial<Events>): void\n\tpublic off<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]): void\n\tpublic off<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.off(e, eventOrEvents[e])\n\t\t\t}\n\t\t} else if (cb !== null && cb !== undefined) {\n\t\t\tconst callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (callbacks) {\n\t\t\t\tthis.#events.set(\n\t\t\t\t\teventOrEvents,\n\t\t\t\t\tcallbacks.filter((c) => c !== cb)\n\t\t\t\t)\n\t\t\t}\n\t\t} else {\n\t\t\t// Remove all listeners for this event\n\t\t\tthis.#events.delete(eventOrEvents)\n\t\t}\n\t}\n\tpublic emit<EventType extends keyof Events>(\n\t\tevent: EventType,\n\t\t...args: Parameters<Events[EventType]>\n\t) {\n\t\tconst callbacks = this.#events.get(event)\n\t\tif (callbacks) for (const cb of callbacks) cb.apply(this, args)\n\t\tfor (const cb of this.#hooks) cb.call(this, event, ...args)\n\t}\n}\n"],"names":[],"mappings":"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"}

package/dist/eventful.js

@@ -1,44 +1,22 @@
 'use strict';
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
+var _tslib = require('./chunks/_tslib-BgjropY9.js');
 
 var _Eventful_events, _Eventful_hooks;
+/**
+ * A type-safe event system that provides a clean API for event handling
+ * @template Events - The event map defining event names and their handler signatures
+ */
 class Eventful {
     constructor() {
         _Eventful_events.set(this, new Map());
         _Eventful_hooks.set(this, []);
     }
     hook(cb) {
-        if (!__classPrivateFieldGet(this, _Eventful_hooks, "f").includes(cb))
-            __classPrivateFieldGet(this, _Eventful_hooks, "f").push(cb);
+        if (!_tslib.__classPrivateFieldGet(this, _Eventful_hooks, "f").includes(cb))
+            _tslib.__classPrivateFieldGet(this, _Eventful_hooks, "f").push(cb);
         return () => {
-            __classPrivateFieldGet(this, _Eventful_hooks, "f").splice(__classPrivateFieldGet(this, _Eventful_hooks, "f").indexOf(cb), 1);
+            _tslib.__classPrivateFieldGet(this, _Eventful_hooks, "f").splice(_tslib.__classPrivateFieldGet(this, _Eventful_hooks, "f").indexOf(cb), 1);
         };
     }
     on(eventOrEvents, cb) {
@@ -48,10 +26,10 @@ class Eventful {
             }
         }
         else if (cb !== undefined) {
-            let callbacks = __classPrivateFieldGet(this, _Eventful_events, "f").get(eventOrEvents);
+            let callbacks = _tslib.__classPrivateFieldGet(this, _Eventful_events, "f").get(eventOrEvents);
             if (!callbacks) {
                 callbacks = [];
-                __classPrivateFieldGet(this, _Eventful_events, "f").set(eventOrEvents, callbacks);
+                _tslib.__classPrivateFieldGet(this, _Eventful_events, "f").set(eventOrEvents, callbacks);
             }
             callbacks.push(cb);
         }
@@ -65,22 +43,22 @@ class Eventful {
             }
         }
         else if (cb !== null && cb !== undefined) {
-            const callbacks = __classPrivateFieldGet(this, _Eventful_events, "f").get(eventOrEvents);
+            const callbacks = _tslib.__classPrivateFieldGet(this, _Eventful_events, "f").get(eventOrEvents);
             if (callbacks) {
-                __classPrivateFieldGet(this, _Eventful_events, "f").set(eventOrEvents, callbacks.filter((c) => c !== cb));
+                _tslib.__classPrivateFieldGet(this, _Eventful_events, "f").set(eventOrEvents, callbacks.filter((c) => c !== cb));
             }
         }
         else {
             // Remove all listeners for this event
-            __classPrivateFieldGet(this, _Eventful_events, "f").delete(eventOrEvents);
+            _tslib.__classPrivateFieldGet(this, _Eventful_events, "f").delete(eventOrEvents);
         }
     }
     emit(event, ...args) {
-        const callbacks = __classPrivateFieldGet(this, _Eventful_events, "f").get(event);
+        const callbacks = _tslib.__classPrivateFieldGet(this, _Eventful_events, "f").get(event);
         if (callbacks)
             for (const cb of callbacks)
                 cb.apply(this, args);
-        for (const cb of __classPrivateFieldGet(this, _Eventful_hooks, "f"))
+        for (const cb of _tslib.__classPrivateFieldGet(this, _Eventful_hooks, "f"))
             cb.call(this, event, ...args);
     }
 }

package/dist/eventful.js.map

@@ -1 +1 @@
-{"version":3,"file":"eventful.js","sources":["../src/eventful.ts"],"sourcesContent":["export class Eventful<Events extends Record<string, (...args: any[]) => void>> {\n\treadonly #events = new Map<keyof Events, ((...args: any[]) => void)[]>()\n\treadonly #hooks = [] as ((...args: any[]) => void)[]\n\n\tpublic hook(\n\t\tcb: <EventType extends keyof Events>(\n\t\t\tevent: EventType,\n\t\t\t...args: Parameters<Events[EventType]>\n\t\t) => void\n\t): () => void {\n\t\tif (!this.#hooks.includes(cb)) this.#hooks.push(cb)\n\t\treturn () => {\n\t\t\tthis.#hooks.splice(this.#hooks.indexOf(cb), 1)\n\t\t}\n\t}\n\n\tpublic on(events: Partial<Events>): void\n\tpublic on<EventType extends keyof Events>(event: EventType, cb: Events[EventType]): () => void\n\tpublic on<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): () => void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.on(e, eventOrEvents[e]!)\n\t\t\t}\n\t\t} else if (cb !== undefined) {\n\t\t\tlet callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (!callbacks) {\n\t\t\t\tcallbacks = []\n\t\t\t\tthis.#events.set(eventOrEvents, callbacks)\n\t\t\t}\n\t\t\tcallbacks.push(cb)\n\t\t}\n\t\t// @ts-expect-error Generic case leads to generic case\n\t\treturn () => this.off(eventOrEvents, cb)\n\t}\n\tpublic off(events: Partial<Events>): void\n\tpublic off<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]): void\n\tpublic off<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.off(e, eventOrEvents[e])\n\t\t\t}\n\t\t} else if (cb !== null && cb !== undefined) {\n\t\t\tconst callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (callbacks) {\n\t\t\t\tthis.#events.set(\n\t\t\t\t\teventOrEvents,\n\t\t\t\t\tcallbacks.filter((c) => c !== cb)\n\t\t\t\t)\n\t\t\t}\n\t\t} else {\n\t\t\t// Remove all listeners for this event\n\t\t\tthis.#events.delete(eventOrEvents)\n\t\t}\n\t}\n\tpublic emit<EventType extends keyof Events>(\n\t\tevent: EventType,\n\t\t...args: Parameters<Events[EventType]>\n\t) {\n\t\tconst callbacks = this.#events.get(event)\n\t\tif (callbacks) for (const cb of callbacks) cb.apply(this, args)\n\t\tfor (const cb of this.#hooks) cb.call(this, event, ...args)\n\t}\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"eventful.js","sources":["../src/eventful.ts"],"sourcesContent":["/**\n * Base type for event maps - all event handlers must be functions\n */\nexport type EventsBase = Record<string, (...args: any[]) => void>\n/**\n * A type-safe event system that provides a clean API for event handling\n * @template Events - The event map defining event names and their handler signatures\n */\nexport class Eventful<Events extends EventsBase> {\n\treadonly #events = new Map<keyof Events, ((...args: any[]) => void)[]>()\n\treadonly #hooks = [] as ((...args: any[]) => void)[]\n\n\tpublic hook(\n\t\tcb: <EventType extends keyof Events>(\n\t\t\tevent: EventType,\n\t\t\t...args: Parameters<Events[EventType]>\n\t\t) => void\n\t): () => void {\n\t\tif (!this.#hooks.includes(cb)) this.#hooks.push(cb)\n\t\treturn () => {\n\t\t\tthis.#hooks.splice(this.#hooks.indexOf(cb), 1)\n\t\t}\n\t}\n\n\tpublic on(events: Partial<Events>): void\n\tpublic on<EventType extends keyof Events>(event: EventType, cb: Events[EventType]): () => void\n\tpublic on<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): () => void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.on(e, eventOrEvents[e]!)\n\t\t\t}\n\t\t} else if (cb !== undefined) {\n\t\t\tlet callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (!callbacks) {\n\t\t\t\tcallbacks = []\n\t\t\t\tthis.#events.set(eventOrEvents, callbacks)\n\t\t\t}\n\t\t\tcallbacks.push(cb)\n\t\t}\n\t\t// @ts-expect-error Generic case leads to generic case\n\t\treturn () => this.off(eventOrEvents, cb)\n\t}\n\tpublic off(events: Partial<Events>): void\n\tpublic off<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]): void\n\tpublic off<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.off(e, eventOrEvents[e])\n\t\t\t}\n\t\t} else if (cb !== null && cb !== undefined) {\n\t\t\tconst callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (callbacks) {\n\t\t\t\tthis.#events.set(\n\t\t\t\t\teventOrEvents,\n\t\t\t\t\tcallbacks.filter((c) => c !== cb)\n\t\t\t\t)\n\t\t\t}\n\t\t} else {\n\t\t\t// Remove all listeners for this event\n\t\t\tthis.#events.delete(eventOrEvents)\n\t\t}\n\t}\n\tpublic emit<EventType extends keyof Events>(\n\t\tevent: EventType,\n\t\t...args: Parameters<Events[EventType]>\n\t) {\n\t\tconst callbacks = this.#events.get(event)\n\t\tif (callbacks) for (const cb of callbacks) cb.apply(this, args)\n\t\tfor (const cb of this.#hooks) cb.call(this, event, ...args)\n\t}\n}\n"],"names":["__classPrivateFieldGet"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,15 +1,19 @@
-export { Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, GenericClassDecorator, LegacyClassDecorator, LegacyPropertyDecorator, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, decorator, legacyDecorator, modernDecorator } from './decorator.js';
-export { ContextManager, Destroyable, DestructionError, allocated, allocatedValues, callOnGC, destructor } from './destroyable.js';
-export { Eventful } from './eventful.js';
-export { Indexable, getAt, setAt } from './indexable.js';
-export { ReactiveBase, ReactiveError, ScopedCallback, atomic, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, reactiveOptions, unreactive, untracked, unwrap, watch } from './reactive.js';
-export { cache, cached, debounce, deprecated, describe, isCached, throttle } from './std-decorators.js';
+export * from './decorator.js'
+export * from './destroyable.js'
+export * from './eventful.js'
+export * from './indexable.js'
+export * from './iterableWeak.js'
+export * from './mixins.js'
+export * from './reactive.js'
+export * from './std-decorators.js'
+export * from './utils.js'
 
-type ElementTypes<T extends readonly unknown[]> = {
-    [K in keyof T]: T[K] extends readonly (infer U)[] ? U : T[K];
-};
-declare function zip<T extends (readonly unknown[])[]>(...args: T): ElementTypes<T>[];
-declare function isConstructor(fn: Function): boolean;
-declare function renamed<F extends Function>(fct: F, name: string): F;
-
-export { isConstructor, renamed, zip };
+// Augment Array.isArray to properly handle readonly arrays in type narrowing
+interface ArrayConstructor {
+	/**
+	 * Determines whether an object is an array.
+	 * @param arg Any value to test.
+	 * @returns True if the value is an array (mutable or readonly), false otherwise.
+	 */
+	isArray(arg: any): arg is any[] | readonly any[]
+}

package/dist/index.esm.js

@@ -1,7 +1,8 @@
-export { D as DecoratorError, d as decorator, i as isConstructor, l as legacyDecorator, m as modernDecorator, r as renamed, z as zip } from './chunks/decorator-AbRkXM5O.esm.js';
+export { D as DecoratorError, R as ReflectGet, b as ReflectSet, a as arrayEquals, d as decorator, i as isConstructor, c as isOwnAccessor, l as legacyDecorator, m as modernDecorator, r as renamed, z as zip } from './chunks/decorator-DqiszP7i.esm.js';
 export { Destroyable, DestructionError, allocated, allocatedValues, callOnGC, destructor } from './destroyable.esm.js';
 export { Eventful } from './eventful.esm.js';
-export { Indexable, getAt, setAt } from './indexable.esm.js';
-export { ReactiveBase, ReactiveError, atomic, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, reactiveOptions, unreactive, untracked, unwrap, watch } from './reactive.esm.js';
+export { ArrayReadForward, Indexable, forwardArray, getAt, setAt } from './indexable.esm.js';
+export { I as IterableWeakMap, a as IterableWeakSet, L as ReactiveBase, U as ReactiveError, R as ReadOnlyError, Q as Register, j as addBatchCleanup, k as atomic, l as biDi, c as buildReactivityGraph, x as cleanedBy, y as cleanup, h as deepWatch, n as defer, z as derived, o as effect, e as enableDevTools, q as getActiveEffect, g as getState, F as immutables, i as isDevtoolsEnabled, G as isNonReactive, K as isReactive, V as isZoneEnabled, C as mapped, E as memoize, m as mixin, O as organize, P as organized, p as profileInfo, J as project, M as reactive, T as reactiveOptions, D as reduced, S as register, r as registerEffectForDebug, H as registerNativeReactivity, d as registerObjectForDebug, u as root, s as setEffectName, f as setObjectName, W as setZoneEnabled, t as touched, b as touched1, v as trackEffect, A as unreactive, w as untracked, N as unwrap, B as watch } from './chunks/index-DzUDtFc7.esm.js';
 export { cache, cached, debounce, deprecated, describe, isCached, throttle } from './std-decorators.esm.js';
+import './chunks/_tslib-Mzh1rNsX.esm.js';
 //# sourceMappingURL=index.esm.js.map

package/dist/index.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}
+{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/dist/index.js

@@ -1,17 +1,22 @@
 'use strict';
 
-var decorator = require('./chunks/decorator-8qjFb7dw.js');
+var decorator = require('./chunks/decorator-DLvrD0UF.js');
 var destroyable = require('./destroyable.js');
 var eventful = require('./eventful.js');
 var indexable = require('./indexable.js');
-var reactive = require('./reactive.js');
+var reactive = require('./chunks/index-HNVqPzjz.js');
 var stdDecorators = require('./std-decorators.js');
+require('./chunks/_tslib-BgjropY9.js');
 
 
 
 exports.DecoratorError = decorator.DecoratorError;
+exports.ReflectGet = decorator.ReflectGet;
+exports.ReflectSet = decorator.ReflectSet;
+exports.arrayEquals = decorator.arrayEquals;
 exports.decorator = decorator.decorator;
 exports.isConstructor = decorator.isConstructor;
+exports.isOwnAccessor = decorator.isOwnAccessor;
 exports.legacyDecorator = decorator.legacyDecorator;
 exports.modernDecorator = decorator.modernDecorator;
 exports.renamed = decorator.renamed;
@@ -23,22 +28,56 @@ exports.allocatedValues = destroyable.allocatedValues;
 exports.callOnGC = destroyable.callOnGC;
 exports.destructor = destroyable.destructor;
 exports.Eventful = eventful.Eventful;
+exports.ArrayReadForward = indexable.ArrayReadForward;
 exports.Indexable = indexable.Indexable;
+exports.forwardArray = indexable.forwardArray;
 exports.getAt = indexable.getAt;
 exports.setAt = indexable.setAt;
+exports.IterableWeakMap = reactive.IterableWeakMap;
+exports.IterableWeakSet = reactive.IterableWeakSet;
 exports.ReactiveBase = reactive.ReactiveBase;
 exports.ReactiveError = reactive.ReactiveError;
+exports.ReadOnlyError = reactive.ReadOnlyError;
+exports.Register = reactive.Register;
+exports.addBatchCleanup = reactive.addBatchCleanup;
 exports.atomic = reactive.atomic;
-exports.computed = reactive.computed;
+exports.biDi = reactive.biDi;
+exports.buildReactivityGraph = reactive.buildReactivityGraph;
+exports.cleanedBy = reactive.cleanedBy;
+exports.cleanup = reactive.cleanup;
+exports.deepWatch = reactive.deepWatch;
+exports.defer = reactive.defer;
+exports.derived = reactive.derived;
 exports.effect = reactive.effect;
+exports.enableDevTools = reactive.enableDevTools;
+exports.getActiveEffect = reactive.getActiveEffect;
 exports.getState = reactive.getState;
 exports.immutables = reactive.immutables;
-exports.invalidateComputed = reactive.invalidateComputed;
+exports.isDevtoolsEnabled = reactive.isDevtoolsEnabled;
 exports.isNonReactive = reactive.isNonReactive;
 exports.isReactive = reactive.isReactive;
+exports.isZoneEnabled = reactive.isZoneEnabled;
+exports.mapped = reactive.mapped;
+exports.memoize = reactive.memoize;
+exports.mixin = reactive.mixin;
+exports.organize = reactive.organize;
+exports.organized = reactive.organized;
 exports.profileInfo = reactive.profileInfo;
+exports.project = reactive.project;
 exports.reactive = reactive.reactive;
-exports.reactiveOptions = reactive.reactiveOptions;
+exports.reactiveOptions = reactive.options;
+exports.reduced = reactive.reduced;
+exports.register = reactive.register;
+exports.registerEffectForDebug = reactive.registerEffectForDebug;
+exports.registerNativeReactivity = reactive.registerNativeReactivity;
+exports.registerObjectForDebug = reactive.registerObjectForDebug;
+exports.root = reactive.root;
+exports.setEffectName = reactive.setEffectName;
+exports.setObjectName = reactive.setObjectName;
+exports.setZoneEnabled = reactive.setZoneEnabled;
+exports.touched = reactive.touched;
+exports.touched1 = reactive.touched1;
+exports.trackEffect = reactive.trackEffect;
 exports.unreactive = reactive.unreactive;
 exports.untracked = reactive.untracked;
 exports.unwrap = reactive.unwrap;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/indexable.d.ts

@@ -1,4 +1,10 @@
+/**
+ * Symbol for defining custom getter logic for numeric index access
+ */
 declare const getAt: unique symbol;
+/**
+ * Symbol for defining custom setter logic for numeric index access
+ */
 declare const setAt: unique symbol;
 interface IndexingAt<Items = any> {
     [getAt](index: number): Items;
@@ -12,20 +18,226 @@ interface Accessor<T, Items> {
 declare abstract class AbstractGetAt<Items = any> {
     abstract [getAt](index: number): Items;
 }
+/**
+ * Creates an indexable class with a base class and accessor object
+ * @param base - The base class to extend
+ * @param accessor - Object containing get/set methods for numeric index access
+ * @returns A class that supports numeric index access
+ */
 declare function Indexable<Items, Base extends abstract new (...args: any[]) => any>(base: Base, accessor: Accessor<InstanceType<Base>, Items>): new (...args: ConstructorParameters<Base>) => InstanceType<Base> & {
     [x: number]: Items;
 };
+/**
+ * Creates an indexable class with only an accessor object (no base class)
+ * @param accessor - Object containing get/set methods for numeric index access
+ * @returns A class that supports numeric index access
+ */
 declare function Indexable<Items>(accessor: Accessor<any, Items>): new () => {
     [x: number]: Items;
 };
+/**
+ * Creates an indexable class with a base class that has [getAt] method
+ * @param base - The base class that implements [getAt] method
+ * @returns A class that supports numeric index access using the base class's [getAt] method
+ */
 declare function Indexable<Base extends new (...args: any[]) => IndexingAt>(base: Base): new (...args: ConstructorParameters<Base>) => InstanceType<Base> & {
     [x: number]: AtReturnType<InstanceType<Base>>;
 };
+/**
+ * Creates an abstract indexable base class
+ * @returns An abstract class that supports numeric index access
+ */
 declare function Indexable<Items>(): abstract new (...args: any[]) => AbstractGetAt & {
     [x: number]: Items;
 };
 type AtReturnType<T> = T extends {
     [getAt](index: number): infer R;
 } ? R : never;
+/**
+ * Symbol for accessing the forwarded array in ArrayReadForward
+ */
+declare const forwardArray: unique symbol;
+/**
+ * A read-only array forwarder that implements all reading/iterating methods of Array
+ * but does not implement modification methods.
+ *
+ * The constructor takes a callback that returns an array, and all methods forward
+ * their behavior to the result of that callback.
+ */
+declare class ArrayReadForward<T> {
+    protected get [forwardArray](): readonly T[];
+    /**
+     * Get the length of the array
+     */
+    get length(): number;
+    /**
+     * Get an element at a specific index
+     */
+    [index: number]: T | undefined;
+    /**
+     * Iterator protocol support
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Creates a new array with the results of calling a provided function on every element
+     */
+    map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
+    /**
+     * Creates a new array with all elements that pass the test implemented by the provided function
+     */
+    filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
+    filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[];
+    /**
+     * Executes a reducer function on each element of the array, resulting in a single output value
+     */
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+    /**
+     * Executes a reducer function on each element of the array (right-to-left), resulting in a single output value
+     */
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+    /**
+     * Executes a provided function once for each array element
+     */
+    forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
+    /**
+     * Returns the value of the first element in the array that satisfies the provided testing function
+     */
+    find<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S | undefined;
+    find(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T | undefined;
+    /**
+     * Returns the index of the first element in the array that satisfies the provided testing function
+     */
+    findIndex(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): number;
+    /**
+     * Returns the value of the last element in the array that satisfies the provided testing function
+     */
+    findLast<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S | undefined;
+    findLast(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T | undefined;
+    /**
+     * Returns the index of the last element in the array that satisfies the provided testing function
+     */
+    findLastIndex(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): number;
+    /**
+     * Determines whether an array includes a certain value among its entries
+     */
+    includes(searchElement: T, fromIndex?: number): boolean;
+    /**
+     * Returns the first index at which a given element can be found in the array
+     */
+    indexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Returns the last index at which a given element can be found in the array
+     */
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Returns a shallow copy of a portion of an array into a new array object
+     */
+    slice(start?: number, end?: number): T[];
+    /**
+     * Returns a new array comprised of this array joined with other array(s) and/or value(s)
+     */
+    concat(...items: ConcatArray<T>[]): T[];
+    concat(...items: (T | ConcatArray<T>)[]): T[];
+    /**
+     * Tests whether all elements in the array pass the test implemented by the provided function
+     */
+    every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+    /**
+     * Tests whether at least one element in the array passes the test implemented by the provided function
+     */
+    some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+    /**
+     * Joins all elements of an array into a string
+     */
+    join(separator?: string): string;
+    /**
+     * Returns a new array iterator that contains the keys for each index in the array
+     */
+    keys(): IterableIterator<number>;
+    /**
+     * Returns a new array iterator that contains the values for each index in the array
+     */
+    values(): IterableIterator<T>;
+    /**
+     * Returns a new array iterator that contains the key/value pairs for each index in the array
+     */
+    entries(): IterableIterator<[number, T]>;
+    /**
+     * Returns a string representation of the array
+     */
+    toString(): string;
+    /**
+     * Returns a localized string representing the array
+     */
+    toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions | Intl.DateTimeFormatOptions): string;
+    /**
+     * Returns the element at the specified index, or undefined if the index is out of bounds
+     */
+    at(index: number): T | undefined;
+    /**
+     * Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth
+     */
+    flat(depth?: number): T[];
+    /**
+     * Returns a new array formed by applying a given callback function to each element of the array,
+     * and then flattening the result by one level
+     */
+    flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: readonly T[]) => U | ReadonlyArray<U>, thisArg?: This): U[];
+    /**
+     * Returns a new array with elements in reversed order (ES2023)
+     */
+    toReversed(): T[];
+    /**
+     * Returns a new array with elements sorted (ES2023)
+     */
+    toSorted(compareFn?: ((a: T, b: T) => number) | undefined): T[];
+    /**
+     * Returns a new array with some elements removed and/or replaced at a given index (ES2023)
+     */
+    toSpliced(start: number, deleteCount?: number, ...items: T[]): T[];
+    /**
+     * Returns a new array with the element at the given index replaced with the given value (ES2023)
+     */
+    with(index: number, value: T): T[];
+    get [Symbol.unscopables](): {
+        readonly [x: number]: boolean;
+        readonly length?: boolean;
+        toString?: boolean;
+        toLocaleString?: boolean;
+        concat?: boolean;
+        join?: boolean;
+        slice?: boolean;
+        indexOf?: boolean;
+        lastIndexOf?: boolean;
+        every?: boolean;
+        some?: boolean;
+        forEach?: boolean;
+        map?: boolean;
+        filter?: boolean;
+        reduce?: boolean;
+        reduceRight?: boolean;
+        find?: boolean;
+        findIndex?: boolean;
+        entries?: boolean;
+        keys?: boolean;
+        values?: boolean;
+        includes?: boolean;
+        flatMap?: boolean;
+        flat?: boolean;
+        at?: boolean;
+        findLast?: boolean;
+        findLastIndex?: boolean;
+        toReversed?: boolean;
+        toSorted?: boolean;
+        toSpliced?: boolean;
+        with?: boolean;
+        [Symbol.iterator]?: boolean;
+        readonly [Symbol.unscopables]?: boolean;
+    };
+}
 
-export { Indexable, getAt, setAt };
+export { ArrayReadForward, Indexable, forwardArray, getAt, setAt };