@oscarpalmer/mora 0.28.0 → 0.30.0

package/dist/value/reactive.mjs

@@ -1,55 +1,16 @@
-import { NAME_MORA } from "../constants.mjs";
-import { subscribe, unsubscribe } from "../subscription.mjs";
 //#region src/value/reactive.ts
-var Reactive = class {
-	state = {
+function reactive(value, options) {
+	const state = {
 		computeds: /* @__PURE__ */ new Set(),
 		effects: /* @__PURE__ */ new Set(),
-		equal: Object.is,
+		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : Object.is,
 		subscriptions: /* @__PURE__ */ new Map(),
-		value: void 0
+		value
 	};
-	constructor(name, value, options) {
-		this.state.value = value;
-		if (typeof options === "object" && typeof options.equal === "function") this.state.equal = options.equal;
-		Object.defineProperty(this, NAME_MORA, { value: name });
-	}
-	/**
-	* Get the value _(without reactivity)_
-	* @return Current value
-	*/
-	peek() {
-		return this.state.value;
-	}
-	/**
-	* Subscribe to changes
-	* @param callback Callback for changes
-	* @return Unsubscribe callback
-	*/
-	subscribe(callback) {
-		return subscribe(this.state, callback);
-	}
-	/**
-	* JSON representation of the value
-	* @return JSON value
-	*/
-	toJSON() {
-		return this.get();
-	}
-	/**
-	* String representation of the value
-	* @return Value as string
-	*/
-	toString() {
-		return String(this.get());
-	}
-	/**
-	* Unsubscribe from changes
-	* @param callback Callback to unsubscribe
-	*/
-	unsubscribe(callback) {
-		unsubscribe(this.state, callback);
-	}
-};
+	return [{
+		toJSON: () => state.value,
+		toString: () => String(state.value)
+	}, state];
+}
 //#endregion
-export { Reactive };
+export { reactive };

package/dist/value/signal.d.mts

@@ -1,26 +1,8 @@
-import { Reactive } from "./reactive.mjs";
-import { ReactiveOptions } from "../models.mjs";
-
+import { ReactiveOptions, Signal } from "../models.mjs";
 //#region src/value/signal.d.ts
-declare class Signal<Value> extends Reactive<Value> {
-  constructor(value: Value, options?: ReactiveOptions<Value>);
-  /**
-   * @inheritdoc
-   */
-  get(): Value;
-  /**
-   * Set the value
-   * @param value New value
-   */
-  set(value: Value | (() => Value | Promise<Value>) | Promise<Value>): void;
-  /**
-   * Update the value _(based on the current value)_
-   * @param callback Callback to update the value
-   */
-  update(callback: (value: Value) => Value): void;
-}
 /**
  * Create a reactive value from a function result
+ *
  * @param value Initial value
  * @param options Reactivity options
  * @returns Reactive value
@@ -28,6 +10,7 @@ declare class Signal<Value> extends Reactive<Value> {
 declare function signal<Value>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
 /**
  * Create a reactive value from a promise
+ *
  * @param value Initial value
  * @param options Reactivity options
  * @returns Reactive value
@@ -35,10 +18,11 @@ declare function signal<Value>(value: () => Value | Promise<Value>, options?: Re
 declare function signal<Value>(value: Promise<Value>, options?: ReactiveOptions<Value>): Signal<Value>;
 /**
  * Create a reactive value
+ *
  * @param value Initial value
  * @param options Reactivity options
  * @returns Reactive value
  */
 declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
 //#endregion
-export { Signal, signal };
+export { signal };

package/dist/value/signal.mjs

@@ -1,59 +1,37 @@
-import { NAME_SIGNAL } from "../constants.mjs";
-import { Reactive } from "./reactive.mjs";
-import { emitValue, getValue } from "../helpers/value.mjs";
+import { NAME_MORA, NAME_SIGNAL } from "../constants.mjs";
+import { emitValue, getSimpleValue, handleSimpleValue } from "../helpers/value.mjs";
+import { subscribe } from "../subscription.mjs";
+import { reactive } from "./reactive.mjs";
 //#region src/value/signal.ts
-var Signal = class extends Reactive {
-	constructor(value, options) {
-		super(NAME_SIGNAL, value, options);
-	}
-	/**
-	* @inheritdoc
-	*/
-	get() {
-		return getValue(this.state);
-	}
-	/**
-	* Set the value
-	* @param value New value
-	*/
-	set(value) {
-		setValue(this.state, value);
-	}
-	/**
-	* Update the value _(based on the current value)_
-	* @param callback Callback to update the value
-	*/
-	update(callback) {
-		this.set(callback(this.state.value));
-	}
-};
 function setAndEmit(state, value) {
 	if (!state.equal(state.value, value)) {
 		state.value = value;
 		emitValue(state);
 	}
 }
-function setValue(state, value) {
-	try {
-		let actual = value;
-		if (typeof value === "function") actual = value();
-		if (actual instanceof Promise) {
-			state.promise = actual;
-			actual.then((value) => {
-				if (actual === state.promise) {
-					state.promise = void 0;
-					setAndEmit(state, value);
-				}
-			}).catch(() => {
-				if (actual === state.promise) state.promise = void 0;
-			});
-		} else setAndEmit(state, actual);
-	} catch {}
-}
 function signal(value, options) {
-	const instance = new Signal(void 0, options);
-	instance.set(value);
-	return instance;
+	const [rx, state] = reactive(void 0, options);
+	const instance = {
+		...rx,
+		get: () => getSimpleValue(state),
+		peek: () => state.value,
+		set: (value) => {
+			handleSimpleValue(state, value, setAndEmit);
+		},
+		update: (callback) => {
+			handleSimpleValue(state, callback(state.value), setAndEmit);
+		},
+		subscribe: (callback) => subscribe(state, callback),
+		unsubscribe: (callback) => {
+			state.subscriptions.delete(callback);
+		}
+	};
+	Object.defineProperty(instance, NAME_MORA, {
+		enumerable: false,
+		value: NAME_SIGNAL
+	});
+	handleSimpleValue(state, value, setAndEmit);
+	return Object.freeze(instance);
 }
 //#endregion
-export { Signal, signal };
+export { signal };

package/dist/value/store.d.mts

@@ -1,112 +1,29 @@
-import { Reactive } from "./reactive.mjs";
-import { ReactiveOptions, Unsubscribe } from "../models.mjs";
-import { Key, PlainObject } from "@oscarpalmer/atoms/models";
-
+import { ReactiveOptions, ReactiveStore } from "../models.mjs";
+import { PlainObject } from "@oscarpalmer/atoms/models";
 //#region src/value/store.d.ts
-declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
-  #private;
-  constructor(value: Value, options?: ReactiveOptions<Value>);
-  /**
-   * @inheritdoc
-   */
-  get(): Value;
-  /**
-   * Get a value by key
-   * @param key Key of the value to get
-   * @returns Value for the specified key, or `undefined` if it doesn't exist
-   */
-  get<Key extends keyof Value>(key: Key): Value[Key];
-  /**
-   * Get a value by key
-   * @param key Key of the value to get
-   * @returns Value for the specified key, or `undefined` if it doesn't exist
-   */
-  get(key: Key): unknown;
-  /**
-   * Notify dependents of changes
-   *
-   * _This bypasses equality checks and will immediately notify dependents.
-   * Use this only if you're modifying nested data that would be ignored by equality checks._
-   */
-  notify(): void;
-  /**
-   * Get the value _(without reactivity)_
-   * @returns The current value
-   */
-  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];
-  /**
-   * 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;
-  /**
-   * Set the value
-   * @param value New value _(defaults to an empty object)_
-   */
-  set(value?: Value | (() => null | undefined | Value | Promise<null | undefined | Value>) | Promise<null | undefined | Value>): void;
-  /**
-   * Set a value by key
-   * @param key Key of the value to set
-   * @param value New value
-   */
-  set<Key extends keyof Value>(key: Key, value: Value[Key] | (() => Value[Key] | Promise<Value[Key]>) | Promise<Value[Key]>): void;
-  /**
-   * Set a value by key
-   * @param key Key of the value to set
-   * @param value New value
-   */
-  set(key: Key, value: unknown): void;
-  /**
-   * @inheritdoc
-   */
-  subscribe(callback: (value: Value) => void): Unsubscribe;
-  /**
-   * Subscribe to changes for a specific key
-   * @param key Key of the value to subscribe to
-   * @param callback Callback for changes
-   * @returns Unsubscribe callback
-   */
-  subscribe<Key extends keyof Value>(key: Key, callback: (value: Value[Key] | undefined) => void): Unsubscribe;
-  /**
-   * Subscribe to changes for a specific key
-   * @param key Key of the value to subscribe to
-   * @param callback Callback for changes
-   * @returns Unsubscribe callback
-   */
-  subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
-  /**
-   * Update the value _(based on the current value)_
-   * @param callback Callback to update the value
-   */
-  update(callback: (value: Value) => Value): void;
-}
 /**
  * Create a reactive store from a function result
+ *
  * @param value Initial object value
  * @param options Reactivity options
  * @returns Reactive store
  */
