@signaltree/core 4.0.15 → 4.1.0

package/dist/enhancers/batching/lib/batching.js

@@ -1,155 +1,161 @@
-import { parsePath } from '@signaltree/shared';
-import { isNodeAccessor } from '../../../lib/utils';
+import { isNodeAccessor } from '../../../lib/utils.js';
+
 let updateQueue = [];
 let isUpdating = false;
 let flushTimeoutId;
 let currentBatchingConfig = {};
 function addToQueue(update, config = currentBatchingConfig) {
-    const maxSize = config.maxBatchSize ?? 100;
-    if (update.path) {
-        updateQueue = updateQueue.filter((existing) => existing.path !== update.path);
-    }
-    updateQueue.push(update);
-    if (updateQueue.length > maxSize) {
-        flushUpdates();
-        return true;
-    }
-    scheduleFlush(config);
-    return false;
+  const maxSize = config.maxBatchSize ?? 100;
+  if (update.path) {
+    updateQueue = updateQueue.filter(existing => existing.path !== update.path);
+  }
+  updateQueue.push(update);
+  if (updateQueue.length > maxSize) {
+    flushUpdates();
+    return true;
+  }
+  scheduleFlush(config);
+  return false;
 }
 function scheduleFlush(config) {
-    if (flushTimeoutId !== undefined) {
-        clearTimeout(flushTimeoutId);
-    }
-    const delay = config.autoFlushDelay ?? 16;
-    flushTimeoutId = setTimeout(() => {
-        flushUpdates();
-    }, delay);
+  if (flushTimeoutId !== undefined) {
+    clearTimeout(flushTimeoutId);
+  }
+  const delay = config.autoFlushDelay ?? 16;
+  flushTimeoutId = setTimeout(() => {
+    flushUpdates();
+  }, delay);
 }
 function flushUpdates() {
-    if (isUpdating)
-        return;
-    let queue;
-    do {
-        if (updateQueue.length === 0)
-            return;
-        isUpdating = true;
-        queue = updateQueue;
-        updateQueue = [];
-        if (flushTimeoutId !== undefined) {
-            clearTimeout(flushTimeoutId);
-            flushTimeoutId = undefined;
-        }
-        queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
-        try {
-            queue.forEach(({ fn }) => fn());
-        }
-        finally {
-            isUpdating = false;
-        }
-    } while (updateQueue.length > 0);
+  if (isUpdating) return;
+  let queue;
+  do {
+    if (updateQueue.length === 0) return;
+    isUpdating = true;
+    queue = updateQueue;
+    updateQueue = [];
+    if (flushTimeoutId !== undefined) {
+      clearTimeout(flushTimeoutId);
+      flushTimeoutId = undefined;
+    }
+    queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
+    try {
+      queue.forEach(({
+        fn
+      }) => fn());
+    } finally {
+      isUpdating = false;
+    }
+  } while (updateQueue.length > 0);
 }
 function batchUpdates(fn, path) {
-    const startTime = performance.now();
-    const depth = path ? parsePath(path).length : 0;
-    const update = { fn, startTime, depth, path };
-    const wasFlushed = addToQueue(update, currentBatchingConfig);
-    if (!wasFlushed) {
-        const isTimedOut = currentBatchingConfig.batchTimeoutMs &&
-            updateQueue.length > 0 &&
-            startTime - updateQueue[0].startTime >=
-                currentBatchingConfig.batchTimeoutMs;
-        if (isTimedOut) {
-            flushUpdates();
-        }
-        else if (!isUpdating && updateQueue.length > 0) {
-            queueMicrotask(() => {
-                flushUpdates();
-            });
-        }
+  const startTime = performance.now();
+  const depth = 0;
+  const update = {
+    fn,
+    startTime,
+    depth,
+    path
+  };
+  const wasFlushed = addToQueue(update, currentBatchingConfig);
+  if (!wasFlushed) {
+    const isTimedOut = currentBatchingConfig.batchTimeoutMs && updateQueue.length > 0 && startTime - updateQueue[0].startTime >= currentBatchingConfig.batchTimeoutMs;
+    if (isTimedOut) {
+      flushUpdates();
+    } else if (!isUpdating && updateQueue.length > 0) {
+      queueMicrotask(() => {
+        flushUpdates();
+      });
     }
+  }
 }
-export function withBatching(config = {}) {
-    const { enabled = true } = config;
-    currentBatchingConfig = { ...currentBatchingConfig, ...config };
-    return (tree) => {
-        if (!enabled) {
-            return tree;
-        }
-        const originalTreeCall = tree.bind(tree);
-        const enhancedTree = function (...args) {
-            if (args.length === 0) {
-                return originalTreeCall();
-            }
-            else {
-                batchUpdates(() => {
-                    if (args.length === 1) {
-                        const arg = args[0];
-                        if (typeof arg === 'function') {
-                            originalTreeCall(arg);
-                        }
-                        else {
-                            originalTreeCall(arg);
-                        }
-                    }
-                });
+function withBatching(config = {}) {
+  const {
+    enabled = true
+  } = config;
+  currentBatchingConfig = {
+    ...currentBatchingConfig,
+    ...config
+  };
+  return tree => {
+    if (!enabled) {
+      return tree;
+    }
+    const originalTreeCall = tree.bind(tree);
+    const enhancedTree = function (...args) {
+      if (args.length === 0) {
+        return originalTreeCall();
+      } else {
+        batchUpdates(() => {
+          if (args.length === 1) {
+            const arg = args[0];
+            if (typeof arg === 'function') {
+              originalTreeCall(arg);
+            } else {
+              originalTreeCall(arg);
             }
-        };
-        Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
-        Object.assign(enhancedTree, tree);
-        if ('state' in tree) {
-            Object.defineProperty(enhancedTree, 'state', {
-                value: tree.state,
-                enumerable: false,
-                configurable: true,
-            });
-        }
-        if ('$' in tree) {
-            Object.defineProperty(enhancedTree, '$', {
-                value: tree['$'],
-                enumerable: false,
-                configurable: true,
-            });
-        }
-        enhancedTree.batchUpdate = (updater) => {
-            batchUpdates(() => {
-                const current = originalTreeCall();
-                const updates = updater(current);
-                Object.entries(updates).forEach(([key, value]) => {
-                    const property = enhancedTree.state[key];
-                    if (property && 'set' in property) {
-                        property.set(value);
-                    }
-                    else if (isNodeAccessor(property)) {
-                        property(value);
-                    }
-                });
-            });
-        };
-        return enhancedTree;
+          }
+        });
+      }
+    };
+    Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
+    Object.assign(enhancedTree, tree);
+    if ('state' in tree) {
+      Object.defineProperty(enhancedTree, 'state', {
+        value: tree.state,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    if ('$' in tree) {
+      Object.defineProperty(enhancedTree, '$', {
+        value: tree['$'],
+        enumerable: false,
+        configurable: true
+      });
+    }
+    enhancedTree.batchUpdate = updater => {
+      batchUpdates(() => {
+        const current = originalTreeCall();
+        const updates = updater(current);
+        Object.entries(updates).forEach(([key, value]) => {
+          const property = enhancedTree.state[key];
+          if (property && 'set' in property) {
+            property.set(value);
+          } else if (isNodeAccessor(property)) {
+            property(value);
+          }
+        });
+      });
     };
+    return enhancedTree;
+  };
 }
-export function withHighPerformanceBatching() {
-    return withBatching({
-        enabled: true,
-        maxBatchSize: 200,
-        batchTimeoutMs: 0,
-    });
+function withHighPerformanceBatching() {
+  return withBatching({
+    enabled: true,
+    maxBatchSize: 200,
+    batchTimeoutMs: 0
+  });
 }
-export function flushBatchedUpdates() {
-    if (updateQueue.length > 0) {
-        const queue = updateQueue.slice();
-        updateQueue = [];
-        isUpdating = false;
-        queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
-        queue.forEach(({ fn }) => {
-            fn();
-        });
-    }
+function flushBatchedUpdates() {
+  if (updateQueue.length > 0) {
+    const queue = updateQueue.slice();
+    updateQueue = [];
+    isUpdating = false;
+    queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
+    queue.forEach(({
+      fn
+    }) => {
+      fn();
+    });
+  }
 }
-export function hasPendingUpdates() {
-    return updateQueue.length > 0;
+function hasPendingUpdates() {
+  return updateQueue.length > 0;
 }
-export function getBatchQueueSize() {
-    return updateQueue.length;
+function getBatchQueueSize() {
+  return updateQueue.length;
 }
+
+export { flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, withBatching, withHighPerformanceBatching };

package/dist/enhancers/computed/lib/computed.js

@@ -1,19 +1,21 @@
 import { computed } from '@angular/core';
-import { createEnhancer } from '../..';
-export function computedEnhancer(_config = {}) {
-    void _config;
-    return createEnhancer({
-        name: 'computed',
-        provides: ['computed'],
-        requires: [],
-    }, (tree) => {
-        const computedTree = tree;
-        computedTree.computed = function (computeFn) {
-            return computed(() => computeFn(tree.state));
-        };
-        return computedTree;
-    });
+import { createEnhancer } from '../../index.js';
+
+function computedEnhancer(_config = {}) {
+  return createEnhancer({
+    name: 'computed',
+    provides: ['computed'],
+    requires: []
+  }, tree => {
+    const computedTree = tree;
+    computedTree.computed = function (computeFn) {
+      return computed(() => computeFn(tree.state));
+    };
+    return computedTree;
+  });
 }
-export function createComputed(dependencies, computeFn) {
-    return computed(computeFn);
+function createComputed(dependencies, computeFn) {
+  return computed(computeFn);
 }
+
+export { computedEnhancer, createComputed };