@oscarpalmer/mora 0.29.0 → 0.31.0

package/dist/value/reactive.mjs

@@ -1,60 +1,16 @@
-import { NAME_MORA } from "../constants.mjs";
-import { subscribe, unsubscribe } from "../subscription.mjs";
 //#region src/value/reactive.ts
-var Reactive = class {
-	/**
-	* Internal state of the reactive value
-	*
-	* @internal
-	*/
-	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/readonly.d.mts

@@ -0,0 +1,7 @@
+import { ReactiveState, ReadonlyFrozenSignal, ReadonlyInstances, ReadonlySignal } from "../models.mjs";
+import { GenericCallback } from "@oscarpalmer/atoms/models";
+//#region src/value/readonly.d.ts
+declare function getReadonlyInstance<Value>(state: ReactiveState<Value, never>, instances: ReadonlyInstances<Value>, handlers: Record<string, GenericCallback>, frozen: boolean): ReadonlySignal<Value>;
+declare function getReadonlySignal<Value>(state: ReactiveState<Value, never>, handlers: Record<string, GenericCallback>, frozen: boolean): ReadonlySignal<Value> | ReadonlyFrozenSignal<Value>;
+//#endregion
+export { getReadonlyInstance, getReadonlySignal };

package/dist/value/readonly.mjs

@@ -0,0 +1,37 @@
+import { NAME_MORA, NAME_READONLY } from "../constants.mjs";
+import { getSimpleValue } from "../helpers/value.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/value/readonly.ts
+function getReadonlyInstance(state, instances, handlers, frozen) {
+	const key = frozen ? "frozen" : "original";
+	instances[key] ??= getReadonlySignal(state, handlers, frozen);
+	return instances[key];
+}
+function getReadonlySignal(state, handlers, frozen) {
+	const instance = {
+		...handlers,
+		get: () => getReadonlyValue(state, false, frozen),
+		peek: () => getReadonlyValue(state, true, frozen)
+	};
+	Object.defineProperties(instance, {
+		[NAME_MORA]: {
+			enumerable: false,
+			value: NAME_READONLY
+		},
+		frozen: {
+			enumerable: true,
+			value: frozen
+		}
+	});
+	return Object.freeze(instance);
+}
+function getReadonlyValue(state, peek, frozen) {
+	let value = peek ? state.value : getSimpleValue(state);
+	if (!frozen) return value;
+	if (Array.isArray(state.value)) value = [...state.value];
+	else if (isPlainObject(state.value)) value = { ...state.value };
+	else value = state.value;
+	return Object.freeze(value);
+}
+//#endregion
+export { getReadonlyInstance, getReadonlySignal };

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,43 @@
-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";
+import { getReadonlyInstance } from "./readonly.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 readonlies = {};
+	const handlers = {
+		...rx,
+		subscribe: (callback) => subscribe(state, callback),
+		unsubscribe: (callback) => {
+			state.subscriptions.delete(callback);
+		}
+	};
+	const instance = {
+		...handlers,
+		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, handlers, frozen === true),
+		get: () => getSimpleValue(state),
+		peek: () => state.value,
+		set: (value) => {
+			handleSimpleValue(state, value, setAndEmit);
+		},
+		update: (callback) => {
+			handleSimpleValue(state, callback(state.value), setAndEmit);
+		}
+	};
+	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,12 @@
-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 { getReadonlyInstance } from "./readonly.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);
 }
@@ -69,13 +28,63 @@ function setObject(state, value) {
 	}
 	stopBatch();
 }
+function peekStoreValue(state, first, second) {
+	let value;
+	if (isKey(first)) value = state.value[first];
+	else value = state.value;
+	if (!(first === true || second === true)) return value;
+	if (Array.isArray(value)) return value.slice();
+	if (isPlainObject(value)) return { ...value };
+	return value;
+}
 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();
+	const readonlies = {};
+	let instance = {};
+	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy({
+		target,
+		property,
+		state,
+		value,
+		isArray: false
+	}) });
+	const handlers = {
+		...rx,
+		get: (value) => isKey(value) ? getReactiveValueInProxy(instance, keyed, value, false).get() : getSimpleValue(state),
+		peek: (first, second) => peekStoreValue(state, 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);
+		}
+	};
+	instance = {
+		...handlers,
+		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, handlers, frozen === true),
+		notify() {
+			emityProxyValues(state, keyed);
+		},
+		set: (first, second) => {
+			setProxyValue(false, state, isStoreObject, isKey, setObject, setProperty, first, second);
+		},
+		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.29.0",
+	"version": "0.31.0",
 	"description": "Signals and stuff…",
 	"keywords": [
 		"reactive",
@@ -39,15 +39,14 @@
 		"test:leak": "vpx vp test run --detect-async-leaks --coverage"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.184"
+		"@oscarpalmer/atoms": "^0.190"
 	},
 	"devDependencies": {
-		"@oxlint/plugins": "^1.62",
-		"@types/node": "^25.6",
-		"@vitest/coverage-istanbul": "^4.1",
-		"jsdom": "^29.1",
-		"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']);
@@ -34,10 +33,18 @@ export const NAME_EFFECT = 'effect';
 
 export const NAME_MORA = '$mora';
 
+export const NAME_READONLY = 'readonly';
+
 export const NAME_SIGNAL = 'signal';
 
 export const NAME_STORE = 'store';
 
-export const NAME_ALL = new Set([NAME_ARRAY, NAME_COMPUTED, NAME_SIGNAL, NAME_STORE]);
+export const NAME_ALL = new Set([
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_READONLY,
+	NAME_SIGNAL,
+	NAME_STORE,
+]);
 
 export const PROPERTY_LENGTH = 'length';