@oscarpalmer/mora 0.15.0 → 0.17.0

package/dist/batch.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const effect = require("./effect.cjs");
 const helpers_is = require("./helpers/is.cjs");
-function flushEffects() {
+function flushHandlers() {
   while (exports.batchDepth === 0 && batchedHandlers.size > 0) {
     const handlers = [...batchedHandlers];
     batchedHandlers.clear();
@@ -22,11 +22,11 @@ function stopBatch() {
   if (exports.batchDepth > 0) {
     exports.batchDepth -= 1;
   }
-  flushEffects();
+  flushHandlers();
 }
 const batchedHandlers = /* @__PURE__ */ new Set();
 exports.batchDepth = 0;
 exports.batchedHandlers = batchedHandlers;
-exports.flushEffects = flushEffects;
+exports.flushHandlers = flushHandlers;
 exports.startBatch = startBatch;
 exports.stopBatch = stopBatch;

package/dist/batch.js

@@ -1,6 +1,6 @@
 import { runEffect } from "./effect.js";
 import { isEffect } from "./helpers/is.js";
-function flushEffects() {
+function flushHandlers() {
   while (batchDepth === 0 && batchedHandlers.size > 0) {
     const handlers = [...batchedHandlers];
     batchedHandlers.clear();
@@ -20,14 +20,14 @@ function stopBatch() {
   if (batchDepth > 0) {
     batchDepth -= 1;
   }
-  flushEffects();
+  flushHandlers();
 }
 const batchedHandlers = /* @__PURE__ */ new Set();
 let batchDepth = 0;
 export {
   batchDepth,
   batchedHandlers,
-  flushEffects,
+  flushHandlers,
   startBatch,
   stopBatch
 };

package/dist/helpers/value.cjs

@@ -1,8 +1,48 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const batch = require("../batch.cjs");
 const effect = require("../effect.cjs");
 const value_computed = require("../value/computed.cjs");
-const helpers_emit = require("./emit.cjs");
+function differentArrays(state, first, second) {
+  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 (!state.equal(first[index], second[index])) {
+        return true;
+      }
+    }
+  }
+  length -= offset;
+  for (let index = offset; index < length; index += 1) {
+    if (!state.equal(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 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 getValue(state) {
   if (value_computed.activeComputed != null) {
     state.computeds.add(value_computed.activeComputed);
@@ -12,11 +52,7 @@ function getValue(state) {
   }
   return state.value;
 }
-function setValue(state, value) {
-  if (!Object.is(state.value, value)) {
-    state.value = value;
-    helpers_emit.emitValue(state);
-  }
-}
+exports.differentArrays = differentArrays;
+exports.differentValues = differentValues;
+exports.emitValue = emitValue;
 exports.getValue = getValue;
-exports.setValue = setValue;

package/dist/helpers/value.js

@@ -1,6 +1,46 @@
+import { batchedHandlers, batchDepth, flushHandlers } from "../batch.js";
 import { activeEffect } from "../effect.js";
 import { activeComputed } from "../value/computed.js";
-import { emitValue } from "./emit.js";
+function differentArrays(state, first, second) {
+  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 (!state.equal(first[index], second[index])) {
+        return true;
+      }
+    }
+  }
+  length -= offset;
+  for (let index = offset; index < length; index += 1) {
+    if (!state.equal(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 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 getValue(state) {
   if (activeComputed != null) {
     state.computeds.add(activeComputed);
@@ -10,13 +50,9 @@ function getValue(state) {
   }
   return state.value;
 }
-function setValue(state, value) {
-  if (!Object.is(state.value, value)) {
-    state.value = value;
-    emitValue(state);
-  }
-}
 export {
-  getValue,
-  setValue
+  differentArrays,
+  differentValues,
+  emitValue,
+  getValue
 };

package/dist/mora.full.js

@@ -68,7 +68,7 @@ function effect(callback) {
 }
 let activeEffect;
 
-function flushEffects() {
+function flushHandlers() {
     while (batchDepth === 0 && batchedHandlers.size > 0) {
         const handlers = [...batchedHandlers];
         batchedHandlers.clear();
@@ -95,49 +95,11 @@ function stopBatch() {
     if (batchDepth > 0) {
         batchDepth -= 1;
     }
-    flushEffects();
+    flushHandlers();
 }
 const batchedHandlers = new Set();
 let batchDepth = 0;
 
-function emitArrayChanges(first, second) {
-    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;
-}
-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) {
-        flushEffects();
-    }
-}
-
 class Subscription {
     state;
     callback;
@@ -170,11 +132,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,
         });
@@ -217,15 +183,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;
@@ -245,7 +211,7 @@ class Computed extends Reactive {
      * @inheritdoc
      */
     get() {
-        if (activeComputed != null && activeComputed !== this) {
+        if (activeComputed != null && this !== activeComputed) {
             this.state.computeds.add(activeComputed);
         }
         if (activeEffect != null && activeEffect !== this.effect.instance) {
@@ -260,10 +226,52 @@ 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(state, first, second) {
+    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 (!state.equal(first[index], second[index])) {
+                return true;
+            }
+        }
+    }
+    length -= offset;
+    for (let index = offset; index < length; index += 1) {
+        if (!state.equal(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 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 getValue(state) {
     if (activeComputed != null) {
         state.computeds.add(activeComputed);
@@ -273,16 +281,10 @@ function getValue(state) {
     }
     return state.value;
 }
-function setValue$1(state, value) {
-    if (!Object.is(state.value, value)) {
-        state.value = value;
-        emitValue(state);
-    }
-}
 
 class Signal extends Reactive {
-    constructor(value) {
-        super(signalName, value);
+    constructor(value, options) {
+        super(signalName, value, options);
     }
     /**
      * @inheritdoc
@@ -294,7 +296,10 @@ class Signal extends Reactive {
      * Set the value
      */
     set(value) {
-        setValue$1(this.state, value);
+        if (differentValues(this.state, this.state.value, value)) {
+            this.state.value = value;
+            emitValue(this.state);
+        }
     }
     /**
      * Update the value
@@ -306,8 +311,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 {
@@ -328,13 +333,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),
-        }));
+        }), options);
         this.#size.set(value.length);
     }
     /**
@@ -343,6 +348,12 @@ class ReactiveArray extends Reactive {
     at(index) {
         return this.get().at(index);
     }
+    /**
+     * Clear the array
+     */
+    clear() {
+        this.length = 0;
+    }
     /**
      * @inheritdoc
      */
@@ -409,8 +420,8 @@ class ReactiveArray extends Reactive {
 /**
  * Create a reactive array
  */
-function array(value) {
-    return new ReactiveArray(Array.isArray(value) ? value : []);
+function array(value, options) {
+    return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 function setValue(target, property, value, state, length) {
     const isIndex = !Number.isNaN(Number(property));
@@ -419,7 +430,7 @@ function setValue(target, property, value, state, length) {
         return Reflect.set(target, property, value);
     }
     const previous = Reflect.get(target, property);
-    if (!Object.is(previous, value)) {
+    if (!state.equal(previous, value)) {
         Reflect.set(target, property, value);
         emitValue(state);
         length.set(target.length);
@@ -434,7 +445,7 @@ function updateArray(type, array, state, length) {
         const result = array[type](...args);
         if (affectsLength
             ? array.length !== previousLength
-            : emitArrayChanges(previousArray, array)) {
+            : differentArrays(state, previousArray, array)) {
             emitValue(state);
             length.set(array.length);
         }

package/dist/value/array.cjs

@@ -7,20 +7,20 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 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_computed = require("./computed.cjs");
 const value_reactive = require("./reactive.cjs");
 const value_signal = require("./signal.cjs");
 class ReactiveArray extends value_reactive.Reactive {
-  constructor(value) {
+  constructor(value, options) {
     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);
@@ -45,6 +45,12 @@ class ReactiveArray extends value_reactive.Reactive {
   at(index) {
     return this.get().at(index);
   }
+  /**
+   * Clear the array
+   */
+  clear() {
+    this.length = 0;
+  }
   /**
    * @inheritdoc
    */
@@ -111,8 +117,8 @@ class ReactiveArray extends value_reactive.Reactive {
   }
 }
 _size = new WeakMap();
-function array(value) {
-  return new ReactiveArray(Array.isArray(value) ? value : []);
+function array(value, options) {
+  return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 function setValue(target, property, value, state, length) {
   const isIndex = !Number.isNaN(Number(property));
@@ -121,9 +127,9 @@ function setValue(target, property, value, state, length) {
     return Reflect.set(target, property, value);
   }
   const previous = Reflect.get(target, property);
-  if (!Object.is(previous, value)) {
+  if (!state.equal(previous, value)) {
     Reflect.set(target, property, value);
-    helpers_emit.emitValue(state);
+    helpers_value.emitValue(state);
     length.set(target.length);
   }
   return true;
@@ -136,8 +142,8 @@ function updateArray(type, array2, state, length) {
     const result = array2[type](
       ...args
     );
-    if (affectsLength ? array2.length !== previousLength : helpers_emit.emitArrayChanges(previousArray, array2)) {
-      helpers_emit.emitValue(state);
+    if (affectsLength ? array2.length !== previousLength : helpers_value.differentArrays(state, previousArray, array2)) {
+      helpers_value.emitValue(state);
       length.set(array2.length);
     }
     return result;

package/dist/value/array.js

@@ -5,20 +5,20 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 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 { getValue, emitValue, differentArrays } from "../helpers/value.js";
 import { computed } from "./computed.js";
 import { Reactive } from "./reactive.js";
 import { signal } from "./signal.js";
 class ReactiveArray extends Reactive {
-  constructor(value) {
+  constructor(value, options) {
     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);
@@ -43,6 +43,12 @@ class ReactiveArray extends Reactive {
   at(index) {
     return this.get().at(index);
   }
+  /**
+   * Clear the array
+   */
+  clear() {
+    this.length = 0;
+  }
   /**
    * @inheritdoc
    */
@@ -109,8 +115,8 @@ class ReactiveArray extends Reactive {
   }
 }
 _size = new WeakMap();
-function array(value) {
-  return new ReactiveArray(Array.isArray(value) ? value : []);
+function array(value, options) {
+  return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 function setValue(target, property, value, state, length) {
   const isIndex = !Number.isNaN(Number(property));
@@ -119,7 +125,7 @@ function setValue(target, property, value, state, length) {
     return Reflect.set(target, property, value);
   }
   const previous = Reflect.get(target, property);
-  if (!Object.is(previous, value)) {
+  if (!state.equal(previous, value)) {
     Reflect.set(target, property, value);
     emitValue(state);
     length.set(target.length);
@@ -134,7 +140,7 @@ function updateArray(type, array2, state, length) {
     const result = array2[type](
       ...args
     );
-    if (affectsLength ? array2.length !== previousLength : emitArrayChanges(previousArray, array2)) {
+    if (affectsLength ? array2.length !== previousLength : differentArrays(state, 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) {
-    super(helpers_is.computedName, void 0);
+  constructor(callback, options) {
+    super(helpers_is.computedName, void 0, options);
     __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 (!Object.is(this.state.value, value)) {
+        if (!this.state.equal(this.state.value, value)) {
           this.state.value = value;
           for (const computed2 of this.state.computeds) {
             computed2.effect.dirty = true;
@@ -41,7 +41,7 @@ class Computed extends value_reactive.Reactive {
    * @inheritdoc
    */
   get() {
-    if (exports.activeComputed != null && exports.activeComputed !== this) {
+    if (exports.activeComputed != null && this !== exports.activeComputed) {
       this.state.computeds.add(exports.activeComputed);
     }
     if (effect.activeEffect != null && effect.activeEffect !== this.effect.instance) {
@@ -53,8 +53,8 @@ class Computed extends value_reactive.Reactive {
     return this.state.value;
   }
 }
-function computed(callback) {
-  return new Computed(callback);
+function computed(callback, options) {
+  return new Computed(callback, options);
 }
 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) {
-    super(computedName, void 0);
+  constructor(callback, options) {
+    super(computedName, void 0, options);
     __publicField(this, "effect", {
       dirty: true,
       instance: void 0
@@ -19,7 +19,7 @@ class Computed extends Reactive {
         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 computed2 of this.state.computeds) {
             computed2.effect.dirty = true;
@@ -39,7 +39,7 @@ class Computed extends Reactive {
    * @inheritdoc
    */
   get() {
-    if (activeComputed != null && activeComputed !== this) {
+    if (activeComputed != null && this !== activeComputed) {
       this.state.computeds.add(activeComputed);
     }
     if (activeEffect != null && activeEffect !== this.effect.instance) {
@@ -51,8 +51,8 @@ class Computed extends Reactive {
     return this.state.value;
   }
 }
-function computed(callback) {
-  return new Computed(callback);
+function computed(callback, options) {
+  return new Computed(callback, options);
 }
 export {
   Computed,

package/dist/value/reactive.cjs

@@ -5,14 +5,18 @@ 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) {
+  constructor(name, value, options) {
     __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,14 +3,18 @@ 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) {
+  constructor(name, value, options) {
     __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
     });