@signaltree/core 1.1.1 → 1.1.2

package/index.d.ts

@@ -1,69 +1,22 @@
 import { Signal, WritableSignal } from '@angular/core';
 
-/**
- * SignalTree Core Types - Recursive Typing System
- *
- * COPYRIGHT NOTICE:
- * This file contains proprietary recursive typing innovations protected under
- * the SignalTree license. The DeepSignalify<T> recursive type system and
- * related implementations are exclusive intellectual property of Jonathan D Borgia.
- *
- * Unauthorized extraction, copying, or reimplementation of these recursive typing
- * concepts is strictly prohibited and constitutes copyright infringement.
- *
- * Licensed under Fair Source License - see LICENSE file for complete terms.
- */
-
-/**
- * NO MORE StateObject constraint!
- * We don't need this at all - remove it or make it accept anything
- */
-/**
- * Primitive types for type checking
- */
 type Primitive = string | number | boolean | null | undefined | bigint | symbol;
-/**
- * Built-in object types that should be treated as primitive values
- * Enhanced detection for better edge case handling
- */
 type BuiltInObject = Date | RegExp | ((...args: unknown[]) => unknown) | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer | DataView | Error | Promise<unknown> | URL | URLSearchParams | FormData | Blob | File;
 type IsPrimitive<T> = T extends Primitive ? true : false;
 type IsBuiltInObject<T> = T extends BuiltInObject ? true : false;
-/**
- * Signal detection
- */
 type IsSignal<T> = T extends Signal<unknown> ? true : false;
 type IsWritableSignal<T> = T extends WritableSignal<unknown> ? true : false;
-/**
- * Enhanced DeepSignalify with better edge case handling
- * Never double-wraps signals and properly handles functions and built-in objects
- */
 type DeepSignalify<T> = IsSignal<T> extends true ? T : T extends Primitive ? WritableSignal<T> : T extends BuiltInObject ? WritableSignal<T> : T extends readonly (infer U)[] ? WritableSignal<U[]> : T extends (infer U)[] ? WritableSignal<U[]> : T extends object ? T extends (...args: unknown[]) => unknown ? WritableSignal<T> : {
     [K in keyof T]: T[K] extends (infer U)[] ? WritableSignal<U[]> : T[K] extends BuiltInObject ? WritableSignal<T[K]> : T[K] extends object ? T[K] extends Signal<infer TK> ? WritableSignal<TK> : DeepSignalify<T[K]> : WritableSignal<T[K]>;
 } : WritableSignal<T>;
