@oscarpalmer/mora 0.31.0 → 0.33.0

package/dist/batch.d.mts

@@ -1,14 +1,13 @@
 //#region src/batch.d.ts
-declare function flushHandlers(): void;
+export declare function flushHandlers(): void;
 /**
  * Start batching effects
  *
  * _(Use {@link stopBatch} to flush and run batched effects)_
  */
-declare function startBatch(): void;
+export declare function startBatch(): void;
 /**
  * Stop batching effects and flush _(run)_ them
  */
-declare function stopBatch(): void;
-//#endregion
-export { flushHandlers, startBatch, stopBatch };
+export declare function stopBatch(): void;
+//#endregion

package/dist/batch.mjs

@@ -1,5 +1,6 @@
 import { BATCH } from "./constants.mjs";
 import { runEffect } from "./effect.mjs";
+import { getFrozenValue, peekSignalValue } from "./helpers/value.mjs";
 //#region src/batch.ts
 function flushHandlers() {
 	if (BATCH.flushing) return;
@@ -10,8 +11,9 @@ function flushHandlers() {
 			const { length } = handlers;
 			BATCH.handlers.clear();
 			for (let index = 0; index < length; index += 1) {
-				const handler = handlers[index];
-				if (typeof handler.destroy === "function") handler.callback(handler.state.value);
+				const [, handler] = handlers[index];
+				const subscription = handler;
+				if (typeof subscription.frozen === "boolean") subscription.callback(subscription.frozen ? getFrozenValue(subscription.state.value) : peekSignalValue.call(subscription.instance, subscription.copy));
 				else runEffect(handler);
 			}
 		}

package/dist/constants.d.mts

@@ -1,20 +1,32 @@
-import { Active, Batch } from "./models.mjs";
+import { Active, Batch, SubscriptionType } from "./models.mjs";
 //#region src/constants.d.ts
-declare const ACTIVE: Active;
-declare const ARRAY_THRESHOLD = 100;
-declare const ARRAY_OFFSET = 25;
-declare const ARRAY_PEEK = 10;
-declare const BATCH: Batch;
-declare const METHODS_AFFECTING_LENGTH: Set<string>;
-declare const METHODS_UPDATE: Set<string>;
-declare const NAME_ARRAY = "array";
-declare const NAME_COMPUTED = "computed";
-declare const NAME_EFFECT = "effect";
-declare const NAME_MORA = "$mora";
-declare const NAME_READONLY = "readonly";
-declare const NAME_SIGNAL = "signal";
-declare const NAME_STORE = "store";
-declare const NAME_ALL: Set<string>;
-declare const PROPERTY_LENGTH = "length";
-//#endregion
-export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_MORA, NAME_READONLY, NAME_SIGNAL, NAME_STORE, PROPERTY_LENGTH };
+export declare const ACTIVE: Active;
+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 NAME_ARRAY = "array";
+export declare const NAME_COMPUTED = "computed";
+export declare const NAME_EFFECT = "effect";
+export declare const NAME_MORA = "$mora";
+export declare const NAME_READONLY = "readonly";
+export declare const NAME_SIGNAL = "signal";
+export declare const NAME_STORE = "store";
+export declare const NAME_SUBSCRIPTION = "subscription";
+export declare const NAME_ALL: Set<string>;
+export declare const PROPERTY_LENGTH = "length";
+export declare const SYMBOL_EFFECT: unique symbol;
+export declare const SYMBOL_STATE: unique symbol;
+export declare const SUBSCRIPTION_PROPERTY: {
+  key: string;
+  value: string;
+};
+export declare const SUBSCRIPTION_TYPE_COPY: SubscriptionType;
+export declare const SUBSCRIPTION_TYPE_FROZEN: SubscriptionType;
+export declare const SUBSCRIPTION_TYPE_ORIGINAL: SubscriptionType;
+export declare const SUBSCRIPTION_TYPE_READONLY: SubscriptionType;
+export declare const SUBSCRIPTION_TYPES_COPY: Set<SubscriptionType>;
+export declare const SUBSCRIPTION_TYPES: Set<SubscriptionType>;
+//#endregion

package/dist/constants.mjs

