@oscarpalmer/mora 0.18.0 → 0.18.1

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.1"
 }

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/helpers/is.d.ts

@@ -3,6 +3,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?
  */
@@ -20,7 +21,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<unknown>;
 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";

package/types/helpers/proxy.d.ts

@@ -0,0 +1,5 @@
+import type { ArrayOrPlainObject } from '@oscarpalmer/atoms/models';
+import type { ReactiveState } from '../value/reactive';
+import type { Signal } from '../value/signal';
+export declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
+export declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(target: Value, property: PropertyKey, value: unknown, state: ReactiveState<Value, Equal>, isArray: boolean, length?: Signal<number>): boolean;

package/types/helpers/value.d.ts

@@ -1,5 +1,4 @@
 import type { ReactiveState } from '../value/reactive';
-export declare function differentArrays(first: unknown[], second: unknown[]): boolean;
-export declare function differentValues(first: unknown, second: unknown): boolean;
-export declare function emitValue<Value>(state: ReactiveState<Value>): void;
-export declare function getValue<Value>(state: ReactiveState<Value>): Value;
+export declare function emitValue<Value>(state: ReactiveState<Value, never>): void;
+export declare function equalArrays<Value>(state: ReactiveState<Value[], Value>, first: Value[], second: Value[]): boolean;
+export declare function getValue<Value>(state: ReactiveState<Value, never>): Value;

package/types/index.d.ts

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

package/types/subscription.d.ts

@@ -1,14 +1,14 @@
 import type { GenericCallback } from '@oscarpalmer/atoms/models';
 import type { ReactiveState } from './value/reactive';
 export 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;
 export declare function noop(): void;
-export declare function subscribe<Value>(state: ReactiveState<Value>, callback: (value: Value) => void): Unsubscribe;
-export declare function unsubscribe<Value>(state: ReactiveState<Value>, callback: (value: Value) => void): void;
+export declare function subscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): Unsubscribe;
+export declare function unsubscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): void;

package/types/value/array.d.ts

@@ -1,6 +1,6 @@
 import { type Computed } from './computed';
-import { Reactive } from './reactive';
-export declare class ReactiveArray<Item> extends Reactive<Item[]> {
+import { Reactive, type ReactiveOptions } from './reactive';
+export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
     #private;
     /**
      * The length of the array
@@ -10,7 +10,7 @@ export 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
      */
@@ -75,4 +75,4 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 /**
  * Create a reactive array
  */
-export declare function array<Item>(value: Item[]): ReactiveArray<Item>;
+export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;

package/types/value/computed.d.ts

@@ -1,17 +1,17 @@
 import { type Effect } from '../effect';
-import { Reactive, type ReactiveState } from './reactive';
+import { Reactive, type ReactiveOptions, type ReactiveState } from './reactive';
 export type ComputedEffect = {
     dirty: boolean;
     instance: Effect;
 };
 export type InternalComputed = {
     readonly effect: ComputedEffect;
-    readonly state: ReactiveState<unknown>;
+    readonly state: ReactiveState<unknown, unknown>;
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> extends Reactive<Value> {
     private readonly effect;
-    constructor(callback: () => Value);
+    constructor(callback: () => Value, options?: ReactiveOptions<Value>);
     /**
      * @inheritdoc
      */
@@ -20,4 +20,4 @@ export declare class Computed<Value> extends Reactive<Value> {
 /**
  * Create a computed value
  */
-export declare function computed<Value>(callback: () => Value): Computed<Value>;
+export declare function computed<Value>(callback: () => Value, options?: ReactiveOptions<Value>): Computed<Value>;

package/types/value/reactive.d.ts

@@ -1,9 +1,9 @@
 import type { Effect } from '../effect';
 import { type Subscription, type Unsubscribe } from '../subscription';
 import type { Computed } from './computed';
-export declare abstract class Reactive<Value> {
-    protected readonly state: ReactiveState<Value>;
-    constructor(name: string, value: Value);
+export declare abstract class Reactive<Value, Equal = Value> {
+    protected readonly state: ReactiveState<Value, Equal>;
+    constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
     /**
      * Get the value
      */
@@ -29,9 +29,16 @@ export 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;
 };

package/types/value/signal.d.ts

@@ -1,6 +1,6 @@
-import { Reactive } from './reactive';
+import { Reactive, type ReactiveOptions } from './reactive';
 export declare class Signal<Value> extends Reactive<Value> {
-    constructor(value: Value);
+    constructor(value: Value, options?: ReactiveOptions<Value>);
     /**
      * @inheritdoc
      */
@@ -17,4 +17,4 @@ export declare class Signal<Value> extends Reactive<Value> {
 /**
  * Create a reactive value
  */
-export declare function signal<Value>(value: Value): Signal<Value>;
+export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;

package/types/value/store.d.ts

@@ -0,0 +1,45 @@
+import type { Key, PlainObject } from '@oscarpalmer/atoms/models';
+import { Reactive, type ReactiveOptions } from './reactive';
+export 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;
+}
+/**
+ * Create a reactive store
+ */
+export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): Store<Value>;