@oscarpalmer/mora 0.18.0 → 0.18.2

package/dist/value/array.cjs

@@ -8,18 +8,27 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var _size;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const helpers_is = require("../helpers/is.cjs");
+const helpers_proxy = require("../helpers/proxy.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))
-      })
+        set: (target, property, value2) => helpers_proxy.setValueInProxy(
+          target,
+          property,
+          value2,
+          this.state,
+          true,
+          __privateGet(this, _size)
+        )
+      }),
+      options
     );
     __privateAdd(this, _size, value_signal.signal(0));
     __privateGet(this, _size).set(value.length);
@@ -116,22 +125,8 @@ class ReactiveArray extends value_reactive.Reactive {
   }
 }
 _size = new WeakMap();
-function array(value) {
-  return new ReactiveArray(Array.isArray(value) ? value : []);
-}
-function setValue(target, property, value, state, length) {
-  const isIndex = !Number.isNaN(Number(property));
-  const isLength = property === "length";
-  if (!isIndex && !isLength) {
-    return Reflect.set(target, property, value);
-  }
-  const previous = Reflect.get(target, property);
-  if (!Object.is(previous, value)) {
-    Reflect.set(target, property, value);
-    helpers_value.emitValue(state);
-    length.set(target.length);
-  }
-  return true;
+function array(value, options) {
+  return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 function updateArray(type, array2, state, length) {
   const affectsLength = lengthAffectingMethods.has(type);
@@ -141,7 +136,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.equalArrays(state, previousArray, array2)) {
       helpers_value.emitValue(state);
       length.set(array2.length);
     }

package/dist/value/array.js

@@ -6,18 +6,27 @@ 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;
 import { arrayName } from "../helpers/is.js";
-import { getValue, emitValue, differentArrays } from "../helpers/value.js";
+import { setValueInProxy } from "../helpers/proxy.js";
+import { getValue, equalArrays, emitValue } 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))
-      })
+        set: (target, property, value2) => setValueInProxy(
+          target,
+          property,
+          value2,
+          this.state,
+          true,
+          __privateGet(this, _size)
+        )
+      }),
+      options
     );
     __privateAdd(this, _size, signal(0));
     __privateGet(this, _size).set(value.length);
@@ -114,22 +123,8 @@ class ReactiveArray extends Reactive {
   }
 }
 _size = new WeakMap();
