@signaltree/core 5.1.6 → 6.0.1

package/src/enhancers/serialization/lib/serialization.d.ts

@@ -1,59 +0,0 @@
-import type { SignalTree } from '../../../lib/types';
-import type { EnhancerWithMeta } from '../../../lib/types';
-export interface SerializationConfig {
-    includeMetadata?: boolean;
-    replacer?: (key: string, value: unknown) => unknown;
-    reviver?: (key: string, value: unknown) => unknown;
-    preserveTypes?: boolean;
-    maxDepth?: number;
-    handleCircular?: boolean;
-}
-export interface SerializedState<T = unknown> {
-    data: T;
-    metadata?: {
-        timestamp: number;
-        version: string;
-        appVersion?: string;
-        types?: Record<string, string>;
-        circularRefs?: Array<{
-            path: string;
-            targetPath: string;
-        }>;
-        nodeMap?: Record<string, 'b' | 'r'>;
-    };
-}
-export interface SerializableSignalTree<T> extends SignalTree<T> {
-    $: any;
-    serialize(config?: SerializationConfig): string;
-    deserialize(json: string, config?: SerializationConfig): void;
-    toJSON(): T;
-    fromJSON(data: T, metadata?: SerializedState<T>['metadata']): void;
-    snapshot(): SerializedState<T>;
-    restore(snapshot: SerializedState<T>): void;
-}
-export interface PersistenceMethods {
-    save(): Promise<void>;
-    load(): Promise<void>;
-    clear(): Promise<void>;
-    __flushAutoSave?: () => Promise<void>;
-}
-export declare function withSerialization<T extends Record<string, unknown> = Record<string, unknown>>(defaultConfig?: SerializationConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
-export declare function enableSerialization<T extends Record<string, unknown> = Record<string, unknown>>(): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
-export interface StorageAdapter {
-    getItem(key: string): string | null | Promise<string | null>;
-    setItem(key: string, value: string): void | Promise<void>;
-    removeItem(key: string): void | Promise<void>;
-}
-export interface PersistenceConfig extends SerializationConfig {
-    key: string;
-    storage?: StorageAdapter;
-    autoSave?: boolean;
-    debounceMs?: number;
-    autoLoad?: boolean;
-    skipCache?: boolean;
-}
-export declare function withPersistence<T extends Record<string, unknown> = Record<string, unknown>>(config: PersistenceConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T> & PersistenceMethods>;
-export declare function createStorageAdapter(getItem: (key: string) => string | null | Promise<string | null>, setItem: (key: string, value: string) => void | Promise<void>, removeItem: (key: string) => void | Promise<void>): StorageAdapter;
-export declare function createIndexedDBAdapter(dbName?: string, storeName?: string): StorageAdapter;
-export declare function applySerialization<T extends Record<string, unknown>>(tree: SignalTree<T>): SerializableSignalTree<T>;
-export declare function applyPersistence<T extends Record<string, unknown>>(tree: SignalTree<T>, cfg: PersistenceConfig): SerializableSignalTree<T> & PersistenceMethods;

package/src/enhancers/time-travel/lib/time-travel.d.ts

@@ -1,36 +0,0 @@
-import type { SignalTree } from '../../../lib/types';
-export interface TimeTravelEntry<T> {
-    state: T;
-    timestamp: number;
-    action: string;
-    payload?: unknown;
-}
-export interface TimeTravelInterface<T> {
-    undo(): boolean;
-    redo(): boolean;
-    getHistory(): TimeTravelEntry<T>[];
-    resetHistory(): void;
-    jumpTo(index: number): boolean;
-    getCurrentIndex(): number;
-    canUndo(): boolean;
-    canRedo(): boolean;
-}
-export interface TimeTravelConfig {
-    maxHistorySize?: number;
-    includePayload?: boolean;
-    actionNames?: {
-        update?: string;
-        set?: string;
-        batch?: string;
-        [key: string]: string | undefined;
-    };
-}
-export declare function withTimeTravel<T>(config?: TimeTravelConfig): (tree: SignalTree<T>) => SignalTree<T> & {
-    __timeTravel: TimeTravelInterface<T>;
-};
-export declare function enableTimeTravel<T>(maxHistorySize?: number): (tree: SignalTree<T>) => SignalTree<T> & {
-    __timeTravel: TimeTravelInterface<T>;
-};
-export declare function getTimeTravel<T>(tree: SignalTree<T> & {
-    __timeTravel?: TimeTravelInterface<T>;
-}): TimeTravelInterface<T> | undefined;

package/src/enhancers/time-travel/lib/utils.d.ts

@@ -1 +0,0 @@
-export { deepClone, deepEqual } from '@signaltree/shared';

package/src/entities.d.ts

@@ -1,28 +0,0 @@
-import type {
-  EntitySignal,
-  SignalTree,
-  EntityAwareTreeNode,
-} from '../../../lib/types';
-interface EntitiesEnhancerConfig {
-  enabled?: boolean;
-}
-export declare function withEntities(config?: EntitiesEnhancerConfig): <T>(
-  tree: SignalTree<T>
-) => Omit<SignalTree<T>, 'state' | '$'> & {
-  state: EntityAwareTreeNode<T>;
-  $: EntityAwareTreeNode<T>;
-};
-export declare function enableEntities(): <T>(tree: SignalTree<T>) => Omit<
-  SignalTree<T>,
-  'state' | '$'
-> & {
-  state: EntityAwareTreeNode<T>;
-  $: EntityAwareTreeNode<T>;
-};
-export declare function withHighPerformanceEntities(): <T>(
-  tree: SignalTree<T>
-) => Omit<SignalTree<T>, 'state' | '$'> & {
-  state: EntityAwareTreeNode<T>;
-  $: EntityAwareTreeNode<T>;
-};
-export {};

package/src/memoization.d.ts

@@ -1,65 +0,0 @@
-import type { SignalTree } from '../../../lib/types';
-export interface MemoizedSignalTree<T> extends SignalTree<T> {
-    memoizedUpdate: (updater: (current: T) => Partial<T>, cacheKey?: string) => void;
-    clearMemoCache: (key?: string) => void;
-    getCacheStats: () => {
-        size: number;
-        hitRate: number;
-        totalHits: number;
-        totalMisses: number;
-        keys: string[];
-    };
-}
-export declare function cleanupMemoizationCache(): void;
-export interface MemoizationConfig {
-    enabled?: boolean;
-    maxCacheSize?: number;
-    ttl?: number;
-    equality?: 'deep' | 'shallow' | 'reference';
-    enableLRU?: boolean;
-}
-export declare function memoize<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string, config?: MemoizationConfig): (...args: TArgs) => TReturn;
-export declare function memoizeShallow<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
-export declare function memoizeReference<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
-export declare const MEMOIZATION_PRESETS: {
-    readonly selector: {
-        readonly equality: "reference";
-        readonly maxCacheSize: 10;
-        readonly enableLRU: false;
-        readonly ttl: undefined;
-    };
-    readonly computed: {
-        readonly equality: "shallow";
-        readonly maxCacheSize: 100;
-        readonly enableLRU: false;
-        readonly ttl: undefined;
-    };
-    readonly deepState: {
-        readonly equality: "deep";
-        readonly maxCacheSize: 1000;
-        readonly enableLRU: true;
-        readonly ttl: number;
-    };
-    readonly highFrequency: {
-        readonly equality: "reference";
-        readonly maxCacheSize: 5;
-        readonly enableLRU: false;
-        readonly ttl: undefined;
-    };
-};
-export declare function withSelectorMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withComputedMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withDeepStateMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withHighFrequencyMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withMemoization<T>(config?: MemoizationConfig): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function enableMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withHighPerformanceMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withLightweightMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withShallowMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function clearAllCaches(): void;
-export declare function getGlobalCacheStats(): {
-    treeCount: number;
-    totalSize: number;
-    totalHits: number;
-    averageCacheSize: number;
-};

package/src/memory-manager.d.ts

@@ -1,30 +0,0 @@
-import type { WritableSignal } from '@angular/core';
-export interface MemoryStats {
-    cachedSignals: number;
-    cleanedUpSignals: number;
-    peakCachedSignals: number;
-    manualDisposes: number;
-    estimatedMemoryBytes: number;
-}
-export interface MemoryManagerConfig {
-    enableAutoCleanup?: boolean;
-    debugMode?: boolean;
-    onCleanup?: (path: string, stats: MemoryStats) => void;
-}
-export declare class SignalMemoryManager {
-    private cache;
-    private registry;
-    private config;
-    private stats;
-    constructor(config?: MemoryManagerConfig);
-    cacheSignal<T>(path: string, signal: WritableSignal<T>): void;
-    getSignal(path: string): WritableSignal<unknown> | undefined;
-    hasSignal(path: string): boolean;
-    removeSignal(path: string): boolean;
-    private handleCleanup;
-    getStats(): MemoryStats;
-    dispose(): void;
-    getCachedPaths(): string[];
-    clearStale(): number;
-    resetStats(): void;
-}

package/src/path-index.d.ts

@@ -1,25 +0,0 @@
-import type { WritableSignal } from '@angular/core';
-export type PathSegment = string | number;
-export type Path = PathSegment[];
-export declare class PathIndex<T extends object = WritableSignal<any>> {
-    private root;
-    private pathCache;
-    private stats;
-    set(path: Path, signal: T): void;
-    get(path: Path): T | null;
-    has(path: Path): boolean;
-    getByPrefix(prefix: Path): Map<string, T>;
-    delete(path: Path): boolean;
-    clear(): void;
-    getStats(): {
-        hits: number;
-        misses: number;
-        sets: number;
-        cleanups: number;
-        hitRate: number;
-        cacheSize: number;
-    };
-    buildFromTree(tree: unknown, path?: Path): void;
-    private pathToString;
-    private collectDescendants;
-}

package/src/path-notifier.d.ts

@@ -1,12 +0,0 @@
-export type PathNotifierInterceptor = (value: unknown, prev: unknown, path: string) => {
-    block?: boolean;
-    transform?: unknown;
-};
-
-export interface PathNotifier {
-    subscribe(pattern: string, handler: (value: unknown, prev: unknown, path: string) => void): () => void;
-    intercept(pattern: string, fn: PathNotifierInterceptor): () => void;
-    notify(path: string, value: unknown, prev: unknown): void;
-}
-
-export function getPathNotifier(): PathNotifier;

package/src/presets.d.ts

@@ -1,11 +0,0 @@
-import type { TreeConfig } from '../../../lib/types';
-export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
-export declare const TREE_PRESETS: Record<TreePreset, Partial<TreeConfig>>;
-export declare function createPresetConfig(preset: TreePreset, overrides?: Partial<TreeConfig>): TreeConfig;
-export declare function validatePreset(preset: TreePreset): boolean;
-export declare function getAvailablePresets(): TreePreset[];
-export declare function combinePresets(presets: TreePreset[], overrides?: Partial<TreeConfig>): TreeConfig;
-export declare function createDevTree(overrides?: Partial<TreeConfig>): {
-    readonly config: TreeConfig;
-    readonly enhancer: (tree: import("../../memoization/lib/memoization").MemoizedSignalTree<unknown>) => import("../../memoization/lib/memoization").MemoizedSignalTree<unknown>;
-};

package/src/security-validator.d.ts

@@ -1,33 +0,0 @@
-export type SecurityEventType = 'dangerous-key-blocked' | 'xss-attempt-blocked' | 'function-value-blocked' | 'validation-error';
-export interface SecurityEvent {
-    type: SecurityEventType;
-    key?: string;
-    value?: unknown;
-    reason: string;
-    timestamp: number;
-}
-export interface SecurityValidatorConfig {
-    preventPrototypePollution?: boolean;
-    preventXSS?: boolean;
-    preventFunctions?: boolean;
-    customDangerousKeys?: string[];
-    onSecurityEvent?: (event: SecurityEvent) => void;
-    sanitizationMode?: 'strict' | 'permissive';
-}
-export declare class SecurityValidator {
-    private readonly config;
-    private readonly dangerousKeys;
-    constructor(config?: SecurityValidatorConfig);
-    validateKey(key: string): void;
-    validateValue<T>(value: T): T;
-    private sanitize;
-    validateKeyValue<T>(key: string, value: T): T;
-    isDangerousKey(key: string): boolean;
-    getConfig(): Readonly<Required<SecurityValidatorConfig>>;
-}
-export declare const SecurityPresets: {
-    strict: () => SecurityValidator;
-    standard: () => SecurityValidator;
-    permissive: () => SecurityValidator;
-    disabled: () => SecurityValidator;
-};

package/src/signal-tree.d.ts

@@ -1,8 +0,0 @@
-import type { SignalTree, TreeConfig, TreePreset, EnhancerWithMeta, NodeAccessor } from './types';
-export declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
-export declare function signalTree<T>(obj: T): SignalTree<T>;
-export declare function signalTree<T>(obj: T, preset: TreePreset): SignalTree<T>;
-export declare function signalTree<T>(obj: T, config: TreeConfig): SignalTree<T>;
-export declare function signalTree<T extends Record<string, unknown>>(obj: Required<T>, configOrPreset?: TreeConfig | TreePreset): SignalTree<Required<T>>;
-export declare function signalTree<T>(obj: T, configOrPreset?: TreeConfig | TreePreset): SignalTree<T>;
-export declare function applyEnhancer<T, O>(tree: SignalTree<T>, enhancer: EnhancerWithMeta<SignalTree<T>, O>): O;

package/src/test-setup.d.ts

@@ -1,3 +0,0 @@
-import '@angular/compiler';
-import 'zone.js';
-import 'zone.js/testing';

package/src/time-travel.d.ts

@@ -1,36 +0,0 @@
-import type { SignalTree } from '../../../lib/types';
-export interface TimeTravelEntry<T> {
-    state: T;
-    timestamp: number;
-    action: string;
-    payload?: unknown;
-}
-export interface TimeTravelInterface<T> {
-    undo(): boolean;
-    redo(): boolean;
-    getHistory(): TimeTravelEntry<T>[];
-    resetHistory(): void;
-    jumpTo(index: number): boolean;
-    getCurrentIndex(): number;
-    canUndo(): boolean;
-    canRedo(): boolean;
-}
-export interface TimeTravelConfig {
-    maxHistorySize?: number;
-    includePayload?: boolean;
-    actionNames?: {
-        update?: string;
-        set?: string;
-        batch?: string;
-        [key: string]: string | undefined;
-    };
-}
-export declare function withTimeTravel<T>(config?: TimeTravelConfig): (tree: SignalTree<T>) => SignalTree<T> & {
-    __timeTravel: TimeTravelInterface<T>;
-};
-export declare function enableTimeTravel<T>(maxHistorySize?: number): (tree: SignalTree<T>) => SignalTree<T> & {
-    __timeTravel: TimeTravelInterface<T>;
-};
-export declare function getTimeTravel<T>(tree: SignalTree<T> & {
-    __timeTravel?: TimeTravelInterface<T>;
-}): TimeTravelInterface<T> | undefined;