@oscarpalmer/mora 0.12.0 → 0.14.0

package/dist/value/array.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var _size;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const helpers_emit = require("../helpers/emit.cjs");
+const helpers_is = require("../helpers/is.cjs");
+const helpers_value = require("../helpers/value.cjs");
+const value_reactive = require("./reactive.cjs");
+const value_signal = require("./signal.cjs");
+class ReactiveArray extends value_reactive.Reactive {
+  constructor(value) {
+    super(
+      helpers_is.arrayName,
+      new Proxy(value, {
+        get: (target, property) => updateMethods.has(property) ? updateArray(property, target, this.state, __privateGet(this, _size)) : Reflect.get(target, property),
+        set: (target, property, value2) => setValue(target, property, value2, this.state, __privateGet(this, _size))
+      })
+    );
+    __privateAdd(this, _size, value_signal.signal(0));
+    __privateGet(this, _size).set(value.length);
+  }
+  /**
+   * The length of the array
+   */
+  get length() {
+    return __privateGet(this, _size).get();
+  }
+  /**
+   * Set the length of the array
+   */
+  set length(value) {
+    if (typeof value === "number" && value >= 0 && value !== this.state.value.length) {
+      this.get().length = value;
+    }
+  }
+  /**
+   * @inheritdoc
+   */
+  get() {
+    return helpers_value.getValue(this.state);
+  }
+  peek(length) {
+    return length === true ? __privateGet(this, _size).peek() : [...this.state.value];
+  }
+  set(first, second) {
+    if (Array.isArray(first)) {
+      this.state.value.splice(0, this.state.value.length, ...first);
+    } else if (first === "length") {
+      this.length = second;
+    } else if (typeof first === "number") {
+      this.state.value[first] = second;
+    }
+  }
+}
+_size = new WeakMap();
+function array(value) {
+  return new ReactiveArray(Array.isArray(value) ? value : []);
+}
+function setValue(target, property, value, state, length) {
+  const isIndex = !Number.isNaN(Number(property));
+  const isLength = property === "length";
+  if (!isIndex && !isLength) {
+    return Reflect.set(target, property, value);
+  }
+  const previous = Reflect.get(target, property);
+  if (!Object.is(previous, value)) {
+    Reflect.set(target, property, value);
+    helpers_emit.emitValue(state);
+    length.set(target.length);
+  }
+  return true;
+}
+function updateArray(type, array2, state, length) {
+  const affectsLength = lengthAffectingMethods.has(type);
+  const previousArray = affectsLength ? [] : [...array2];
+  const previousLength = array2.length;
+  return (...args) => {
+    const result = array2[type](
+      ...args
+    );
+    if (affectsLength ? array2.length !== previousLength : helpers_emit.emitArrayChanges(previousArray, array2)) {
+      helpers_emit.emitValue(state);
+      length.set(array2.length);
+    }
+    return result;
+  };
+}
+const lengthAffectingMethods = /* @__PURE__ */ new Set([
+  "pop",
+  "push",
+  "shift",
+  "unshift"
+]);
+const updateMethods = /* @__PURE__ */ new Set([
+  ...lengthAffectingMethods,
+  "copyWithin",
+  "fill",
+  "reverse",
+  "sort",
+  "splice"
+]);
+exports.ReactiveArray = ReactiveArray;
+exports.array = array;

package/dist/value/array.js

