@signaltree/core 6.0.3 → 6.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "6.0.3",
+  "version": "6.0.6",
   "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/enhancers/batching/batching.d.ts

@@ -1,11 +1,11 @@
-import type { ISignalTree, Enhancer, BatchingConfig } from '../../lib/types';
+import type { ISignalTree, BatchingConfig } from '../../lib/types';
 export type BatchingMethods<T> = import('../../lib/types').BatchingMethods<T>;
-export declare function batchingWithConfig<T>(config?: BatchingConfig): Enhancer<BatchingMethods<T>>;
-export declare function batching(config?: BatchingConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & BatchingMethods<any>;
-export declare function highPerformanceBatching<T>(): Enhancer<import("../../lib/types").BatchingMethods<T>>;
+export declare function batchingWithConfig(config?: BatchingConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & BatchingMethods<T>;
+export declare function batching(config?: BatchingConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & BatchingMethods<T>;
+export declare function highPerformanceBatching(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & BatchingMethods<T>;
 export declare function flushBatchedUpdates(): void;
 export declare function hasPendingUpdates(): boolean;
 export declare function getBatchQueueSize(): number;
-export declare const withBatching: ((config?: BatchingConfig) => Enhancer<import("../../lib/types").BatchingMethods<unknown>>) & {
+export declare const withBatching: ((config?: BatchingConfig) => <T>(tree: ISignalTree<T>) => ISignalTree<T> & BatchingMethods<T>) & {
     highPerformance: typeof highPerformanceBatching;
 };

package/src/enhancers/devtools/devtools.d.ts

@@ -57,10 +57,10 @@ export interface ModularDevToolsInterface {
         }>;
     };
 }
-export declare function devTools(config?: DevToolsConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & DevToolsMethods;
-export declare function enableDevTools(treeName?: string): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & DevToolsMethods;
-export declare function fullDevTools(treeName?: string): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & DevToolsMethods;
-export declare function productionDevTools(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & DevToolsMethods;
+export declare function devTools(config?: DevToolsConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & DevToolsMethods;
+export declare function enableDevTools(treeName?: string): <T>(tree: ISignalTree<T>) => ISignalTree<T> & DevToolsMethods;
+export declare function fullDevTools(treeName?: string): <T>(tree: ISignalTree<T>) => ISignalTree<T> & DevToolsMethods;
+export declare function productionDevTools(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & DevToolsMethods;
 export declare const withDevTools: typeof devTools & {
     production: typeof productionDevTools;
     full: typeof fullDevTools;

package/src/enhancers/effects/effects.d.ts

@@ -2,8 +2,8 @@ import type { ISignalTree, EffectsMethods } from '../../lib/types';
 export interface EffectsConfig {
     enabled?: boolean;
 }
-export declare function effects(config?: EffectsConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EffectsMethods<any>;
-export declare function enableEffects(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EffectsMethods<any>;
-export declare const withEffects: ((config?: EffectsConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EffectsMethods<any>) & {
+export declare function effects(config?: EffectsConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & EffectsMethods<T>;
+export declare function enableEffects(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & EffectsMethods<T>;
+export declare const withEffects: ((config?: EffectsConfig) => <T>(tree: ISignalTree<T>) => ISignalTree<T> & EffectsMethods<T>) & {
     enable: typeof enableEffects;
 };

package/src/enhancers/entities/entities.d.ts

@@ -2,9 +2,9 @@ import type { ISignalTree, EntitiesEnabled } from '../../lib/types';
 export interface EntitiesEnhancerConfig {
     enabled?: boolean;
 }
-export declare function entities(config?: EntitiesEnhancerConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EntitiesEnabled;
-export declare function enableEntities(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EntitiesEnabled;
-export declare function highPerformanceEntities(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EntitiesEnabled;
+export declare function entities(config?: EntitiesEnhancerConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & EntitiesEnabled;
+export declare function enableEntities(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & EntitiesEnabled;
+export declare function highPerformanceEntities(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & EntitiesEnabled;
 export declare const withEntities: typeof entities & {
     highPerformance: typeof highPerformanceEntities;
     enable: typeof enableEntities;

package/src/enhancers/memoization/memoization.d.ts

@@ -30,21 +30,21 @@ export declare const MEMOIZATION_PRESETS: {
         readonly ttl: undefined;
     };
 };
-export declare function selectorMemoization(): <S>(tree: ISignalTree<S>) => ISignalTree<S> & MemoizationMethods<S>;
-export declare function computedMemoization(): <S>(tree: ISignalTree<S>) => ISignalTree<S> & MemoizationMethods<S>;
-export declare function deepStateMemoization(): <S>(tree: ISignalTree<S>) => ISignalTree<S> & MemoizationMethods<S>;
-export declare function highFrequencyMemoization(): <S>(tree: ISignalTree<S>) => ISignalTree<S> & MemoizationMethods<S>;
-export declare const withMemoization: ((config?: MemoizationConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>) & {
+export declare function selectorMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
+export declare function computedMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
+export declare function deepStateMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
+export declare function highFrequencyMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
+export declare const withMemoization: ((config?: MemoizationConfig) => <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>) & {
     selector: typeof selectorMemoization;
     computed: typeof computedMemoization;
     deep: typeof deepStateMemoization;
     fast: typeof highFrequencyMemoization;
 };
-export declare function memoization(config?: MemoizationConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
-export declare function enableMemoization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
-export declare function highPerformanceMemoization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
-export declare function lightweightMemoization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
-export declare function shallowMemoization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
+export declare function memoization(config?: MemoizationConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
+export declare function enableMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
+export declare function highPerformanceMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
+export declare function lightweightMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
+export declare function shallowMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
 export declare function clearAllCaches(): void;
 export declare function getGlobalCacheStats(): {
     treeCount: number;

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

@@ -44,9 +44,9 @@ export interface PersistenceMethods {
     clear(): Promise<void>;
     __flushAutoSave?: () => Promise<void>;
 }
-export declare function serialization(defaultConfig?: SerializationConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods;
-export declare const withSerialization: (defaultConfig?: SerializationConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods;
-export declare function enableSerialization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods;
+export declare function serialization(defaultConfig?: SerializationConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & SerializationMethods;
+export declare const withSerialization: (defaultConfig?: SerializationConfig) => <T>(tree: ISignalTree<T>) => ISignalTree<T> & SerializationMethods;
+export declare function enableSerialization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & SerializationMethods;
 export interface StorageAdapter {
     getItem(key: string): string | null | Promise<string | null>;
     setItem(key: string, value: string): void | Promise<void>;
@@ -60,8 +60,8 @@ export interface PersistenceConfig extends SerializationConfig {
     autoLoad?: boolean;
     skipCache?: boolean;
 }
-export declare function persistence(config: PersistenceConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods & PersistenceMethods;
-export declare const withPersistence: (cfg: PersistenceConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods & PersistenceMethods;
+export declare function persistence(config: PersistenceConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & SerializationMethods & PersistenceMethods;
+export declare const withPersistence: (cfg: PersistenceConfig) => <T>(tree: ISignalTree<T>) => ISignalTree<T> & SerializationMethods & 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: ISignalTree<T>): ISignalTree<T> & SerializationMethods;

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

@@ -1,10 +1,10 @@
 import type { ISignalTree, TimeTravelMethods, TimeTravelConfig, TimeTravelEntry } from '../../lib/types';
 export type { TimeTravelConfig, TimeTravelEntry };
-export declare function timeTravel(config?: TimeTravelConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
-export declare function enableTimeTravel(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
-export declare function timeTravelHistory(maxHistorySize: number): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
-export declare const withTimeTravel: ((config?: TimeTravelConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods) & {
-    minimal: () => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
-    debug: () => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
+export declare function timeTravel(config?: TimeTravelConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & TimeTravelMethods<T>;
+export declare function enableTimeTravel(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & TimeTravelMethods<T>;
+export declare function timeTravelHistory(maxHistorySize: number): <T>(tree: ISignalTree<T>) => ISignalTree<T> & TimeTravelMethods<T>;
+export declare const withTimeTravel: ((config?: TimeTravelConfig) => <T>(tree: ISignalTree<T>) => ISignalTree<T> & TimeTravelMethods<T>) & {
+    minimal: () => <T>(tree: ISignalTree<T>) => ISignalTree<T> & TimeTravelMethods<T>;
+    debug: () => <T>(tree: ISignalTree<T>) => ISignalTree<T> & TimeTravelMethods<T>;
     history: typeof timeTravelHistory;
 };

package/src/lib/presets.d.ts

@@ -21,7 +21,7 @@ export type ProdSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMet
 export type MinimalSignalTree<T> = ISignalTree<T> & EffectsMethods<T>;
 export declare function createDevTree<T extends object>(initialState: T, config?: DevTreeConfig): FullSignalTree<T>;
 export declare function createDevTree(): {
-    enhancer: <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EffectsMethods<any> & BatchingMethods & MemoizationMethods<any> & EntitiesEnabled & TimeTravelMethods & DevToolsMethods;
+    enhancer: <T>(tree: ISignalTree<T>) => ISignalTree<T> & EffectsMethods<T> & BatchingMethods<T> & MemoizationMethods<T> & EntitiesEnabled & TimeTravelMethods<T> & DevToolsMethods;
 };
 export declare function createProdTree<T extends object>(initialState: T, config?: ProdTreeConfig): ProdSignalTree<T>;
 export declare function createMinimalTree<T extends object>(initialState: T, config?: MinimalTreeConfig): MinimalSignalTree<T>;

package/src/lib/types.d.ts

@@ -37,7 +37,7 @@ export type TreeNode<T> = {
 export interface ISignalTree<T> extends NodeAccessor<T> {
     readonly state: TreeNode<T>;
     readonly $: TreeNode<T>;
-    with<R>(enhancer: (tree: this) => R): R;
+    with<E extends (tree: this) => any>(enhancer: E): this & Omit<ReturnType<E>, keyof ISignalTree<T>>;
     bind(thisArg?: unknown): NodeAccessor<T>;
     destroy(): void;
 }
@@ -282,7 +282,7 @@ export type CallableWritableSignal<T> = WritableSignal<T> & {
 };
 export type AccessibleNode<T> = NodeAccessor<T> & TreeNode<T>;
 export declare const ENHANCER_META: unique symbol;
-export type Enhancer<TAdded> = <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TAdded;
+export type Enhancer<TAdded> = <T>(tree: ISignalTree<T>) => ISignalTree<T> & TAdded;
 export type EnhancerWithMeta<TAdded> = Enhancer<TAdded> & {
     metadata?: EnhancerMeta;
 };