@signaltree/core 4.0.1 → 4.0.2

package/dist/enhancers/batching/index.js

@@ -1,406 +0,0 @@
-import '@signaltree/shared';
-import '@angular/core';
-
-/** Symbol to mark callable signals - using global symbol to match across files */
-const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
-/**
- * Checks if a value is a node accessor created by makeNodeAccessor
- */
-function isNodeAccessor(value) {
-    return (typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value);
-}
-
-/** Global queue for batched updates awaiting processing */
-let updateQueue = [];
-/** Flag to prevent recursive batch processing */
-let isUpdating = false;
-/** Timeout ID for scheduled flush operations */
-let flushTimeoutId;
-/** Current batching configuration */
-let currentBatchingConfig = {};
-/**
- * Enhanced queue management with priority and deduplication
- * Returns true if queue was flushed immediately, false if scheduled for later
- */
-function addToQueue(update, config = currentBatchingConfig) {
-    const maxSize = config.maxBatchSize ?? 100;
-    // Remove duplicates based on path if available
-    if (update.path) {
-        updateQueue = updateQueue.filter((existing) => existing.path !== update.path);
-    }
-    updateQueue.push(update);
-    // Check if we should flush immediately due to maxBatchSize
-    // Flush when we exceed maxBatchSize, not when we reach it
-    if (updateQueue.length > maxSize) {
-        // Flush immediately when max batch size is exceeded
-        flushUpdates();
-        return true; // Indicate that queue was flushed
-    }
-    // Schedule auto-flush if not already scheduled
-    scheduleFlush(config);
-    return false; // Indicate that queue was scheduled for later
-}
-/**
- * Schedules automatic queue flushing with configurable timing
- */
-function scheduleFlush(config) {
-    if (flushTimeoutId !== undefined) {
-        clearTimeout(flushTimeoutId);
-    }
-    const delay = config.autoFlushDelay ?? 16; // Default to 60fps
-    flushTimeoutId = setTimeout(() => {
-        flushUpdates();
-    }, delay);
-}
-/**
- * Processes the update queue immediately with race condition protection.
- * Handles updates that arrive during flush execution.
- */
-function flushUpdates() {
-    if (isUpdating)
-        return;
-    let queue;
-    do {
-        if (updateQueue.length === 0)
-            return;
-        isUpdating = true;
-        queue = updateQueue;
-        updateQueue = []; // Clear queue atomically
-        // Clear any pending flush timeout
-        if (flushTimeoutId !== undefined) {
-            clearTimeout(flushTimeoutId);
-            flushTimeoutId = undefined;
-        }
-        // Sort by depth (deepest first) for optimal update propagation
-        queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
-        try {
-            queue.forEach(({ fn }) => fn());
-        }
-        finally {
-            isUpdating = false;
-        }
-        // Process any updates that were added during flush
-    } while (updateQueue.length > 0);
-}
-/**
- * Core batching function that intelligently queues updates and processes them in optimized microtasks.
- * Updates are sorted by depth (deepest first) for optimal update propagation and minimal re-computations.
- *
- * @param fn - The update function to batch
- * @param path - Optional state path for update grouping and optimization
- *
- * @example
- * ```typescript
- * // Simple batched update
- * batchUpdates(() => tree.update(() => ({ count: 1 })));
- *
- * // Path-aware batching for nested updates
- * batchUpdates(() => tree.update(() => ({ user: { name: 'John' } })), 'user.name');
- *
- * // Multiple updates get automatically batched
- * batchUpdates(() => tree.update(() => ({ loading: true })));
- * batchUpdates(() => tree.update(() => ({ error: null })));
- * // Both execute in single microtask
- * ```
- */
-function batchUpdates(fn, path) {
-    const startTime = performance.now();
-    const depth = 0;
-    const update = { fn, startTime, depth, path };
-    // Use enhanced queue management
-    const wasFlushed = addToQueue(update, currentBatchingConfig);
-    // Only schedule additional flush if queue wasn't already flushed
-    if (!wasFlushed) {
-        // Check if we need to process immediately due to timeout
-        const isTimedOut = currentBatchingConfig.batchTimeoutMs &&
-            updateQueue.length > 0 &&
-            startTime - updateQueue[0].startTime >=
-                currentBatchingConfig.batchTimeoutMs;
-        if (isTimedOut) {
-            flushUpdates();
-        }
-        else if (!isUpdating && updateQueue.length > 0) {
-            // Schedule flush but don't set isUpdating until the microtask runs
-            queueMicrotask(() => {
-                flushUpdates();
-            });
-        }
-    }
-}
-/**
- * Enhances a SignalTree with intelligent batching capabilities for optimal performance.
- * Automatically groups rapid state updates into efficient batch cycles to eliminate UI thrashing.
- *
- * @template T - The state object type extending StateObject
- * @param config - Configuration options for batching behavior
- * @returns Function that enhances a SignalTree with batching capabilities
- *
- * @example
- * ```typescript
- * // Basic batching with default settings
- * const tree = create(initialState).with(withBatching());
- *
- * // High-performance batching for demanding applications
- * const tree = create(initialState).with(withBatching({
- *   maxBatchSize: 50,
- *   autoFlushDelay: 8, // ~120fps
- *   batchTimeoutMs: 50
- * }));
- *
- * // Conservative batching for stable UIs
- * const tree = create(initialState).with(withBatching({
- *   maxBatchSize: 10,
- *   autoFlushDelay: 100,
- *   batchTimeoutMs: 200
- * }));
- *
- * // Use batching methods
- * tree.batchUpdate((state) => ({
- *   users: [...state.users, newUser],
- *   loading: false,
- *   error: null
- * }));
- * Uses unconstrained recursive typing - no limitations on T
- * ```
- */
-function withBatching(config = {}) {
-    const { enabled = true } = config;
-    // Update global config for this batching instance
-    currentBatchingConfig = { ...currentBatchingConfig, ...config };
-    return (tree) => {
-        if (!enabled) {
-            return tree;
-        }
-        // Store the original callable tree function
-        const originalTreeCall = tree.bind(tree);
-        // Create enhanced tree function that batches update operations
-        const enhancedTree = function (...args) {
-            if (args.length === 0) {
-                // Get operation - call original directly
-                return originalTreeCall();
-            }
-            else {
-                // Set or update operation - batch it
-                batchUpdates(() => {
-                    if (args.length === 1) {
-                        const arg = args[0];
-                        if (typeof arg === 'function') {
-                            originalTreeCall(arg);
-                        }
-                        else {
-                            originalTreeCall(arg);
-                        }
-                    }
-                });
-            }
-        };
-        // Copy all properties and methods from original tree
-        Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
-        Object.assign(enhancedTree, tree);
-        // Ensure state and $ properties are preserved
-        if ('state' in tree) {
-            Object.defineProperty(enhancedTree, 'state', {
-                value: tree.state,
-                enumerable: false,
-                configurable: true,
-            });
-        }
-        // Ensure $ alias is preserved
-        if ('$' in tree) {
-            Object.defineProperty(enhancedTree, '$', {
-                value: tree['$'],
-                enumerable: false,
-                configurable: true,
-            });
-        }
-        // Replace the stub batchUpdate method with actual batching logic
-        enhancedTree.batchUpdate = (updater) => {
-            batchUpdates(() => {
-                const current = originalTreeCall();
-                const updates = updater(current);
-                // Apply updates to individual properties
-                Object.entries(updates).forEach(([key, value]) => {
-                    const property = enhancedTree.state[key];
-                    if (property && 'set' in property) {
-                        // It's a WritableSignal - use .set()
-                        property.set(value);
-                    }
-                    else if (isNodeAccessor(property)) {
-                        // It's a NodeAccessor - use callable syntax
-                        property(value);
-                    }
-                });
-            });
-        };
-        return enhancedTree;
-    };
-}
-/**
- * Convenience function to enable batching with default settings.
- * Equivalent to withBatching({ enabled: true }) but more concise for common usage.
- *
- * @template T - The state object type extending StateObject
- * @returns Function that enhances a SignalTree with default batching settings
- *
- * @example
- * ```typescript
- * // Simple batching enablement
- * const tree = create(initialState).with(enableBatching());
- *
- * // Equivalent to:
- * const tree = create(initialState).with(withBatching({ enabled: true }));
- * Uses unconstrained recursive typing - no limitations on T
- * ```
- */
-/**
- * Creates high-performance batching configuration optimized for demanding applications.
- * Uses aggressive batching settings for maximum performance in high-frequency update scenarios.
- * Uses unconstrained recursive typing - no limitations on T
- *
- * @template T - The state object type extending StateObject
- * @returns Function that enhances a SignalTree with high-performance batching
- *
- * @example
- * ```typescript
- * // For performance-critical applications
- * const gameTree = create(gameState).with(withHighPerformanceBatching());
- *
- * // Perfect for:
- * // - Real-time games
- * // - High-frequency data updates
- * // - Animation-heavy UIs
- * // - Large dataset operations
- *
- * // Automatically includes:
- * // - Large batch sizes (200 updates)
- * // - Immediate processing (0ms timeout)
- * // - Aggressive optimization
- * Uses unconstrained recursive typing - no limitations on T
- * ```
- */
-function withHighPerformanceBatching() {
-    return withBatching({
-        enabled: true,
-        maxBatchSize: 200,
-        batchTimeoutMs: 0,
-    });
-}
-/**
- * Manually flushes all pending batched updates immediately.
- * Forces synchronous execution of queued updates, bypassing normal batching delays.
- * Useful for testing scenarios or when immediate state consistency is required.
- *
- * @example
- * ```typescript
- * // Queue some updates
- * tree.batchUpdate(() => ({ count: 1 }));
- * tree.batchUpdate(() => ({ name: 'test' }));
- *
- * // In tests, ensure updates are applied immediately
- * flushBatchedUpdates();
- * expect(tree().count).toBe(1);
- * expect(tree().name).toBe('test');
- *
- * // Before critical operations that need current state
- * flushBatchedUpdates();
- * const currentState = tree(); // Guaranteed to be up-to-date
- *
- * // In animation frames for precise timing
- * requestAnimationFrame(() => {
- *   flushBatchedUpdates(); // Ensure updates are applied before render
- *   updateUI();
- * });
- * ```
- */
-function flushBatchedUpdates() {
-    if (updateQueue.length > 0) {
-        // Force flush regardless of isUpdating state
-        const queue = updateQueue.slice();
-        updateQueue = [];
-        isUpdating = false; // Reset the updating flag
-        // Sort by depth (deepest first) for optimal update propagation
-        queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
-        queue.forEach(({ fn }) => {
-            fn();
-        });
-    }
-}
-/**
- * Checks if there are pending batched updates waiting to be processed.
- * Useful for testing, debugging, or conditional logic based on update queue state.
- *
- * @returns True if updates are queued, false if queue is empty
- *
- * @example
- * ```typescript
- * // Check before critical operations
- * tree.batchUpdate(() => ({ loading: true }));
- *
- * if (hasPendingUpdates()) {
- *   console.log('Updates are queued for processing');
- *   flushBatchedUpdates(); // Process them now if needed
- * }
- *
- * // In testing
- * tree.batchUpdate(() => ({ count: 1 }));
- * expect(hasPendingUpdates()).toBe(true);
- *
- * flushBatchedUpdates();
- * expect(hasPendingUpdates()).toBe(false);
- *
- * // Conditional behavior
- * function performCriticalOperation() {
- *   if (hasPendingUpdates()) {
- *     flushBatchedUpdates(); // Ensure consistent state
- *   }
- *   // Proceed with operation
- * }
- * ```
- */
-function hasPendingUpdates() {
-    return updateQueue.length > 0;
-}
-/**
- * Gets the current number of updates waiting in the batch queue.
- * Useful for performance monitoring, debugging, and batch size optimization.
- *
- * @returns Number of queued updates
- *
- * @example
- * ```typescript
- * // Performance monitoring
- * function monitorBatchPerformance() {
- *   const queueSize = getBatchQueueSize();
- *
- *   if (queueSize > 50) {
- *     console.warn(`Large batch queue detected: ${queueSize} updates`);
- *   }
- *
- *   // Log metrics
- *   console.log(`Current queue size: ${queueSize}`);
- * }
- *
- * // Debug batching behavior
- * tree.batchUpdate(() => ({ a: 1 }));
- * tree.batchUpdate(() => ({ b: 2 }));
- * tree.batchUpdate(() => ({ c: 3 }));
- *
- * console.log(`Queue size: ${getBatchQueueSize()}`); // 3
- *
- * flushBatchedUpdates();
- * console.log(`Queue size after flush: ${getBatchQueueSize()}`); // 0
- *
- * // Optimize batch configuration
- * const currentQueueSize = getBatchQueueSize();
- * if (currentQueueSize > 100) {
- *   // Consider reducing maxBatchSize or autoFlushDelay
- *   console.log('Consider optimizing batch configuration');
- * }
- * ```
- */
-function getBatchQueueSize() {
-    return updateQueue.length;
-}
-
-export { flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, withBatching, withHighPerformanceBatching };
-//# sourceMappingURL=index.js.map

