@adbl/cells 0.0.1 → 0.0.3

package/index.js

@@ -1,3 +1,3 @@
-/// <reference types="./types/index.d.ts" />
+// <reference types="./types/index.d.ts" />
 
 export * from './library/index.js';

package/library/classes.js

@@ -326,7 +326,7 @@ export class Cell {
   update() {
     // Run watchers.
     for (const effect of this.__effects) {
-      let watcher = effect.callback;
+      const watcher = effect.callback;
       if (watcher === undefined) continue;
 
       if (root.batchNestingLevel > 0) {
@@ -593,6 +593,8 @@ export class Cell {
 
     async function run(input = initialInput) {
       pending.value = true;
+      error.value = null;
+      data.value = null;
       try {
         initialInput = input;
         const result = await getter(/** @type {X} */ (input));
@@ -684,6 +686,9 @@ export class SourceCell extends Cell {
   /** @type {Partial<CellOptions<T>>} */
   options;
 
+  /** @type {object | undefined} */
+  #originalObject;
+
   /**
    * Creates a new Cell with the provided value.
    * @param {T} value
@@ -694,6 +699,32 @@ export class SourceCell extends Cell {
 
     this.setValue(options?.shallowProxied ? value : this.proxy(value));
     this.options = options ?? {};
+
+    if (typeof value === 'object' && value !== null) {
+      this.#originalObject = value;
+    }
+  }
+
+  /**
+   * For cells containing objects, returns the object itself.
+   * This can be useful in scenarios where unfettered access to the original object is needed,
+   * such as when using the object as a cache.
+   *
+   * @example
+   * const cell = new SourceCell({ a: 1, b: 2 });
+   * console.log(cell.originalObject); // { a: 1, b: 2 }
+   *
+   * cell.value = { a: 3, b: 4 };
+   * console.log(cell.originalObject); // { a: 3, b: 4 }
+   *
+   * @returns {T extends object ? T : never} The original object if T is an object, otherwise never.
+   */
+  deproxy() {
+    const originalObject = this.#originalObject;
+    if (typeof originalObject === 'object' && originalObject !== null) {
+      return /** @type {T extends object ? T : never} */ (originalObject);
+    }
+    throw new Error('Cannot deproxy a non-object cell.');
   }
 
   get value() {
@@ -713,7 +744,7 @@ export class SourceCell extends Cell {
 
     const isEqual = this.options.equals
       ? this.options.equals(oldValue, value)
-      : oldValue === value;
+      : deepEqual(oldValue, value);
 
     if (isEqual) return;
 
@@ -728,7 +759,10 @@ export class SourceCell extends Cell {
       }
     }
 
-    this.setValue(value);
+    this.setValue(this.options?.shallowProxied ? value : this.proxy(value));
+    if (typeof value === 'object' && value !== null) {
+      this.#originalObject = value;
+    }
     this.update();
   }
 
@@ -750,10 +784,53 @@ export class SourceCell extends Cell {
         return this.proxy(Reflect.get(target, prop));
       },
       set: (target, prop, value) => {
+        const formerValue = Reflect.get(target, prop);
         Reflect.set(target, prop, value);
-        this.update();
+
+        const isEqual = deepEqual(formerValue, value);
+        if (!isEqual) this.update();
+
         return true;
       },
     });
   }
 }
+
+/**
+ * Recursively compares two values for deep equality.
+ * @param {any} a - The first value to compare.
+ * @param {any} b - The second value to compare.
+ * @returns {boolean} - True if the values are deeply equal, false otherwise.
+ */
+function deepEqual(a, b) {
+  if (a === b) return true;
+
+  if (
+    typeof a !== typeof b ||
+    typeof a !== 'object' ||
+    a === null ||
+    b === null
+  )
+    return false;
+
+  if (Array.isArray(a)) {
+    const aLength = a.length;
+    if (!Array.isArray(b) || aLength !== b.length) return false;
+
+    for (let i = 0; i < aLength; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+  } else {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    const keysALength = keysA.length;
+    if (keysALength !== keysB.length) return false;
+
+    for (let i = 0; i < keysALength; i++) {
+      const key = keysA[i];
+      if (a === b) return true;
+      if (!(key in b) || !deepEqual(a[key], b[key])) return false;
+    }
+  }
+  return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adbl/cells",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A simple implementation of reactive updates for JavaScript",
   "main": "index.js",
   "private": false,

package/types/library/classes.d.ts

@@ -147,10 +147,10 @@ export class Cell<T> {
      */
     protected __effects: Array<Effect<T>>;
     /**
-     * @type {Array<WeakRef<[DerivedCell<any>, () => any]>>}
+     * @type {Array<[WeakRef<DerivedCell<any>>, () => any]>}
      * @protected
      */
-    protected __derivedCells: Array<WeakRef<[DerivedCell<any>, () => any]>>;
+    protected __derivedCells: Array<[WeakRef<DerivedCell<any>>, () => any]>;
     /**
      * @readonly
      */
@@ -264,6 +264,21 @@ export class SourceCell<T> extends Cell<T> {
     constructor(value: T, options?: Partial<CellOptions<T>> | undefined);
     /** @type {Partial<CellOptions<T>>} */
     options: Partial<CellOptions<T>>;
+    /**
+     * For cells containing objects, returns the object itself.
+     * This can be useful in scenarios where unfettered access to the original object is needed,
+     * such as when using the object as a cache.
+     *
+     * @example
+     * const cell = new SourceCell({ a: 1, b: 2 });
+     * console.log(cell.originalObject); // { a: 1, b: 2 }
+     *
+     * cell.value = { a: 3, b: 4 };
+     * console.log(cell.originalObject); // { a: 3, b: 4 }
+     *
+     * @returns {T extends object ? T : never} The original object if T is an object, otherwise never.
+     */
+    deproxy(): T extends object ? T : never;
     /**
      * Sets the value stored in the Cell and triggers an update.
      * @param {T} value
@@ -278,6 +293,7 @@ export class SourceCell<T> extends Cell<T> {
      * @private
      */
     private proxy;
+    #private;
 }
 export type AsyncRequestAtoms<Input, Output> = {
     /**