@oscarpalmer/mora 0.34.0 → 0.35.0

package/dist/value/signal.mjs

@@ -1,28 +1,22 @@
 import { NAME_MORA, NAME_SIGNAL, SYMBOL_STATE } from "../constants.mjs";
-import { emitValue, getSignalValue, getStringValue, handleSignalValue, peekSignalValue, updateSignalValue } from "../helpers/value.mjs";
+import { emitValue, getJsonValue, getSignalValue, getStringValue, handleSignal, peekSignalValue, updateSignal } from "../helpers/value.mjs";
 import { getState } from "../helpers/misc.mjs";
 import { subscribeToSignal } from "../helpers/subscription.mjs";
-import { getReadonlyInstance } from "./readonly.mjs";
+import { getReadonlySignal } from "./readonly.mjs";
 //#region src/value/signal.ts
 function Signal(value, options) {
 	this[SYMBOL_STATE] = getState(void 0, options);
-	handleSignalValue(this, value, setAndEmit);
+	handleSignal(this, value, setAndEmit);
 }
 Signal.prototype[NAME_MORA] = NAME_SIGNAL;
-Signal.prototype.asReadonly = getReadonlyInstance;
+Signal.prototype.asReadonly = getReadonlySignal;
 Signal.prototype.get = getSignalValue;
 Signal.prototype.peek = peekSignalValue;
+Signal.prototype.set = setSignalValue;
 Signal.prototype.subscribe = subscribeToSignal;
 Signal.prototype.toString = getStringValue;
