@oscarpalmer/mora 0.18.0 → 0.18.1

package/dist/helpers/is.cjs

@@ -18,11 +18,15 @@ function isReactive(value) {
 function isSignal(value) {
   return isMora(value, signalName);
 }
+function isStore(value) {
+  return isMora(value, storeName);
+}
 const arrayName = "array";
 const computedName = "computed";
 const effectName = "effect";
 const signalName = "signal";
-const reactiveNames = /* @__PURE__ */ new Set([arrayName, computedName, signalName]);
+const storeName = "store";
+const reactiveNames = /* @__PURE__ */ new Set([arrayName, computedName, signalName, storeName]);
 exports.arrayName = arrayName;
 exports.computedName = computedName;
 exports.effectName = effectName;
@@ -31,4 +35,6 @@ exports.isComputed = isComputed;
 exports.isEffect = isEffect;
 exports.isReactive = isReactive;
 exports.isSignal = isSignal;
+exports.isStore = isStore;
 exports.signalName = signalName;
+exports.storeName = storeName;

package/dist/helpers/is.js

@@ -16,11 +16,15 @@ function isReactive(value) {
 function isSignal(value) {
   return isMora(value, signalName);
 }
+function isStore(value) {
+  return isMora(value, storeName);
+}
 const arrayName = "array";
 const computedName = "computed";
 const effectName = "effect";
 const signalName = "signal";
-const reactiveNames = /* @__PURE__ */ new Set([arrayName, computedName, signalName]);
+const storeName = "store";
+const reactiveNames = /* @__PURE__ */ new Set([arrayName, computedName, signalName, storeName]);
 export {
   arrayName,
   computedName,
@@ -30,5 +34,7 @@ export {
   isEffect,
   isReactive,
   isSignal,
-  signalName
+  isStore,
+  signalName,
+  storeName
 };

package/dist/helpers/proxy.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const batch = require("../batch.cjs");
+const helpers_value = require("./value.cjs");
+function setProxyValue(proxy, value) {
+  batch.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[key] = valueKeys.includes(key) ? value[key] : void 0;
+  }
+  length = valueKeys.length;
+  for (let index = 0; index < length; index += 1) {
+    const key = valueKeys[index];
+    if (!proxyKeys.includes(key)) {
+      const keyedValue = value[key];
+      proxy[key] = keyedValue;
+    }
+  }
+  batch.stopBatch();
+}
+function setValueInProxy(target, property, value, state, isArray, length) {
+  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, value)) {
+    Reflect.set(target, property, value);
+    helpers_value.emitValue(state);
+    if (isArray) {
+      length == null ? void 0 : length.set(target.length);
+    }
+  }
+  return true;
+}
+exports.setProxyValue = setProxyValue;
+exports.setValueInProxy = setValueInProxy;

package/dist/helpers/proxy.js

@@ -0,0 +1,43 @@
+import { startBatch, stopBatch } from "../batch.js";
+import { emitValue } from "./value.js";
+function setProxyValue(proxy, value) {
+  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[key] = valueKeys.includes(key) ? value[key] : void 0;
+  }
+  length = valueKeys.length;
+  for (let index = 0; index < length; index += 1) {
+    const key = valueKeys[index];
+    if (!proxyKeys.includes(key)) {
+      const keyedValue = value[key];
+      proxy[key] = keyedValue;
+    }
+  }
+  stopBatch();
+}
+function setValueInProxy(target, property, value, state, isArray, length) {
+  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, value)) {
+    Reflect.set(target, property, value);
+    emitValue(state);
+    if (isArray) {
+      length == null ? void 0 : length.set(target.length);
+    }
+  }
+  return true;
+}
+export {
+  setProxyValue,
+  setValueInProxy
+};

package/dist/helpers/value.cjs

