@signaltree/core 7.0.0 → 7.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
   "type": "module",
   "sideEffects": false,

package/src/lib/markers/derived.d.ts

@@ -5,4 +5,5 @@ export interface DerivedMarker<T> {
     readonly __type?: T;
 }
 export type DerivedType<T> = T extends DerivedMarker<infer R> ? R : never;
+export declare function isDerivedMarker(value: unknown): value is DerivedMarker<unknown>;
 export {};

package/src/lib/path-notifier.d.ts

@@ -2,3 +2,33 @@ export type PathNotifierInterceptor = (value: unknown, prev: unknown, path: stri
     block?: boolean;
     transform?: unknown;
 };
+export declare class PathNotifier {
+    private subscribers;
+    private interceptors;
+    private batchingEnabled;
+    private pendingFlush;
+    private pending;
+    private firstValues;
+    private flushCallbacks;
+    constructor(options?: {
+        batching?: boolean;
+    });
+    setBatchingEnabled(enabled: boolean): void;
+    isBatchingEnabled(): boolean;
+    subscribe(pattern: string, handler: PathNotifierHandler): () => void;
+    intercept(pattern: string, interceptor: PathNotifierInterceptor): () => void;
+    notify(path: string, value: unknown, prev: unknown): {
+        blocked: boolean;
+        value: unknown;
+    };
+    private _runNotify;
+    private flush;
+    flushSync(): void;
+    onFlush(callback: () => void): () => void;
+    hasPending(): boolean;
+    private matches;
+    clear(): void;
+    getSubscriberCount(): number;
+    getInterceptorCount(): number;
+}
+export declare function getPathNotifier(): PathNotifier;

package/src/lib/utils.d.ts

@@ -1,5 +1,4 @@
 import { WritableSignal } from '@angular/core';
-import { deepEqual, isBuiltInObject, parsePath } from '@signaltree/shared';
 export { deepEqual };
 export { deepEqual as equal };
 export { isBuiltInObject };
@@ -11,6 +10,22 @@ export interface MemoryManager {
     dispose(): void;
 }
 import type { NodeAccessor, TreeNode } from './types';
+
+// Inlined from @signaltree/shared (internal package)
+declare function deepEqual<T>(a: T, b: T): boolean;
+declare function deepClone<T>(obj: T): T;
+declare function isBuiltInObject(value: unknown): boolean;
+declare function parsePath(path: string): string[];
+declare class LRUCache<K, V> {
+  constructor(maxSize: number);
+  get(key: K): V | undefined;
+  set(key: K, value: V): void;
+  has(key: K): boolean;
+  delete(key: K): boolean;
+  clear(): void;
+  get size(): number;
+}
+declare const DEFAULT_PATH_CACHE_SIZE: number;
 export declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
 export declare function isAnySignal(value: unknown): boolean;
 export declare function toWritableSignal<T>(node: NodeAccessor<T>, injector?: unknown): WritableSignal<T>;