@oscarpalmer/mora 0.23.0 → 0.25.0

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 { 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";
-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();
@@ -36,19 +36,17 @@ var ReactiveArray = class extends Reactive {
 	}
 	get(first) {
 		if (typeof first === "number") return getReactiveValueInProxy(this, this.#indiced, first, true).get();
-		if (first === "length") return this.length;
-		return getValue(this.state);
+		return first === "length" ? this.length : getValue(this.state);
 	}
 	map(callback) {
 		return computed(() => this.get().map(callback));
 	}
 	notify() {
-		emitValue(this.state);
+		emityProxyValues(this.state, this.#indiced);
 	}
 	peek(value) {
 		if (value === "length") return this.#size.peek();
-		if (typeof value === "number") return this.state.value.at(value);
-		return [...this.state.value];
+		return typeof value === "number" ? this.state.value.at(value) : [...this.state.value];
 	}
 	pop() {
 		return this.state.value.pop();

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/store.js

@@ -1,8 +1,8 @@
-import { noop, subscribe } from "../subscription.js";
 import { NAME_STORE } from "../constants.js";
+import { noop, subscribe } from "../subscription.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();
@@ -18,6 +18,9 @@ var Store = class extends Reactive {
 	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,21 +4,19 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.114"
+		"@oscarpalmer/atoms": "^0.115"
 	},
 	"description": "Signals and stuff…",
 	"devDependencies": {
-		"@biomejs/biome": "^2.3",
-		"@rollup/plugin-node-resolve": "^16",
-		"@rollup/plugin-typescript": "^12.3",
-		"@types/node": "^24.9",
+		"@types/node": "^25",
 		"@vitest/coverage-istanbul": "^4",
-		"glob": "^11",
-		"jsdom": "^27.1",
-		"rollup": "^4.52",
+		"jsdom": "^27.3",
+		"oxfmt": "^0.18",
+		"oxlint": "^1.33",
+		"rolldown": "1.0.0-beta.55",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
-		"vite": "npm:rolldown-vite@latest",
+		"vite": "8.0.0-beta.2",
 		"vitest": "^4"
 	},
 	"exports": {
@@ -38,14 +36,14 @@
 		"url": "git+https://github.com/oscarpalmer/mora.git"
 	},
 	"scripts": {
-		"build": "npm run clean && npx vite build && npm run rollup:build && npx tsc",
+		"build": "npm run clean && npx vite build && npm run rolldown:build && npx tsc",
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
-		"rollup:build": "npx rollup -c",
-		"rollup:watch": "npx rollup -c --watch",
+		"rolldown:build": "npx rolldown -c",
+		"rolldown:watch": "npx rolldown -c --watch",
 		"test": "npx vitest --coverage",
 		"watch": "npx vite build --watch"
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.23.0"
+	"version": "0.25.0"
 }

package/src/batch.ts

@@ -20,7 +20,7 @@ export function flushHandlers(): void {
 
 /**
  * Start batching effects
- * 
+ *
  * _(Use {@link stopBatch} to flush and run batched effects)_
  */
 export function startBatch(): void {

package/src/constants.ts

@@ -15,14 +15,14 @@ export const BATCH: Batch = {
 	handlers: new Set<Effect | Subscription>(),
 };
 
-export const METHODS_AFFECTING_LENGTH: Set<string> = new Set<string>([
+export const METHODS_AFFECTING_LENGTH = new Set<string>([
 	'pop',
 	'push',
 	'shift',
 	'unshift',
 ]);
 
-export const METHODS_UPDATE: Set<string> = new Set<string>([
+export const METHODS_UPDATE = new Set<string>([
 	...METHODS_AFFECTING_LENGTH,
 	'copyWithin',
 	'fill',
@@ -37,13 +37,12 @@ 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 NAME_ALL = new Set([NAME_ARRAY, NAME_COMPUTED, NAME_SIGNAL, NAME_STORE]);
+
+export const PROPERTY_LENGTH = 'length';

package/src/effect.ts

@@ -1,14 +1,14 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {ACTIVE, NAME_EFFECT} from './constants';
+import {ACTIVE, NAME_EFFECT, NAME_MORA} from './constants';
 import type {EffectState, InternalEffect} from './models';
 
 export class Effect {
-	private declare readonly $mora: string;
+	declare private readonly $mora: string;
 
-	private declare readonly state: EffectState;
+	declare private readonly state: EffectState;
 
 	constructor(callback: GenericCallback) {
-		Object.defineProperty(this, '$mora', {
+		Object.defineProperty(this, NAME_MORA, {
 			value: NAME_EFFECT,
 		});
 
@@ -38,7 +38,5 @@ export function runEffect(effect: Effect): void {
  * @returns Effect
  */
 export function effect(callback: GenericCallback): Effect {
-	return typeof callback === 'function'
-		? new Effect(callback)
-		: (undefined as never);
+	return typeof callback === 'function' ? new Effect(callback) : (undefined as never);
 }

package/src/helpers/is.ts

@@ -3,9 +3,10 @@ import {
 	NAME_ARRAY,
 	NAME_COMPUTED,
 	NAME_EFFECT,
+	NAME_MORA,
 	NAME_SIGNAL,
 	NAME_STORE,
-	NAMES,
+	NAME_ALL,
 } from '../constants';
 import type {Effect} from '../effect';
 import type {ReactiveArray} from '../value/array';
@@ -45,10 +46,10 @@ 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))
 	);
 }
 
@@ -57,10 +58,8 @@ function isMora<T>(value: unknown, name: string | Set<string>): value is T {
  * @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);
+export function isReactive<Value, Equal = Value>(value: unknown): value is Reactive<Value, Equal> {
+	return isMora<Reactive<Value, Equal>>(value, NAME_ALL);
 }
 
 /**
@@ -77,8 +76,6 @@ export function isSignal<Value>(value: unknown): value is Signal<Value> {
  * @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> {
+export function isStore<Value extends PlainObject>(value: unknown): value is Store<Value> {
 	return isMora<Store<Value>>(value, NAME_STORE);
 }

package/src/helpers/proxy.ts

@@ -1,15 +1,36 @@
-import type {
-	ArrayOrPlainObject,
-	Key,
-	PlainObject,
-} from '@oscarpalmer/atoms/models';
+import type {ArrayOrPlainObject, Key, PlainObject} from '@oscarpalmer/atoms/models';
 import {startBatch, stopBatch} from '../batch';
-import type {SetValueInProxyParameters} from '../models';
+import {PROPERTY_LENGTH} from '../constants';
+import type {InternalComputed, ReactiveState, SetValueInProxyParameters} from '../models';
 import type {ReactiveArray} from '../value/array';
 import {type Computed, computed} from '../value/computed';
 import type {Store} from '../value/store';
 import {emitValue} from './value';
 
+export function emityProxyValues<Value>(
+	state: ReactiveState<Value, Value>,
+	mapped: Map<Key, Computed<unknown>>,
+): void;
+
+export function emityProxyValues<Value>(
+	state: ReactiveState<Value[], Value>,
+	mapped: Map<Key, Computed<unknown>>,
+): void;
+
+export function emityProxyValues(
+	state: ReactiveState<unknown, unknown>,
+	mapped: Map<Key, Computed<unknown>>,
+): void {
+	const values = [...mapped.values()];
+	const {length} = values;
+
+	for (let index = 0; index < length; index += 1) {
+		(values[index] as unknown as InternalComputed).effect.dirty = true;
+	}
+
+	emitValue(state);
+}
+
 export function getReactiveValueInProxy<Value>(
 	array: ReactiveArray<Value>,
 	mapped: Map<Key, Computed<unknown>>,
@@ -33,13 +54,11 @@ export function getReactiveValueInProxy(
 	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>;
+		item = computed(() =>
+			isArray
+				? (reactive.get() as unknown[]).at(key as number)
+				: (reactive.get() as PlainObject)[key],
+		) as Computed<unknown>;
 
 		mapped.set(key, item);
 	}
@@ -47,10 +66,7 @@ export function getReactiveValueInProxy(
 	return item;
 }
 
-export function setProxyValue(
-	proxy: ArrayOrPlainObject,
-	value: ArrayOrPlainObject,
-): void {
+export function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void {
 	startBatch();
 
 	const proxyKeys = Object.keys(proxy);
@@ -61,9 +77,7 @@ export function setProxyValue(
 	for (let index = 0; index < length; index += 1) {
 		const key = proxyKeys[index];
 
-		(proxy as PlainObject)[key] = valueKeys.includes(key)
-			? (value as PlainObject)[key]
-			: undefined;
+		(proxy as PlainObject)[key] = valueKeys.includes(key) ? (value as PlainObject)[key] : undefined;
 	}
 
 	length = valueKeys.length;
@@ -88,7 +102,7 @@ export function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(
 
 	if (isArray) {
 		const isIndex = !Number.isNaN(Number(property));
-		const isLength = property === 'length';
+		const isLength = property === PROPERTY_LENGTH;
 
 		if (!(isIndex || isLength)) {
 			return Reflect.set(target, property, value);

package/src/helpers/value.ts

@@ -1,11 +1,5 @@
 import {flushHandlers} from '../batch';
-import {
-	ACTIVE,
-	ARRAY_OFFSET,
-	ARRAY_PEEK,
-	ARRAY_THRESHOLD,
-	BATCH,
-} from '../constants';
+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 {

package/src/index.ts

@@ -1,12 +1,6 @@
 export {startBatch, stopBatch} from './batch';
 export {effect, type Effect} from './effect';
-export {
-	isArray,
-	isComputed,
-	isEffect,
-	isReactive,
-	isSignal,
-} from './helpers/is';
+export {isArray, isComputed, isEffect, isReactive, isSignal} from './helpers/is';
 export type {Unsubscribe} from './models';
 export {array, type ReactiveArray} from './value/array';
 export {computed, type Computed} from './value/computed';

package/src/value/array.ts

@@ -1,10 +1,6 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {
-	METHODS_AFFECTING_LENGTH,
-	METHODS_UPDATE,
-	NAME_ARRAY,
-} from '../constants';
-import {getReactiveValueInProxy, setValueInProxy} from '../helpers/proxy';
+import {METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY, PROPERTY_LENGTH} from '../constants';
+import {emityProxyValues, getReactiveValueInProxy, setValueInProxy} from '../helpers/proxy';
 import {emitValue, equalArrays, getValue} from '../helpers/value';
 import type {ReactiveOptions, ReactiveState, Unsubscribe} from '../models';
 import {noop, subscribe} from '../subscription';
@@ -28,11 +24,7 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * Set the length of the array
 	 */
 	set length(value: number) {
-		if (
-			typeof value === 'number' &&
-			value >= 0 &&
-			value !== this.state.value.length
-		) {
+		if (typeof value === 'number' && value >= 0 && value !== this.state.value.length) {
 			this.get().length = value;
 		}
 	}
@@ -73,9 +65,7 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * @param callback Callback to evaluate each item
 	 * @return Computed array of filtered items
 	 */
-	filter(
-		callback: (item: Item, index: number, array: Item[]) => boolean,
-	): Computed<Item[]> {
+	filter(callback: (item: Item, index: number, array: Item[]) => boolean): Computed<Item[]> {
 		return computed(() => this.get().filter(callback));
 	}
 
@@ -102,11 +92,7 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 			return getReactiveValueInProxy(this, this.#indiced, first, true).get();
 		}
 
-		if (first === 'length') {
-			return this.length;
-		}
-
-		return getValue(this.state);
+		return first === PROPERTY_LENGTH ? this.length : getValue(this.state);
 	}
 
 	/**
@@ -114,9 +100,7 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * @param callback Callback to transform each item
 	 * @return Computed array of mapped items
 	 */
-	map<Mapped>(
-		callback: (item: Item, index: number, array: Item[]) => Mapped,
-	): Computed<Mapped[]> {
+	map<Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped): Computed<Mapped[]> {
 		return computed(() => this.get().map(callback));
 	}
 
@@ -127,37 +111,33 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * Use this only if you're modifying nested data that would be ignored by equality checks._
 	 */
 	notify(): void {
-		emitValue(this.state);
+		emityProxyValues(this.state, this.#indiced);
 	}
 
 	/**
 	 * @inheritdoc
 	 */
-	peek(): Item[];
+	override peek(): Item[];
 
 	/**
 	 * Get the value at an index _(without reactivity)_
 	 * @param index Index of item to get _(if negative, starts from the end)_
 	 * @returns Item at index, or `undefined` if it doesn't exist
 	 */
-	peek(index: number): Item | undefined;
+	override peek(index: number): Item | undefined;
 
 	/**
 	 * Get the length of the array _(without reactivity)_
 	 * @returns Length of the array
 	 */
-	peek(property: 'length'): number;
+	override peek(property: 'length'): number;
 
-	peek(value?: unknown): unknown {
+	override peek(value?: unknown): unknown {
 		if (value === 'length') {
 			return this.#size.peek();
 		}
 
-		if (typeof value === 'number') {
-			return this.state.value.at(value);
-		}
-
-		return [...this.state.value];
+		return typeof value === 'number' ? this.state.value.at(value) : [...this.state.value];
 	}
 
 	/**
@@ -222,17 +202,13 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * @returns Removed items
 	 */
 	splice(from: number, to?: number, ...items: Item[]): Item[] {
-		return this.state.value.splice(
-			from,
-			to ?? this.state.value.length,
-			...items,
-		);
+		return this.state.value.splice(from, to ?? this.state.value.length, ...items);
 	}
 
 	/**
 	 * @inheritdoc
 	 */
-	subscribe(callback: (value: Item[]) => void): Unsubscribe;
+	override subscribe(callback: (value: Item[]) => void): Unsubscribe;
 
 	/**
 	 * Subscribe to changes at a specific index
@@ -240,22 +216,11 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * @param callback Callback for changes
 	 * @returns Unsubscribe callback
 	 */
-	subscribe(
-		index: number,
-		callback: (value: Item | undefined) => void,
-	): Unsubscribe;
-
-	subscribe(
-		first: number | GenericCallback,
-		second?: GenericCallback,
-	): Unsubscribe {
+	override subscribe(index: number, callback: (value: Item | undefined) => void): Unsubscribe;
+
+	override subscribe(first: number | GenericCallback, second?: GenericCallback): Unsubscribe {
 		if (typeof first === 'number' && typeof second === 'function') {
-			return getReactiveValueInProxy(
-				this,
-				this.#indiced,
-				first,
-				true,
-			).subscribe(second);
+			return getReactiveValueInProxy(this, this.#indiced, first, true).subscribe(second);
 		}
 
 		return typeof first === 'function' ? subscribe(this.state, first) : noop;
@@ -286,13 +251,10 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 /**
  * Create a reactive array
  * @param value Initial array of items
- * @param options Optional reactivity options
+ * @param options Reactivity options
  * @returns Reactive array
  */
-export function array<Item>(
-	value: Item[],
-	options?: ReactiveOptions<Item>,
-): ReactiveArray<Item> {
+export function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item> {
 	return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 
@@ -307,14 +269,10 @@ function updateArray<Item>(
 	const previousLength = array.length;
 
 	return (...args: unknown[]): unknown => {
-		const result = (array[type as never] as (...args: unknown[]) => unknown)(
-			...args,
-		);
+		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(state, previousArray, array)
 		) {
 			emitValue(state);
 

package/src/value/computed.ts

@@ -67,6 +67,9 @@ export class Computed<Value> extends Reactive<Value> {
 
 /**
  * Create a computed value
+ * @param callback Callback to compute the value
+ * @param options Reactivity options
+ * @returns Computed value
  */
 export function computed<Value>(
 	callback: () => Value,

package/src/value/reactive.ts

@@ -1,3 +1,4 @@
+import {NAME_MORA} from '../constants';
 import type {ReactiveOptions, ReactiveState, Unsubscribe} from '../models';
 import {subscribe, unsubscribe} from '../subscription';
 
@@ -17,7 +18,7 @@ export abstract class Reactive<Value, Equal = Value> {
 			this.state.equal = options.equal;
 		}
 
-		Object.defineProperty(this, '$mora', {
+		Object.defineProperty(this, NAME_MORA, {
 			value: name,
 		});
 	}

package/src/value/signal.ts

@@ -39,12 +39,9 @@ export class Signal<Value> extends Reactive<Value> {
 /**
  * Create a reactive value
  * @param value Initial value
- * @param options Optional reactivity options
+ * @param options Reactivity options
  * @returns Reactive value
  */
-export function signal<Value>(
-	value: Value,
-	options?: ReactiveOptions<Value>,
-): Signal<Value> {
+export function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value> {
 	return new Signal<Value>(value, options);
 }