@oscarpalmer/mora 0.33.0 → 0.35.0

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,

package/src/models.ts

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

package/src/value/array.ts

@@ -18,10 +18,10 @@ import {
 	updateProxyValue,
 } from '../helpers/proxy';
 import {subscribeToProxy} from '../helpers/subscription';
-import {emitValue, equalArrays, getStringValue} from '../helpers/value';
-import type {InternalProxy, ReactiveArray, ReactiveOptions, ReactiveState} from '../models';
+import {emitValue, equalArrays, getJsonValue, getStringValue} from '../helpers/value';
+import type {Computed, InternalArray, ReactiveArray, ReactiveOptions} from '../models';
 import {computed} from './computed';
-import {getReadonlyInstance} from './readonly';
+import {getReadonlySignal} from './readonly';
 import {signal} from './signal';
 
 // #region Instance
@@ -35,73 +35,43 @@ function ReactiveArray(this: any, value: unknown, options?: ReactiveOptions<unkn
 
 	this[SYMBOL_STATE].value = new Proxy([], {
 		get: (target, property) =>
-			METHODS_UPDATE.has(property as string)
-				? updateArray(this, property as string, target)
+			METHODS_UPDATE.has(property)
+				? updateArray(this, property, target)
 				: Reflect.get(target, property),
 		set: (target, property, value) => setValueInProxy(this, target, property, value),
 	});
 
-	Object.defineProperty(this, PROPERTY_LENGTH, {
-		enumerable: true,
-		get: () => this[SYMBOL_STATE].length.get(),
-		set: (value: number) => setArrayLength(this[SYMBOL_STATE], value),
-	});
-
 	setProxyValue.call(this, value);
 }
 
 ReactiveArray.prototype[NAME_MORA] = NAME_ARRAY;
 
-ReactiveArray.prototype.asReadonly = getReadonlyInstance;
+Object.defineProperty(ReactiveArray.prototype, PROPERTY_LENGTH, {
+	enumerable: true,
+	get: getArrayLength,
+	set: setArrayLength,
+});
+
+ReactiveArray.prototype.asReadonly = getReadonlySignal;
 ReactiveArray.prototype.at = getArrayValues;
+ReactiveArray.prototype.clear = clearArrayValues;
+ReactiveArray.prototype.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
+ReactiveArray.prototype.map = mapArrayValues;
 ReactiveArray.prototype.notify = emitProxyValues;
 ReactiveArray.prototype.peek = peekArrayValue;
+ReactiveArray.prototype.pop = popArrayValue;
+ReactiveArray.prototype.push = pushArrayValues;
+ReactiveArray.prototype.select = selectArrayValues;
+ReactiveArray.prototype.shift = shiftArrayValue;
 ReactiveArray.prototype.set = setProxyValue;
+ReactiveArray.prototype.splice = spliceArrayValues;
 ReactiveArray.prototype.subscribe = subscribeToProxy;
 ReactiveArray.prototype.toString = getStringValue;
+ReactiveArray.prototype.toJSON = getJsonValue;
+ReactiveArray.prototype.unshift = unshiftArrayValues;
 ReactiveArray.prototype.update = updateProxyValue;
 
-ReactiveArray.prototype.clear = function () {
-	this[SYMBOL_STATE].value.length = 0;
-};
-
-ReactiveArray.prototype.filter = function (callback: never) {
-	return computed(() => filter(getArrayValues.call(this) as never, callback) as never);
-};
-
-ReactiveArray.prototype.map = function (callback: never) {
-	return computed(() => (getArrayValues.call(this) as unknown[]).map(callback));
-};
-
-ReactiveArray.prototype.pop = function () {
-	return this[SYMBOL_STATE].value.pop();
-};
-
-ReactiveArray.prototype.push = function (...items: unknown[]) {
-	return this[SYMBOL_STATE].value.push(...items);
-};
-
-ReactiveArray.prototype.select = function (filter: never, map: never) {
-	return computed(() => select(getArrayValues.call(this) as unknown[], filter, map));
-};
-
-ReactiveArray.prototype.shift = function () {
-	return this[SYMBOL_STATE].value.shift();
-};
-
-ReactiveArray.prototype.splice = function (from: never, to?: never, ...items: unknown[]) {
-	return this[SYMBOL_STATE].value.splice(from, to ?? this[SYMBOL_STATE].value.length, ...items);
-};
-
-ReactiveArray.prototype.toJSON = function () {
-	return this[SYMBOL_STATE].value;
-};
-
-ReactiveArray.prototype.unshift = function (...items: unknown[]) {
-	return this[SYMBOL_STATE].value.unshift(...items);
-};
-
 // #endregion
 
 // #region Functions