@@ -3,45 +3,42 @@ 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(first, second) {
+function emitValue(state) {
+  for (const computed of state.computeds) {
+    computed.effect.dirty = true;
+  }
+  for (const effect2 of state.effects) {
+    batch.batchedHandlers.add(effect2);
+  }
+  for (const [, subscription] of state.subscriptions) {
+    batch.batchedHandlers.add(subscription);
+  }
+  if (batch.batchDepth === 0) {
+    batch.flushHandlers();
+  }
+}
+function equalArrays(state, first, second) {
   let { length } = first;
   if (length !== second.length) {
-    return true;
+    return false;
   }
   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;
+      if (!state.equal(first[index], second[index])) {
+        return false;
       }
     }
   }
   length -= offset;
   for (let index = offset; index < length; index += 1) {
-    if (!Object.is(first[index], second[index])) {
-      return true;
+    if (!state.equal(first[index], second[index])) {
+      return false;
     }
   }
-  return false;
-}
-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) {
-    computed.effect.dirty = true;
-  }
-  for (const effect2 of state.effects) {
-    batch.batchedHandlers.add(effect2);
-  }
-  for (const [, subscription] of state.subscriptions) {
-    batch.batchedHandlers.add(subscription);
-  }
-  if (batch.batchDepth === 0) {
-    batch.flushHandlers();
-  }
+  return true;
 }
 function getValue(state) {
   if (value_computed.activeComputed != null) {
@@ -52,7 +49,6 @@ function getValue(state) {
   }
   return state.value;
 }
-exports.differentArrays = differentArrays;
-exports.differentValues = differentValues;
 exports.emitValue = emitValue;
+exports.equalArrays = equalArrays;
 exports.getValue = getValue;

package/dist/helpers/value.js

@@ -1,45 +1,42 @@
 import { batchedHandlers, batchDepth, flushHandlers } from "../batch.js";
 import { activeEffect } from "../effect.js";
 import { activeComputed } from "../value/computed.js";
-function differentArrays(first, second) {
+function emitValue(state) {
+  for (const computed of state.computeds) {
+    computed.effect.dirty = true;
+  }
+  for (const effect of state.effects) {
+    batchedHandlers.add(effect);
+  }
+  for (const [, subscription] of state.subscriptions) {
+    batchedHandlers.add(subscription);
+  }
+  if (batchDepth === 0) {
+    flushHandlers();
+  }
+}
+function equalArrays(state, first, second) {
   let { length } = first;
   if (length !== second.length) {
-    return true;
+    return false;
   }
   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;
+      if (!state.equal(first[index], second[index])) {
+        return false;
       }
     }
   }
   length -= offset;
   for (let index = offset; index < length; index += 1) {
-    if (!Object.is(first[index], second[index])) {
-      return true;
+    if (!state.equal(first[index], second[index])) {
+      return false;
     }
   }
-  return false;
-}
-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) {
-    computed.effect.dirty = true;
-  }
-  for (const effect of state.effects) {
-    batchedHandlers.add(effect);
-  }
-  for (const [, subscription] of state.subscriptions) {
-    batchedHandlers.add(subscription);
-  }
-  if (batchDepth === 0) {
-    flushHandlers();
-  }
+  return true;
 }
 function getValue(state) {
   if (activeComputed != null) {
@@ -51,8 +48,7 @@ function getValue(state) {
   return state.value;
 }
 export {
-  differentArrays,
-  differentValues,
   emitValue,
+  equalArrays,
   getValue
 };

package/dist/index.cjs

@@ -6,6 +6,7 @@ const helpers_is = require("./helpers/is.cjs");
 const value_array = require("./value/array.cjs");
 const value_computed = require("./value/computed.cjs");
 const value_signal = require("./value/signal.cjs");
+const value_store = require("./value/store.cjs");
 exports.startBatch = batch.startBatch;
 exports.stopBatch = batch.stopBatch;
 exports.effect = effect.effect;
@@ -17,3 +18,4 @@ exports.isSignal = helpers_is.isSignal;
 exports.array = value_array.array;
 exports.computed = value_computed.computed;
 exports.signal = value_signal.signal;
+exports.store = value_store.store;

package/dist/index.js

@@ -4,6 +4,7 @@ import { isArray, isComputed, isEffect, isReactive, isSignal } from "./helpers/i
 import { array } from "./value/array.js";
 import { computed } from "./value/computed.js";
 import { signal } from "./value/signal.js";
+import { store } from "./value/store.js";
 export {
   array,
   computed,
@@ -15,5 +16,6 @@ export {
   isSignal,
   signal,
   startBatch,
-  stopBatch
+  stopBatch,
+  store
 };

package/dist/mora.full.js

@@ -37,7 +37,8 @@ const arrayName = 'array';
 const computedName = 'computed';
 const effectName = 'effect';
 const signalName = 'signal';
-const reactiveNames = new Set([arrayName, computedName, signalName]);
+const storeName = 'store';
+const reactiveNames = new Set([arrayName, computedName, signalName, storeName]);
 
 class Effect {
     constructor(callback) {
@@ -132,11 +133,15 @@ class Reactive {
     state = {
         computeds: new Set(),
         effects: new Set(),
+        equal: Object.is,
         subscriptions: new Map(),
         value: undefined,
     };
-    constructor(name, 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, '$mora', {
             value: name,
         });
@@ -179,15 +184,15 @@ class Computed extends Reactive {
         dirty: true,
         instance: undefined,
     };
-    constructor(callback) {
-        super(computedName, undefined);
+    constructor(callback, options) {
+        super(computedName, undefined, options);
         this.effect.instance = effect(() => {
             if (this.effect.dirty) {
                 const previousComputed = activeComputed;
                 activeComputed = this;
                 const value = callback();
                 activeComputed = previousComputed;
-                if (!Object.is(this.state.value, value)) {
+                if (!this.state.equal(this.state.value, value)) {
                     this.state.value = value;
                     for (const computed of this.state.computeds) {
                         computed.effect.dirty = true;
@@ -222,51 +227,46 @@ class Computed extends Reactive {
 /**
  * Create a computed value
  */
-function computed(callback) {
-    return new Computed(callback);
+function computed(callback, options) {
+    return new Computed(callback, options);
 }
 
-function differentArrays(first, second) {
+function emitValue(state) {
+    for (const computed of state.computeds) {
+        computed.effect.dirty = true;
+    }
+    for (const effect of state.effects) {
+        batchedHandlers.add(effect);
+    }
+    for (const [, subscription] of state.subscriptions) {
+        batchedHandlers.add(subscription);
+    }
+    if (batchDepth === 0) {
+        flushHandlers();
+    }
+}
+function equalArrays(state, first, second) {
     let { length } = first;
     if (length !== second.length) {
-        return true;
+        return false;
     }
     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;
+            if (!state.equal(first[index], second[index])) {
+                return false;
             }
         }
     }
     length -= offset;
     for (let index = offset; index < length; index += 1) {
-        if (!Object.is(first[index], second[index])) {
-            return true;
+        if (!state.equal(first[index], second[index])) {
+            return false;
         }
     }
-    return false;
-}
-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) {
-        computed.effect.dirty = true;
-    }
-    for (const effect of state.effects) {
-        batchedHandlers.add(effect);
-    }
-    for (const [, subscription] of state.subscriptions) {
-        batchedHandlers.add(subscription);
-    }
-    if (batchDepth === 0) {
-        flushHandlers();
-    }
+    return true;
 }
 function getValue(state) {
     if (activeComputed != null) {
@@ -278,9 +278,49 @@ function getValue(state) {
     return state.value;
 }
 
+function setProxyValue(proxy, value) {
+    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[key] = valueKeys.includes(key)
+            ? value[key]
+            : undefined;
+    }
+    length = valueKeys.length;
+    for (let index = 0; index < length; index += 1) {
+        const key = valueKeys[index];
+        if (!proxyKeys.includes(key)) {
+            const keyedValue = value[key];
+            proxy[key] = keyedValue;
+        }
+    }
+    stopBatch();
+}
+function setValueInProxy(target, property, value, state, isArray, length) {
+    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, value)) {
+        Reflect.set(target, property, value);
+        emitValue(state);
+        if (isArray) {
+            length?.set(target.length);
+        }
+    }
+    return true;
+}
+
 class Signal extends Reactive {
-    constructor(value) {
-        super(signalName, value);
+    constructor(value, options) {
+        super(signalName, value, options);
     }
     /**
      * @inheritdoc
@@ -292,7 +332,7 @@ class Signal extends Reactive {
      * Set the value
      */
     set(value) {
-        if (differentValues(this.state.value, value)) {
+        if (!this.state.equal(this.state.value, value)) {
             this.state.value = value;
             emitValue(this.state);
         }
@@ -307,8 +347,8 @@ class Signal extends Reactive {
 /**
  * Create a reactive value
  */
-function signal(value) {
-    return new Signal(value);
+function signal(value, options) {
+    return new Signal(value, options);
 }
 
 class ReactiveArray extends Reactive {
@@ -329,13 +369,13 @@ class ReactiveArray extends Reactive {
             this.get().length = value;
         }
     }
-    constructor(value) {
+    constructor(value, options) {
         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),
-        }));
+            set: (target, property, value) => setValueInProxy(target, property, value, this.state, true, this.#size),
+        }), options);
         this.#size.set(value.length);
     }
     /**
@@ -416,22 +456,8 @@ class ReactiveArray extends Reactive {
 /**
  * Create a reactive array
  */
-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 array(value, options) {
+    return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 function updateArray(type, array, state, length) {
     const affectsLength = lengthAffectingMethods.has(type);
@@ -441,7 +467,7 @@ function updateArray(type, array, state, length) {
         const result = array[type](...args);
         if (affectsLength
             ? array.length !== previousLength
-            : differentArrays(previousArray, array)) {
+            : !equalArrays(state, previousArray, array)) {
             emitValue(state);
             length.set(array.length);
         }
@@ -463,4 +489,46 @@ const updateMethods = new Set([
     'splice',
 ]);
 
-export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch };
+function isKey(value) {
+  return typeof value === "number" || typeof value === "string";
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (Symbol.toStringTag in value || Symbol.iterator in value) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+
+class Store extends Reactive {
+    constructor(value, options) {
+        super(storeName, new Proxy(value, {
+            set: (target, property, value) => setValueInProxy(target, property, value, this.state, false),
+        }), options);
+    }
+    get(key) {
+        return isKey(key) ? this.state.value[key] : getValue(this.state);
+    }
+    peek(key) {
+        return isKey(key) ? this.state.value[key] : { ...this.state.value };
+    }
+    set(first, second) {
+        if (isKey(first)) {
+            this.state.value[first] = second;
+        }
+        else if (first == null || isPlainObject(first)) {
+            setProxyValue(this.state.value, first ?? {});
+        }
+    }
+}
+/**
+ * Create a reactive store
+ */
+function store(value, options) {
+    return new Store((isPlainObject(value) ? value : {}), options);
+}
+
+export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/is.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isKey(value) {
+  return typeof value === "number" || typeof value === "string";
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (Symbol.toStringTag in value || Symbol.iterator in value) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+exports.isKey = isKey;
+exports.isPlainObject = isPlainObject;

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/is.js

@@ -0,0 +1,17 @@
+function isKey(value) {
+  return typeof value === "number" || typeof value === "string";
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (Symbol.toStringTag in value || Symbol.iterator in value) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+export {
+  isKey,
+  isPlainObject
+};