@@ -6,7 +6,7 @@ const ARRAY_PEEK = 10;
 const BATCH = {
 	depth: 0,
 	flushing: false,
-	handlers: /* @__PURE__ */ new Set()
+	handlers: /* @__PURE__ */ new Map()
 };
 const METHODS_AFFECTING_LENGTH = /* @__PURE__ */ new Set([
 	"pop",
@@ -29,6 +29,7 @@ const NAME_MORA = "$mora";
 const NAME_READONLY = "readonly";
 const NAME_SIGNAL = "signal";
 const NAME_STORE = "store";
+const NAME_SUBSCRIPTION = "subscription";
 const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
@@ -37,5 +38,21 @@ const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_STORE
 ]);
 const PROPERTY_LENGTH = "length";
+const SYMBOL_EFFECT = Symbol("effect");
+const SYMBOL_STATE = Symbol("state");
+const SUBSCRIPTION_PROPERTY = {
+	key: NAME_MORA,
+	value: NAME_SUBSCRIPTION
+};
+const SUBSCRIPTION_TYPE_COPY = "copy";
+const SUBSCRIPTION_TYPE_FROZEN = "frozen";
+const SUBSCRIPTION_TYPE_ORIGINAL = "original";
+const SUBSCRIPTION_TYPE_READONLY = "readonly";
+const SUBSCRIPTION_TYPES_COPY = /* @__PURE__ */ new Set([SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_READONLY]);
+const SUBSCRIPTION_TYPES = /* @__PURE__ */ new Set([
+	...SUBSCRIPTION_TYPES_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPE_ORIGINAL
+]);
 //#endregion
-export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_MORA, NAME_READONLY, NAME_SIGNAL, NAME_STORE, PROPERTY_LENGTH };
+export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_MORA, NAME_READONLY, NAME_SIGNAL, NAME_STORE, NAME_SUBSCRIPTION, PROPERTY_LENGTH, SUBSCRIPTION_PROPERTY, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SUBSCRIPTION_TYPE_READONLY, SYMBOL_EFFECT, SYMBOL_STATE };

package/dist/effect.d.mts

@@ -1,14 +1,14 @@
 import { Effect, EffectState } from "./models.mjs";
 import { GenericCallback } from "@oscarpalmer/atoms/models";
 //#region src/effect.d.ts
+declare function Effect(this: any, callback: GenericCallback): void;
 /**
  * Create an effect
  *
  * @param callback Callback for handling signal effects
  * @returns Effect
  */
-declare function effect(callback: GenericCallback): Effect;
-declare function internalEffect(callback: GenericCallback): EffectState;
-declare function runEffect(state: EffectState): void;
-//#endregion
-export { effect, internalEffect, runEffect };
+export declare function effect(callback: GenericCallback): Effect;
+export declare function internalEffect(callback: GenericCallback): EffectState;
+export declare function runEffect(state: EffectState): void;
+//#endregion

package/dist/effect.mjs

@@ -1,5 +1,10 @@
-import { ACTIVE, NAME_EFFECT } from "./constants.mjs";
+import { ACTIVE, NAME_EFFECT, NAME_MORA, SYMBOL_STATE } from "./constants.mjs";
 //#region src/effect.ts
+function Effect(callback) {
+	this[SYMBOL_STATE] = { callback };
+	runEffect(this[SYMBOL_STATE]);
+}
+Effect.prototype[NAME_MORA] = NAME_EFFECT;
 /**
 * Create an effect
 *
@@ -11,10 +16,8 @@ function effect(callback) {
 	return getEffect(callback)[0];
 }
 function getEffect(callback) {
-	const state = { callback };
-	const instance = Object.freeze({ $mora: NAME_EFFECT });
-	runEffect(state);
-	return [instance, state];
+	const instance = new Effect(callback);
+	return [instance, instance[SYMBOL_STATE]];
 }
 function internalEffect(callback) {
 	return getEffect(callback)[1];

package/dist/helpers/is.d.mts

@@ -7,42 +7,47 @@ import { PlainObject } from "@oscarpalmer/atoms/models";
  * @param value Value to check
  * @returns True if value is a {@link Computed}
  */
-declare function isComputed<Value>(value: unknown): value is Computed<Value>;
+export declare function isComputed<Value = unknown>(value: unknown): value is Computed<Value>;
 /**
  * Is the value an effect?
  *
  * @param value Value to check
  * @returns True if value is an {@link Effect}
  */
-declare function isEffect(value: unknown): value is Effect;
+export declare function isEffect(value: unknown): value is Effect;
 /**
  * Is the value reactive?
  *
  * @param value Value to check
  * @returns True if value is a {@link Reactive}
  */
-declare function isReactive<Value>(value: unknown): value is Reactive<Value>;
+export declare function isReactive<Value = unknown>(value: unknown): value is Reactive<Value>;
 /**
  * Is the value a signal?
  *
  * @param value Value to check
  * @returns True if value is a {@link Signal}
  */
