@oscarpalmer/mora 0.17.0 → 0.18.0

package/dist/helpers/value.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const batch = require("../batch.cjs");
 const effect = require("../effect.cjs");
 const value_computed = require("../value/computed.cjs");
-function differentArrays(state, first, second) {
+function differentArrays(first, second) {
   let { length } = first;
   if (length !== second.length) {
     return true;
@@ -13,21 +13,21 @@ function differentArrays(state, first, second) {
     offset = Math.round(length / 10);
     offset = offset > 25 ? 25 : offset;
     for (let index = 0; index < offset; index += 1) {
-      if (!state.equal(first[index], second[index])) {
+      if (!Object.is(first[index], second[index])) {
         return true;
       }
     }
   }
   length -= offset;
   for (let index = offset; index < length; index += 1) {
-    if (!state.equal(first[index], second[index])) {
+    if (!Object.is(first[index], second[index])) {
       return true;
     }
   }
   return false;
 }
-function differentValues(state, first, second) {
-  return Array.isArray(first) && Array.isArray(second) ? differentArrays(state, first, second) : !state.equal(first, second);
+function differentValues(first, second) {
+  return Array.isArray(first) && Array.isArray(second) ? differentArrays(first, second) : !Object.is(first, second);
 }
 function emitValue(state) {
   for (const computed of state.computeds) {

package/dist/helpers/value.js

@@ -1,7 +1,7 @@
 import { batchedHandlers, batchDepth, flushHandlers } from "../batch.js";
 import { activeEffect } from "../effect.js";
 import { activeComputed } from "../value/computed.js";
-function differentArrays(state, first, second) {
+function differentArrays(first, second) {
   let { length } = first;
   if (length !== second.length) {
     return true;
@@ -11,21 +11,21 @@ function differentArrays(state, first, second) {
     offset = Math.round(length / 10);
     offset = offset > 25 ? 25 : offset;
     for (let index = 0; index < offset; index += 1) {
-      if (!state.equal(first[index], second[index])) {
+      if (!Object.is(first[index], second[index])) {
         return true;
       }
     }
   }
   length -= offset;
   for (let index = offset; index < length; index += 1) {
-    if (!state.equal(first[index], second[index])) {
+    if (!Object.is(first[index], second[index])) {
       return true;
     }
   }
   return false;
 }
-function differentValues(state, first, second) {
-  return Array.isArray(first) && Array.isArray(second) ? differentArrays(state, first, second) : !state.equal(first, second);
+function differentValues(first, second) {
+  return Array.isArray(first) && Array.isArray(second) ? differentArrays(first, second) : !Object.is(first, second);
 }
 function emitValue(state) {
   for (const computed of state.computeds) {

package/dist/mora.full.js

@@ -132,15 +132,11 @@ class Reactive {
     state = {
         computeds: new Set(),
         effects: new Set(),
-        equal: Object.is,
         subscriptions: new Map(),
         value: undefined,
     };
-    constructor(name, value, options) {
+    constructor(name, value) {
         this.state.value = value;
-        if (typeof options === 'object' && typeof options.equal === 'function') {
-            this.state.equal = options.equal;
-        }
         Object.defineProperty(this, '$mora', {
             value: name,
         });
@@ -183,15 +179,15 @@ class Computed extends Reactive {
         dirty: true,
         instance: undefined,
     };
-    constructor(callback, options) {
-        super(computedName, undefined, options);
+    constructor(callback) {
+        super(computedName, undefined);
         this.effect.instance = effect(() => {
             if (this.effect.dirty) {
                 const previousComputed = activeComputed;
                 activeComputed = this;
                 const value = callback();
                 activeComputed = previousComputed;
-                if (!this.state.equal(this.state.value, value)) {
+                if (!Object.is(this.state.value, value)) {
                     this.state.value = value;
                     for (const computed of this.state.computeds) {
                         computed.effect.dirty = true;
@@ -226,11 +222,11 @@ class Computed extends Reactive {
 /**
  * Create a computed value
  */
-function computed(callback, options) {
-    return new Computed(callback, options);
+function computed(callback) {
+    return new Computed(callback);
 }
 
-function differentArrays(state, first, second) {
+function differentArrays(first, second) {
     let { length } = first;
     if (length !== second.length) {
         return true;
@@ -240,23 +236,23 @@ function differentArrays(state, first, second) {
         offset = Math.round(length / 10);
         offset = offset > 25 ? 25 : offset;
         for (let index = 0; index < offset; index += 1) {
-            if (!state.equal(first[index], second[index])) {
+            if (!Object.is(first[index], second[index])) {
                 return true;
             }
         }
     }
     length -= offset;
     for (let index = offset; index < length; index += 1) {
-        if (!state.equal(first[index], second[index])) {
+        if (!Object.is(first[index], second[index])) {
             return true;
         }
     }
     return false;
 }
-function differentValues(state, first, second) {
+function differentValues(first, second) {
     return Array.isArray(first) && Array.isArray(second)
-        ? differentArrays(state, first, second)
-        : !state.equal(first, second);
+        ? differentArrays(first, second)
+        : !Object.is(first, second);
 }
 function emitValue(state) {
     for (const computed of state.computeds) {
@@ -283,8 +279,8 @@ function getValue(state) {
 }
 
 class Signal extends Reactive {
-    constructor(value, options) {
-        super(signalName, value, options);
+    constructor(value) {
+        super(signalName, value);
     }
     /**
      * @inheritdoc
@@ -296,7 +292,7 @@ class Signal extends Reactive {
      * Set the value
      */
     set(value) {
-        if (differentValues(this.state, this.state.value, value)) {
+        if (differentValues(this.state.value, value)) {
             this.state.value = value;
             emitValue(this.state);
         }
@@ -311,8 +307,8 @@ class Signal extends Reactive {
 /**
  * Create a reactive value
  */
-function signal(value, options) {
-    return new Signal(value, options);
+function signal(value) {
+    return new Signal(value);
 }
 
 class ReactiveArray extends Reactive {
@@ -333,13 +329,13 @@ class ReactiveArray extends Reactive {
             this.get().length = value;
         }
     }
-    constructor(value, options) {
+    constructor(value) {
         super(arrayName, new Proxy(value, {
             get: (target, property) => updateMethods.has(property)
                 ? updateArray(property, target, this.state, this.#size)
                 : Reflect.get(target, property),
             set: (target, property, value) => setValue(target, property, value, this.state, this.#size),
-        }), options);
+        }));
         this.#size.set(value.length);
     }
     /**
@@ -420,8 +416,8 @@ class ReactiveArray extends Reactive {
 /**
  * Create a reactive array
  */
-function array(value, options) {
-    return new ReactiveArray(Array.isArray(value) ? value : [], options);
+function array(value) {
+    return new ReactiveArray(Array.isArray(value) ? value : []);
 }
 function setValue(target, property, value, state, length) {
     const isIndex = !Number.isNaN(Number(property));
@@ -430,7 +426,7 @@ function setValue(target, property, value, state, length) {
         return Reflect.set(target, property, value);
     }
     const previous = Reflect.get(target, property);
-    if (!state.equal(previous, value)) {
+    if (!Object.is(previous, value)) {
         Reflect.set(target, property, value);
         emitValue(state);
         length.set(target.length);
@@ -445,7 +441,7 @@ function updateArray(type, array, state, length) {
         const result = array[type](...args);
         if (affectsLength
             ? array.length !== previousLength
-            : differentArrays(state, previousArray, array)) {
+            : differentArrays(previousArray, array)) {
             emitValue(state);
             length.set(array.length);
         }

package/dist/value/array.cjs

@@ -13,14 +13,13 @@ const value_computed = require("./computed.cjs");
 const value_reactive = require("./reactive.cjs");
 const value_signal = require("./signal.cjs");
 class ReactiveArray extends value_reactive.Reactive {
-  constructor(value, options) {
+  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))
-      }),
-      options
+      })
     );
     __privateAdd(this, _size, value_signal.signal(0));
     __privateGet(this, _size).set(value.length);
@@ -117,8 +116,8 @@ class ReactiveArray extends value_reactive.Reactive {
   }
 }
 _size = new WeakMap();
-function array(value, options) {
-  return new ReactiveArray(Array.isArray(value) ? value : [], options);
+function array(value) {
+  return new ReactiveArray(Array.isArray(value) ? value : []);
 }
 function setValue(target, property, value, state, length) {
   const isIndex = !Number.isNaN(Number(property));
@@ -127,7 +126,7 @@ function setValue(target, property, value, state, length) {
     return Reflect.set(target, property, value);
   }
   const previous = Reflect.get(target, property);
-  if (!state.equal(previous, value)) {
+  if (!Object.is(previous, value)) {
     Reflect.set(target, property, value);
     helpers_value.emitValue(state);
     length.set(target.length);
@@ -142,7 +141,7 @@ function updateArray(type, array2, state, length) {
     const result = array2[type](
       ...args
     );
-    if (affectsLength ? array2.length !== previousLength : helpers_value.differentArrays(state, previousArray, array2)) {
+    if (affectsLength ? array2.length !== previousLength : helpers_value.differentArrays(previousArray, array2)) {
       helpers_value.emitValue(state);
       length.set(array2.length);
     }

package/dist/value/array.js

@@ -11,14 +11,13 @@ import { computed } from "./computed.js";
 import { Reactive } from "./reactive.js";
 import { signal } from "./signal.js";
 class ReactiveArray extends Reactive {
-  constructor(value, options) {
+  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))
-      }),
-      options
+      })
     );
     __privateAdd(this, _size, signal(0));
     __privateGet(this, _size).set(value.length);
@@ -115,8 +114,8 @@ class ReactiveArray extends Reactive {
   }
 }
 _size = new WeakMap();
-function array(value, options) {
-  return new ReactiveArray(Array.isArray(value) ? value : [], options);
+function array(value) {
+  return new ReactiveArray(Array.isArray(value) ? value : []);
 }
 function setValue(target, property, value, state, length) {
   const isIndex = !Number.isNaN(Number(property));
@@ -125,7 +124,7 @@ function setValue(target, property, value, state, length) {
     return Reflect.set(target, property, value);
   }
   const previous = Reflect.get(target, property);
-  if (!state.equal(previous, value)) {
+  if (!Object.is(previous, value)) {
     Reflect.set(target, property, value);
     emitValue(state);
     length.set(target.length);
@@ -140,7 +139,7 @@ function updateArray(type, array2, state, length) {
     const result = array2[type](
       ...args
     );
-    if (affectsLength ? array2.length !== previousLength : differentArrays(state, previousArray, array2)) {
+    if (affectsLength ? array2.length !== previousLength : differentArrays(previousArray, array2)) {
       emitValue(state);
       length.set(array2.length);
     }

package/dist/value/computed.cjs

@@ -9,8 +9,8 @@ const helpers_is = require("../helpers/is.cjs");
 const value_reactive = require("./reactive.cjs");
 exports.activeComputed = void 0;
 class Computed extends value_reactive.Reactive {
-  constructor(callback, options) {
-    super(helpers_is.computedName, void 0, options);
+  constructor(callback) {
+    super(helpers_is.computedName, void 0);
     __publicField(this, "effect", {
       dirty: true,
       instance: void 0
@@ -21,7 +21,7 @@ class Computed extends value_reactive.Reactive {
         exports.activeComputed = this;
         const value = callback();
         exports.activeComputed = previousComputed;
-        if (!this.state.equal(this.state.value, value)) {
+        if (!Object.is(this.state.value, value)) {
           this.state.value = value;
           for (const computed2 of this.state.computeds) {
             computed2.effect.dirty = true;
@@ -53,8 +53,8 @@ class Computed extends value_reactive.Reactive {
     return this.state.value;
   }
 }
-function computed(callback, options) {
-  return new Computed(callback, options);
+function computed(callback) {
+  return new Computed(callback);
 }
 exports.Computed = Computed;
 exports.computed = computed;

package/dist/value/computed.js

@@ -7,8 +7,8 @@ import { computedName } from "../helpers/is.js";
 import { Reactive } from "./reactive.js";
 let activeComputed;
 class Computed extends Reactive {
-  constructor(callback, options) {
-    super(computedName, void 0, options);
+  constructor(callback) {
+    super(computedName, void 0);
     __publicField(this, "effect", {
       dirty: true,
       instance: void 0
@@ -19,7 +19,7 @@ class Computed extends Reactive {
         activeComputed = this;
         const value = callback();
         activeComputed = previousComputed;
-        if (!this.state.equal(this.state.value, value)) {
+        if (!Object.is(this.state.value, value)) {
           this.state.value = value;
           for (const computed2 of this.state.computeds) {
             computed2.effect.dirty = true;
@@ -51,8 +51,8 @@ class Computed extends Reactive {
     return this.state.value;
   }
 }
-function computed(callback, options) {
-  return new Computed(callback, options);
+function computed(callback) {
+  return new Computed(callback);
 }
 export {
   Computed,

package/dist/value/reactive.cjs

@@ -5,18 +5,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const subscription = require("../subscription.cjs");
 class Reactive {
-  constructor(name, value, options) {
+  constructor(name, value) {
     __publicField(this, "state", {
       computeds: /* @__PURE__ */ new Set(),
       effects: /* @__PURE__ */ new Set(),
-      equal: Object.is,
       subscriptions: /* @__PURE__ */ new Map(),
       value: void 0
     });
     this.state.value = value;
-    if (typeof options === "object" && typeof options.equal === "function") {
-      this.state.equal = options.equal;
-    }
     Object.defineProperty(this, "$mora", {
       value: name
     });

package/dist/value/reactive.js

@@ -3,18 +3,14 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { subscribe, unsubscribe } from "../subscription.js";
 class Reactive {
-  constructor(name, value, options) {
+  constructor(name, value) {
     __publicField(this, "state", {
       computeds: /* @__PURE__ */ new Set(),
       effects: /* @__PURE__ */ new Set(),
-      equal: Object.is,
       subscriptions: /* @__PURE__ */ new Map(),
       value: void 0
     });
     this.state.value = value;
-    if (typeof options === "object" && typeof options.equal === "function") {
-      this.state.equal = options.equal;
-    }
     Object.defineProperty(this, "$mora", {
       value: name
     });

package/dist/value/signal.cjs

@@ -4,8 +4,8 @@ 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, options) {
-    super(helpers_is.signalName, value, options);
+  constructor(value) {
+    super(helpers_is.signalName, value);
   }
   /**
    * @inheritdoc
@@ -17,7 +17,7 @@ class Signal extends value_reactive.Reactive {
    * Set the value
    */
   set(value) {
-    if (helpers_value.differentValues(this.state, this.state.value, value)) {
+    if (helpers_value.differentValues(this.state.value, value)) {
       this.state.value = value;
       helpers_value.emitValue(this.state);
     }
@@ -29,8 +29,8 @@ class Signal extends value_reactive.Reactive {
     this.set(callback(this.state.value));
   }
 }
-function signal(value, options) {
-  return new Signal(value, options);
+function signal(value) {
+  return new Signal(value);
 }
 exports.Signal = Signal;
 exports.signal = signal;

package/dist/value/signal.js

@@ -2,8 +2,8 @@ import { signalName } from "../helpers/is.js";
 import { getValue, differentValues, emitValue } from "../helpers/value.js";
 import { Reactive } from "./reactive.js";
 class Signal extends Reactive {
-  constructor(value, options) {
-    super(signalName, value, options);
+  constructor(value) {
+    super(signalName, value);
   }
   /**
    * @inheritdoc
@@ -15,7 +15,7 @@ class Signal extends Reactive {
    * Set the value
    */
   set(value) {
-    if (differentValues(this.state, this.state.value, value)) {
+    if (differentValues(this.state.value, value)) {
       this.state.value = value;
       emitValue(this.state);
     }
@@ -27,8 +27,8 @@ class Signal extends Reactive {
     this.set(callback(this.state.value));
   }
 }
-function signal(value, options) {
-  return new Signal(value, options);
+function signal(value) {
+  return new Signal(value);
 }
 export {
   Signal,

package/package.json

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

package/src/helpers/is.ts

@@ -4,6 +4,7 @@ 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';
 
 /**
  * Is the value a reactive array?
@@ -48,9 +49,14 @@ export function isSignal(value: unknown): value is Signal<unknown> {
 	return isMora<Signal<unknown>>(value, signalName);
 }
 
+export function isStore(value: unknown): value is Store<unknown> {
+	return isMora<Reactive<unknown>>(value, storeName);
+}
+
 export const arrayName = 'array';
 export const computedName = 'computed';
 export const effectName = 'effect';
 export const signalName = 'signal';
+export const storeName = 'store';
 
-const reactiveNames = new Set([arrayName, computedName, signalName]);
+const reactiveNames = new Set([arrayName, computedName, signalName, storeName]);

package/src/helpers/proxy.ts

@@ -0,0 +1,72 @@
+import {isArrayOrPlainObject} from '@oscarpalmer/atoms/is';
+import type {ArrayOrPlainObject, PlainObject} from '@oscarpalmer/atoms/models';
+import {startBatch, stopBatch} from '../batch';
+import type {ReactiveState} from '../value/reactive';
+import type {Signal} from '../value/signal';
+import {emitValue} from './value';
+
+export function setProxyValue(
+	proxy: ArrayOrPlainObject,
+	value: ArrayOrPlainObject,
+): void {
+	startBatch();
+
+	const proxyKeys = Object.keys(proxy);
+	const valueKeys = Object.keys(value);
+
+	let {length} = proxyKeys;
+
+	for (let index = 0; index < length; index += 1) {
+		const key = proxyKeys[index];
+
+		(proxy as PlainObject)[key] = valueKeys.includes(key)
+			? (value as PlainObject)[key]
+			: undefined;
+	}
+
+	length = valueKeys.length;
+
+	for (let index = 0; index < length; index += 1) {
+		const key = valueKeys[index];
+
+		if (!proxyKeys.includes(key)) {
+			const keyedValue = (value as PlainObject)[key];
+
+			(proxy as PlainObject)[key] = keyedValue;
+		}
+	}
+
+	stopBatch();
+}
+
+export function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(
+	target: Value,
+	property: PropertyKey,
+	value: unknown,
+	state: ReactiveState<Value, Equal>,
+	isArray: boolean,
+	length?: Signal<number>,
+): boolean {
+	if (isArray) {
+		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 (!state.equal(previous as never, value as never)) {
+		Reflect.set(target, property, value);
+
+		emitValue(state);
+
+		if (isArray) {
+			length?.set((target as unknown[]).length);
+		}
+	}
+
+	return true;
+}

package/src/helpers/value.ts

@@ -3,7 +3,25 @@ import {activeEffect} from '../effect';
 import {type InternalComputed, activeComputed} from '../value/computed';
 import type {ReactiveState} from '../value/reactive';
 
-export function differentArrays<Value>(
+export function emitValue<Value>(state: ReactiveState<Value, never>): 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) {
+		flushHandlers();
+	}
+}
+
+export function equalArrays<Value>(
 	state: ReactiveState<Value[], Value>,
 	first: Value[],
 	second: Value[],
@@ -11,7 +29,7 @@ export function differentArrays<Value>(
 	let {length} = first;
 
 	if (length !== second.length) {
-		return true;
+		return false;
 	}
 
 	let offset = 0;
@@ -22,7 +40,7 @@ export function differentArrays<Value>(
 
 		for (let index = 0; index < offset; index += 1) {
 			if (!state.equal(first[index], second[index])) {
-				return true;
+				return false;
 			}
 		}
 	}
@@ -31,39 +49,11 @@ export function differentArrays<Value>(
 
 	for (let index = offset; index < length; index += 1) {
 		if (!state.equal(first[index], second[index])) {
-			return true;
+			return false;
 		}
 	}
 
-	return false;
-}
-
-export function differentValues<Value>(
-	state: ReactiveState<Value, Value>,
-	first: Value,
-	second: Value,
-): boolean {
-	return Array.isArray(first) && Array.isArray(second)
-		? differentArrays(state as never, first, second)
-		: !state.equal(first, second);
-}
-
-export function emitValue<Value>(state: ReactiveState<Value, never>): 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) {
-		flushHandlers();
-	}
+	return true;
 }
 
 export function getValue<Value>(state: ReactiveState<Value, never>): Value {

package/src/index.ts

@@ -11,3 +11,4 @@ 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';
+export {store, type Store} from './value/store';