@signaltree/core 5.1.4 → 6.0.0

package/src/enhancers/memoization/lib/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/enhancers/memoization/test-setup.d.ts

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

package/src/enhancers/presets/index.d.ts

@@ -1 +0,0 @@
-export * from './lib/presets';

package/src/enhancers/presets/lib/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/enhancers/presets/test-setup.d.ts

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

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

@@ -1,14 +0,0 @@
-export declare const TYPE_MARKERS: {
-    readonly DATE: "§d";
-    readonly REGEXP: "§r";
-    readonly MAP: "§m";
-    readonly SET: "§s";
-    readonly UNDEFINED: "§u";
-    readonly NAN: "§n";
-    readonly INFINITY: "§i";
-    readonly NEG_INFINITY: "§-i";
-    readonly BIGINT: "§b";
-    readonly SYMBOL: "§y";
-    readonly FUNCTION: "§f";
-    readonly CIRCULAR: "§c";
-};

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

@@ -1,2 +0,0 @@
-export * from './lib/serialization';
-export * from './constants';

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/serialization/test-setup.d.ts

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

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

@@ -1 +0,0 @@
-export * from './lib/time-travel';

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/enhancers/time-travel/test-setup.d.ts

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

package/src/enhancers/types.d.ts

@@ -1,74 +0,0 @@
-export interface BatchingConfig {
-    maxBatchSize?: number;
-    debounceMs?: number;
-    flushOnMicrotask?: boolean;
-}
-export interface BatchUpdate<T = unknown> {
-    path: string[];
-    value: T;
-    timestamp: number;
-}
-export interface ComputedSignal<T> {
-    (): T;
-    readonly value: T;
-}
-export interface ComputedConfig {
-    lazy?: boolean;
-    memoize?: boolean;
-}
-export interface MemoizationConfig {
-    maxSize?: number;
-    ttl?: number;
-    strategy?: 'lru' | 'fifo' | 'lfu';
-}
-export interface MemoizedFunction<T extends (...args: never[]) => unknown> {
-    (...args: Parameters<T>): ReturnType<T>;
-    clear(): void;
-    stats(): {
-        hits: number;
-        misses: number;
-        size: number;
-    };
-}
-export interface TimeTravelConfig {
-    maxHistorySize?: number;
-    enableCompression?: boolean;
-}
-export interface TimeTravelState {
-    canUndo: boolean;
-    canRedo: boolean;
-    historySize: number;
-    currentIndex: number;
-}
-export interface DevToolsConfig {
-    name?: string;
-    enabled?: boolean;
-    logLevel?: 'debug' | 'info' | 'warn' | 'error';
-}
-export interface DevToolsAction {
-    type: string;
-    payload?: unknown;
-    timestamp: number;
-    source: string;
-}
-export interface PresetConfig {
-    name: string;
-    enhancers: unknown[];
-    config?: Record<string, unknown>;
-}
-export interface EntityConfig {
-    idField?: string;
-    indexes?: string[];
-    relations?: Record<string, string>;
-}
-export interface SerializationConfig {
-    includeComputed?: boolean;
-    includeMeta?: boolean;
-    customSerializers?: Record<string, (value: unknown) => unknown>;
-}
-export interface SerializedState {
-    version: string;
-    timestamp: number;
-    data: unknown;
-    meta?: Record<string, unknown>;
-}

package/src/entities.d.ts

@@ -1,20 +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>;
-    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
-};
-export declare function enableEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
-    state: EntityAwareTreeNode<T>;
-    $: EntityAwareTreeNode<T>;
-    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
-};
-export declare function withHighPerformanceEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
-    state: EntityAwareTreeNode<T>;
-    $: EntityAwareTreeNode<T>;
-    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
-};
-export {};

package/src/entity-signal.d.ts

@@ -1 +0,0 @@
-export {};

package/src/index.d.ts

