@oscarpalmer/mora 0.22.0 → 0.23.0

package/dist/value/array.js

@@ -1,5 +1,5 @@
 import { noop, subscribe } from "../subscription.js";
-import { arrayName } from "../helpers/is.js";
+import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY } from "../constants.js";
 import { Reactive } from "./reactive.js";
 import { computed } from "./computed.js";
 import { emitValue, equalArrays, getValue } from "../helpers/value.js";
@@ -15,28 +15,38 @@ var ReactiveArray = class extends Reactive {
 		if (typeof value === "number" && value >= 0 && value !== this.state.value.length) this.get().length = value;
 	}
 	constructor(value, options) {
-		super(arrayName, new Proxy(value, {
-			get: (target, property) => updateMethods.has(property) ? updateArray(property, target, this.state, this.#size) : Reflect.get(target, property),
-			set: (target, property, value$1) => setValueInProxy(target, property, value$1, this.state, true, this.#size)
+		super(NAME_ARRAY, new Proxy(value, {
+			get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, this.state, this.#size) : Reflect.get(target, property),
+			set: (target, property, value$1) => setValueInProxy({
+				property,
+				target,
+				value: value$1,
+				isArray: true,
+				state: this.state,
+				length: this.#size
+			})
 		}), options);
 		this.#size.set(value.length);
 	}
 	clear() {
 		this.length = 0;
 	}
+	filter(callback) {
+		return computed(() => this.get().filter(callback));
+	}
 	get(first) {
 		if (typeof first === "number") return getReactiveValueInProxy(this, this.#indiced, first, true).get();
 		if (first === "length") return this.length;
 		return getValue(this.state);
 	}
-	filter(callback) {
-		return computed(() => this.get().filter(callback));
-	}
 	map(callback) {
 		return computed(() => this.get().map(callback));
 	}
+	notify() {
+		emitValue(this.state);
+	}
 	peek(value) {
-		if (value === true) return this.#size.peek();
+		if (value === "length") return this.#size.peek();
 		if (typeof value === "number") return this.state.value.at(value);
 		return [...this.state.value];
 	}
@@ -49,7 +59,7 @@ var ReactiveArray = class extends Reactive {
 	set(first, second) {
 		if (first == null || Array.isArray(first)) this.state.value.splice(0, this.state.value.length, ...first ?? []);
 		else if (first === "length") this.length = second;
-		else if (typeof first === "number") this.state.value[first] = second;
+		else if (typeof first === "number" && !Number.isNaN(first)) setAtIndex(this.state.value, first, second);
 	}
 	shift() {
 		return this.state.value.shift();
@@ -73,7 +83,7 @@ function array(value, options) {
 	return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 function updateArray(type, array$1, state, length) {
-	const affectsLength = lengthAffectingMethods.has(type);
+	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
 	const previousArray = affectsLength ? [] : [...array$1];
 	const previousLength = array$1.length;
 	return (...args) => {
@@ -85,18 +95,8 @@ function updateArray(type, array$1, state, length) {
 		return result;
 	};
 }
-var lengthAffectingMethods = new Set([
-	"pop",
-	"push",
-	"shift",
-	"unshift"
-]);
-var updateMethods = new Set([
-	...lengthAffectingMethods,
-	"copyWithin",
-	"fill",
-	"reverse",
-	"sort",
-	"splice"
-]);
+function setAtIndex(array$1, index, value) {
+	const actual = index < 0 ? array$1.length + index : index;
+	if (actual > -1) array$1[actual] = value;
+}
 export { ReactiveArray, array };

package/dist/value/computed.js

@@ -1,39 +1,36 @@
-import { computedName } from "../helpers/is.js";
-import { activeEffect, effect, runEffect } from "../effect.js";
-import { batchDepth, batchedHandlers } from "../batch.js";
+import { ACTIVE, BATCH, NAME_COMPUTED } from "../constants.js";
+import { effect, runEffect } from "../effect.js";
 import { Reactive } from "./reactive.js";
-let activeComputed;
 var Computed = class extends Reactive {
 	effect = {
 		dirty: true,
 		instance: void 0
 	};
 	constructor(callback, options) {
-		super(computedName, void 0, options);
+		super(NAME_COMPUTED, void 0, options);
 		this.effect.instance = effect(() => {
-			if (this.effect.dirty) {
-				const previousComputed = activeComputed;
-				activeComputed = this;
-				const value = callback();
-				activeComputed = previousComputed;
-				if (!this.state.equal(this.state.value, value)) {
-					this.state.value = value;
-					for (const computed$1 of this.state.computeds) computed$1.effect.dirty = true;
-					for (const effect$1 of this.state.effects) batchedHandlers.add(effect$1);
-					for (const [, subscription] of this.state.subscriptions) subscription.callback(value);
-				}
-				this.effect.dirty = false;
+			if (!this.effect.dirty) return;
+			const previousComputed = ACTIVE.computed;
+			ACTIVE.computed = this;
+			const value = callback();
+			ACTIVE.computed = previousComputed;
+			if (!this.state.equal(this.state.value, value)) {
+				this.state.value = value;
+				for (const computed$1 of this.state.computeds) computed$1.effect.dirty = true;
+				for (const effect$1 of this.state.effects) BATCH.handlers.add(effect$1);
+				for (const [, subscription] of this.state.subscriptions) subscription.callback(value);
 			}
+			this.effect.dirty = false;
 		});
 	}
 	get() {
-		if (activeComputed != null && this !== activeComputed) this.state.computeds.add(activeComputed);
-		if (activeEffect != null && activeEffect !== this.effect.instance) this.state.effects.add(activeEffect);
-		if (this.effect.dirty && batchDepth === 0) runEffect(this.effect.instance);
+		if (ACTIVE.computed != null && this !== ACTIVE.computed) this.state.computeds.add(ACTIVE.computed);
+		if (ACTIVE.effect != null && ACTIVE.effect !== this.effect.instance) this.state.effects.add(ACTIVE.effect);
+		if (this.effect.dirty && BATCH.depth === 0) runEffect(this.effect.instance);
 		return this.state.value;
 	}
 };
 function computed(callback, options) {
 	return new Computed(callback, options);
 }
-export { Computed, activeComputed, computed };
+export { Computed, computed };

package/dist/value/signal.js

@@ -1,9 +1,9 @@
-import { signalName } from "../helpers/is.js";
+import { NAME_SIGNAL } from "../constants.js";
 import { Reactive } from "./reactive.js";
 import { emitValue, getValue } from "../helpers/value.js";
 var Signal = class extends Reactive {
 	constructor(value, options) {
-		super(signalName, value, options);
+		super(NAME_SIGNAL, value, options);
 	}
 	get() {
 		return getValue(this.state);

package/dist/value/store.js

@@ -1,5 +1,5 @@
 import { noop, subscribe } from "../subscription.js";
-import { storeName } from "../helpers/is.js";
+import { NAME_STORE } from "../constants.js";
 import { Reactive } from "./reactive.js";
 import { getValue } from "../helpers/value.js";
 import { getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.js";
@@ -7,7 +7,13 @@ import { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
 var Store = class extends Reactive {
 	#keyed = /* @__PURE__ */ new Map();
 	constructor(value, options) {
-		super(storeName, new Proxy(value, { set: (target, property, value$1) => setValueInProxy(target, property, value$1, this.state, false) }), options);
+		super(NAME_STORE, new Proxy(value, { set: (target, property, value$1) => setValueInProxy({
+			target,
+			property,
+			value: value$1,
+			isArray: false,
+			state: this.state
+		}) }), options);
 	}
 	get(key) {
 		return isKey(key) ? getReactiveValueInProxy(this, this.#keyed, key, false).get() : getValue(this.state);

package/package.json

@@ -4,23 +4,22 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.102"
+		"@oscarpalmer/atoms": "^0.114"
 	},
 	"description": "Signals and stuff…",
 	"devDependencies": {
-		"@biomejs/biome": "^2.2",
+		"@biomejs/biome": "^2.3",
 		"@rollup/plugin-node-resolve": "^16",
-		"@rollup/plugin-typescript": "^12.1",
-		"@types/node": "^24.3",
-		"@vitest/coverage-istanbul": "^3.2",
-		"dts-bundle-generator": "^9.5",
+		"@rollup/plugin-typescript": "^12.3",
+		"@types/node": "^24.9",
+		"@vitest/coverage-istanbul": "^4",
 		"glob": "^11",
-		"jsdom": "^26.1",
-		"rollup": "^4.50",
+		"jsdom": "^27.1",
+		"rollup": "^4.52",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
 		"vite": "npm:rolldown-vite@latest",
-		"vitest": "^3.2"
+		"vitest": "^4"
 	},
 	"exports": {
 		"./package.json": "./package.json",
@@ -48,5 +47,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.22.0"
+	"version": "0.23.0"
 }

package/src/batch.ts

@@ -1,12 +1,12 @@
-import {type Effect, runEffect} from './effect';
+import {BATCH} from './constants';
+import {runEffect} from './effect';
 import {isEffect} from './helpers/is';
-import type {Subscription} from './subscription';
 
 export function flushHandlers(): void {
-	while (batchDepth === 0 && batchedHandlers.size > 0) {
-		const handlers = [...batchedHandlers];
+	while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
+		const handlers = [...BATCH.handlers];
 
-		batchedHandlers.clear();
+		BATCH.handlers.clear();
 
 		for (const handler of handlers) {
 			if (isEffect(handler)) {
@@ -19,23 +19,21 @@ export function flushHandlers(): void {
 }
 
 /**
- * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ * Start batching effects
+ * 
+ * _(Use {@link stopBatch} to flush and run batched effects)_
  */
 export function startBatch(): void {
-	batchDepth += 1;
+	BATCH.depth += 1;
 }
 
 /**
  * Stop batching effects and flush _(run)_ them
  */
 export function stopBatch(): void {
-	if (batchDepth > 0) {
-		batchDepth -= 1;
+	if (BATCH.depth > 0) {
+		BATCH.depth -= 1;
 	}
 
 	flushHandlers();
 }
-
-export const batchedHandlers = new Set<Effect | Subscription>();
-
-export let batchDepth = 0;

package/src/constants.ts

@@ -0,0 +1,49 @@
+import type {Effect} from './effect';
+import type {Active, Batch} from './models';
+import type {Subscription} from './subscription';
+
+export const ACTIVE: Active = {};
+
+export const ARRAY_THRESHOLD = 100;
+
+export const ARRAY_OFFSET = 25;
+
+export const ARRAY_PEEK = 10;
+
+export const BATCH: Batch = {
+	depth: 0,
+	handlers: new Set<Effect | Subscription>(),
+};
+
+export const METHODS_AFFECTING_LENGTH: Set<string> = new Set<string>([
+	'pop',
+	'push',
+	'shift',
+	'unshift',
+]);
+
+export const METHODS_UPDATE: Set<string> = new Set<string>([
+	...METHODS_AFFECTING_LENGTH,
+	'copyWithin',
+	'fill',
+	'reverse',
+	'sort',
+	'splice',
+]);
+
+export const NAME_ARRAY = 'array';
+
+export const NAME_COMPUTED = 'computed';
+
+export const NAME_EFFECT = 'effect';
+
+export const NAME_SIGNAL = 'signal';
+
+export const NAME_STORE = 'store';
+
+export const NAMES: Set<string> = new Set([
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_SIGNAL,
+	NAME_STORE,
+]);

package/src/effect.ts

@@ -1,13 +1,6 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {effectName} from './helpers/is';
-
-type EffectState = {
-	callback: GenericCallback;
-};
-
-type InternalEffect = {
-	state: EffectState;
-};
+import {ACTIVE, NAME_EFFECT} from './constants';
+import type {EffectState, InternalEffect} from './models';
 
 export class Effect {
 	private declare readonly $mora: string;
@@ -16,7 +9,7 @@ export class Effect {
 
 	constructor(callback: GenericCallback) {
 		Object.defineProperty(this, '$mora', {
-			value: effectName,
+			value: NAME_EFFECT,
 		});
 
 		this.state = {
@@ -28,22 +21,24 @@ export class Effect {
 }
 
 export function runEffect(effect: Effect): void {
-	const previousEffect = activeEffect;
+	const previousEffect = ACTIVE.effect;
 
-	activeEffect = effect;
+	ACTIVE.effect = effect;
 
 	try {
 		(effect as unknown as InternalEffect).state.callback();
 	} finally {
-		activeEffect = previousEffect;
+		ACTIVE.effect = previousEffect;
 	}
 }
 
 /**
  * Create an effect
+ * @param callback Callback for handling signal effects
+ * @returns Effect
  */
 export function effect(callback: GenericCallback): Effect {
-	return new Effect(callback);
+	return typeof callback === 'function'
+		? new Effect(callback)
+		: (undefined as never);
 }
-
-export let activeEffect: Effect | undefined;

package/src/helpers/is.ts

@@ -1,4 +1,12 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_EFFECT,
+	NAME_SIGNAL,
+	NAME_STORE,
+	NAMES,
+} from '../constants';
 import type {Effect} from '../effect';
 import type {ReactiveArray} from '../value/array';
 import type {Computed} from '../value/computed';
@@ -8,23 +16,29 @@ import type {Store} from '../value/store';
 
 /**
  * Is the value a reactive array?
+ * @param value Value to check
+ * @returns True if value is a {@link ReactiveArray}
  */
-export function isArray(value: unknown): value is ReactiveArray<unknown> {
-	return isMora<ReactiveArray<unknown>>(value, arrayName);
+export function isArray<Item>(value: unknown): value is ReactiveArray<Item> {
+	return isMora<ReactiveArray<Item>>(value, NAME_ARRAY);
 }
 
 /**
  * Is the value a computed signal?
+ * @param value Value to check
+ * @returns True if value is a {@link Computed}
  */
-export function isComputed(value: unknown): value is Computed<unknown> {
-	return isMora<Computed<unknown>>(value, computedName);
+export function isComputed<Value>(value: unknown): value is Computed<Value> {
+	return isMora<Computed<Value>>(value, NAME_COMPUTED);
 }
 
 /**
  * Is the value an effect?
+ * @param value Value to check
+ * @returns True if value is an {@link Effect}
  */
 export function isEffect(value: unknown): value is Effect {
-	return isMora<Effect>(value, effectName);
+	return isMora<Effect>(value, NAME_EFFECT);
 }
 
 function isMora<T>(value: unknown, name: string | Set<string>): value is T {
@@ -38,25 +52,33 @@ function isMora<T>(value: unknown, name: string | Set<string>): value is T {
 	);
 }
 
-export function isReactive(value: unknown): value is Reactive<unknown> {
-	return isMora<Reactive<unknown>>(value, reactiveNames);
+/**
+ * Is the value reactive?
+ * @param value Value to check
+ * @returns True if value is a {@link Reactive}
+ */
+export function isReactive<Value, Equal = Value>(
+	value: unknown,
+): value is Reactive<Value, Equal> {
+	return isMora<Reactive<Value, Equal>>(value, NAMES);
 }
 
 /**
  * Is the value a signal?
+ * @param value Value to check
+ * @returns True if value is a {@link Signal}
  */
-export function isSignal(value: unknown): value is Signal<unknown> {
-	return isMora<Signal<unknown>>(value, signalName);
+export function isSignal<Value>(value: unknown): value is Signal<Value> {
+	return isMora<Signal<Value>>(value, NAME_SIGNAL);
 }
 
-export function isStore(value: unknown): value is Store<PlainObject> {
-	return isMora<Reactive<unknown>>(value, storeName);
+/**
+ * Is the value a reactive store?
+ * @param value Value to check
+ * @returns True if value is a {@link Store}
+ */
+export function isStore<Value extends PlainObject>(
+	value: unknown,
+): value is Store<Value> {
+	return isMora<Store<Value>>(value, NAME_STORE);
 }
-
-export const arrayName = 'array';
-export const computedName = 'computed';
-export const effectName = 'effect';
-export const signalName = 'signal';
-export const storeName = 'store';
-
-const reactiveNames = new Set([arrayName, computedName, signalName, storeName]);

package/src/helpers/proxy.ts

@@ -4,50 +4,49 @@ import type {
 	PlainObject,
 } from '@oscarpalmer/atoms/models';
 import {startBatch, stopBatch} from '../batch';
+import type {SetValueInProxyParameters} from '../models';
 import type {ReactiveArray} from '../value/array';
 import {type Computed, computed} from '../value/computed';
-import type {ReactiveState} from '../value/reactive';
-import type {Signal} from '../value/signal';
 import type {Store} from '../value/store';
 import {emitValue} from './value';
 
 export function getReactiveValueInProxy<Value>(
-		array: ReactiveArray<Value>,
-		mapped: Map<Key, Computed<unknown>>,
-		index: number,
-		isArray: true,
-	): Computed<unknown>;
+	array: ReactiveArray<Value>,
+	mapped: Map<Key, Computed<unknown>>,
+	index: number,
+	isArray: true,
+): Computed<unknown>;
 
 export function getReactiveValueInProxy<Value extends PlainObject>(
-		store: Store<Value>,
-		mapped: Map<Key, Computed<unknown>>,
-		key: Key,
-		isArray: false,
-	): Computed<unknown>;
+	store: Store<Value>,
+	mapped: Map<Key, Computed<unknown>>,
+	key: Key,
+	isArray: false,
+): Computed<unknown>;
 
 export function getReactiveValueInProxy(
-		reactive: ReactiveArray<unknown> | Store<PlainObject>,
-		mapped: Map<Key, Computed<unknown>>,
-		key: Key,
-		isArray: boolean,
-	): Computed<unknown> {
-		let item = mapped.get(key);
-
-		if (item == null) {
-			item = computed(() => {
-				const value = reactive.get();
-
-				return isArray
-					? (value as unknown[]).at(key as number)
-					: (value as PlainObject)[key];
-			}) as Computed<unknown>;
-
-			mapped.set(key, item);
-		}
+	reactive: ReactiveArray<unknown> | Store<PlainObject>,
+	mapped: Map<Key, Computed<unknown>>,
+	key: Key,
+	isArray: boolean,
+): Computed<unknown> {
+	let item = mapped.get(key);
+
+	if (item == null) {
+		item = computed(() => {
+			const value = reactive.get();
+
+			return isArray
+				? (value as unknown[]).at(key as number)
+				: (value as PlainObject)[key];
+		}) as Computed<unknown>;
 
-		return item;
+		mapped.set(key, item);
 	}
 
+	return item;
+}
+
 export function setProxyValue(
 	proxy: ArrayOrPlainObject,
 	value: ArrayOrPlainObject,
@@ -83,18 +82,15 @@ export function setProxyValue(
 }
 
 export function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(
-	target: Value,
-	property: PropertyKey,
-	value: unknown,
-	state: ReactiveState<Value, Equal>,
-	isArray: boolean,
-	length?: Signal<number>,
+	parameters: SetValueInProxyParameters<Value, Equal>,
 ): boolean {
+	const {isArray, length, property, state, target, value} = parameters;
+
 	if (isArray) {
 		const isIndex = !Number.isNaN(Number(property));
 		const isLength = property === 'length';
 
-		if (!isIndex && !isLength) {
+		if (!(isIndex || isLength)) {
 			return Reflect.set(target, property, value);
 		}
 	}

package/src/helpers/value.ts

@@ -1,7 +1,12 @@
-import {batchDepth, batchedHandlers, flushHandlers} from '../batch';
-import {activeEffect} from '../effect';
-import {activeComputed, type InternalComputed} from '../value/computed';
-import type {ReactiveState} from '../value/reactive';
+import {flushHandlers} from '../batch';
+import {
+	ACTIVE,
+	ARRAY_OFFSET,
+	ARRAY_PEEK,
+	ARRAY_THRESHOLD,
+	BATCH,
+} from '../constants';
+import type {InternalComputed, ReactiveState} from '../models';
 
 export function emitValue<Value>(state: ReactiveState<Value, never>): void {
 	for (const computed of state.computeds) {
@@ -9,14 +14,14 @@ export function emitValue<Value>(state: ReactiveState<Value, never>): void {
 	}
 
 	for (const effect of state.effects) {
-		batchedHandlers.add(effect);
+		BATCH.handlers.add(effect);
 	}
 
 	for (const [, subscription] of state.subscriptions) {
-		batchedHandlers.add(subscription as never);
+		BATCH.handlers.add(subscription);
 	}
 
-	if (batchDepth === 0) {
+	if (BATCH.depth === 0) {
 		flushHandlers();
 	}
 }
@@ -34,9 +39,9 @@ export function equalArrays<Value>(
 
 	let offset = 0;
 
-	if (length >= 100) {
-		offset = Math.round(length / 10);
-		offset = offset > 25 ? 25 : offset;
+	if (length >= ARRAY_THRESHOLD) {
+		offset = Math.round(length / ARRAY_PEEK);
+		offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : offset;
 
 		for (let index = 0; index < offset; index += 1) {
 			if (!state.equal(first[index], second[index])) {
@@ -57,12 +62,12 @@ export function equalArrays<Value>(
 }
 
 export function getValue<Value>(state: ReactiveState<Value, never>): Value {
-	if (activeComputed != null) {
-		state.computeds.add(activeComputed);
+	if (ACTIVE.computed != null) {
+		state.computeds.add(ACTIVE.computed);
 	}
 
-	if (activeEffect != null) {
-		state.effects.add(activeEffect);
+	if (ACTIVE.effect != null) {
+		state.effects.add(ACTIVE.effect);
 	}
 
 	return state.value;

package/src/index.ts

@@ -7,6 +7,7 @@ export {
 	isReactive,
 	isSignal,
 } from './helpers/is';
+export type {Unsubscribe} from './models';
 export {array, type ReactiveArray} from './value/array';
 export {computed, type Computed} from './value/computed';
 export type {Reactive} from './value/reactive';