-declare function store<Value extends PlainObject>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): Store<Value>;
+declare function store<Value extends PlainObject>(value: () => Value | Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
 /**
  * Create a reactive store from a promise
+ *
  * @param value Initial object value
  * @param options Reactivity options
  * @returns Reactive store
  */
-declare function store<Value extends PlainObject>(value: Promise<Value>, options?: ReactiveOptions<Value>): Store<Value>;
+declare function store<Value extends PlainObject>(value: Promise<Value>, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
 /**
  * Create a reactive store
+ *
  * @param value Initial object value
  * @param options Reactivity options
  * @returns Reactive store
  */
-declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): Store<Value>;
+declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): ReactiveStore<Value>;
 //#endregion
-export { Store, store };
+export { store };

package/dist/value/store.mjs

@@ -1,53 +1,11 @@
-import { NAME_STORE } from "../constants.mjs";
+import { NAME_MORA, NAME_STORE } from "../constants.mjs";
 import { startBatch, stopBatch } from "../batch.mjs";
-import { noop, subscribe } from "../subscription.mjs";
-import { Reactive } from "./reactive.mjs";
-import { getValue } from "../helpers/value.mjs";
+import { getSimpleValue } from "../helpers/value.mjs";
+import { noop, subscribe, unsubscribe } from "../subscription.mjs";
+import { reactive } from "./reactive.mjs";
 import { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.mjs";
 import { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/value/store.ts
-var Store = class extends Reactive {
-	#keyed = /* @__PURE__ */ new Map();
-	constructor(value, options) {
-		super(NAME_STORE, new Proxy(value, { set: (target, property, value) => setValueInProxy({
-			target,
-			property,
-			value,
-			isArray: false,
-			state: this.state
-		}) }), options);
-	}
-	get(key) {
-		return isKey(key) ? getReactiveValueInProxy(this, this.#keyed, key, false).get() : getValue(this.state);
-	}
-	/**
-	* Notify dependents of changes
-	*
-	* _This bypasses equality checks and will immediately notify dependents.
-	* Use this only if you're modifying nested data that would be ignored by equality checks._
-	*/
-	notify() {
-		emityProxyValues(this.state, this.#keyed);
-	}
-	peek(key) {
-		return isKey(key) ? this.state.value[key] : { ...this.state.value };
-	}
-	set(first, second) {
-		setProxyValue(false, this.state, isStoreObject, isKey, setObject, setProperty, first, second);
-	}
-	subscribe(first, second) {
-		if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(second);
-		return typeof first === "function" ? subscribe(this.state, first) : noop;
-	}
-	/**
-	* Update the value _(based on the current value)_
-	* @param callback Callback to update the value
-	*/
-	update(callback) {
-		const updated = callback(this.state.value);
-		if (updated == null || isPlainObject(updated)) setObject(this.state, updated);
-	}
-};
 function isStoreObject(value) {
 	return value == null || isPlainObject(value);
 }
@@ -73,9 +31,44 @@ function setProperty(state, key, value) {
 	state.value[key] = value;
 }
 function store(value, options) {
-	const instance = new Store({}, options);
+	const [rx, state] = reactive(void 0, options);
+	const keyed = /* @__PURE__ */ new Map();
+	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy({
+		target,
+		property,
+		state,
+		value,
+		isArray: false
+	}) });
+	const instance = {
+		...rx,
+		get: (value) => isKey(value) ? getReactiveValueInProxy(instance, keyed, value, false).get() : getSimpleValue(state),
+		notify() {
+			emityProxyValues(state, keyed);
+		},
+		peek: (value) => isKey(value) ? state.value[value] : { ...state.value },
+		set: (first, second) => {
+			setProxyValue(false, state, isStoreObject, isKey, setObject, setProperty, first, second);
+		},
+		subscribe: (first, second) => {
+			if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(instance, keyed, first, false).subscribe(second);
+			return typeof first === "function" ? subscribe(state, first) : noop;
+		},
+		unsubscribe: (first, second) => {
+			if (isKey(first) && typeof second === "function") getReactiveValueInProxy(instance, keyed, first, false)?.unsubscribe(second);
+			else if (typeof first === "function") unsubscribe(state, first);
+		},
+		update: (callback) => {
+			const updated = callback(state.value);
+			if (updated == null || isPlainObject(updated)) setObject(state, updated);
+		}
+	};
+	Object.defineProperty(instance, NAME_MORA, {
+		enumerable: false,
+		value: NAME_STORE
+	});
 	instance.set(value);
-	return instance;
+	return Object.freeze(instance);
 }
 //#endregion
-export { Store, store };
+export { store };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/mora",
-	"version": "0.28.0",
+	"version": "0.30.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",
@@ -35,18 +35,18 @@
 		"build": "vpx vp run tsdown:build && vpx vp pack",
 		"tsdown:build": "vpx tsdown -c ./tsdown.config.ts",
 		"tsdown:watch": "vpx tsdown -c ./tsdown.config.ts --watch",
-		"test": "vpx vp test run --coverage",
+		"test": "npx vp test run --coverage",
 		"test:leak": "vpx vp test run --detect-async-leaks --coverage"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.172"
+		"@oscarpalmer/atoms": "^0.190"
 	},
 	"devDependencies": {
-		"@types/node": "^25.5",
-		"@vitest/coverage-istanbul": "^4.1",
-		"jsdom": "^29",
-		"tsdown": "^0.21",
-		"typescript": "^5.9",
+		"@types/node": "^26.2",
+		"@vitest/coverage-istanbul": "4.1.10",
+		"jsdom": "^30",
+		"tsdown": "^0.22",
+		"typescript": "^6",
 		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
 		"vite-plus": "latest",
 		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"

package/src/batch.ts

@@ -1,20 +1,33 @@
 import {BATCH} from './constants';
 import {runEffect} from './effect';
-import {isEffect} from './helpers/is';
+import type {EffectState, Subscription} from './models';
 
 export function flushHandlers(): void {
-	while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
-		const handlers = [...BATCH.handlers];
+	if (BATCH.flushing) {
+		return;
+	}
+
+	BATCH.flushing = true;
+
+	try {
+		while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
+			const handlers = [...BATCH.handlers];
+			const {length} = handlers;
+
+			BATCH.handlers.clear();
 
-		BATCH.handlers.clear();
+			for (let index = 0; index < length; index += 1) {
+				const handler = handlers[index];
 
-		for (const handler of handlers) {
-			if (isEffect(handler)) {
-				runEffect(handler);
-			} else {
-				handler.callback(handler.state.value);
+				if (typeof (handler as Subscription).destroy === 'function') {
+					(handler as Subscription).callback((handler as Subscription).state.value);
+				} else {
+					runEffect(handler as EffectState);
+				}
 			}
 		}
+	} finally {
+		BATCH.flushing = false;
 	}
 }
 

package/src/constants.ts

@@ -1,6 +1,4 @@
-import type {Effect} from './effect';
-import type {Active, Batch} from './models';
-import type {Subscription} from './subscription';
+import type {Active, Batch, EffectState, Subscription} from './models';
 
 export const ACTIVE: Active = {};
 
@@ -12,7 +10,8 @@ export const ARRAY_PEEK = 10;
 
 export const BATCH: Batch = {
 	depth: 0,
-	handlers: new Set<Effect | Subscription>(),
+	flushing: false,
+	handlers: new Set<EffectState | Subscription>(),
 };
 
 export const METHODS_AFFECTING_LENGTH = new Set<string>(['pop', 'push', 'shift', 'unshift']);

package/src/effect.ts

@@ -1,42 +1,47 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {ACTIVE, NAME_EFFECT, NAME_MORA} from './constants';
-import type {EffectState, InternalEffect} from './models';
+import {ACTIVE, NAME_EFFECT} from './constants';
+import type {Effect, EffectState} from './models';
 
-export class Effect {
-	declare private readonly $mora: string;
+/**
+ * Create an effect
+ *
+ * @param callback Callback for handling signal effects
+ * @returns Effect
+ */
+export function effect(callback: GenericCallback): Effect {
+	if (typeof callback !== 'function') {
+		throw new TypeError('Effect callback must be a function');
+	}
 
-	declare private readonly state: EffectState;
+	return getEffect(callback)[0];
+}
 
-	constructor(callback: GenericCallback) {
-		Object.defineProperty(this, NAME_MORA, {
-			value: NAME_EFFECT,
-		});
+function getEffect(callback: GenericCallback): [Effect, EffectState] {
+	const state: EffectState = {
+		callback,
+	};
 
-		this.state = {
-			callback,
-		};
+	const instance = Object.freeze({
+		$mora: NAME_EFFECT,
+	});
 
-		runEffect(this);
-	}
+	runEffect(state);
+
+	return [instance, state];
 }
 
-export function runEffect(effect: Effect): void {
+export function internalEffect(callback: GenericCallback): EffectState {
+	return getEffect(callback)[1];
+}
+
+export function runEffect(state: EffectState): void {
 	const previousEffect = ACTIVE.effect;
 
-	ACTIVE.effect = effect;
+	ACTIVE.effect = state;
 
 	try {
-		(effect as unknown as InternalEffect).state.callback();
+		state.callback();
 	} finally {
 		ACTIVE.effect = previousEffect;
 	}
 }
-
-/**
- * Create an effect
- * @param callback Callback for handling signal effects
- * @returns Effect
- */
-export function effect(callback: GenericCallback): Effect {
-	return typeof callback === 'function' ? new Effect(callback) : (undefined as never);
-}

package/src/helpers/is.ts

@@ -8,15 +8,11 @@ import {
 	NAME_SIGNAL,
 	NAME_STORE,
 } from '../constants';
-import type {Effect} from '../effect';
-import type {ReactiveArray} from '../value/array';
-import type {Computed} from '../value/computed';
-import type {Reactive} from '../value/reactive';
-import type {Signal} from '../value/signal';
-import type {Store} from '../value/store';
+import type {Computed, Effect, Reactive, ReactiveArray, ReactiveStore, Signal} from '../models';
 
 /**
  * Is the value a reactive array?
+ *
  * @param value Value to check
  * @returns True if value is a {@link ReactiveArray}
  */
@@ -26,6 +22,7 @@ export function isArray<Item>(value: unknown): value is ReactiveArray<Item> {
 
 /**
  * Is the value a computed signal?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Computed}
  */
@@ -35,6 +32,7 @@ export function isComputed<Value>(value: unknown): value is Computed<Value> {
 
 /**
  * Is the value an effect?
+ *
  * @param value Value to check
  * @returns True if value is an {@link Effect}
  */
@@ -55,15 +53,17 @@ function isMora<T>(value: unknown, name: string | Set<string>): value is T {
 
 /**
  * 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, NAME_ALL);
+export function isReactive<Value>(value: unknown): value is Reactive<Value> {
+	return isMora<Reactive<Value>>(value, NAME_ALL);
 }
 
 /**
  * Is the value a signal?
+ *
  * @param value Value to check
  * @returns True if value is a {@link Signal}
  */
@@ -73,9 +73,10 @@ export function isSignal<Value>(value: unknown): value is Signal<Value> {
 
 /**
  * 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 function isStore<Value extends PlainObject>(value: unknown): value is ReactiveStore<Value> {
+	return isMora<ReactiveStore<Value>>(value, NAME_STORE);
 }