@oscarpalmer/mora 0.16.0 → 0.17.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(first, second) {
+function differentArrays(state, first, second) {
   let { length } = first;
   if (length !== second.length) {
     return true;
@@ -13,21 +13,21 @@ function differentArrays(first, second) {
     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])) {
+      if (!state.equal(first[index], second[index])) {
         return true;
       }
     }
   }
   length -= offset;
   for (let index = offset; index < length; index += 1) {
-    if (!Object.is(first[index], second[index])) {
+    if (!state.equal(first[index], second[index])) {
       return true;
     }
   }
   return false;
 }
-function differentValues(first, second) {
-  return Array.isArray(first) && Array.isArray(second) ? differentArrays(first, second) : !Object.is(first, second);
+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) {

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(first, second) {
+function differentArrays(state, first, second) {
   let { length } = first;
   if (length !== second.length) {
     return true;
@@ -11,21 +11,21 @@ function differentArrays(first, second) {
     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])) {
+      if (!state.equal(first[index], second[index])) {
         return true;
       }
     }
   }
   length -= offset;
   for (let index = offset; index < length; index += 1) {
-    if (!Object.is(first[index], second[index])) {
+    if (!state.equal(first[index], second[index])) {
       return true;
     }
   }
   return false;
 }
-function differentValues(first, second) {
-  return Array.isArray(first) && Array.isArray(second) ? differentArrays(first, second) : !Object.is(first, second);
+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) {

package/dist/mora.full.js

@@ -132,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,
         });
@@ -179,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;
@@ -222,11 +226,11 @@ 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 differentArrays(state, first, second) {
     let { length } = first;
     if (length !== second.length) {
         return true;
@@ -236,23 +240,23 @@ function differentArrays(first, second) {
         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])) {
+            if (!state.equal(first[index], second[index])) {
                 return true;
             }
         }
     }
     length -= offset;
     for (let index = offset; index < length; index += 1) {
-        if (!Object.is(first[index], second[index])) {
+        if (!state.equal(first[index], second[index])) {
             return true;
         }
     }
     return false;
 }