-declare function isSignal<Value>(value: unknown): value is Signal<Value>;
+export declare function isSignal<Value = unknown>(value: unknown): value is Signal<Value>;
 /**
  * Is the value a reactive array?
  *
  * @param value Value to check
  * @returns True if value is a {@link ReactiveArray}
  */
-declare function isReactiveArray<Item>(value: unknown): value is ReactiveArray<Item>;
+export declare function isReactiveArray<Item = unknown>(value: unknown): value is ReactiveArray<Item>;
 /**
  * Is the value a reactive store?
  *
  * @param value Value to check
  * @returns True if value is a {@link Store}
  */
-declare function isReactiveStore<Value extends PlainObject>(value: unknown): value is ReactiveStore<Value>;
-declare function isReadonlySignal<Value>(value: unknown): value is ReadonlySignal<Value>;
-//#endregion
-export { isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal };
+export declare function isReactiveStore<Value extends PlainObject = PlainObject>(value: unknown): value is ReactiveStore<Value>;
+/**
+ * Is the value a readonly signal?
+ *
+ * @param value Value to check
+ * @returns True if value is a {@link ReadonlySignal}
+ */
+export declare function isReadonlySignal<Value = unknown>(value: unknown): value is ReadonlySignal<Value>;
+//#endregion

package/dist/helpers/is.mjs

