@oscarpalmer/mora 0.32.0 → 0.33.0

package/dist/batch.mjs

@@ -1,6 +1,6 @@
 import { BATCH } from "./constants.mjs";
 import { runEffect } from "./effect.mjs";
-import { getFrozenValue, peekSimpleValue } from "./helpers/value.mjs";
+import { getFrozenValue, peekSignalValue } from "./helpers/value.mjs";
 //#region src/batch.ts
 function flushHandlers() {
 	if (BATCH.flushing) return;
@@ -13,7 +13,7 @@ function flushHandlers() {
 			for (let index = 0; index < length; index += 1) {
 				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));
+				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

@@ -17,6 +17,8 @@ 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;

package/dist/constants.mjs

@@ -38,6 +38,8 @@ 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
@@ -53,4 +55,4 @@ const SUBSCRIPTION_TYPES = /* @__PURE__ */ new Set([
 	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, NAME_SUBSCRIPTION, PROPERTY_LENGTH, SUBSCRIPTION_PROPERTY, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_FROZEN, SUBSCRIPTION_TYPE_ORIGINAL, SUBSCRIPTION_TYPE_READONLY };
+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,6 +1,7 @@
 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
  *

package/dist/effect.mjs

@@ -1,5 +1,10 @@
-import { ACTIVE, NAME_EFFECT, NAME_MORA } 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({ [NAME_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,7 +7,7 @@ import { PlainObject } from "@oscarpalmer/atoms/models";
  * @param value Value to check
  * @returns True if value is a {@link Computed}
  */
-export 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?
  *
@@ -21,33 +21,33 @@ export declare function isEffect(value: unknown): value is Effect;
  * @param value Value to check
  * @returns True if value is a {@link Reactive}
  */
-export 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}
  */
-export 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}
  */
-export 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}
  */
-export declare function isReactiveStore<Value extends PlainObject>(value: unknown): value is ReactiveStore<Value>;
+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>(value: unknown): value is ReadonlySignal<Value>;
+export declare function isReadonlySignal<Value = unknown>(value: unknown): value is ReadonlySignal<Value>;
 //#endregion

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,13 +1,11 @@
-import { Computed, ComputedEffect, ReactiveArray, ReactiveState, ReactiveStore, Signal } from "../models.mjs";
+import { Computed, InternalProxy, ReactiveArray, ReactiveStore } from "../models.mjs";
 import { Key } from "@oscarpalmer/atoms/models";
 //#region src/helpers/proxy.d.ts
-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;
+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,47 +1,84 @@
-import "../constants.mjs";
-import { emitValue, getSimpleValue, peekSimpleValue } 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 emitProxyValues(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) {
+function getReactiveValueInProxy(instance, key) {
+	const state = instance[SYMBOL_STATE];
+	state.mapped ??= /* @__PURE__ */ new Map();
 	const mapKey = String(key);
-	let item = mapped.get(mapKey);
+	let item = state.mapped.get(mapKey);
 	if (item == null) {
-		item = internalComputed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
-		mapped.set(mapKey, item);
+		item = internalComputed(() => state.isArray ? instance.get().at(key) : instance.get()[key]);
+		state.mapped.set(mapKey, item);
 	}
 	return item[0];
 }
-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 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(isArray, state, first, second) {
+function peekValueInProxy(first, second) {
+	const state = this[SYMBOL_STATE];
 	let value;
-	if (isArray ? typeof first === "number" : isKey(first)) value = isArray ? state.value.at(first) : state.value[first];
+	if (state.isArray ? typeof first === "number" : isKey(first)) value = state.isArray ? state.value.at(first) : state.value[first];
 	else value = state.value;
-	return peekSimpleValue(value, first === true || second === true);
+	return peekSignalValue.call([this, value], first === true || second === true);
 }
-function setProxyValue(isArray, state, setObject, setProperty, first, second) {
-	if (isArray && first === "length") {
+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 (isProxyObject(isArray, first)) {
-		setObject(state, first);
+	if (isProxyObject(state.isArray, first)) {
+		setProxyObject(state, first);
 		return;
 	}
-	const property = isArray ? typeof first === "number" : isKey(first);
-	if (isArray && 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();
@@ -56,35 +93,36 @@ function setProxyValue(isArray, state, setObject, setProperty, first, second) {
 		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 && isProxyObject(isArray, 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 (isProxyObject(isArray, actual)) setObject(state, actual);
+	} else if (property) setProxyProperty(state, first, actual);
+	else if (isProxyObject(state.isArray, actual)) setProxyObject(state, actual);
 }
-function setValueInProxy(isArray, state, target, property, value, length) {
-	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(isArray, state, setObject, setProperty, callback) {
+function updateProxyValue(callback) {
 	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	setProxyValue(isArray, state, setObject, setProperty, callback(state.value));
+	setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
 }
 //#endregion
 export { emitProxyValues, getReactiveValueInProxy, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue };

package/dist/helpers/subscription.d.mts

@@ -1,8 +1,8 @@
-import { Computed, ComputedEffect, ReactiveArray, ReactiveState, ReactiveStore, SubscriptionType } from "../models.mjs";
+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<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;
+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

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

package/dist/helpers/value.d.mts

@@ -1,10 +1,11 @@
-import { ReactiveState } from "../models.mjs";
+import { InternalSignal, ReactiveState } from "../models.mjs";
 //#region src/helpers/value.d.ts
-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 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 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;
+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,14 +1,16 @@
-import { ACTIVE, BATCH, SUBSCRIPTION_TYPES, SUBSCRIPTION_TYPES_COPY, SUBSCRIPTION_TYPE_FROZEN } 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.set(effect, effect);
+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) for (const [subscription, callback] of subscriptions) BATCH.handlers.set(subscription, {
+		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)
@@ -17,16 +19,17 @@ function emitValue(state) {
 	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 getFrozenValue(value) {
@@ -35,12 +38,22 @@ function getFrozenValue(value) {
 	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);
-	return state.value;
+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 getStringValue(json) {
+	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
 }
-function handleSimpleValue(state, origin, setValue, onAfter) {
+function handleSignalValue(instance, origin, setValue, onAfter) {
+	const state = instance[SYMBOL_STATE];
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
 		if (actual instanceof Promise) {
@@ -48,26 +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 peekSimpleValue(value, copy) {
-	let peeked = value;
-	if (!copy) return peeked;
+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 updateSimpleValue(state, callback, setValue) {
+function updateSignalValue(instance, callback, setValue) {
 	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	handleSimpleValue(state, callback(state.value), setValue);
+	handleSignalValue(instance, callback(instance[SYMBOL_STATE].value), setValue);
 }
 //#endregion
-export { emitValue, equalArrays, getFrozenValue, getSimpleValue, handleSimpleValue, peekSimpleValue, updateSimpleValue };
+export { emitValue, equalArrays, getFrozenValue, getSignalValue, getStringValue, handleSignalValue, peekSignalValue, updateSignalValue };