@@ -144,30 +114,75 @@ export function array(value: unknown, options?: ReactiveOptions<unknown>): React
 	return new ReactiveArray(value, options);
 }
 
-function getArrayValues(this: InternalProxy, value?: unknown): unknown {
+function clearArrayValues(this: InternalArray): void {
+	(this[SYMBOL_STATE].value as unknown[]).length = 0;
+}
+
+function filterArrayValues(this: InternalArray, callback: never): Computed<unknown[]> {
+	return computed(() => filter(getArrayValues.call(this) as never, callback) as never);
+}
+
+function getArrayLength(this: InternalArray): number {
+	return this[SYMBOL_STATE].length!.get();
+}
+
+function getArrayValues(this: InternalArray, value?: unknown): unknown {
 	return value === PROPERTY_LENGTH
 		? this[SYMBOL_STATE].length!.get()
 		: getValueInProxy.call(this, value);
 }
 
-function peekArrayValue(this: InternalProxy, first?: unknown, second?: boolean): unknown {
+function mapArrayValues(this: InternalArray, callback: never): Computed<unknown[]> {
+	return computed(() => (getArrayValues.call(this) as unknown[]).map(callback));
+}
+
+function peekArrayValue(this: InternalArray, first?: unknown, second?: boolean): unknown {
 	return first === PROPERTY_LENGTH
 		? this[SYMBOL_STATE].length!.peek()
 		: peekValueInProxy.call(this, first, second);
 }
 
-function setArrayLength(state: ReactiveState, value: number): void {
-	if (
-		typeof value === 'number' &&
-		!Number.isNaN(value) &&
-		value >= 0 &&
-		value !== (state.value as unknown[]).length
-	) {
-		(state.value as unknown[]).length = value;
+function popArrayValue(this: InternalArray): unknown {
+	return (this[SYMBOL_STATE].value as unknown[]).pop();
+}
+
+function pushArrayValues(this: InternalArray, ...items: unknown[]): number {
+	return (this[SYMBOL_STATE].value as unknown[]).push(...items);
+}
+
+function selectArrayValues(this: InternalArray, filter: never, map: never): Computed<unknown[]> {
+	return computed(() => select(getArrayValues.call(this) as unknown[], filter, map));
+}
+
+function setArrayLength(this: InternalArray, value: number): void {
+	const state = this[SYMBOL_STATE];
+	const values = state.value as unknown[];
+
+	if (typeof value === 'number' && !Number.isNaN(value) && value >= 0 && value !== values.length) {
+		values.length = value;
 	}
 }
 
-function updateArray(instance: InternalProxy, type: string, array: unknown[]): unknown {
+function shiftArrayValue(this: InternalArray): unknown {
+	return (this[SYMBOL_STATE].value as unknown[]).shift();
+}
+
+function spliceArrayValues(
+	this: InternalArray,
+	from: never,
+	to?: never,
+	...items: unknown[]
+): unknown[] {
+	const values = this[SYMBOL_STATE].value as unknown[];
+
+	return values.splice(from, to ?? values.length, ...items);
+}
+
+function unshiftArrayValues(this: InternalArray, ...items: unknown[]): number {
+	return (this[SYMBOL_STATE].value as unknown[]).unshift(...items);
+}
+
+function updateArray(instance: InternalArray, type: string | symbol, array: unknown[]): unknown {
 	const state = instance[SYMBOL_STATE];
 
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
@@ -178,7 +193,9 @@ function updateArray(instance: InternalProxy, type: string, array: unknown[]): u
 		const result = (array[type as never] as (...args: unknown[]) => unknown)(...args);
 
 		if (
-			affectsLength ? array.length !== previousLength : !equalArrays(state, previousArray, array)
+			affectsLength
+				? array.length !== previousLength
+				: !equalArrays(previousArray, array, state.equal)
 		) {
 			emitValue(instance);
 

package/src/value/computed.ts

@@ -14,20 +14,19 @@ import {
 import {internalEffect, runEffect} from '../effect';
 import {getState} from '../helpers/misc';
 import {subscribeToSignal} from '../helpers/subscription';
-import {getStringValue, handleSignalValue, peekSignalValue} from '../helpers/value';
+import {getJsonValue, getStringValue, handleSignal, peekSignalValue} from '../helpers/value';
 import type {
 	Computed,
 	ComputedEffect,
-	ReactiveOptions,
 	InternalComputed,
-	InternalSignal,
+	InternalStateful,
+	ReactiveOptions,
 } from '../models';
 
 // #region Instance
 
 function Computed(this: any, callback: GenericCallback, options?: ReactiveOptions<unknown>) {
 	this[SYMBOL_STATE] = getState(undefined, options);
-
 	this[SYMBOL_EFFECT] = getComputedEffect(this, callback);
 }
 
@@ -36,12 +35,9 @@ Computed.prototype[NAME_MORA] = NAME_COMPUTED;
 Computed.prototype.get = getComputedValue;
 Computed.prototype.peek = peekSignalValue;
 Computed.prototype.subscribe = subscribeToSignal;
+Computed.prototype.toJSON = getJsonValue;
 Computed.prototype.toString = getStringValue;
 
-Computed.prototype.toJSON = function () {
-	return this[SYMBOL_STATE].value;
-};
-
 // #endregion
 
 // #region Functions
@@ -57,13 +53,13 @@ export function computed<Value>(
 	callback: () => Value | Promise<Value>,
 	options?: ReactiveOptions<Value>,
 ): Computed<Value> {
-	return getComputed(callback, options)[0];
+	return getComputed(callback, options)[0] as Computed<Value>;
 }
 
 function getComputed<Value>(
 	callback: GenericCallback,
 	options?: ReactiveOptions<Value>,
-): [Computed<Value>, ComputedEffect] {
+): [InternalComputed, ComputedEffect] {
 	if (typeof callback !== 'function') {
 		throw new TypeError('Computed callback must be a function');
 	}
@@ -71,11 +67,11 @@ function getComputed<Value>(
 	// @ts-expect-error All good, no worries :-)
 	const instance = new Computed(callback, options);
 
-	return [instance as never, instance[SYMBOL_EFFECT]];
+	return [instance, instance[SYMBOL_EFFECT]];
 }
 
 function getComputedEffect(
-	instance: InternalSignal,
+	instance: InternalStateful,
 	callback: GenericAsyncCallback,
 ): ComputedEffect {
 	const fx: ComputedEffect = {
@@ -89,7 +85,7 @@ function getComputedEffect(
 
 			ACTIVE.computed = fx;
 
-			handleSignalValue(instance, callback, setAndEmit, () => {
+			handleSignal(instance, callback, setAndEmit, () => {
 				ACTIVE.computed = previousComputed;
 			});
 
@@ -126,14 +122,14 @@ function getComputedValue(this: InternalComputed): unknown {
 export function internalComputed(
 	callback: GenericCallback,
 	options?: ReactiveOptions<unknown>,
-): [Computed<unknown>, ComputedEffect] {
+): [InternalComputed, ComputedEffect] {
 	return getComputed(callback, options);
 }
 
-function setAndEmit(instance: InternalSignal, value: unknown): void {
+function setAndEmit(instance: InternalStateful, value: unknown): void {
 	const state = instance[SYMBOL_STATE];
 
-	if ((state.equal ?? Object.is)(state.value as never, value as never)) {
+	if ((state.equal ?? Object.is)(state.value, value)) {
 		return;
 	}