-function array(value) {
-  return new ReactiveArray(Array.isArray(value) ? value : []);
-}
-function setValue(target, property, value, state, length) {
-  const isIndex = !Number.isNaN(Number(property));
-  const isLength = property === "length";
-  if (!isIndex && !isLength) {
-    return Reflect.set(target, property, value);
-  }
-  const previous = Reflect.get(target, property);
-  if (!Object.is(previous, value)) {
-    Reflect.set(target, property, value);
-    emitValue(state);
-    length.set(target.length);
-  }
-  return true;
+function array(value, options) {
+  return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 function updateArray(type, array2, state, length) {
   const affectsLength = lengthAffectingMethods.has(type);
@@ -139,7 +134,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 : !equalArrays(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 (!this.state.equal(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

@@ -1,9 +1,9 @@
 import { signalName } from "../helpers/is.js";
-import { getValue, differentValues, emitValue } from "../helpers/value.js";
+import { getValue, 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 (!this.state.equal(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/dist/value/store.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const is = require("../node_modules/@oscarpalmer/atoms/dist/internal/is.cjs");
+const helpers_is = require("../helpers/is.cjs");
+const helpers_proxy = require("../helpers/proxy.cjs");
+const helpers_value = require("../helpers/value.cjs");
+const value_reactive = require("./reactive.cjs");
+class Store extends value_reactive.Reactive {
+  constructor(value, options) {
+    super(
+      helpers_is.storeName,
+      new Proxy(value, {
+        set: (target, property, value2) => helpers_proxy.setValueInProxy(target, property, value2, this.state, false)
+      }),
+      options
+    );
+  }
+  get(key) {
+    return is.isKey(key) ? this.state.value[key] : helpers_value.getValue(this.state);
+  }
+  peek(key) {
+    return is.isKey(key) ? this.state.value[key] : { ...this.state.value };
+  }
+  set(first, second) {
+    if (is.isKey(first)) {
+      this.state.value[first] = second;
+    } else if (first == null || is.isPlainObject(first)) {
+      helpers_proxy.setProxyValue(this.state.value, first ?? {});
+    }
+  }
+}
+function store(value, options) {
+  return new Store(is.isPlainObject(value) ? value : {}, options);
+}
+exports.Store = Store;
+exports.store = store;

package/dist/value/store.js

@@ -0,0 +1,36 @@
+import { isPlainObject, isKey } from "../node_modules/@oscarpalmer/atoms/dist/internal/is.js";
+import { storeName } from "../helpers/is.js";
+import { setValueInProxy, setProxyValue } from "../helpers/proxy.js";
+import { getValue } from "../helpers/value.js";
+import { Reactive } from "./reactive.js";
+class Store extends Reactive {
+  constructor(value, options) {
+    super(
+      storeName,
+      new Proxy(value, {
+        set: (target, property, value2) => setValueInProxy(target, property, value2, 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 ?? {});
+    }
+  }
+}
+function store(value, options) {
+  return new Store(isPlainObject(value) ? value : {}, options);
+}
+export {
+  Store,
+  store
+};

package/package.json

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

package/src/helpers/is.ts

@@ -49,7 +49,7 @@ export function isSignal(value: unknown): value is Signal<unknown> {
 	return isMora<Signal<unknown>>(value, signalName);
 }
 
-export function isStore(value: unknown): value is Store<unknown> {
+export function isStore(value: unknown): value is Store<PlainObject> {
 	return isMora<Reactive<unknown>>(value, storeName);
 }
 

package/src/helpers/proxy.ts

@@ -1,4 +1,3 @@
-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';

package/types/batch.d.cts

@@ -8,15 +8,15 @@ declare class Effect {
 }
 declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
 	get(): Value;
 }
-declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
 	/**
 	 * Get the value
 	 */
@@ -42,16 +42,23 @@ declare abstract class Reactive<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
 declare class Subscription<Value> {
-	state: ReactiveState<Value>;
+	state: ReactiveState<Value, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes

package/types/helpers/is.d.cts

@@ -1,6 +1,14 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
+/**
+ * A useful key type
+ */
+export type Key = number | string;
+/**
+ * A generic object
+ */
+export type PlainObject = Record<PropertyKey, unknown>;
 declare class Effect {
 	private readonly $mora;
 	private readonly state;
@@ -8,15 +16,15 @@ declare class Effect {
 }
 declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
 	get(): Value;
 }
-declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
 	/**
 	 * Get the value
 	 */
@@ -42,22 +50,29 @@ declare abstract class Reactive<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
 declare class Subscription<Value> {
-	state: ReactiveState<Value>;
+	state: ReactiveState<Value, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
-declare class ReactiveArray<Item> extends Reactive<Item[]> {
+declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	#private;
 	/**
 	 * The length of the array
@@ -67,7 +82,7 @@ declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Set the length of the array
 	 */
 	set length(value: number);
-	constructor(value: Item[]);
+	constructor(value: Item[], options?: ReactiveOptions<Item>);
 	/**
 	 * Get an indexed item
 	 */
@@ -130,7 +145,7 @@ declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	unshift(...items: Item[]): number;
 }
 declare class Signal<Value> extends Reactive<Value> {
-	constructor(value: Value);
+	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
@@ -144,6 +159,45 @@ declare class Signal<Value> extends Reactive<Value> {
 	 */
 	update(callback: (value: Value) => Value): void;
 }
+declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	constructor(value: Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): Value;
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	get(key: keyof Value): Value[keyof Value];
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	get(key: Key): unknown;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	peek(key: keyof Value): Value[keyof Value];
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	peek(key: Key): unknown;
+	/**
+	 * Set the value
+	 */
+	set(value?: Value): void;
+	/**
+	 * Set a value by key
+	 */
+	set(key: keyof Value, value: Value[keyof Value]): void;
+	/**
+	 * Set a value by key
+	 */
+	set(key: Key, value: unknown): void;
+}
 /**
  * Is the value a reactive array?
  */
@@ -161,9 +215,11 @@ export declare function isReactive(value: unknown): value is Reactive<unknown>;
  * Is the value a signal?
  */
 export declare function isSignal(value: unknown): value is Signal<unknown>;
+export declare function isStore(value: unknown): value is Store<PlainObject>;
 export declare const arrayName = "array";
 export declare const computedName = "computed";
 export declare const effectName = "effect";
 export declare const signalName = "signal";
+export declare const storeName = "store";
 
 export {};

package/types/helpers/is.d.ts

@@ -1,8 +1,10 @@
+import type { PlainObject } from '@oscarpalmer/atoms/models';
 import type { Effect } from '../effect';
 import type { ReactiveArray } from '../value/array';
 import type { Computed } from '../value/computed';
 import type { Reactive } from '../value/reactive';
 import type { Signal } from '../value/signal';
+import type { Store } from '../value/store';
 /**
  * Is the value a reactive array?
  */
@@ -20,7 +22,9 @@ export declare function isReactive(value: unknown): value is Reactive<unknown>;
  * Is the value a signal?
  */
 export declare function isSignal(value: unknown): value is Signal<unknown>;
+export declare function isStore(value: unknown): value is Store<PlainObject>;
 export declare const arrayName = "array";
 export declare const computedName = "computed";
 export declare const effectName = "effect";
 export declare const signalName = "signal";
+export declare const storeName = "store";