-function differentValues(first, second) {
+function differentValues(state, first, second) {
     return Array.isArray(first) && Array.isArray(second)
-        ? differentArrays(first, second)
-        : !Object.is(first, second);
+        ? differentArrays(state, first, second)
+        : !state.equal(first, second);
 }
 function emitValue(state) {
     for (const computed of state.computeds) {
@@ -279,8 +283,8 @@ function getValue(state) {
 }
 
 class Signal extends Reactive {
-    constructor(value) {
-        super(signalName, value);
+    constructor(value, options) {
+        super(signalName, value, options);
     }
     /**
      * @inheritdoc
@@ -292,7 +296,7 @@ class Signal extends Reactive {
      * Set the value
      */
     set(value) {
-        if (differentValues(this.state.value, value)) {
+        if (differentValues(this.state, this.state.value, value)) {
             this.state.value = value;
             emitValue(this.state);
         }
@@ -307,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 {
@@ -329,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);
     }
     /**
@@ -416,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));
@@ -426,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);
@@ -441,7 +445,7 @@ function updateArray(type, array, state, length) {
         const result = array[type](...args);
         if (affectsLength
             ? array.length !== previousLength
-            : differentArrays(previousArray, array)) {
+            : differentArrays(state, previousArray, array)) {
             emitValue(state);
             length.set(array.length);
         }

package/dist/value/array.cjs

@@ -13,13 +13,14 @@ 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);
@@ -116,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));
@@ -126,7 +127,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);
     helpers_value.emitValue(state);
     length.set(target.length);
@@ -141,7 +142,7 @@ function updateArray(type, array2, state, length) {
     const result = array2[type](
       ...args
     );
-    if (affectsLength ? array2.length !== previousLength : helpers_value.differentArrays(previousArray, array2)) {
+    if (affectsLength ? array2.length !== previousLength : helpers_value.differentArrays(state, previousArray, array2)) {
       helpers_value.emitValue(state);
       length.set(array2.length);
     }

package/dist/value/array.js

@@ -11,13 +11,14 @@ 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);
@@ -114,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));
@@ -124,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);
@@ -139,7 +140,7 @@ function updateArray(type, array2, state, length) {
     const result = array2[type](
       ...args
     );
-    if (affectsLength ? array2.length !== previousLength : differentArrays(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;
@@ -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;
@@ -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
     });

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

package/package.json

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

package/src/helpers/value.ts

@@ -3,7 +3,11 @@ import {activeEffect} from '../effect';
 import {type InternalComputed, activeComputed} from '../value/computed';
 import type {ReactiveState} from '../value/reactive';
 
-export function differentArrays(first: unknown[], second: unknown[]): boolean {
+export function differentArrays<Value>(
+	state: ReactiveState<Value[], Value>,
+	first: Value[],
+	second: Value[],
+): boolean {
 	let {length} = first;
 
 	if (length !== second.length) {
@@ -17,7 +21,7 @@ export function differentArrays(first: unknown[], second: unknown[]): boolean {
 		offset = offset > 25 ? 25 : offset;
 
 		for (let index = 0; index < offset; index += 1) {
-			if (!Object.is(first[index], second[index])) {
+			if (!state.equal(first[index], second[index])) {
 				return true;
 			}
 		}
@@ -26,7 +30,7 @@ export function differentArrays(first: unknown[], second: unknown[]): boolean {
 	length -= offset;
 
 	for (let index = offset; index < length; index += 1) {
-		if (!Object.is(first[index], second[index])) {
+		if (!state.equal(first[index], second[index])) {
 			return true;
 		}
 	}
@@ -34,13 +38,17 @@ export function differentArrays(first: unknown[], second: unknown[]): boolean {
 	return false;
 }
 
-export function differentValues(first: unknown, second: unknown): boolean {
+export function differentValues<Value>(
+	state: ReactiveState<Value, Value>,
+	first: Value,
+	second: Value,
+): boolean {
 	return Array.isArray(first) && Array.isArray(second)
-		? differentArrays(first, second)
-		: !Object.is(first, second);
+		? differentArrays(state as never, first, second)
+		: !state.equal(first, second);
 }
 
-export function emitValue<Value>(state: ReactiveState<Value>): void {
+export function emitValue<Value>(state: ReactiveState<Value, never>): void {
 	for (const computed of state.computeds) {
 		(computed as unknown as InternalComputed).effect.dirty = true;
 	}
@@ -58,7 +66,7 @@ export function emitValue<Value>(state: ReactiveState<Value>): void {
 	}
 }
 
-export function getValue<Value>(state: ReactiveState<Value>): Value {
+export function getValue<Value>(state: ReactiveState<Value, never>): Value {
 	if (activeComputed != null) {
 		state.computeds.add(activeComputed);
 	}

package/src/subscription.ts

@@ -3,7 +3,7 @@ import type {ReactiveState} from './value/reactive';
 
 export class Subscription<Value> {
 	constructor(
-		public state: ReactiveState<Value>,
+		public state: ReactiveState<Value, never>,
 		public callback: GenericCallback,
 	) {
 		callback(state.value);
@@ -18,7 +18,7 @@ export type Unsubscribe = () => void;
 export function noop(): void {}
 
 export function subscribe<Value>(
-	state: ReactiveState<Value>,
+	state: ReactiveState<Value, never>,
 	callback: (value: Value) => void,
 ): Unsubscribe {
 	if (typeof callback !== 'function' || state.subscriptions.has(callback)) {
@@ -33,7 +33,7 @@ export function subscribe<Value>(
 }
 
 export function unsubscribe<Value>(
-	state: ReactiveState<Value>,
+	state: ReactiveState<Value, never>,
 	callback: (value: Value) => void,
 ): void {
 	const subscription = state.subscriptions.get(callback);

package/src/value/array.ts

@@ -1,10 +1,10 @@
 import {arrayName} from '../helpers/is';
 import {differentArrays, emitValue, getValue} from '../helpers/value';
 import {type Computed, computed} from './computed';
-import {Reactive, type ReactiveState} from './reactive';
+import {Reactive, type ReactiveOptions, type ReactiveState} from './reactive';
 import {type Signal, signal} from './signal';
 
-export class ReactiveArray<Item> extends Reactive<Item[]> {
+export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	#size = signal(0);
 
 	/**
@@ -27,7 +27,7 @@ export class ReactiveArray<Item> extends Reactive<Item[]> {
 		}
 	}
 
-	constructor(value: Item[]) {
+	constructor(value: Item[], options?: ReactiveOptions<Item>) {
 		super(
 			arrayName,
 			new Proxy(value, {
@@ -38,6 +38,7 @@ export class ReactiveArray<Item> extends Reactive<Item[]> {
 				set: (target, property, value) =>
 					setValue(target, property, value, this.state, this.#size),
 			}),
+			options,
 		);
 
 		this.#size.set(value.length);
@@ -164,15 +165,18 @@ export class ReactiveArray<Item> extends Reactive<Item[]> {
 /**
  * Create a reactive array
  */
-export function array<Item>(value: Item[]): ReactiveArray<Item> {
-	return new ReactiveArray(Array.isArray(value) ? value : []);
+export function array<Item>(
+	value: Item[],
+	options?: ReactiveOptions<Item>,
+): ReactiveArray<Item> {
+	return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 
 function setValue<Item>(
 	target: Item[],
 	property: PropertyKey,
-	value: unknown,
-	state: ReactiveState<Item[]>,
+	value: Item,
+	state: ReactiveState<Item[], Item>,
 	length: Signal<number>,
 ): boolean {
 	const isIndex = !Number.isNaN(Number(property));
@@ -184,7 +188,7 @@ function setValue<Item>(
 
 	const previous = Reflect.get(target, property);
 
-	if (!Object.is(previous, value)) {
+	if (!state.equal(previous, value)) {
 		Reflect.set(target, property, value);
 
 		emitValue(state);
@@ -198,7 +202,7 @@ function setValue<Item>(
 function updateArray<Item>(
 	type: string,
 	array: Item[],
-	state: ReactiveState<Item[]>,
+	state: ReactiveState<Item[], Item>,
 	length: Signal<number>,
 ): unknown {
 	const affectsLength = lengthAffectingMethods.has(type);
@@ -213,7 +217,7 @@ function updateArray<Item>(
 		if (
 			affectsLength
 				? array.length !== previousLength
-				: differentArrays(previousArray, array)
+				: differentArrays(state, previousArray, array)
 		) {
 			emitValue(state);