package/dist/enhancers/batching/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../packages/core/src/lib/utils.ts","../../../../../../../packages/core/src/enhancers/batching/lib/batching.ts"],"sourcesContent":[null,null],"names":[],"mappings":"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"}

package/dist/enhancers/batching/types/packages/core/src/enhancers/batching/index.d.ts

@@ -1,2 +0,0 @@
-export * from './lib/batching';
-//# sourceMappingURL=index.d.ts.map

package/dist/enhancers/batching/types/packages/core/src/enhancers/batching/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/batching/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/enhancers/batching/types/packages/core/src/enhancers/batching/jest.config.d.ts

@@ -1,16 +0,0 @@
-declare const _default: {
-    displayName: string;
-    preset: string;
-    setupFilesAfterEnv: string[];
-    coverageDirectory: string;
-    transform: {
-        '^.+\\.(ts|mjs|js|html)$': (string | {
-            tsconfig: string;
-            stringifyContentPathRegex: string;
-        })[];
-    };
-    transformIgnorePatterns: string[];
-    snapshotSerializers: string[];
-};
-export default _default;
-//# sourceMappingURL=jest.config.d.ts.map

package/dist/enhancers/batching/types/packages/core/src/enhancers/batching/jest.config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jest.config.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/batching/jest.config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,wBAoBE"}