@signaltree/core 9.0.1 → 9.2.0

package/README.md

@@ -2064,6 +2064,7 @@ tree.unwrap(); // Get plain object
 
 // Tree operations
 tree.update(updater); // Update entire tree
+tree.updateAndReport(updater); // Update + return changed leaf paths (9.1+)
 tree.effect(fn); // Create reactive effects
 tree.subscribe(fn); // Manual subscriptions
 tree.destroy(); // Cleanup resources
@@ -2075,6 +2076,26 @@ tree.destroy(); // Cleanup resources
 // tree.$.users.selectBy(pred);  // Filtered signal
 ```
 
+### updateAndReport (9.1+)
+
+Like `update`, but returns the dot-paths of every leaf signal whose value
+actually changed. Useful for diff logging, audit trails, optimistic-update
+rollback, and selective re-syncing to a server.
+
+```typescript
+const tree = signalTree({ user: { name: 'Ada', age: 36 }, count: 0 });
+
+const changed = tree.updateAndReport({
+  user: { name: 'Ada', age: 37 }, // age changes, name is ref-equal
+  count: 0, // ref-equal, skipped
+});
+// changed === ['user.age']
+```
+
+Reference-equal values are skipped automatically by the underlying
+`update` path, so passing a server-returned partial that mostly matches
+local state is cheap (`O(changed)` instead of `O(N)`).
+
 ## Extending with enhancers
 
 SignalTree Core includes all enhancers built-in:

package/dist/lib/signal-tree.js

@@ -1,4 +1,4 @@
-import { signal, isSignal } from '@angular/core';
+import { signal, isSignal, untracked } from '@angular/core';
 import { SIGNAL_TREE_MESSAGES, SIGNAL_TREE_CONSTANTS } from './constants.js';
 import { batchScope } from './internals/batch-scope.js';
 import { isRegisteredMarker, materializeMarkers } from './internals/materialize-markers.js';
@@ -114,19 +114,25 @@ function makeNodeAccessor(store) {
   }
   return accessor;
 }
-function recursiveUpdate(target, updates) {
+function recursiveUpdate(target, updates, out, pathPrefix = '') {
   if (!updates || typeof updates !== 'object') return;
   const targetObj = isNodeAccessor(target) ? target : target;
   for (const [key, value] of Object.entries(updates)) {
     const prop = targetObj[key];
     if (prop === undefined) continue;
+    const childPath = pathPrefix ? `${pathPrefix}.${key}` : key;
     if (isSignal(prop) && 'set' in prop) {
-      prop.set(value);
+      const sig = prop;
+      const current = untracked(() => sig());
+      if (current === value) continue;
+      sig.set(value);
+      if (out) out.push(childPath);
     } else if (isNodeAccessor(prop)) {
       if (value && typeof value === 'object') {
-        recursiveUpdate(prop, value);
+        recursiveUpdate(prop, value, out, childPath);
       } else {
         prop(value);
+        if (out) out.push(childPath);
       }
     }
   }
@@ -333,6 +339,25 @@ function create(initialState, config) {
     writable: true,
     configurable: true
   });
+  Object.defineProperty(tree, 'updateAndReport', {
+    value: function (arg) {
+      if (arguments.length === 0) return [];
+      const out = [];
+      if (typeof arg === 'function') {
+        const updater = arg;
+        const current = unwrap(signalState);
+        batchScope(() => recursiveUpdate(signalState, updater(current), out));
+      } else if (typeof arg === 'object' && arg !== null && !Array.isArray(arg)) {
+        batchScope(() => recursiveUpdate(signalState, arg, out));
+      } else {
+        recursiveUpdate(signalState, arg, out);
+      }
+      return out;
+    },
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
   for (const key of Object.keys(signalState)) {
     if (!(key in tree)) {
       Object.defineProperty(tree, key, {
@@ -453,6 +478,26 @@ function createBuilder(baseTree) {
       configurable: true
     });
   }
+  Object.defineProperty(builder, 'updateAndReport', {
+    value: function (arg) {
+      finalize();
+      const fn = baseTree['updateAndReport'];
+      return fn ? fn.call(baseTree, arg) : [];
+    },
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
+  Object.defineProperty(builder, 'batchUpdate', {
+    value: function (arg) {
+      finalize();
+      const fn = baseTree['batchUpdate'];
+      if (fn) fn.call(baseTree, arg);
+    },
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
   Object.defineProperty(builder, 'derived', {
     value: function (factory) {
       if (isFinalized) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "9.0.1",
+  "version": "9.2.0",
   "description": "Reactive JSON for Angular. JSON branches, reactive leaves. No actions. No reducers. No selectors.",
   "license": "MIT",
   "type": "module",
@@ -32,9 +32,9 @@
     "./package.json": "./package.json"
   },
   "peerDependencies": {
-    "@angular/core": "^20.0.0",
-    "@angular/compiler": "^20.0.0",
-    "@angular/platform-browser-dynamic": "^20.0.0",
+    "@angular/core": "^20.0.0 || ^21.0.0",
+    "@angular/compiler": "^20.0.0 || ^21.0.0",
+    "@angular/platform-browser-dynamic": "^20.0.0 || ^21.0.0",
     "zone.js": "^0.15.0",
     "tslib": "^2.0.0"
   },
@@ -55,6 +55,7 @@
   "files": [
     "dist/**/*.js",
     "src/**/*.d.ts",
+    "skills/**/*",
     "README.md"
   ]
 }

package/src/lib/types.d.ts

@@ -16,12 +16,6 @@ export interface TimeTravelConfig {
 }
 export type Primitive = string | number | boolean | null | undefined | bigint | symbol;
 export type NotFn<T> = T extends (...args: unknown[]) => unknown ? never : T;
-declare module '@angular/core' {
-    interface WritableSignal<T> {
-        (value: NotFn<T>): void;
-        (updater: (current: T) => T): void;
-    }
-}
 export interface NodeAccessor<T> {
     (): T;
     (value: Partial<T>): void;
@@ -38,6 +32,7 @@ export interface ISignalTree<T> extends NodeAccessor<T> {
     destroy(): void;
     readonly destroyed: Signal<boolean>;
     registerCleanup(fn: EnhancerCleanup): void;
+    updateAndReport(updates: Partial<T> | ((current: T) => Partial<T>)): string[];
 }
 export type EnhancerCleanup = () => void;
 export interface EffectsMethods<T> {
@@ -271,10 +266,11 @@ export type PathInterceptor = (ctx: {
     blocked: boolean;
     blockReason?: string;
 }, next: () => void) => void | Promise<void>;
-export type CallableWritableSignal<T> = WritableSignal<T> & {
+export interface CallableWritableSignal<T> extends WritableSignal<T> {
+    (): T;
     (value: NotFn<T>): void;
     (updater: (current: T) => T): void;
-};
+}
 export type AccessibleNode<T> = NodeAccessor<T> & TreeNode<T>;
 export declare const ENHANCER_META: unique symbol;
 export type Enhancer<TAdded> = (tree: ISignalTree<any>) => ISignalTree<any> & TAdded;