@oscarpalmer/mora 0.34.0 → 0.36.0

package/dist/constants.d.mts

@@ -5,8 +5,8 @@ export declare const ARRAY_THRESHOLD = 100;
 export declare const ARRAY_OFFSET = 25;
 export declare const ARRAY_PEEK = 10;
 export declare const BATCH: Batch;
-export declare const METHODS_AFFECTING_LENGTH: Set<string>;
-export declare const METHODS_UPDATE: Set<string>;
+export declare const METHODS_AFFECTING_LENGTH: Set<string | symbol>;
+export declare const METHODS_UPDATE: Set<string | symbol>;
 export declare const NAME_ARRAY = "array";
 export declare const NAME_COMPUTED = "computed";
 export declare const NAME_EFFECT = "effect";

package/dist/helpers/proxy.d.mts

@@ -1,11 +1,11 @@
-import { Computed, InternalProxy, ReactiveArray, ReactiveStore } from "../models.mjs";
+import { InternalArray, InternalComputed, InternalStore } from "../models.mjs";
 import { Key } from "@oscarpalmer/atoms/models";
 //#region src/helpers/proxy.d.ts
-export declare function emitProxyValues(this: InternalProxy): void;
-export declare function getReactiveValueInProxy(instance: ReactiveArray<unknown> | ReactiveStore<unknown>, key: Key): Computed<unknown>;
-export declare function getValueInProxy(this: InternalProxy, first?: unknown): unknown;
-export declare function peekValueInProxy(this: InternalProxy, first?: unknown, second?: boolean): unknown;
-export declare function setProxyValue(this: InternalProxy, first?: unknown, second?: unknown): void;
-export declare function setValueInProxy(instance: InternalProxy, target: object, property: PropertyKey, value: unknown): boolean;
-export declare function updateProxyValue(this: InternalProxy, callback: unknown): void;
+export declare function emitProxyValues(this: InternalArray | InternalStore): void;
+export declare function getReactiveValueInProxy(instance: InternalArray | InternalStore, key: Key): InternalComputed;
+export declare function getValueInProxy(this: InternalArray | InternalStore, first?: unknown): unknown;
+export declare function peekValueInProxy(this: InternalArray | InternalStore, first?: unknown, second?: boolean): unknown;
+export declare function setProxyValue(this: InternalArray | InternalStore, first?: unknown, second?: unknown): void;
+export declare function setValueInProxy(instance: InternalArray | InternalStore, target: object, property: PropertyKey, value: unknown): boolean;
+export declare function updateProxyValue(this: InternalArray | InternalStore, callback: unknown): void;
 //#endregion

package/dist/helpers/proxy.mjs

@@ -24,8 +24,12 @@ function getReactiveValueInProxy(instance, key) {
 	return item[0];
 }
 function getValueInProxy(first) {
-	if (this[SYMBOL_STATE].isArray ? typeof first === "number" : isKey(first)) return getReactiveValueInProxy(this, first).get();
-	return getSignalValue.call(this);
+	let signal;
+	if (this[SYMBOL_STATE].isArray ? typeof first === "number" : isKey(first)) signal = getReactiveValueInProxy(this, first);
+	return getSignalValue.call(signal ?? this);
+}
+function isProxyKey(isArray, value) {
+	return isArray ? typeof value === "number" : isKey(value);
 }
 function isProxyObject(isArray, value) {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
@@ -39,23 +43,24 @@ function peekValueInProxy(first, second) {
 }
 function setProxyObject(state, value) {
 	if (state.isArray) {
-		state.value.splice(0, state.value.length, ...value ?? []);
+		const values = state.value;
+		values.splice(0, values.length, ...value ?? []);
 		return;
 	}
 	startBatch();
-	const actual = value ?? {};
-	const proxy = state.value;
-	const proxyKeys = Object.keys(proxy);
-	const actualKeys = Object.keys(actual);
-	let { length } = proxyKeys;
+	const current = state.value;
+	const next = value ?? {};
+	const currentKeys = Object.keys(current);
+	const nextKeys = Object.keys(next);
+	let { length } = currentKeys;
 	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
-		proxy[key] = actualKeys.includes(key) ? actual[key] : void 0;
+		const key = currentKeys[index];
+		current[key] = nextKeys.includes(key) ? next[key] : void 0;
 	}
-	length = actualKeys.length;
+	length = nextKeys.length;
 	for (let index = 0; index < length; index += 1) {
-		const key = actualKeys[index];
-		if (!proxyKeys.includes(key)) proxy[key] = actual[key];
+		const key = nextKeys[index];
+		if (!currentKeys.includes(key)) current[key] = next[key];
 	}
 	stopBatch();
 }