@@ -1,18 +0,0 @@
-export { signalTree } from './lib/signal-tree';
-export type { SignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, DeepPath, DeepAccess, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, PerformanceMetrics, EntityHelpers, TimeTravelEntry, } from './lib/types';
-export { entityMap } from './lib/types';
-export { equal, deepEqual, isNodeAccessor, isAnySignal, toWritableSignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
-export { getPathNotifier } from './lib/path-notifier';
-export { SecurityValidator, SecurityPresets, type SecurityEvent, type SecurityEventType, type SecurityValidatorConfig, } from './lib/security/security-validator';
-export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
-export { ENHANCER_META } from './lib/types';
-export { withBatching, withHighPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/lib/batching';
-export { withMemoization, withSelectorMemoization, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withShallowMemoization, memoize, memoizeShallow, memoizeReference, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/lib/memoization';
-export { withTimeTravel, enableTimeTravel, getTimeTravel, type TimeTravelInterface, } from './enhancers/time-travel/lib/time-travel';
-export { withEntities, enableEntities, withHighPerformanceEntities, } from './enhancers/entities/lib/entities';
-export { withSerialization, enableSerialization, withPersistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/lib/serialization';
-export { withDevTools, enableDevTools, withFullDevTools, withProductionDevTools, } from './enhancers/devtools/lib/devtools';
-export { createAsyncOperation, trackAsync } from './lib/async-helpers';
-export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, } from './enhancers/presets/lib/presets';
-export { computedEnhancer, createComputed, type ComputedConfig, type ComputedSignal, type ComputedSignalTree, } from './enhancers/computed/lib/computed';
-export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants';

package/src/lib/async-helpers.d.ts

@@ -1,8 +0,0 @@
-import type { SignalTree } from './types';
-export declare function createAsyncOperation<T, TResult>(name: string, operation: () => Promise<TResult>): (tree: SignalTree<T>) => Promise<TResult>;
-export declare function trackAsync<T>(operation: () => Promise<T>): {
-    pending: import("@angular/core").Signal<boolean>;
-    error: import("@angular/core").Signal<Error | null>;
-    result: import("@angular/core").Signal<T | null>;
-    execute: () => Promise<T>;
-};

package/src/lib/constants.d.ts

@@ -1,41 +0,0 @@
-export declare const SIGNAL_TREE_CONSTANTS: {
-    readonly MAX_PATH_CACHE_SIZE: 1000;
-    readonly LAZY_THRESHOLD: 50;
-    readonly ESTIMATE_MAX_DEPTH: 3;
-    readonly ESTIMATE_SAMPLE_SIZE_ARRAY: 3;
-    readonly ESTIMATE_SAMPLE_SIZE_OBJECT: 5;
-    readonly DEFAULT_CACHE_SIZE: 100;
-    readonly DEFAULT_BATCH_SIZE: 10;
-};
-export declare const SIGNAL_TREE_MESSAGES: Readonly<{
-    readonly NULL_OR_UNDEFINED: "null/undefined";
-    readonly CIRCULAR_REF: "circular ref";
-    readonly UPDATER_INVALID: "updater invalid";
-    readonly LAZY_FALLBACK: "lazy fallback";
-    readonly SIGNAL_CREATION_FAILED: "signal creation failed";
-    readonly UPDATE_PATH_NOT_FOUND: "update path not found";
-    readonly UPDATE_FAILED: "update failed";
-    readonly ROLLBACK_FAILED: "rollback failed";
-    readonly CLEANUP_ERROR: "cleanup error";
-    readonly PRESET_UNKNOWN: "unknown preset";
-    readonly STRATEGY_SELECTION: "strategy select";
-    readonly TREE_DESTROYED: "destroyed";
-    readonly UPDATE_TRANSACTION: "update tx";
-    readonly BATCH_NOT_ENABLED: "batching disabled";
-    readonly MEMOIZE_NOT_ENABLED: "memoize disabled";
-    readonly MIDDLEWARE_NOT_AVAILABLE: "middleware missing";
-    readonly ENTITY_HELPERS_NOT_AVAILABLE: "entity helpers missing";
-    readonly TIME_TRAVEL_NOT_AVAILABLE: "time travel missing";
-    readonly OPTIMIZE_NOT_AVAILABLE: "optimize missing";
-    readonly UPDATE_OPTIMIZED_NOT_AVAILABLE: "update optimized missing";
-    readonly CACHE_NOT_AVAILABLE: "cache missing";
-    readonly PERFORMANCE_NOT_ENABLED: "performance disabled";
-    readonly ENHANCER_ORDER_FAILED: "enhancer order failed";
-    readonly ENHANCER_CYCLE_DETECTED: "enhancer cycle";
-    readonly ENHANCER_REQUIREMENT_MISSING: "enhancer req missing";
-    readonly ENHANCER_PROVIDES_MISSING: "enhancer provides missing";
-    readonly ENHANCER_FAILED: "enhancer failed";
-    readonly ENHANCER_NOT_FUNCTION: "enhancer not function";
-    readonly EFFECT_NO_CONTEXT: "no angular context";
-    readonly SUBSCRIBE_NO_CONTEXT: "no angular context";
-}>;

package/src/lib/entity-signal.d.ts

@@ -1 +0,0 @@
-export {};

package/src/lib/memory/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/lib/path-notifier.d.ts

@@ -1,4 +0,0 @@
-export type PathNotifierInterceptor = (value: unknown, prev: unknown, path: string) => {
-    block?: boolean;
-    transform?: unknown;
-};

package/src/lib/performance/diff-engine.d.ts

@@ -1,33 +0,0 @@
-import type { Path } from './path-index';
-export declare enum ChangeType {
-    ADD = "add",
-    UPDATE = "update",
-    DELETE = "delete",
-    REPLACE = "replace"
-}
-export interface Change {
-    type: ChangeType;
-    path: Path;
-    value?: unknown;
-    oldValue?: unknown;
-}
-export interface Diff {
-    changes: Change[];
-    hasChanges: boolean;
-}
-export interface DiffOptions {
-    maxDepth?: number;
-    detectDeletions?: boolean;
-    ignoreArrayOrder?: boolean;
-    equalityFn?: (a: unknown, b: unknown) => boolean;
-    keyValidator?: (key: string) => boolean;
-}
-export declare class DiffEngine {
-    private defaultOptions;
-    diff(current: unknown, updates: unknown, options?: DiffOptions): Diff;
-    private traverse;
-    private diffArrays;
-    private diffArraysOrdered;
-    private diffArraysUnordered;
-    private stringify;
-}

package/src/lib/performance/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/lib/performance/update-engine.d.ts

@@ -1,32 +0,0 @@
-import { PathIndex } from './path-index';
-import type { DiffOptions } from './diff-engine';
-export interface UpdateOptions extends DiffOptions {
-    batch?: boolean;
-    batchSize?: number;
-}
-export interface UpdateResult {
-    changed: boolean;
-    duration: number;
-    changedPaths: string[];
-    stats?: {
-        totalPaths: number;
-        optimizedPaths: number;
-        batchedUpdates: number;
-    };
-}
-export declare class OptimizedUpdateEngine {
-    private pathIndex;
-    private diffEngine;
-    constructor(tree: unknown);
-    update(tree: unknown, updates: unknown, options?: UpdateOptions): UpdateResult;
-    rebuildIndex(tree: unknown): void;
-    getIndexStats(): ReturnType<PathIndex['getStats']>;
-    private createPatches;
-    private createPatch;
-    private calculatePriority;
-    private sortPatches;
-    private applyPatches;
-    private batchApplyPatches;
-    private applyPatch;
-    private isEqual;
-}

package/src/lib/security/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/lib/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;