-/**
- * SignalTree type - NO CONSTRAINTS on T
- */
 type SignalTree<T> = {
-    /**
-     * The reactive state object with deep signal conversion
-     */
     state: DeepSignalify<T>;
-    /**
-     * Shorthand alias for state
-     */
     $: DeepSignalify<T>;
-    /**
-     * Core methods
-     */
     unwrap(): T;
     update(updater: (current: T) => Partial<T>): void;
     effect(fn: (tree: T) => void): void;
     subscribe(fn: (tree: T) => void): () => void;
     destroy(): void;
-    /**
-     * Pipe method for composition
-     */
     pipe(): SignalTree<T>;
     pipe<R1>(fn1: (tree: SignalTree<T>) => R1): R1;
     pipe<R1, R2>(fn1: (tree: SignalTree<T>) => R1, fn2: (arg: R1) => R2): R2;
@@ -145,182 +98,17 @@ interface TimeTravelEntry<T> {
     payload: unknown;
 }
 
-/**
- * SignalTree Core Implementation - Recursive Typing Engine
- *
- * COPYRIGHT NOTICE:
- * This file contains the proprietary recursive typing implementation protected
- * under the SignalTree license. The signal-store pattern, recursive type-runtime
- * alignment, and "initiation defines structure" paradigm are exclusive intellectual
- * property of Jonathan D Borgia.
- *
- * The createSignalStore and createLazySignalTree functions implement patented
- * approaches to recursive type preservation that are strictly protected.
- *
- * Licensed under Fair Source License - see LICENSE file for complete terms.
- */
-
-/**
- * Creates a reactive signal tree with smart progressive enhancement.
- *
- * MAXIMUM FLEXIBILITY: Accepts ANY type T - no StateObject constraint!
- * This is the key difference from constrained approaches.
- *
- * Features auto-enable on first use. Uses intelligent defaults based on
- * environment (development vs production). Enhanced with safety features
- * to prevent common issues like signal double-wrapping.
- *
- * @template T - ANY type (no constraints for maximum flexibility)
- * @param obj - The initial state object to convert into a reactive tree
- * @returns A SignalTree with auto-enabling features
- *
- * @example
- * ```typescript
- * // Works with ANY object - no constraints!
- * const tree = signalTree({
- *   count: 0,
- *   users: [],
- *   metadata: new Map(),  // Non-plain objects work!
- *   fn: () => 'hello',    // Functions work!
- *   symbol: Symbol('id')  // Symbols work!
- * });
- *
- * // Core functionality always works
- * tree.state.count.set(5);
- * tree.update(state => ({ count: state.count + 1 }));
- *
- * // Composition with pipe
- * tree.pipe(
- *   withBatching(),
- *   withMemoization(),
- *   withTimeTravel()
- * );
- * ```
- */
 declare function signalTree<T>(obj: T): SignalTree<T>;
-/**
- * Creates a reactive signal tree with preset configuration.
- *
- * Uses predefined configurations for common scenarios while still
- * allowing features to auto-enable as needed.
- *
- * @template T - The state object type, must extend Record<string, unknown>
- * @param obj - The initial state object to convert into a reactive tree
- * @param preset - Preset configuration ('basic', 'performance', 'development', 'production')
- * @returns A SignalTree configured with the specified preset
- *
- * @example
- * ```typescript
- * // Optimized for production
- * const prodTree = signalTree(state, 'production');
- *
- * // Full debugging capabilities
- * const devTree = signalTree(state, 'development');
- *
- * // Maximum performance
- * const perfTree = signalTree(state, 'performance');
- * ```
- */
 declare function signalTree<T>(obj: T, preset: TreePreset): SignalTree<T>;
-/**
- * Creates a reactive signal tree with custom configuration.
- *
- * Provides full control over feature enablement while maintaining
- * auto-enabling behavior for unspecified features. Enhanced with safety features.
- *
- * @template T - ANY type (no constraints for maximum flexibility)
- * @param obj - The initial state object to convert into a reactive tree
- * @param config - Custom configuration object
- * @returns A SignalTree configured with custom options
- *
- * @example
- * ```typescript
- * // Custom configuration - works with ANY object!
- * const customTree = signalTree({
- *   data: state,
- *   metadata: new Map(),  // Any object type
- *   fn: () => 'custom'    // Even functions
- * }, {
- *   batchUpdates: true,
- *   useMemoization: true,
- *   maxCacheSize: 500,
- *   treeName: 'MyApp'
- * });
- * ```
- */
 declare function signalTree<T>(obj: T, config: TreeConfig): SignalTree<T>;
-/**
- * Implementation of the signalTree factory function.
- */
-/**
- * Main SignalTree factory function with superior type inference
- *
- * Key improvements from signal-store.ts approach:
- * 1. Uses Required<T> for better type inference when possible
- * 2. Maintains complete type information through recursion
- * 3. Proper handling of nested objects and arrays
- * 4. No type constraints - maximum flexibility
- */
 declare function signalTree<T extends Record<string, unknown>>(obj: Required<T>, configOrPreset?: TreeConfig | TreePreset): SignalTree<Required<T>>;
 declare function signalTree<T>(obj: T, configOrPreset?: TreeConfig | TreePreset): SignalTree<T>;
 
-/**
- * SignalTree Utility Functions - Recursive Typing Implementation
- *
- * COPYRIGHT NOTICE:
- * This file contains proprietary utility functions for the recursive typing system.
- * The createLazySignalTree function and built-in object detection methods are
- * protected intellectual property of Jonathan D Borgia.
- *
- * Licensed under Fair Source License - see LICENSE file for complete terms.
- */
-
-/**
- * Enhanced equality function inspired by the monolithic implementation.
- * Uses deep equality for arrays and objects, === for primitives.
- * Optimized with early exits and type-specific comparisons.
- */
 declare function equal<T>(a: T, b: T): boolean;
-/**
- * Creates a terminal signal with the enhanced equality function.
- * This should be used instead of Angular's signal() when you want
- * the same deep equality behavior as signalTree.
- *
- * Inspired by the monolithic implementation's terminal signal creation.
- */
 declare function terminalSignal<T>(value: T, customEqual?: (a: T, b: T) => boolean): WritableSignal<T>;
-/**
- * Parses a dot-notation path into an array of keys with LRU memoization.
- * Critical for performance when accessing nested properties frequently.
- * Includes proper LRU cache management to prevent memory leaks.
- *
- * @example
- * ```typescript
- * const keys1 = parsePath('user.name'); // Splits and caches
- * const keys2 = parsePath('user.name'); // Returns cached result
- * ```
- */
 declare function parsePath(path: string): string[];
-/**
- * Creates a lazy signal tree using Proxy for on-demand signal creation.
- * Only creates signals when properties are first accessed, providing
- * massive memory savings for large state objects.
- * Uses WeakMap for memory-safe caching.
- *
- * @param obj - Source object to lazily signalify
- * @param equalityFn - Equality function for signal comparison
- * @param basePath - Base path for nested objects (internal use)
- * @returns Proxied object that creates signals on first access
- */
 declare function createLazySignalTree<T extends object>(obj: T, equalityFn: (a: unknown, b: unknown) => boolean, basePath?: string): DeepSignalify<T>;
-/**
- * Native deep equality check for arrays and objects.
- * Handles all common cases that lodash.isEqual handles for our use cases.
- */
-declare function deepEqual<T>(a: T, b: T): boolean;
-/**
- * Shallow equality check for objects and arrays.
- */
+declare const deepEqual: typeof equal;
 declare function shallowEqual<T>(a: T, b: T): boolean;
 
 export { createLazySignalTree, deepEqual, equal, parsePath, shallowEqual, signalTree, terminalSignal };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
   "peerDependencies": {
     "@angular/core": "^20.1.0"