@oscarpalmer/mora 0.21.0 → 0.23.0

package/package.json

@@ -4,39 +4,33 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.102"
+		"@oscarpalmer/atoms": "^0.114"
 	},
 	"description": "Signals and stuff…",
 	"devDependencies": {
-		"@biomejs/biome": "^1.9",
+		"@biomejs/biome": "^2.3",
 		"@rollup/plugin-node-resolve": "^16",
-		"@rollup/plugin-typescript": "^12.1",
-		"@types/node": "^24",
-		"@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",
+		"jsdom": "^27.1",
+		"rollup": "^4.52",
 		"tslib": "^2.8",
-		"typescript": "^5.8",
-		"vite": "^6.3",
-		"vitest": "^3.2"
+		"typescript": "^5.9",
+		"vite": "npm:rolldown-vite@latest",
+		"vitest": "^4"
 	},
 	"exports": {
+		"./package.json": "./package.json",
 		".": {
-			"import": {
-				"types": "./types/index.d.ts",
-				"default": "./dist/index.js"
-			},
-			"require": {
-				"types": "./types/index.d.cts",
-				"default": "./dist/index.cjs"
-			}
+			"types": "./types/index.d.ts",
+			"default": "./dist/index.js"
 		}
 	},
 	"files": ["dist", "src", "types"],
 	"keywords": ["signal", "signals", "reactive"],
 	"license": "MIT",
-	"main": "./dist/index.cjs",
 	"module": "./dist/index.js",
 	"name": "@oscarpalmer/mora",
 	"repository": {
@@ -44,15 +38,14 @@
 		"url": "git+https://github.com/oscarpalmer/mora.git"
 	},
 	"scripts": {
-		"build": "npm run clean && npm run build:js && npm run rollup && npm run types",
-		"build:js": "npx vite build",
+		"build": "npm run clean && npx vite build && npm run rollup:build && npx tsc",
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
-		"rollup": "npx rollup -c",
+		"rollup:build": "npx rollup -c",
+		"rollup:watch": "npx rollup -c --watch",
 		"test": "npx vitest --coverage",
-		"types": "npx tsc && npx dts-bundle-generator --config ./dts.config.cts --silent",
 		"watch": "npx vite build --watch"
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.21.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 {type InternalComputed, activeComputed} 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,9 +7,9 @@ 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';
 export {signal, type Signal} from './value/signal';
 export {store, type Store} from './value/store';
-

package/src/models.ts

@@ -0,0 +1,66 @@
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import type {Effect} from './effect';
+import type {Subscription} from './subscription';
+import type {Computed} from './value/computed';
+import type {Signal} from './value/signal';
+
+export type Active = {
+	computed?: Computed<unknown>;
+	effect?: Effect;
+};
+
+export type Batch = {
+	depth: number;
+	handlers: Set<Effect | Subscription>;
+};
+
+export type ComputedEffect = {
+	dirty: boolean;
+	instance: Effect;
+};
+
+export type EffectState = {
+	callback: GenericCallback;
+};
+
+export type InternalComputed = {
+	readonly effect: ComputedEffect;
+	readonly state: ReactiveState<unknown, unknown>;
+};
+
+export type InternalEffect = {
+	state: EffectState;
+};
+
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method for comparing values for equality
+	 * @param first First value
+	 * @param second Second value
+	 * @returns Are the values equal?
+	 * @default Object.is
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+
+export type ReactiveState<Value, Equal> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
+	subscriptions: Map<GenericCallback, Subscription>;
+	value: Value;
+};
+
+export type SetValueInProxyParameters<Value, Equal> = {
+	target: Value;
+	property: PropertyKey;
+	value: unknown;
+	state: ReactiveState<Value, Equal>;
+	isArray: boolean;
+	length?: Signal<number>;
+};
+
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;

package/src/subscription.ts

@@ -1,19 +1,22 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import type {ReactiveState} from './value/reactive';
+import type {ReactiveState, Unsubscribe} from './models';
 
 export class Subscription {
-	constructor(
-		public state: ReactiveState<unknown, never>,
-		public callback: GenericCallback,
-	) {
+	callback: GenericCallback;
+	state: ReactiveState<unknown, never>;
+
+	constructor(state: ReactiveState<unknown, never>, callback: GenericCallback) {
+		this.state = state;
+		this.callback = callback;
+
 		callback(state.value);
 	}
-}
 
-/**
- * Unsubscribe from changes
- */
-export type Unsubscribe = () => void;
+	destroy(): void {
+		this.callback = noop;
+		this.state = undefined as never;
+	}
+}
 
 export function noop(): void {}
 
@@ -36,12 +39,7 @@ export function unsubscribe<Value>(
 	state: ReactiveState<Value, never>,
 	callback: (value: Value) => void,
 ): void {
-	const subscription = state.subscriptions.get(callback);
+	state.subscriptions.get(callback)?.destroy();
 
 	state.subscriptions.delete(callback);
-
-	if (subscription != null) {
-		subscription.callback = noop;
-		subscription.state = undefined as never;
-	}
 }