@oscarpalmer/mora 0.31.0 → 0.32.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, peekSimpleValue } 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) : peekSimpleValue(subscription.state.value, subscription.copy));
 				else runEffect(handler);
 			}
 		}

package/dist/constants.d.mts

@@ -1,20 +1,30 @@
-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 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,19 @@ const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_STORE
 ]);
 const PROPERTY_LENGTH = "length";
+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 };

package/dist/effect.d.mts

@@ -7,8 +7,7 @@ import { GenericCallback } from "@oscarpalmer/atoms/models";
  * @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,4 +1,4 @@
-import { ACTIVE, NAME_EFFECT } from "./constants.mjs";
+import { ACTIVE, NAME_EFFECT, NAME_MORA } from "./constants.mjs";
 //#region src/effect.ts
 /**
 * Create an effect
@@ -12,7 +12,7 @@ function effect(callback) {
 }
 function getEffect(callback) {
 	const state = { callback };
-	const instance = Object.freeze({ $mora: NAME_EFFECT });
+	const instance = Object.freeze({ [NAME_MORA]: NAME_EFFECT });
 	runEffect(state);
 	return [instance, state];
 }

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>(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>(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>(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>(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>(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>(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/proxy.d.mts

@@ -1,11 +1,13 @@
-import { Computed, ComputedEffect, ReactiveArray, ReactiveState, ReactiveStore, SetValueInProxyParameters } from "../models.mjs";
-import { ArrayOrPlainObject, Key, PlainObject } from "@oscarpalmer/atoms/models";
+import { Computed, ComputedEffect, ReactiveArray, ReactiveState, ReactiveStore, Signal } 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 };
+type SetObjectCallback<Value, Item> = (state: ReactiveState<Value, Item>, value: Value | undefined) => void;
+type SetPropertyCallback<Value, Item> = (state: ReactiveState<Value, Item>, property: unknown, value: Item) => void;
+export declare function emitProxyValues<Value, Item = Value>(state: ReactiveState<Value, Item>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>): void;
+export declare function getReactiveValueInProxy<Value>(reactive: ReactiveArray<Value> | ReactiveStore<Value>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>, key: Key, isArray: boolean): Computed<unknown>;
+export declare function getValueInProxy<Value, Item = Value>(isArray: boolean, instance: ReactiveArray<Value> | ReactiveStore<Value>, state: ReactiveState<Value, Item>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>, first?: unknown): unknown;
+export declare function peekValueInProxy<Value, Item = Value>(isArray: boolean, state: ReactiveState<Value, Item>, first?: unknown, second?: boolean): unknown;
+export declare function setProxyValue<Value, Item = Value>(isArray: boolean, state: ReactiveState<Value, Item>, setObject: SetObjectCallback<Value, Item>, setProperty: SetPropertyCallback<Value, Item>, first?: unknown, second?: unknown): void;
+export declare function setValueInProxy<Value, Item = Value>(isArray: boolean, state: ReactiveState<Value, Item>, target: object, property: PropertyKey, value: unknown, length?: Signal<number>): boolean;
+export declare function updateProxyValue<Value, Item = Value>(isArray: boolean, state: ReactiveState<Value, Item>, setObject: SetObjectCallback<Value, Item>, setProperty: SetPropertyCallback<Value, Item>, callback: unknown): void;
+//#endregion

package/dist/helpers/proxy.mjs

@@ -1,32 +1,47 @@
 import "../constants.mjs";
-import { emitValue } from "./value.mjs";
+import { emitValue, getSimpleValue, peekSimpleValue } from "./value.mjs";
 import { internalComputed } from "../value/computed.mjs";
+import { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/helpers/proxy.ts
-function emityProxyValues(state, mapped) {
+function emitProxyValues(state, mapped) {
 	const values = [...mapped.values()];
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) values[index][1].dirty = true;
 	emitValue(state);
 }
 function getReactiveValueInProxy(reactive, mapped, key, isArray) {
-	let item = mapped.get(key);
+	const mapKey = String(key);
+	let item = mapped.get(mapKey);
 	if (item == null) {
 		item = internalComputed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
-		mapped.set(key, item);
+		mapped.set(mapKey, item);
 	}
 	return item[0];
 }
-function setProxyValue(array, state, isObject, isProperty, setObject, setProperty, first, second) {
-	if (array && first === "length") {
+function getValueInProxy(isArray, instance, state, mapped, first) {
+	if (isArray ? typeof first === "number" : isKey(first)) return getReactiveValueInProxy(instance, mapped, first, isArray).get();
+	return getSimpleValue(state);
+}
+function isProxyObject(isArray, value) {
+	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
+}
+function peekValueInProxy(isArray, state, first, second) {
+	let value;
+	if (isArray ? typeof first === "number" : isKey(first)) value = isArray ? state.value.at(first) : state.value[first];
+	else value = state.value;
+	return peekSimpleValue(value, first === true || second === true);
+}
+function setProxyValue(isArray, state, setObject, setProperty, first, second) {
+	if (isArray && first === "length") {
 		state.value.length = second;
 		return;
 	}
-	if (isObject(first)) {
+	if (isProxyObject(isArray, first)) {
 		setObject(state, first);
 		return;
 	}
-	const property = isProperty(first);
-	if (array && property && Number.isNaN(first)) return;
+	const property = isArray ? typeof first === "number" : isKey(first);
+	if (isArray && property && Number.isNaN(first)) return;
 	let actual = property ? second : first;
 	if (typeof actual === "function") try {
 		actual = actual();
@@ -44,7 +59,7 @@ function setProxyValue(array, state, isObject, isProperty, setObject, setPropert
 				setProperty(state, first, value);
 				return;
 			}
-			if (!property && isObject(value) && state.promise === actual) {
+			if (!property && isProxyObject(isArray, value) && state.promise === actual) {
 				state.promise = void 0;
 				setObject(state, value);
 			}
@@ -53,10 +68,9 @@ function setProxyValue(array, state, isObject, isProperty, setObject, setPropert
 			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 (isProxyObject(isArray, actual)) setObject(state, actual);
 }
-function setValueInProxy(parameters) {
-	const { isArray, length, property, state, target, value } = parameters;
+function setValueInProxy(isArray, state, target, property, value, length) {
 	if (isArray) {
 		if (!(!Number.isNaN(Number(property)) || property === "length")) return Reflect.set(target, property, value);
 	}
@@ -68,5 +82,9 @@ function setValueInProxy(parameters) {
 	}
 	return true;
 }
+function updateProxyValue(isArray, state, setObject, setProperty, callback) {
+	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+	setProxyValue(isArray, state, setObject, setProperty, callback(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 { Computed, ComputedEffect, ReactiveArray, ReactiveState, ReactiveStore, SubscriptionType } 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<Value, Item = Value>(isArray: boolean, instance: ReactiveArray<Value> | ReactiveStore<Value>, state: ReactiveState<Value, Item>, mapped: Map<Key, [Computed<unknown>, ComputedEffect]>, first: Key | ((value: unknown) => unknown), second?: ((value: unknown) => unknown) | boolean, third?: boolean): Subscription;
+export declare function subscribeToReactive<Value, Item = Value>(type: SubscriptionType, state: ReactiveState<Value, Item>, callback: (value: unknown) => unknown): Subscription;
+export declare function subscribeToSignal<Value, Item = Value>(state: ReactiveState<Value, Item>, callback: (value: unknown) => unknown, copy: boolean): Subscription;
+//#endregion

package/dist/helpers/subscription.mjs

@@ -0,0 +1,27 @@
+import { SUBSCRIPTION_PROPERTY, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_ORIGINAL } from "../constants.mjs";
+import { getFrozenValue, peekSimpleValue } 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(isArray, instance, state, mapped, first, second, third) {
+	if (isKey(first)) return getReactiveValueInProxy(instance, mapped, first, isArray).subscribe(second, third);
+	return subscribeToSignal(state, first, second === true);
+}
+function subscribeToReactive(type, state, callback) {
+	state.subscriptions ??= subscriptions({
+		keys: SUBSCRIPTION_TYPES,
+		property: SUBSCRIPTION_PROPERTY
+	});
+	const [subscription, existing] = state.subscriptions.create({
+		key: type,
+		value: callback
+	});
+	if (!existing) callback(type === "frozen" ? getFrozenValue(state.value) : peekSimpleValue(state.value, SUBSCRIPTION_TYPES_COPY.has(type)));
+	return subscription;
+}
+function subscribeToSignal(state, callback, copy) {
+	return subscribeToReactive(copy ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL, state, callback);
+}
+//#endregion
+export { subscribeToProxy, subscribeToReactive, subscribeToSignal };

package/dist/helpers/value.d.mts

@@ -1,8 +1,10 @@
 import { 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<Value>(state: ReactiveState<Value, never>): void;
+export declare function equalArrays<Value>(state: ReactiveState<Value[], Value>, first: Value[], second: Value[]): boolean;
+export declare function getFrozenValue(value: unknown): unknown;
+export declare function getSimpleValue<Value>(state: ReactiveState<Value, never>): Value;
+export 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;
+export declare function peekSimpleValue(value: unknown, copy: boolean): unknown;
+export declare function updateSimpleValue<Value>(state: ReactiveState<Value, Value>, callback: (value: Value) => Value, setValue: (state: ReactiveState<Value, Value>, value: Value) => void): void;
+//#endregion

package/dist/helpers/value.mjs

@@ -1,10 +1,19 @@
-import { ACTIVE, BATCH } from "../constants.mjs";
+import { ACTIVE, BATCH, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_FROZEN } 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);
+	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) for (const [subscription, callback] of subscriptions) BATCH.handlers.set(subscription, {
+			callback,
+			state,
+			frozen: type === SUBSCRIPTION_TYPE_FROZEN,
+			copy: SUBSCRIPTION_TYPES_COPY.has(type)
+		});
+	}
 	if (BATCH.depth === 0) flushHandlers();
 }
 function equalArrays(state, first, second) {
@@ -20,6 +29,12 @@ function equalArrays(state, first, second) {
 	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
 	return true;
 }
+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 getSimpleValue(state) {
 	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
 	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
@@ -43,5 +58,16 @@ function handleSimpleValue(state, origin, setValue, onAfter) {
 		onAfter?.();
 	}
 }
+function peekSimpleValue(value, copy) {
+	let peeked = value;
+	if (!copy) return peeked;
+	if (Array.isArray(peeked)) peeked = peeked.slice();
+	else if (isPlainObject(peeked)) peeked = { ...peeked };
+	return peeked;
+}
+function updateSimpleValue(state, callback, setValue) {
+	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+	handleSimpleValue(state, callback(state.value), setValue);
+}
 //#endregion
-export { emitValue, equalArrays, getSimpleValue, handleSimpleValue };
+export { emitValue, equalArrays, getFrozenValue, getSimpleValue, handleSimpleValue, peekSimpleValue, updateSimpleValue };

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 };