@@ -57,6 +57,12 @@ function isReactiveArray(value) {
 function isReactiveStore(value) {
 	return isMora(value, NAME_STORE);
 }
+/**
+* Is the value a readonly signal?
+*
+* @param value Value to check
+* @returns True if value is a {@link ReadonlySignal}
+*/
 function isReadonlySignal(value) {
 	return isMora(value, NAME_READONLY);
 }

package/dist/helpers/misc.d.mts

@@ -0,0 +1,4 @@
+import { ReactiveOptions, ReactiveState } from "../models.mjs";
+//#region src/helpers/misc.d.ts
+export declare function getState(value: unknown, options?: ReactiveOptions<unknown>): ReactiveState;
+//#endregion

package/dist/helpers/misc.mjs

@@ -0,0 +1,9 @@
+//#region src/helpers/misc.ts
+function getState(value, options) {
+	return {
+		value,
+		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : void 0
+	};
+}
+//#endregion
+export { getState };

package/dist/helpers/proxy.d.mts

@@ -1,11 +1,11 @@
-import { Computed, ComputedEffect, ReactiveArray, ReactiveState, ReactiveStore, SetValueInProxyParameters } from "../models.mjs";
-import { ArrayOrPlainObject, Key, PlainObject } from "@oscarpalmer/atoms/models";
+import { Computed, InternalProxy, ReactiveArray, ReactiveStore } from "../models.mjs";
+import { Key } from "@oscarpalmer/atoms/models";
 //#region src/helpers/proxy.d.ts
-declare function emityProxyValues<Value>(state: ReactiveState<Value, Value>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>): void;
-declare function emityProxyValues<Value>(state: ReactiveState<Value[], Value>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>): void;
-declare function getReactiveValueInProxy<Value, Result = Value>(array: ReactiveArray<Value>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>, index: number, isArray: true): Computed<Result>;
-declare function getReactiveValueInProxy<Value extends PlainObject>(store: ReactiveStore<Value>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>, key: Key, isArray: false): Computed<unknown>;
-declare function setProxyValue<Value, Item = Value>(array: boolean, state: ReactiveState<Value, Item>, isObject: (value: unknown) => value is Value | undefined, isProperty: (value: unknown) => boolean, setObject: (state: ReactiveState<Value, Item>, value: Value | undefined) => void, setProperty: (state: ReactiveState<Value, Item>, property: unknown, value: Item) => void, first?: unknown, second?: unknown): void;
-declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(parameters: SetValueInProxyParameters<Value, Equal>): boolean;
-//#endregion
-export { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy };
+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;
+//#endregion

package/dist/helpers/proxy.mjs

@@ -1,32 +1,84 @@
-import "../constants.mjs";
-import { emitValue } from "./value.mjs";
+import { SYMBOL_STATE } from "../constants.mjs";
+import { emitValue, getSignalValue, peekSignalValue } from "./value.mjs";
+import { startBatch, stopBatch } from "../batch.mjs";
 import { internalComputed } from "../value/computed.mjs";
+import { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/helpers/proxy.ts
-function emityProxyValues(state, mapped) {
-	const values = [...mapped.values()];
+function emitProxyValues() {
+	const state = this[SYMBOL_STATE];
+	state.mapped ??= /* @__PURE__ */ new Map();
+	const values = [...state.mapped.values()];
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) values[index][1].dirty = true;
-	emitValue(state);
+	emitValue(this);
 }
-function getReactiveValueInProxy(reactive, mapped, key, isArray) {
-	let item = mapped.get(key);
+function getReactiveValueInProxy(instance, key) {
+	const state = instance[SYMBOL_STATE];
+	state.mapped ??= /* @__PURE__ */ new Map();
+	const mapKey = String(key);
+	let item = state.mapped.get(mapKey);
 	if (item == null) {
-		item = internalComputed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
-		mapped.set(key, item);
+		item = internalComputed(() => state.isArray ? instance.get().at(key) : instance.get()[key]);
+		state.mapped.set(mapKey, item);
 	}
 	return item[0];
 }
-function setProxyValue(array, state, isObject, isProperty, setObject, setProperty, first, second) {
-	if (array && first === "length") {
+function getValueInProxy(first) {
+	if (this[SYMBOL_STATE].isArray ? typeof first === "number" : isKey(first)) return getReactiveValueInProxy(this, first).get();
+	return getSignalValue.call(this);
+}
+function isProxyObject(isArray, value) {
+	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
+}
+function peekValueInProxy(first, second) {
+	const state = this[SYMBOL_STATE];
+	let value;
+	if (state.isArray ? typeof first === "number" : isKey(first)) value = state.isArray ? state.value.at(first) : state.value[first];
+	else value = state.value;
+	return peekSignalValue.call([this, value], first === true || second === true);
+}
+function setProxyObject(state, value) {
+	if (state.isArray) {
+		state.value.splice(0, state.value.length, ...value ?? []);
+		return;
+	}
+	startBatch();
+	const actual = value ?? {};
+	const proxy = state.value;
+	const proxyKeys = Object.keys(proxy);
+	const actualKeys = Object.keys(actual);
+	let { length } = proxyKeys;
+	for (let index = 0; index < length; index += 1) {
+		const key = proxyKeys[index];
+		proxy[key] = actualKeys.includes(key) ? actual[key] : void 0;
+	}
+	length = actualKeys.length;
+	for (let index = 0; index < length; index += 1) {
+		const key = actualKeys[index];
+		if (!proxyKeys.includes(key)) proxy[key] = actual[key];
+	}
+	stopBatch();
+}
+function setProxyProperty(state, property, value) {
+	if (!state.isArray) {
+		state.value[property] = value;
+		return;
+	}
+	const actual = property < 0 ? state.value.length + property : property;
+	if (actual > -1) state.value[actual] = value;
+}
+function setProxyValue(first, second) {
+	const state = this[SYMBOL_STATE];
+	if (state.isArray && first === "length") {
 		state.value.length = second;
 		return;
 	}
-	if (isObject(first)) {
-		setObject(state, first);
+	if (isProxyObject(state.isArray, first)) {
+		setProxyObject(state, first);
 		return;
 	}
-	const property = isProperty(first);
-	if (array && property && Number.isNaN(first)) return;
+	const property = state.isArray ? typeof first === "number" : isKey(first);
+	if (state.isArray && property && Number.isNaN(first)) return;
 	let actual = property ? second : first;
 	if (typeof actual === "function") try {
 		actual = actual();
@@ -41,32 +93,36 @@ function setProxyValue(array, state, isObject, isProperty, setObject, setPropert
 		actual.then((value) => {
 			if (property && state.promises.get(first) === actual) {
 				state.promises.delete(first);
-				setProperty(state, first, value);
+				setProxyProperty(state, first, value);
 				return;
 			}
-			if (!property && isObject(value) && state.promise === actual) {
+			if (!property && isProxyObject(state.isArray, value) && state.promise === actual) {
 				state.promise = void 0;
-				setObject(state, value);
+				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;
 		});
-	} else if (property) setProperty(state, first, actual);
-	else if (isObject(actual)) setObject(state, actual);
+	} else if (property) setProxyProperty(state, first, actual);
+	else if (isProxyObject(state.isArray, actual)) setProxyObject(state, actual);
 }
-function setValueInProxy(parameters) {
-	const { isArray, length, property, state, target, value } = parameters;
-	if (isArray) {
+function setValueInProxy(instance, target, property, value) {
+	const state = instance[SYMBOL_STATE];
+	if (state.isArray) {
 		if (!(!Number.isNaN(Number(property)) || property === "length")) return Reflect.set(target, property, value);
 	}
 	const previous = Reflect.get(target, property);
-	if (!state.equal(previous, value)) {
+	if (!(state.equal ?? Object.is)(previous, value)) {
 		Reflect.set(target, property, value);
-		emitValue(state);
-		if (isArray) length?.set(target.length);
+		emitValue(instance);
+		if (state.isArray) state.length?.set(target.length);
 	}
 	return true;
 }
+function updateProxyValue(callback) {
+	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+	setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
+}
 //#endregion
-export { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy };
+export { emitProxyValues, getReactiveValueInProxy, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue };

package/dist/helpers/subscription.d.mts

@@ -0,0 +1,8 @@
+import { InternalProxy, InternalReadonly, InternalSignal, 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 subscribeToReadonly(this: InternalReadonly, subscriber: Subscriber<unknown>): Subscription;
+export declare function subscribeToSignal(this: InternalSignal, subscriber: Subscriber<unknown>, copy?: unknown): Subscription;
+//#endregion

package/dist/helpers/subscription.mjs

@@ -0,0 +1,30 @@
+import { SUBSCRIPTION_PROPERTY, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SUBSCRIPTION_TYPE_READONLY, SYMBOL_STATE } from "../constants.mjs";
+import { getFrozenValue, peekSignalValue } from "./value.mjs";
+import { getReactiveValueInProxy } from "./proxy.mjs";
+import { isKey } from "@oscarpalmer/atoms/is";
+import { subscriptions } from "@oscarpalmer/atoms/subscription";
+//#region src/helpers/subscription.ts
+function subscribeToProxy(first, second, third) {
+	if (isKey(first)) return getReactiveValueInProxy(this, first).subscribe(second, third);
+	return subscribeToSignal.call(this, first, second);
+}
+function subscribeToReactive(type, subscriber) {
+	this[SYMBOL_STATE].subscriptions ??= subscriptions({
+		keys: SUBSCRIPTION_TYPES,
+		property: SUBSCRIPTION_PROPERTY
+	});
+	const [subscription, existing] = this[SYMBOL_STATE].subscriptions.create({
+		key: type,
+		value: subscriber
+	});
+	if (!existing) subscriber(type === "frozen" ? getFrozenValue(this[SYMBOL_STATE].value) : peekSignalValue.call(this, SUBSCRIPTION_TYPES_COPY.has(type)), subscription);
+	return subscription;
+}
+function subscribeToReadonly(subscriber) {
+	return subscribeToReactive.call(this, this.frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY, subscriber);
+}
+function subscribeToSignal(subscriber, copy) {
+	return subscribeToReactive.call(this, copy === true ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL, subscriber);
+}
+//#endregion
+export { subscribeToProxy, subscribeToReadonly, subscribeToSignal };

package/dist/helpers/value.d.mts

@@ -1,8 +1,11 @@
-import { ReactiveState } from "../models.mjs";
+import { InternalSignal, ReactiveState } from "../models.mjs";
 //#region src/helpers/value.d.ts
-declare function emitValue<Value>(state: ReactiveState<Value, never>): void;
-declare function equalArrays<Value>(state: ReactiveState<Value[], Value>, first: Value[], second: Value[]): boolean;
-declare function getSimpleValue<Value>(state: ReactiveState<Value, never>): Value;
-declare function handleSimpleValue<Value>(state: ReactiveState<Value, Value>, origin: Value | (() => Value | Promise<Value>) | Promise<Value>, setValue: (state: ReactiveState<Value, Value>, value: Value) => void, onAfter?: () => void): void;
-//#endregion
-export { emitValue, equalArrays, getSimpleValue, handleSimpleValue };
+export declare function emitValue(instance: InternalSignal): void;
+export declare function equalArrays(state: ReactiveState, first: unknown[], second: unknown[]): 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;
+//#endregion

package/dist/helpers/value.mjs

@@ -1,31 +1,59 @@
-import { ACTIVE, BATCH } from "../constants.mjs";
+import { ACTIVE, BATCH, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_FROZEN, SYMBOL_STATE } from "../constants.mjs";
 import { flushHandlers } from "../batch.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/helpers/value.ts
-function emitValue(state) {
-	for (const computed of state.computeds) computed.dirty = true;
-	for (const effect of state.effects) BATCH.handlers.add(effect);
-	for (const [, subscription] of state.subscriptions) BATCH.handlers.add(subscription);
+function emitValue(instance) {
+	const state = instance[SYMBOL_STATE];
+	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) computed.dirty = true;
+	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	for (const type of SUBSCRIPTION_TYPES) {
+		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
+		if (subscriptions != null && subscriptions.size > 0) for (const [subscription, callback] of subscriptions) BATCH.handlers.set(subscription, {
+			callback,
+			instance,
+			state,
+			frozen: type === SUBSCRIPTION_TYPE_FROZEN,
+			copy: SUBSCRIPTION_TYPES_COPY.has(type)
+		});
+	}
 	if (BATCH.depth === 0) flushHandlers();
 }
 function equalArrays(state, first, second) {
-	let { length } = first;
+	const { length } = first;
 	if (length !== second.length) return false;
+	const eq = state.equal ?? Object.is;
 	let offset = 0;
 	if (length >= 100) {
 		offset = Math.round(length / 10);
 		offset = offset > 25 ? 25 : offset;
-		for (let index = 0; index < offset; index += 1) if (!state.equal(first[index], second[index])) return false;
+		for (let index = 0; index < offset; index += 1) if (!(eq(first[index], second[index]) && eq(first[length - index - 1], second[length - index - 1]))) return false;
 	}
-	length -= offset;
-	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
+	const end = length - offset;
+	for (let index = offset; index < end; index += 1) if (!eq(first[index], second[index])) return false;
 	return true;
 }
-function getSimpleValue(state) {
-	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
-	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
-	return state.value;
+function getFrozenValue(value) {
+	let frozen = value;
+	if (Array.isArray(frozen)) frozen = Object.freeze(frozen.slice());
+	else if (isPlainObject(frozen)) frozen = Object.freeze({ ...frozen });
+	return frozen;
+}
+function getSignalValue() {
+	if (ACTIVE.computed != null) {
+		this[SYMBOL_STATE].computeds ??= /* @__PURE__ */ new Set();
+		this[SYMBOL_STATE].computeds.add(ACTIVE.computed);
+	}
+	if (ACTIVE.effect != null) {
+		this[SYMBOL_STATE].effects ??= /* @__PURE__ */ new Set();
+		this[SYMBOL_STATE].effects.add(ACTIVE.effect);
+	}
+	return this[SYMBOL_STATE].value;
 }
-function handleSimpleValue(state, origin, setValue, onAfter) {
+function getStringValue(json) {
+	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
+}
+function handleSignalValue(instance, origin, setValue, onAfter) {
+	const state = instance[SYMBOL_STATE];
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
 		if (actual instanceof Promise) {
@@ -33,15 +61,26 @@ function handleSimpleValue(state, origin, setValue, onAfter) {
 			actual.then((value) => {
 				if (actual === state.promise) {
 					state.promise = void 0;
-					setValue(state, value);
+					setValue(instance, value);
 				}
 			}).catch(() => {
 				if (actual === state.promise) state.promise = void 0;
 			});
-		} else setValue(state, actual);
+		} else setValue(instance, actual);
 	} catch {} finally {
 		onAfter?.();
 	}
 }
+function peekSignalValue(copy) {
+	let peeked = Array.isArray(this) ? this[1] : this[SYMBOL_STATE].value;
+	if (copy !== true) return peeked;
+	if (Array.isArray(peeked)) peeked = peeked.slice();
+	else if (isPlainObject(peeked)) peeked = { ...peeked };
+	return peeked;
+}
+function updateSignalValue(instance, callback, setValue) {
+	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+	handleSignalValue(instance, callback(instance[SYMBOL_STATE].value), setValue);
+}
 //#endregion
-export { emitValue, equalArrays, getSimpleValue, handleSimpleValue };
+export { emitValue, equalArrays, getFrozenValue, getSignalValue, getStringValue, handleSignalValue, peekSignalValue, updateSignalValue };

package/dist/index.d.mts

@@ -1,9 +1,10 @@
 import { startBatch, stopBatch } from "./batch.mjs";
-import { Computed, Effect, ReactiveArray, ReactiveStore, ReadonlySignal, Signal, Unsubscribe } from "./models.mjs";
+import { Computed, Effect, 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";
 import { computed } from "./value/computed.mjs";
 import { signal } from "./value/signal.mjs";
 import { store } from "./value/store.mjs";
-export { type Computed, type Effect, type ReactiveArray, type ReactiveStore, type ReadonlySignal, type Signal, type Unsubscribe, array, computed, effect, isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal, signal, startBatch, stopBatch, store };
+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 };