@oscarpalmer/mora 0.24.0 → 0.26.0

package/package.json

@@ -4,20 +4,19 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.114"
+		"@oscarpalmer/atoms": "^0.124"
 	},
 	"description": "Signals and stuff…",
 	"devDependencies": {
-		"@biomejs/biome": "^2.3",
-		"@rollup/plugin-node-resolve": "^16",
-		"@rollup/plugin-typescript": "^12.3",
-		"@types/node": "^24.10",
+		"@types/node": "^25",
 		"@vitest/coverage-istanbul": "^4",
-		"jsdom": "^27.2",
-		"rollup": "^4.53",
+		"jsdom": "^27.3",
+		"oxfmt": "^0.21",
+		"oxlint": "^1.36",
+		"rolldown": "1.0.0-beta.58",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
-		"vite": "npm:rolldown-vite@latest",
+		"vite": "8.0.0-beta.5",
 		"vitest": "^4"
 	},
 	"exports": {
@@ -37,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.24.0"
+	"version": "0.26.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',
@@ -43,11 +43,6 @@ 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

@@ -3,9 +3,9 @@ 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, NAME_MORA, {
@@ -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

@@ -6,7 +6,7 @@ import {
 	NAME_MORA,
 	NAME_SIGNAL,
 	NAME_STORE,
-	NAMES,
+	NAME_ALL,
 } from '../constants';
 import type {Effect} from '../effect';
 import type {ReactiveArray} from '../value/array';
@@ -58,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);
 }
 
 /**
@@ -78,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,7 @@
-import type {
-	ArrayOrPlainObject,
-	Key,
-	PlainObject,
-} from '@oscarpalmer/atoms/models';
+import type {ArrayOrPlainObject, Key, PlainObject} from '@oscarpalmer/atoms/models';
 import {startBatch, stopBatch} from '../batch';
 import {PROPERTY_LENGTH} from '../constants';
-import type {
-	InternalComputed,
-	ReactiveState,
-	SetValueInProxyParameters,
-} from '../models';
+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';
@@ -74,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);
@@ -88,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;

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,5 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {
-	METHODS_AFFECTING_LENGTH,
-	METHODS_UPDATE,
-	NAME_ARRAY,
-	PROPERTY_LENGTH,
-} from '../constants';
+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';
@@ -29,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;
 		}
 	}
@@ -74,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));
 	}
 
@@ -111,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));
 	}
 
@@ -130,29 +117,27 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	/**
 	 * @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();
 		}
 
-		return typeof value === 'number'
-			? this.state.value.at(value)
-			: [...this.state.value];
+		return typeof value === 'number' ? this.state.value.at(value) : [...this.state.value];
 	}
 
 	/**
@@ -217,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
@@ -235,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;
@@ -281,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);
 }
 
@@ -302,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/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);
 }

package/src/value/store.ts

@@ -1,9 +1,5 @@
 import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
-import type {
-	GenericCallback,
-	Key,
-	PlainObject,
-} from '@oscarpalmer/atoms/models';
+import type {GenericCallback, Key, PlainObject} from '@oscarpalmer/atoms/models';
 import {NAME_STORE} from '../constants';
 import {
 	getReactiveValueInProxy,
@@ -11,8 +7,8 @@ import {
 	setProxyValue,
 	setValueInProxy,
 } from '../helpers/proxy';
-import {emitValue, getValue} from '../helpers/value';
-import type {InternalComputed, ReactiveOptions, Unsubscribe} from '../models';
+import {getValue} from '../helpers/value';
+import type {ReactiveOptions, Unsubscribe} from '../models';
 import {noop, subscribe} from '../subscription';
 import type {Computed} from './computed';
 import {Reactive} from './reactive';
@@ -76,23 +72,23 @@ export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
 	 * Get the value _(without reactivity)_
 	 * @returns The current value
 	 */
-	peek(): Value;
+	override peek(): Value;
 
 	/**
 	 * Get a value by key _(without reactivity)_
 	 * @param key Key of the value to get
 	 * @returns Value for the specified key, or `undefined` if it doesn't exist
 	 */
-	peek<Key extends keyof Value>(key: Key): Value[Key];
+	override peek<Key extends keyof Value>(key: Key): Value[Key];
 
 	/**
 	 * Get a value by key _(without reactivity)_
 	 * @param key Key of the value to get
 	 * @returns Value for the specified key, or `undefined` if it doesn't exist
 	 */
-	peek(key: Key): unknown;
+	override peek(key: Key): unknown;
 
-	peek(key?: unknown): unknown {
+	override peek(key?: unknown): unknown {
 		return isKey(key) ? this.state.value[key] : {...this.state.value};
 	}
 
@@ -127,7 +123,7 @@ export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
 	/**
 	 * @inheritdoc
 	 */
-	subscribe(callback: (value: Value) => void): Unsubscribe;
+	override subscribe(callback: (value: Value) => void): Unsubscribe;
 
 	/**
 	 * Subscribe to changes for a specific key
@@ -135,7 +131,7 @@ export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
 	 * @param callback Callback for changes
 	 * @returns Unsubscribe callback
 	 */
-	subscribe<Key extends keyof Value>(
+	override subscribe<Key extends keyof Value>(
 		key: Key,
 		callback: (value: Value[Key] | undefined) => void,
 	): Unsubscribe;
@@ -146,16 +142,11 @@ export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
 	 * @param callback Callback for changes
 	 * @returns Unsubscribe callback
 	 */
-	subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
+	override subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
 
-	subscribe(
-		first: Key | GenericCallback,
-		second?: GenericCallback,
-	): Unsubscribe {
+	override subscribe(first: Key | GenericCallback, second?: GenericCallback): Unsubscribe {
 		if (isKey(first) && typeof second === 'function') {
-			return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(
-				second,
-			);
+			return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(second);
 		}
 
 		return typeof first === 'function' ? subscribe(this.state, first) : noop;
@@ -177,7 +168,7 @@ export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
 /**
  * Create a reactive store
  * @param value Initial object value
- * @param options Optional reactivity options
+ * @param options Reactivity options
  * @returns Reactive store
  */
 export function store<Value extends PlainObject>(

package/types/constants.d.ts

@@ -12,5 +12,5 @@ export declare const NAME_EFFECT = "effect";
 export declare const NAME_MORA = "$mora";
 export declare const NAME_SIGNAL = "signal";
 export declare const NAME_STORE = "store";
-export declare const NAMES: Set<string>;
+export declare const NAME_ALL: Set<string>;
 export declare const PROPERTY_LENGTH = "length";

package/types/index.d.ts

@@ -1,6 +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/types/value/array.d.ts

@@ -131,7 +131,7 @@ export declare 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 declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;

package/types/value/computed.d.ts

@@ -10,5 +10,8 @@ export declare 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 declare function computed<Value>(callback: () => Value, options?: ReactiveOptions<Value>): Computed<Value>;

package/types/value/signal.d.ts

@@ -20,7 +20,7 @@ export declare 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 declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;

package/types/value/store.d.ts

@@ -88,7 +88,7 @@ export declare class Store<Value extends PlainObject> extends Reactive<Value, Va
 /**
  * Create a reactive store
  * @param value Initial object value
- * @param options Optional reactivity options
+ * @param options Reactivity options
  * @returns Reactive store
  */
 export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): Store<Value>;