@oscarpalmer/mora 0.22.0 → 0.24.0

package/dist/subscription.js

@@ -1,9 +1,15 @@
 var Subscription = class {
+	callback;
+	state;
 	constructor(state, callback) {
 		this.state = state;
 		this.callback = callback;
 		callback(state.value);
 	}
+	destroy() {
+		this.callback = noop;
+		this.state = void 0;
+	}
 };
 function noop() {}
 function subscribe(state, callback) {
@@ -14,11 +20,7 @@ function subscribe(state, callback) {
 	};
 }
 function unsubscribe(state, callback) {
-	const subscription = state.subscriptions.get(callback);
+	state.subscriptions.get(callback)?.destroy();
 	state.subscriptions.delete(callback);
-	if (subscription != null) {
-		subscription.callback = noop;
-		subscription.state = void 0;
-	}
 }
 export { Subscription, noop, subscribe, unsubscribe };

package/dist/value/array.js

@@ -1,9 +1,9 @@
+import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, PROPERTY_LENGTH } from "../constants.js";
 import { noop, subscribe } from "../subscription.js";
-import { arrayName } from "../helpers/is.js";
 import { Reactive } from "./reactive.js";
 import { computed } from "./computed.js";
 import { emitValue, equalArrays, getValue } from "../helpers/value.js";
-import { getReactiveValueInProxy, setValueInProxy } from "../helpers/proxy.js";
+import { emityProxyValues, getReactiveValueInProxy, setValueInProxy } from "../helpers/proxy.js";
 import { signal } from "./signal.js";
 var ReactiveArray = class extends Reactive {
 	#indiced = /* @__PURE__ */ new Map();
@@ -15,30 +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;
 	}
-	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));
 	}
+	get(first) {
+		if (typeof first === "number") return getReactiveValueInProxy(this, this.#indiced, first, true).get();
+		return first === "length" ? this.length : getValue(this.state);
+	}
 	map(callback) {
 		return computed(() => this.get().map(callback));
 	}
+	notify() {
+		emityProxyValues(this.state, this.#indiced);
+	}
 	peek(value) {
-		if (value === true) return this.#size.peek();
-		if (typeof value === "number") return this.state.value.at(value);
-		return [...this.state.value];
+		if (value === "length") return this.#size.peek();
+		return typeof value === "number" ? this.state.value.at(value) : [...this.state.value];
 	}
 	pop() {
 		return this.state.value.pop();
@@ -49,7 +57,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 +81,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 +93,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/reactive.js

@@ -1,3 +1,4 @@
+import { NAME_MORA } from "../constants.js";
 import { subscribe, unsubscribe } from "../subscription.js";
 var Reactive = class {
 	state = {
@@ -10,7 +11,7 @@ var Reactive = class {
 	constructor(name, value, options) {
 		this.state.value = value;
 		if (typeof options === "object" && typeof options.equal === "function") this.state.equal = options.equal;
-		Object.defineProperty(this, "$mora", { value: name });
+		Object.defineProperty(this, NAME_MORA, { value: name });
 	}
 	peek() {
 		return this.state.value;

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,17 +1,26 @@
+import { NAME_STORE } from "../constants.js";
 import { noop, subscribe } from "../subscription.js";
-import { storeName } from "../helpers/is.js";
 import { Reactive } from "./reactive.js";
 import { getValue } from "../helpers/value.js";
-import { getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.js";
+import { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.js";
 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);
 	}
+	notify() {
+		emityProxyValues(this.state, this.#keyed);
+	}
 	peek(key) {
 		return isKey(key) ? this.state.value[key] : { ...this.state.value };
 	}

package/package.json

@@ -4,23 +4,21 @@
 		"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",
-		"glob": "^11",
-		"jsdom": "^26.1",
-		"rollup": "^4.50",
+		"@rollup/plugin-typescript": "^12.3",
+		"@types/node": "^24.10",
+		"@vitest/coverage-istanbul": "^4",
+		"jsdom": "^27.2",
+		"rollup": "^4.53",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
 		"vite": "npm:rolldown-vite@latest",
-		"vitest": "^3.2"
+		"vitest": "^4"
 	},
 	"exports": {
 		"./package.json": "./package.json",
@@ -48,5 +46,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.22.0"
+	"version": "0.24.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,53 @@
+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_MORA = '$mora';
+
+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,
+]);
+
+export const PROPERTY_LENGTH = 'length';

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, NAME_MORA} from './constants';
+import type {EffectState, InternalEffect} from './models';
 
 export class Effect {
 	private declare readonly $mora: string;
@@ -15,8 +8,8 @@ export class Effect {
 	private declare readonly state: EffectState;
 
 	constructor(callback: GenericCallback) {
-		Object.defineProperty(this, '$mora', {
-			value: effectName,
+		Object.defineProperty(this, NAME_MORA, {
+			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,13 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_EFFECT,
+	NAME_MORA,
+	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,55 +17,69 @@ 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 {
 	return (
 		typeof value === 'object' &&
 		value != null &&
-		'$mora' in value &&
+		NAME_MORA in value &&
 		(typeof name === 'string'
-			? (value as PlainObject).$mora === name
-			: name.has((value as PlainObject).$mora as never))
+			? (value as PlainObject)[NAME_MORA] === name
+			: name.has((value as PlainObject)[NAME_MORA] as never))
 	);
 }
 
-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]);