@@ -0,0 +1,108 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var _size;
+import { emitValue, emitArrayChanges } from "../helpers/emit.js";
+import { arrayName } from "../helpers/is.js";
+import { getValue } from "../helpers/value.js";
+import { Reactive } from "./reactive.js";
+import { signal } from "./signal.js";
+class ReactiveArray extends Reactive {
+  constructor(value) {
+    super(
+      arrayName,
+      new Proxy(value, {
+        get: (target, property) => updateMethods.has(property) ? updateArray(property, target, this.state, __privateGet(this, _size)) : Reflect.get(target, property),
+        set: (target, property, value2) => setValue(target, property, value2, this.state, __privateGet(this, _size))
+      })
+    );
+    __privateAdd(this, _size, signal(0));
+    __privateGet(this, _size).set(value.length);
+  }
+  /**
+   * The length of the array
+   */
+  get length() {
+    return __privateGet(this, _size).get();
+  }
+  /**
+   * Set the length of the array
+   */
+  set length(value) {
+    if (typeof value === "number" && value >= 0 && value !== this.state.value.length) {
+      this.get().length = value;
+    }
+  }
+  /**
+   * @inheritdoc
+   */
+  get() {
+    return getValue(this.state);
+  }
+  peek(length) {
+    return length === true ? __privateGet(this, _size).peek() : [...this.state.value];
+  }
+  set(first, second) {
+    if (Array.isArray(first)) {
+      this.state.value.splice(0, this.state.value.length, ...first);
+    } else if (first === "length") {
+      this.length = second;
+    } else if (typeof first === "number") {
+      this.state.value[first] = second;
+    }
+  }
+}
+_size = new WeakMap();
+function array(value) {
+  return new ReactiveArray(Array.isArray(value) ? value : []);
+}
+function setValue(target, property, value, state, length) {
+  const isIndex = !Number.isNaN(Number(property));
+  const isLength = property === "length";
+  if (!isIndex && !isLength) {
+    return Reflect.set(target, property, value);
+  }
+  const previous = Reflect.get(target, property);
+  if (!Object.is(previous, value)) {
+    Reflect.set(target, property, value);
+    emitValue(state);
+    length.set(target.length);
+  }
+  return true;
+}
+function updateArray(type, array2, state, length) {
+  const affectsLength = lengthAffectingMethods.has(type);
+  const previousArray = affectsLength ? [] : [...array2];
+  const previousLength = array2.length;
+  return (...args) => {
+    const result = array2[type](
+      ...args
+    );
+    if (affectsLength ? array2.length !== previousLength : emitArrayChanges(previousArray, array2)) {
+      emitValue(state);
+      length.set(array2.length);
+    }
+    return result;
+  };
+}
+const lengthAffectingMethods = /* @__PURE__ */ new Set([
+  "pop",
+  "push",
+  "shift",
+  "unshift"
+]);
+const updateMethods = /* @__PURE__ */ new Set([
+  ...lengthAffectingMethods,
+  "copyWithin",
+  "fill",
+  "reverse",
+  "sort",
+  "splice"
+]);
+export {
+  ReactiveArray,
+  array
+};

package/dist/{computed.cjs → value/computed.cjs}

@@ -3,13 +3,14 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const batch = require("./batch.cjs");
-const effect = require("./effect.cjs");
-const reactive = require("./reactive.cjs");
+const batch = require("../batch.cjs");
+const effect = require("../effect.cjs");
+const helpers_is = require("../helpers/is.cjs");
+const value_reactive = require("./reactive.cjs");
 exports.activeComputed = void 0;