@@ -64,8 +69,10 @@ function setProxyProperty(state, property, value) {
 		state.value[property] = value;
 		return;
 	}
-	const actual = property < 0 ? state.value.length + property : property;
-	if (actual > -1) state.value[actual] = value;
+	const array = state.value;
+	const index = property;
+	const actual = index < 0 ? array.length + index : index;
+	if (actual > -1) array[actual] = value;
 }
 function setProxyValue(first, second) {
 	const state = this[SYMBOL_STATE];
@@ -77,34 +84,34 @@ function setProxyValue(first, second) {
 		setProxyObject(state, first);
 		return;
 	}
-	const property = state.isArray ? typeof first === "number" : isKey(first);
-	if (state.isArray && property && Number.isNaN(first)) return;
-	let actual = property ? second : first;
+	const keyed = isProxyKey(state.isArray, first);
+	if (state.isArray && keyed && Number.isNaN(first)) return;
+	let actual = keyed ? second : first;
 	if (typeof actual === "function") try {
 		actual = actual();
 	} catch {
 		return;
 	}
 	if (actual instanceof Promise) {
-		if (property) {
+		if (keyed) {
 			state.promises ??= /* @__PURE__ */ new Map();
 			state.promises.set(first, actual);
 		} else state.promise = actual;
 		actual.then((value) => {
-			if (property && state.promises.get(first) === actual) {
-				state.promises.delete(first);
+			if (keyed && state.promises?.get(first) === actual) {
+				state.promises?.delete(first);
 				setProxyProperty(state, first, value);
 				return;
 			}
-			if (!property && isProxyObject(state.isArray, value) && state.promise === actual) {
+			if (!keyed && isProxyObject(state.isArray, value) && state.promise === actual) {
 				state.promise = void 0;
 				setProxyObject(state, value);
 			}
 		}).catch(() => {
-			if (property && state.promises.get(first) === actual) state.promises.delete(first);
-			else if (!property && state.promise === actual) state.promise = void 0;
+			if (keyed && state.promises?.get(first) === actual) state.promises?.delete(first);
+			else if (!keyed && state.promise === actual) state.promise = void 0;
 		});
-	} else if (property) setProxyProperty(state, first, actual);
+	} else if (keyed) setProxyProperty(state, first, actual);
 	else if (isProxyObject(state.isArray, actual)) setProxyObject(state, actual);
 }
 function setValueInProxy(instance, target, property, value) {

package/dist/helpers/subscription.d.mts

@@ -1,8 +1,8 @@
-import { InternalProxy, InternalReadonly, InternalSignal, Subscriber } from "../models.mjs";
+import { InternalArray, InternalReadonly, InternalStateful, InternalStore, Subscriber } from "../models.mjs";
 import { Subscription } from "@oscarpalmer/atoms/subscription";
 import { Key } from "@oscarpalmer/atoms/models";
 //#region src/helpers/subscription.d.ts
-export declare function subscribeToProxy(this: InternalProxy, first: Key | Subscriber<unknown>, second?: Subscriber<unknown> | boolean, third?: boolean): Subscription;
+export declare function subscribeToProxy(this: InternalArray | InternalStore, first: Key | Subscriber<unknown>, second?: Subscriber<unknown> | boolean, third?: boolean): Subscription;
 export declare function subscribeToReadonly(this: InternalReadonly, subscriber: Subscriber<unknown>): Subscription;
-export declare function subscribeToSignal(this: InternalSignal, subscriber: Subscriber<unknown>, copy?: unknown): Subscription;
+export declare function subscribeToSignal(this: InternalStateful, subscriber: Subscriber<unknown>, copy?: unknown): Subscription;
 //#endregion

package/dist/helpers/value.d.mts

@@ -1,11 +1,12 @@
-import { InternalSignal, ReactiveState } from "../models.mjs";
+import { InternalStateful } from "../models.mjs";
 //#region src/helpers/value.d.ts
-export declare function emitValue(instance: InternalSignal): void;
-export declare function equalArrays(state: ReactiveState, first: unknown[], second: unknown[]): boolean;
+export declare function emitValue(instance: InternalStateful): void;
+export declare function equalArrays(first: unknown[], second: unknown[], equal?: (first: unknown, second: unknown) => boolean): boolean;
 export declare function getFrozenValue(value: unknown): unknown;
-export declare function getSignalValue(this: InternalSignal): unknown;
-export declare function getStringValue(this: InternalSignal, json?: boolean): string;
-export declare function handleSignalValue(instance: InternalSignal, origin: unknown, setValue: (instance: InternalSignal, value: unknown) => void, onAfter?: () => void): void;
-export declare function peekSignalValue(this: InternalSignal | [InternalSignal, unknown], copy?: boolean): unknown;
-export declare function updateSignalValue(instance: InternalSignal, callback: (value: unknown) => unknown, setValue: (instance: InternalSignal, value: unknown) => void): void;
+export declare function getJsonValue(this: InternalStateful): unknown;
+export declare function getSignalValue(this: InternalStateful): unknown;
+export declare function getStringValue(this: InternalStateful, json?: boolean): string;
+export declare function handleSignal(instance: InternalStateful, origin: unknown, setValue: (instance: InternalStateful, value: unknown) => void, onAfter?: () => void): void;
+export declare function peekSignalValue(this: InternalStateful | [InternalStateful, unknown], copy?: boolean): unknown;
+export declare function updateSignal(instance: InternalStateful, callback: (value: unknown) => unknown, setValue: (instance: InternalStateful, value: unknown) => void): void;
 //#endregion

package/dist/helpers/value.mjs

@@ -18,10 +18,10 @@ function emitValue(instance) {
 	}
 	if (BATCH.depth === 0) flushHandlers();
 }
-function equalArrays(state, first, second) {
+function equalArrays(first, second, equal) {
 	const { length } = first;
 	if (length !== second.length) return false;
-	const eq = state.equal ?? Object.is;
+	const eq = equal ?? Object.is;
 	let offset = 0;
 	if (length >= 100) {
 		offset = Math.round(length / 10);
@@ -38,21 +38,25 @@ function getFrozenValue(value) {
 	else if (isPlainObject(frozen)) frozen = Object.freeze({ ...frozen });
 	return frozen;
 }
+function getJsonValue() {
+	return this[SYMBOL_STATE].value;
+}
 function getSignalValue() {
+	const state = this[SYMBOL_STATE];
 	if (ACTIVE.computed != null) {
-		this[SYMBOL_STATE].computeds ??= /* @__PURE__ */ new Set();
-		this[SYMBOL_STATE].computeds.add(ACTIVE.computed);
+		state.computeds ??= /* @__PURE__ */ new Set();
+		state.computeds.add(ACTIVE.computed);
 	}
 	if (ACTIVE.effect != null) {
-		this[SYMBOL_STATE].effects ??= /* @__PURE__ */ new Set();
-		this[SYMBOL_STATE].effects.add(ACTIVE.effect);
+		state.effects ??= /* @__PURE__ */ new Set();
+		state.effects.add(ACTIVE.effect);
 	}
-	return this[SYMBOL_STATE].value;
+	return state.value;
 }
 function getStringValue(json) {
 	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
 }
-function handleSignalValue(instance, origin, setValue, onAfter) {
+function handleSignal(instance, origin, setValue, onAfter) {
 	const state = instance[SYMBOL_STATE];
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
@@ -78,9 +82,9 @@ function peekSignalValue(copy) {
 	else if (isPlainObject(peeked)) peeked = { ...peeked };
 	return peeked;
 }
-function updateSignalValue(instance, callback, setValue) {
+function updateSignal(instance, callback, setValue) {
 	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	handleSignalValue(instance, callback(instance[SYMBOL_STATE].value), setValue);
+	handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
 }
 //#endregion
-export { emitValue, equalArrays, getFrozenValue, getSignalValue, getStringValue, handleSignalValue, peekSignalValue, updateSignalValue };
+export { emitValue, equalArrays, getFrozenValue, getJsonValue, getSignalValue, getStringValue, handleSignal, peekSignalValue, updateSignal };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { startBatch, stopBatch } from "./batch.mjs";
-import { Computed, Effect, ReactiveArray, ReactiveStore, ReadonlySignal, Signal } from "./models.mjs";
+import { Computed, Effect, Reactive, ReactiveArray, ReactiveStore, ReadonlySignal, Signal } from "./models.mjs";
 import { effect } from "./effect.mjs";
 import { isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal } from "./helpers/is.mjs";
 import { array } from "./value/array.mjs";
@@ -7,4 +7,4 @@ import { computed } from "./value/computed.mjs";
 import { signal } from "./value/signal.mjs";
 import { store } from "./value/store.mjs";
 import { Subscription } from "@oscarpalmer/atoms/subscription";
-export { type Computed, type Effect, type ReactiveArray, type ReactiveStore, type ReadonlySignal, type Signal, type Subscription, array, computed, effect, isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal, signal, startBatch, stopBatch, store };
+export { type Computed, type Effect, type Reactive, type ReactiveArray, type ReactiveStore, type ReadonlySignal, type Signal, type Subscription, array, computed, effect, isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal, signal, startBatch, stopBatch, store };

package/dist/models.d.mts

@@ -11,7 +11,7 @@ export type Batch = {
   flushing: boolean;
   handlers: Map<EffectState | Subscription, EffectState | StoredSubscription>;
 };
-export type Computed<Value> = Reactive<Value> & SimpleReactive<Value>;
+export type Computed<Value> = Reactive<Value>;
 export type ComputedEffect = {
   dirty: boolean;
   instance: EffectState;
@@ -20,19 +20,37 @@ export type Effect = {};
 export type EffectState = {
   callback: GenericCallback;
 };
+export type InternalArray = {
+  [SYMBOL_STATE]: ReactiveProxyState;
+} & ReactiveArray<unknown>;
 export type InternalComputed = {
   [SYMBOL_EFFECT]: ComputedEffect;
-} & InternalSignal;
-export type InternalProxy = {
-  [SYMBOL_STATE]: ReactiveProxyState;
-};
+  [SYMBOL_STATE]: SignalState;
+} & Computed<unknown>;
 export type InternalReadonly = {
   frozen: boolean;
-} & InternalSignal;
-export type InternalSignal = {
+} & InternalStateful & ReadonlySignal<unknown>;
+export type InternalSignal = InternalStateful & Signal<unknown>;
+export type InternalStateful = {
   [SYMBOL_STATE]: SignalState;
 };
+export type InternalStore = {
+  [SYMBOL_STATE]: ReactiveProxyState;
+} & ReactiveStore<PlainObject>;
 export type Reactive<Value> = {
+  /**
+   * Get the value
+   *
+   * @returns Current value
+   */
+  get(): Value;
+  /**
+   * Get the value _(without reactivity)_
+   *
+   * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+   * @returns Current value
+   */
+  peek(copy?: boolean): Value;
   /**
    * _JSON_ representation of the value
    *
@@ -46,6 +64,14 @@ export type Reactive<Value> = {
    * @returns Value as string
    */
   toString(json?: boolean): string;
+  /**
+   * Subscribe to changes
+   *
+   * @param subscriber Callback for changes
+   * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
+   * @returns Subscription
+   */
+  subscribe(subscriber: Subscriber<Value>, copy?: boolean): Subscription;
 };
 export type ReactiveArray<Item> = {
   /**
@@ -240,16 +266,16 @@ export type ReactiveOptions<Value> = {
 export type ReactiveProxyState = {
   isArray: boolean;
   length?: Signal<number>;
-  mapped?: Map<string, [Computed<unknown>, ComputedEffect]>;
+  mapped?: Map<string, [InternalComputed, ComputedEffect]>;
 } & SignalState;
-export type ReactiveState = {
+export type ReactiveState<Value = unknown, Item = Value> = {
   computeds?: Set<ComputedEffect>;
   effects?: Set<EffectState>;
-  equal?: (first: unknown, second: unknown) => boolean;
+  equal?: (first: Item, second: Item) => boolean;
   promise?: Promise<unknown>;
   promises?: Map<Key, Promise<never>>;
   subscriptions?: Subscriptions<GenericCallback>;
-  value: unknown;
+  value: Value;
 };
 export type ReactiveStore<Store> = {
   /**
@@ -379,7 +405,7 @@ export type ReadonlySignal<Value> = {
    * Is the signal frozen?
    */
   get frozen(): boolean;
-} & Reactive<Value> & SimpleReactive<Value>;
+} & Reactive<Value>;
 export type ReadonlySignalValue<Value> = Value extends unknown[] ? Readonly<Value> : Value extends PlainObject ? Readonly<Value> : Value;
 export type Signal<Value> = {
   /**
@@ -408,38 +434,15 @@ export type Signal<Value> = {
    * @param callback Callback to update the value
    */
   update(callback: (value: Value) => Value): void;
-} & Reactive<Value> & SimpleReactive<Value>;
+} & Reactive<Value>;
 export type SignalState = {
   readonlies?: ReadonlyInstances<unknown>;
 } & ReactiveState;
-type SimpleReactive<Value> = {
-  /**
-   * Get the value
-   *
-   * @returns Current value
-   */
-  get(): Value;
-  /**
-   * Get the value _(without reactivity)_
-   *
-   * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
-   * @returns Current value
-   */
-  peek(copy?: boolean): Value;
-  /**
-   * Subscribe to changes
-   *
-   * @param subscriber Callback for changes
-   * @param copy If the value is an array or record, should it be copied? _(defaults to `false`)_
-   * @returns Subscription
-   */
-  subscribe(subscriber: Subscriber<Value>, copy?: boolean): Subscription;
-};
 export type StoredSubscription = {
   callback: GenericCallback;
   copy: boolean;
   frozen: boolean;
-  instance: InternalSignal;
+  instance: InternalStateful;
   state: SignalState;
 };
 export type Subscriber<Value> = (value: Value, subscription: Subscription) => void;