-Signal.prototype.set = function(value) {
-	return handleSignalValue(this, value, setAndEmit);
-};
-Signal.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
-Signal.prototype.update = function(callback) {
-	return updateSignalValue(this, callback, setAndEmit);
-};
+Signal.prototype.toJSON = getJsonValue;
+Signal.prototype.update = updateSignalValue;
 function setAndEmit(instance, value) {
 	const state = instance[SYMBOL_STATE];
 	if (!(state.equal ?? Object.is)(state.value, value)) {
@@ -30,8 +24,14 @@ function setAndEmit(instance, value) {
 		emitValue(instance);
 	}
 }
+function setSignalValue(value) {
+	handleSignal(this, value, setAndEmit);
+}
 function signal(value, options) {
 	return new Signal(value, options);
 }
+function updateSignalValue(callback) {
+	updateSignal(this, callback, setAndEmit);
+}
 //#endregion
 export { signal };

package/dist/value/store.mjs

@@ -1,9 +1,9 @@
 import { NAME_MORA, NAME_STORE, SYMBOL_STATE } from "../constants.mjs";
-import { getStringValue } from "../helpers/value.mjs";
+import { getJsonValue, getStringValue } from "../helpers/value.mjs";
 import { getState } from "../helpers/misc.mjs";
 import { subscribeToProxy } from "../helpers/subscription.mjs";
 import { emitProxyValues, getValueInProxy, peekValueInProxy, setProxyValue, setValueInProxy, updateProxyValue } from "../helpers/proxy.mjs";
-import { getReadonlyInstance } from "./readonly.mjs";
+import { getReadonlySignal } from "./readonly.mjs";
 //#region src/value/store.ts
 function ReactiveStore(value, options) {
 	this[SYMBOL_STATE] = {
@@ -14,17 +14,15 @@ function ReactiveStore(value, options) {
 	setProxyValue.call(this, value);
 }
 ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
-ReactiveStore.prototype.asReadonly = getReadonlyInstance;
+ReactiveStore.prototype.asReadonly = getReadonlySignal;
 ReactiveStore.prototype.get = getValueInProxy;
 ReactiveStore.prototype.notify = emitProxyValues;
 ReactiveStore.prototype.peek = peekValueInProxy;
 ReactiveStore.prototype.set = setProxyValue;
 ReactiveStore.prototype.subscribe = subscribeToProxy;
+ReactiveStore.prototype.toJSON = getJsonValue;
 ReactiveStore.prototype.toString = getStringValue;
 ReactiveStore.prototype.update = updateProxyValue;
-ReactiveStore.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
 function store(value, options) {
 	return new ReactiveStore(value, options);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/mora",
-	"version": "0.34.0",
+	"version": "0.35.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",

package/src/batch.ts

@@ -1,7 +1,7 @@
 import {BATCH} from './constants';
 import {runEffect} from './effect';
 import {getFrozenValue, peekSignalValue} from './helpers/value';
-import type {EffectState, StoredSubscription} from './models';
+import type {StoredSubscription} from './models';
 
 // #region Functions
 
@@ -30,7 +30,7 @@ export function flushHandlers(): void {
 							: peekSignalValue.call(subscription.instance, subscription.copy),
 					);
 				} else {
-					runEffect(handler as EffectState);
+					runEffect(handler);
 				}
 			}
 		}

package/src/constants.ts

@@ -16,9 +16,14 @@ export const BATCH: Batch = {
 	handlers: new Map(),
 };
 
-export const METHODS_AFFECTING_LENGTH = new Set<string>(['pop', 'push', 'shift', 'unshift']);
+export const METHODS_AFFECTING_LENGTH = new Set<string | symbol>([
+	'pop',
+	'push',
+	'shift',
+	'unshift',
+]);
 
-export const METHODS_UPDATE = new Set<string>([
+export const METHODS_UPDATE = new Set<string | symbol>([
 	...METHODS_AFFECTING_LENGTH,
 	'copyWithin',
 	'fill',

package/src/helpers/is.ts

@@ -46,9 +46,7 @@ function isMora<Instance>(value: unknown, name: string | Set<string>): value is
 		typeof value === 'object' &&
 		value != null &&
 		NAME_MORA in value &&
-		(typeof name === 'string'
-			? (value as PlainObject)[NAME_MORA] === name
-			: name.has((value as PlainObject)[NAME_MORA] as never))
+		(typeof name === 'string' ? value[NAME_MORA] === name : name.has(value[NAME_MORA] as never))
 	);
 }
 

package/src/helpers/proxy.ts

@@ -1,20 +1,19 @@
 import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
-import type {ArrayOrPlainObject, Key, PlainObject} from '@oscarpalmer/atoms/models';
+import type {
+	ArrayOrPlainObject,
+	GenericCallback,
+	Key,
+	PlainObject,
+} from '@oscarpalmer/atoms/models';
 import {startBatch, stopBatch} from '../batch';
 import {PROPERTY_LENGTH, SYMBOL_STATE} from '../constants';
-import type {
-	Computed,
-	ReactiveArray,
-	ReactiveProxyState,
-	ReactiveStore,
-	InternalProxy,
-} from '../models';
+import type {InternalArray, InternalComputed, InternalStore, ReactiveProxyState} from '../models';
 import {internalComputed} from '../value/computed';
 import {emitValue, getSignalValue, peekSignalValue} from './value';
 
 // #region Functions
 
-export function emitProxyValues(this: InternalProxy): void {
+export function emitProxyValues(this: InternalArray | InternalStore): void {
 	const state = this[SYMBOL_STATE];
 
 	state.mapped ??= new Map();
@@ -30,10 +29,10 @@ export function emitProxyValues(this: InternalProxy): void {
 }
 
 export function getReactiveValueInProxy(
-	instance: ReactiveArray<unknown> | ReactiveStore<unknown>,
+	instance: InternalArray | InternalStore,
 	key: Key,
-): Computed<unknown> {
-	const state = (instance as unknown as InternalProxy)[SYMBOL_STATE];
+): InternalComputed {
+	const state = instance[SYMBOL_STATE];
 
 	state.mapped ??= new Map();
 
@@ -54,19 +53,29 @@ export function getReactiveValueInProxy(
 	return item[0];
 }
 
-export function getValueInProxy(this: InternalProxy, first?: unknown): unknown {
+export function getValueInProxy(this: InternalArray | InternalStore, first?: unknown): unknown {
+	let signal: InternalComputed | undefined;
+
 	if (this[SYMBOL_STATE].isArray ? typeof first === 'number' : isKey(first)) {
-		return getReactiveValueInProxy(this as never, first as Key).get();
+		signal = getReactiveValueInProxy(this, first as Key);
 	}
 
-	return getSignalValue.call(this);
+	return getSignalValue.call(signal ?? this);
+}
+
+function isProxyKey(isArray: boolean, value: unknown): value is Key {
+	return isArray ? typeof value === 'number' : isKey(value);
 }
 
 function isProxyObject(isArray: boolean, value: unknown): value is ArrayOrPlainObject {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
 }
 
-export function peekValueInProxy(this: InternalProxy, first?: unknown, second?: boolean): unknown {
+export function peekValueInProxy(
+	this: InternalArray | InternalStore,
+	first?: unknown,
+	second?: boolean,
+): unknown {
 	const state = this[SYMBOL_STATE];
 
 	let value: unknown;
@@ -84,40 +93,38 @@ export function peekValueInProxy(this: InternalProxy, first?: unknown, second?:
 
 function setProxyObject(state: ReactiveProxyState, value: unknown): void {
 	if (state.isArray) {
-		(state.value as unknown[]).splice(
-			0,
-			(state.value as unknown[]).length,
-			...((value ?? []) as unknown[]),
-		);
+		const values = state.value as unknown[];
+
+		values.splice(0, values.length, ...((value ?? []) as unknown[]));
 
 		return;
 	}
 
 	startBatch();
 
-	const actual = (value as Record<string, unknown>) ?? {};
-	const proxy = state.value as PlainObject;
+	const current = state.value as PlainObject;
+	const next = (value as Record<string, unknown>) ?? {};
 
-	const proxyKeys = Object.keys(proxy);
-	const actualKeys = Object.keys(actual);
+	const currentKeys = Object.keys(current);
+	const nextKeys = Object.keys(next);
 
-	let {length} = proxyKeys;
+	let {length} = currentKeys;
 
 	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
+		const key = currentKeys[index];
 
-		proxy[key] = actualKeys.includes(key) ? actual[key] : undefined;
+		current[key] = nextKeys.includes(key) ? next[key] : undefined;
 	}
 
-	length = actualKeys.length;
+	length = nextKeys.length;
 
 	for (let index = 0; index < length; index += 1) {
-		const key = actualKeys[index];
+		const key = nextKeys[index];
 
-		if (!proxyKeys.includes(key)) {
-			const keyedValue = actual[key];
+		if (!currentKeys.includes(key)) {
+			const keyedValue = next[key];
 
-			proxy[key] = keyedValue;
+			current[key] = keyedValue;
 		}
 	}
 
@@ -131,18 +138,22 @@ function setProxyProperty(state: ReactiveProxyState, property: unknown, value: u
 		return;
 	}
 
-	const actual =
-		(property as number) < 0
-			? (state.value as unknown[]).length + (property as number)
-			: (property as number);
+	const array = state.value as unknown[];
+	const index = property as number;
+
+	const actual = index < 0 ? array.length + index : index;
 
 	if (actual > -1) {
-		(state.value as unknown[])[actual] = value;
+		array[actual] = value;
 	}
 }
 
-export function setProxyValue(this: InternalProxy, first?: unknown, second?: unknown): void {
-	const state = this[SYMBOL_STATE] as ReactiveProxyState;
+export function setProxyValue(
+	this: InternalArray | InternalStore,
+	first?: unknown,
+	second?: unknown,
+): void {
+	const state = this[SYMBOL_STATE];
 
 	if (state.isArray && first === PROPERTY_LENGTH) {
 		(state.value as unknown[]).length = second as number;
@@ -156,55 +167,55 @@ export function setProxyValue(this: InternalProxy, first?: unknown, second?: unk
 		return;
 	}
 
-	const property = state.isArray ? typeof first === 'number' : isKey(first);
+	const keyed = isProxyKey(state.isArray, first);
 
-	if (state.isArray && property && Number.isNaN(first)) {
+	if (state.isArray && keyed && Number.isNaN(first)) {
 		return;
 	}
 
-	let actual = property ? second : first;
+	let actual = keyed ? second : first;
 
 	if (typeof actual === 'function') {
 		try {
-			actual = (actual as Function)();
+			actual = (actual as GenericCallback)();
 		} catch {
 			return;
 		}
 	}
 
 	if (actual instanceof Promise) {
-		if (property) {
+		if (keyed) {
 			state.promises ??= new Map();
 
-			state.promises.set(first as Key, actual as Promise<never>);
+			state.promises.set(first, actual as Promise<never>);
 		} else {
 			state.promise = actual as Promise<never>;
 		}
 
 		void actual
 			.then(value => {
-				if (property && state.promises!.get(first as Key) === actual) {
-					state.promises!.delete(first as Key);
+				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 = undefined;
 
 					setProxyObject(state, value);
 				}
 			})
 			.catch(() => {
-				if (property && state.promises!.get(first as Key) === actual) {
-					state.promises!.delete(first as Key);
-				} else if (!property && state.promise === actual) {
+				if (keyed && state.promises?.get(first) === actual) {
+					state.promises?.delete(first);
+				} else if (!keyed && state.promise === actual) {
 					state.promise = undefined;
 				}
 			});
-	} else if (property) {
+	} else if (keyed) {
 		setProxyProperty(state, first, actual);
 	} else if (isProxyObject(state.isArray, actual)) {
 		setProxyObject(state, actual);
@@ -212,7 +223,7 @@ export function setProxyValue(this: InternalProxy, first?: unknown, second?: unk
 }
 
 export function setValueInProxy(
-	instance: InternalProxy,
+	instance: InternalArray | InternalStore,
 	target: object,
 	property: PropertyKey,
 	value: unknown,
@@ -228,9 +239,9 @@ export function setValueInProxy(
 		}
 	}
 
-	const previous = Reflect.get(target as object, property);
+	const previous = Reflect.get(target, property);
 
-	if (!(state.equal ?? Object.is)(previous as never, value as never)) {
+	if (!(state.equal ?? Object.is)(previous, value)) {
 		Reflect.set(target, property, value);
 
 		emitValue(instance);
@@ -243,7 +254,7 @@ export function setValueInProxy(
 	return true;
 }
 
-export function updateProxyValue(this: InternalProxy, callback: unknown): void {
+export function updateProxyValue(this: InternalArray | InternalStore, callback: unknown): void {
 	if (typeof callback !== 'function') {
 		throw new TypeError('Callback must be a function');
 	}

package/src/helpers/subscription.ts

@@ -12,9 +12,10 @@ import {
 	SYMBOL_STATE,
 } from '../constants';
 import type {
-	InternalProxy,
+	InternalArray,
 	InternalReadonly,
-	InternalSignal,
+	InternalStateful,
+	InternalStore,
 	Subscriber,
 	SubscriptionType,
 } from '../models';
@@ -24,20 +25,20 @@ import {getFrozenValue, peekSignalValue} from './value';
 // #region Functions
 
 export function subscribeToProxy(
-	this: InternalProxy,
+	this: InternalArray | InternalStore,
 	first: Key | Subscriber<unknown>,
 	second?: Subscriber<unknown> | boolean,
 	third?: boolean,
 ): Subscription {
 	if (isKey(first)) {
-		return getReactiveValueInProxy(this as never, first).subscribe(second as never, third as never);
+		return getReactiveValueInProxy(this, first).subscribe(second as Subscriber<unknown>, third);
 	}
 
 	return subscribeToSignal.call(this, first, second);
 }
 
 function subscribeToReactive(
-	this: InternalSignal,
+	this: InternalStateful,
 	type: SubscriptionType,
 	subscriber: Subscriber<unknown>,
 ): Subscription {
@@ -75,7 +76,7 @@ export function subscribeToReadonly(
 }
 
 export function subscribeToSignal(
-	this: InternalSignal,
+	this: InternalStateful,
 	subscriber: Subscriber<unknown>,
 	copy?: unknown,
 ): Subscription {

package/src/helpers/value.ts

@@ -6,16 +6,16 @@ import {
 	ARRAY_PEEK,
 	ARRAY_THRESHOLD,
 	BATCH,
-	SUBSCRIPTION_TYPES_COPY,
 	SUBSCRIPTION_TYPE_FROZEN,
 	SUBSCRIPTION_TYPES,
+	SUBSCRIPTION_TYPES_COPY,
 	SYMBOL_STATE,
 } from '../constants';
-import type {ReactiveState, InternalSignal} from '../models';
+import type {InternalStateful} from '../models';
 
 // #region Functions
 
-export function emitValue(instance: InternalSignal): void {
+export function emitValue(instance: InternalStateful): void {
 	const state = instance[SYMBOL_STATE];
 
 	if (state.computeds != null && state.computeds.size > 0) {
@@ -51,14 +51,18 @@ export function emitValue(instance: InternalSignal): void {
 	}
 }
 
-export function equalArrays(state: ReactiveState, first: unknown[], second: unknown[]): boolean {
+export function equalArrays(
+	first: unknown[],
+	second: unknown[],
+	equal?: (first: unknown, second: unknown) => boolean,
+): boolean {
 	const {length} = first;
 
 	if (length !== second.length) {
 		return false;
 	}
 
-	const eq = state.equal ?? Object.is;
+	const eq = equal ?? Object.is;
 
 	let offset = 0;
 
@@ -101,32 +105,38 @@ export function getFrozenValue(value: unknown): unknown {
 	return frozen;
 }
 
-export function getSignalValue(this: InternalSignal): unknown {
+export function getJsonValue(this: InternalStateful): unknown {
+	return this[SYMBOL_STATE].value;
+}
+
+export function getSignalValue(this: InternalStateful): unknown {
+	const state = this[SYMBOL_STATE];
+
 	if (ACTIVE.computed != null) {
-		this[SYMBOL_STATE].computeds ??= new Set();
+		state.computeds ??= new Set();
 
-		this[SYMBOL_STATE].computeds.add(ACTIVE.computed);
+		state.computeds.add(ACTIVE.computed);
 	}
 
 	if (ACTIVE.effect != null) {
-		this[SYMBOL_STATE].effects ??= new Set();
+		state.effects ??= new Set();
 
-		this[SYMBOL_STATE].effects.add(ACTIVE.effect);
+		state.effects.add(ACTIVE.effect);
 	}
 
-	return this[SYMBOL_STATE].value;
+	return state.value;
 }
 
-export function getStringValue(this: InternalSignal, json?: boolean): string {
+export function getStringValue(this: InternalStateful, json?: boolean): string {
 	return json === true
 		? JSON.stringify(this[SYMBOL_STATE].value)
 		: String(this[SYMBOL_STATE].value);
 }
 
-export function handleSignalValue(
-	instance: InternalSignal,
+export function handleSignal(
+	instance: InternalStateful,
 	origin: unknown,
-	setValue: (instance: InternalSignal, value: unknown) => void,
+	setValue: (instance: InternalStateful, value: unknown) => void,
 	onAfter?: () => void,
 ): void {
 	const state = instance[SYMBOL_STATE];
@@ -161,7 +171,7 @@ export function handleSignalValue(
 }
 
 export function peekSignalValue(
-	this: InternalSignal | [InternalSignal, unknown],
+	this: InternalStateful | [InternalStateful, unknown],
 	copy?: boolean,
 ): unknown {
 	let peeked: unknown = Array.isArray(this) ? this[1] : this[SYMBOL_STATE].value;
@@ -179,16 +189,16 @@ export function peekSignalValue(
 	return peeked;
 }
 
-export function updateSignalValue(
-	instance: InternalSignal,
+export function updateSignal(
+	instance: InternalStateful,
 	callback: (value: unknown) => unknown,
-	setValue: (instance: InternalSignal, value: unknown) => void,
+	setValue: (instance: InternalStateful, value: unknown) => void,
 ): void {
 	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

package/src/index.ts

@@ -13,6 +13,7 @@ export {
 export type {
 	Computed,
 	Effect,
+	Reactive,
 	ReactiveArray,
 	ReactiveStore,
 	ReadonlySignal,