-class Computed extends reactive.Reactive {
+class Computed extends value_reactive.Reactive {
   constructor(callback) {
-    super("computed", void 0);
+    super(helpers_is.computedName, void 0);
     __publicField(this, "effect", {
       dirty: true,
       instance: void 0

package/dist/{computed.js → value/computed.js}

@@ -1,13 +1,14 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { batchedHandlers, batchDepth } from "./batch.js";
-import { effect, activeEffect, runEffect } from "./effect.js";
+import { batchedHandlers, batchDepth } from "../batch.js";
+import { effect, activeEffect, runEffect } from "../effect.js";
+import { computedName } from "../helpers/is.js";
 import { Reactive } from "./reactive.js";
 let activeComputed;
 class Computed extends Reactive {
   constructor(callback) {
-    super("computed", void 0);
+    super(computedName, void 0);
     __publicField(this, "effect", {
       dirty: true,
       instance: void 0

package/dist/{reactive.cjs → value/reactive.cjs}

@@ -3,7 +3,7 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const subscription = require("./subscription.cjs");
+const subscription = require("../subscription.cjs");
 class Reactive {
   constructor(name, value) {
     __publicField(this, "state", {
@@ -29,6 +29,18 @@ class Reactive {
   subscribe(callback) {
     return subscription.subscribe(this.state, callback);
   }
+  /**
+   * JSON representation of the value
+   */
+  toJSON() {
+    return this.get();
+  }
+  /**
+   * String representation of the value
+   */
+  toString() {
+    return String(this.get());
+  }
   /**
    * Unsubscribe from changes
    */

package/dist/{reactive.js → value/reactive.js}

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { subscribe, unsubscribe } from "./subscription.js";
+import { subscribe, unsubscribe } from "../subscription.js";
 class Reactive {
   constructor(name, value) {
     __publicField(this, "state", {
@@ -27,6 +27,18 @@ class Reactive {
   subscribe(callback) {
     return subscribe(this.state, callback);
   }
+  /**
+   * JSON representation of the value
+   */
+  toJSON() {
+    return this.get();
+  }
+  /**
+   * String representation of the value
+   */
+  toString() {
+    return String(this.get());
+  }
   /**
    * Unsubscribe from changes
    */

package/dist/value/signal.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const helpers_is = require("../helpers/is.cjs");
+const helpers_value = require("../helpers/value.cjs");
+const value_reactive = require("./reactive.cjs");
+class Signal extends value_reactive.Reactive {
+  constructor(value) {
+    super(helpers_is.signalName, value);
+  }
+  /**
+   * @inheritdoc
+   */
+  get() {
+    return helpers_value.getValue(this.state);
+  }
+  /**
+   * Set the value
+   */
+  set(value) {
+    helpers_value.setValue(this.state, value);
+  }
+  /**
+   * Update the value
+   */
+  update(callback) {
+    this.set(callback(this.state.value));
+  }
+}
+function signal(value) {
+  return new Signal(value);
+}
+exports.Signal = Signal;
+exports.signal = signal;

package/dist/value/signal.js

@@ -0,0 +1,33 @@
+import { signalName } from "../helpers/is.js";
+import { getValue, setValue } from "../helpers/value.js";
+import { Reactive } from "./reactive.js";
+class Signal extends Reactive {
+  constructor(value) {
+    super(signalName, value);
+  }
+  /**
+   * @inheritdoc
+   */
+  get() {
+    return getValue(this.state);
+  }
+  /**
+   * Set the value
+   */
+  set(value) {
+    setValue(this.state, value);
+  }
+  /**
+   * Update the value
+   */
+  update(callback) {
+    this.set(callback(this.state.value));
+  }
+}
+function signal(value) {
+  return new Signal(value);
+}
+export {
+  Signal,
+  signal
+};

package/package.json

@@ -54,5 +54,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.12.0"
+	"version": "0.14.0"
 }

package/src/batch.ts

@@ -1,5 +1,5 @@
 import {type Effect, runEffect} from './effect';
-import {isEffect} from './is';
+import {isEffect} from './helpers/is';
 import type {Subscription} from './subscription';
 
 export function flushEffects(): void {

package/src/effect.ts

@@ -1,4 +1,5 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import {effectName} from './helpers/is';
 
 type EffectState = {
 	callback: GenericCallback;
@@ -9,22 +10,22 @@ type InternalEffect = {
 };
 
 export class Effect {
-		private declare readonly $mora: string;
+	private declare readonly $mora: string;
 
-		private declare readonly state: EffectState;
+	private declare readonly state: EffectState;
 
-		constructor(callback: GenericCallback) {
-			Object.defineProperty(this, '$mora', {
-				value: 'effect',
-			});
+	constructor(callback: GenericCallback) {
+		Object.defineProperty(this, '$mora', {
+			value: effectName,
+		});
 
-			this.state = {
-				callback,
-			};
+		this.state = {
+			callback,
+		};
 
-			runEffect(this);
-		}
+		runEffect(this);
 	}
+}
 
 export function runEffect(effect: Effect): void {
 	const previousEffect = activeEffect;

package/src/helpers/emit.ts

@@ -0,0 +1,52 @@
+import {batchDepth, batchedHandlers, flushEffects} from '../batch';
+import type {InternalComputed} from '../value/computed';
+import type {ReactiveState} from '../value/reactive';
+
+export function emitArrayChanges(first: unknown[], second: unknown[]): boolean {
+	let {length} = first;
+
+	if (length !== second.length) {
+		return true;
+	}
+
+	let offset = 0;
+
+	if (length >= 100) {
+		offset = Math.round(length / 10);
+		offset = offset > 25 ? 25 : offset;
+
+		for (let index = 0; index < offset; index += 1) {
+			if (!Object.is(first[index], second[index])) {
+				return true;
+			}
+		}
+	}
+
+	length -= offset;
+
+	for (let index = offset; index < length; index += 1) {
+		if (!Object.is(first[index], second[index])) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+export function emitValue<Value>(state: ReactiveState<Value>): void {
+	for (const computed of state.computeds) {
+		(computed as unknown as InternalComputed).effect.dirty = true;
+	}
+
+	for (const effect of state.effects) {
+		batchedHandlers.add(effect);
+	}
+
+	for (const [, subscription] of state.subscriptions) {
+		batchedHandlers.add(subscription as never);
+	}
+
+	if (batchDepth === 0) {
+		flushEffects();
+	}
+}

package/src/helpers/is.ts

@@ -0,0 +1,56 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import type {Effect} from '../effect';
+import type {ReactiveArray} from '../value/array';
+import type {Computed} from '../value/computed';
+import type {Reactive} from '../value/reactive';
+import {signal, type Signal} from '../value/signal';
+
+/**
+ * Is the value a reactive array?
+ */
+export function isArray(value: unknown): value is ReactiveArray<unknown> {
+	return isMora<ReactiveArray<unknown>>(value, arrayName);
+}
+
+/**
+ * Is the value a computed signal?
+ */
+export function isComputed(value: unknown): value is Computed<unknown> {
+	return isMora<Computed<unknown>>(value, computedName);
+}
+
+/**
+ * Is the value an effect?
+ */
+export function isEffect(value: unknown): value is Effect {
+	return isMora<Effect>(value, effectName);
+}
+
+function isMora<T>(value: unknown, name: string | Set<string>): value is T {
+	return (
+		typeof value === 'object' &&
+		value != null &&
+		'$mora' in value &&
+		(typeof name === 'string'
+			? (value as PlainObject).$mora === name
+			: name.has((value as PlainObject).$mora as never))
+	);
+}
+
+export function isReactive(value: unknown): value is Reactive<unknown> {
+	return isMora<Reactive<unknown>>(value, reactiveNames);
+}
+
+/**
+ * Is the value a signal?
+ */
+export function isSignal(value: unknown): value is Signal<unknown> {
+	return isMora<Signal<unknown>>(value, signalName);
+}
+
+export const arrayName = 'array';
+export const computedName = 'computed';
+export const effectName = 'effect';
+export const signalName = 'signal';
+
+const reactiveNames = new Set([arrayName, computedName, signalName]);

package/src/helpers/value.ts

@@ -0,0 +1,27 @@
+import {activeEffect} from '../effect';
+import {activeComputed} from '../value/computed';
+import type {ReactiveState} from '../value/reactive';
+import {emitValue} from './emit';
+
+export function getValue<Value>(state: ReactiveState<Value>): Value {
+	if (activeComputed != null) {
+		state.computeds.add(activeComputed);
+	}
+
+	if (activeEffect != null) {
+		state.effects.add(activeEffect);
+	}
+
+	return state.value;
+}
+
+export function setValue<Value>(
+	state: ReactiveState<Value>,
+	value: Value,
+): void {
+	if (!Object.is(state.value, value)) {
+		state.value = value;
+
+		emitValue(state);
+	}
+}

package/src/index.ts

@@ -1,7 +1,13 @@
 export {startBatch, stopBatch} from './batch';
-export {computed, type Computed} from './computed';
 export {effect, type Effect} from './effect';
-export {isComputed, isEffect, isReactive, isSignal} from './is';
-export type {Reactive} from './reactive';
-export {signal, type Signal} from './signal';
-
+export {
+	isArray,
+	isComputed,
+	isEffect,
+	isReactive,
+	isSignal,
+} from './helpers/is';
+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';

package/src/subscription.ts

@@ -1,5 +1,5 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import type {ReactiveState} from './reactive';
+import type {ReactiveState} from './value/reactive';
 
 export class Subscription<Value> {
 	constructor(