@blac/core 2.0.14 → 2.0.16

package/dist/resolve-dependencies-CTzV1txG.js

@@ -1,731 +0,0 @@
-import {
-  a as BLAC_DEFAULTS,
-  o as BLAC_ERROR_PREFIX,
-} from './StateContainerRegistry-DC4N73O6.js';
-import { t as getRegistry } from './config-CR_Bz7RD.js';
-//#region src/tracking/path-utils.ts
-/**
- * Path utilities for dependency tracking
- *
- * Provides utilities for parsing property paths and extracting values
- * from nested objects using path strings.
- *
- * @internal
- */
-/**
- * Parse a property path string into an array of segments
- *
- * @internal
- *
- * Handles both dot notation (a.b.c) and bracket notation (a[0].b)
- *
- * @example
- * ```ts
- * parsePath('user.name') // ['user', 'name']
- * parsePath('items[0].name') // ['items', '0', 'name']
- * parsePath('data.users[2].address.city') // ['data', 'users', '2', 'address', 'city']
- * ```
- */
-function parsePath(path) {
-  const segments = [];
-  let current = '';
-  let i = 0;
-  while (i < path.length) {
-    const char = path[i];
-    if (char === '.') {
-      if (current) segments.push(current);
-      current = '';
-    } else if (char === '[') {
-      if (current) segments.push(current);
-      current = '';
-      i++;
-      while (i < path.length && path[i] !== ']') current += path[i++];
-      if (current) segments.push(current);
-      current = '';
-    } else current += char;
-    i++;
-  }
-  if (current) segments.push(current);
-  return segments;
-}
-/**
- * Get a value from an object using a path of segments
- *
- * @example
- * ```ts
- * const obj = { user: { name: 'Alice', age: 30 } }
- * getValueAtPath(obj, ['user', 'name']) // 'Alice'
- * getValueAtPath(obj, ['user', 'age']) // 30
- * getValueAtPath(obj, ['user', 'missing']) // undefined
- * ```
- *
- * @internal
- */
-function getValueAtPath(obj, segments) {
-  if (obj == null) return void 0;
-  let current = obj;
-  for (let i = 0; i < segments.length; i++) {
-    current = current[segments[i]];
-    if (current == null) return void 0;
-  }
-  return current;
-}
-/**
- * Shallow equality comparison for arrays
- *
- * Compares two arrays element-by-element using Object.is
- *
- * @example
- * ```ts
- * shallowEqual([1, 2, 3], [1, 2, 3]) // true
- * shallowEqual([1, 2, 3], [1, 2, 4]) // false
- * shallowEqual([1, 2], [1, 2, 3]) // false
- * ```
- *
- * @internal
- */
-function shallowEqual(arr1, arr2) {
-  if (arr1.length !== arr2.length) return false;
-  for (let i = 0; i < arr1.length; i++)
-    if (!Object.is(arr1[i], arr2[i])) return false;
-  return true;
-}
-//#endregion
-//#region src/tracking/tracking-proxy.ts
-/**
- * Consolidated Tracking System
- *
- * This module provides all dependency and getter tracking functionality:
- * - Proxy creation for automatic property access tracking
- * - Dependency path tracking and change detection
- * - Getter execution tracking for computed properties
- * - Combined tracking proxy for watch/waitUntil use cases
- */
-/**
- * Check if a value can be proxied
- * Returns true for plain objects and arrays only.
- * @internal
- */
-function isProxyable(value) {
-  if (typeof value !== 'object' || value === null) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === Array.prototype;
-}
-/**
- * Create a new proxy tracker state
- * @internal
- */
-function createProxyState() {
-  return {
-    trackedPaths: /* @__PURE__ */ new Set(),
-    isTracking: false,
-    proxyCache: /* @__PURE__ */ new WeakMap(),
-    boundFunctionsCache: null,
-    lastProxiedState: null,
-    lastProxy: null,
-    maxDepth: 10,
-  };
-}
-/**
- * Start tracking property accesses
- * @internal
- */
-function startProxy(state) {
-  state.isTracking = true;
-  state.trackedPaths.clear();
-}
-/**
- * Stop tracking and return the tracked paths
- * @internal
- */
-function stopProxy(state) {
-  state.isTracking = false;
-  return new Set(state.trackedPaths);
-}
-/**
- * Create a proxy for an array with property access tracking
- * @internal
- */
-function createArrayProxy(state, target, path, depth = 0) {
-  const proxy = new Proxy(target, {
-    get: (arr, prop) => {
-      if (typeof prop === 'symbol') return Reflect.get(arr, prop);
-      const value = Reflect.get(arr, prop);
-      if (typeof value === 'function') {
-        if (!state.boundFunctionsCache)
-          state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
-        const cached = state.boundFunctionsCache.get(value);
-        if (cached) return cached;
-        const bound = value.bind(arr);
-        state.boundFunctionsCache.set(value, bound);
-        return bound;
-      }
-      if (prop === 'length') {
-        if (state.isTracking) {
-          const fullPath = path ? `${path}.length` : 'length';
-          state.trackedPaths.add(fullPath);
-        }
-        return value;
-      }
-      let fullPath;
-      if (typeof prop === 'string') {
-        const index = Number(prop);
-        if (!isNaN(index) && index >= 0)
-          fullPath = path ? `${path}[${index}]` : `[${index}]`;
-        else fullPath = path ? `${path}.${prop}` : prop;
-      } else return value;
-      if (isProxyable(value))
-        return createInternal(state, value, fullPath, depth + 1);
-      if (state.isTracking) state.trackedPaths.add(fullPath);
-      return value;
-    },
-  });
-  state.proxyCache.set(target, proxy);
-  return proxy;
-}
-/**
- * Create a proxy for an object with property access tracking
- * @internal
- */
-function createInternal(state, target, path = '', depth = 0) {
-  if (!state.isTracking || !isProxyable(target)) return target;
-  if (depth >= state.maxDepth) {
-    console.warn(
-      `${BLAC_ERROR_PREFIX} Proxy depth limit (${state.maxDepth}) reached at path "${path}". Deeper property accesses won't be tracked for re-renders.`,
-    );
-    return target;
-  }
-  if (state.proxyCache.has(target)) return state.proxyCache.get(target);
-  if (Array.isArray(target))
-    return createArrayProxy(state, target, path, depth);
-  const proxy = new Proxy(target, {
-    get: (obj, prop) => {
-      if (typeof prop === 'symbol') return Reflect.get(obj, prop);
-      const value = Reflect.get(obj, prop);
-      if (typeof value === 'function') {
-        if (!state.boundFunctionsCache)
-          state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
-        const cached = state.boundFunctionsCache.get(value);
-        if (cached) return cached;
-        const bound = value.bind(obj);
-        state.boundFunctionsCache.set(value, bound);
-        return bound;
-      }
-      const fullPath = path ? `${path}.${String(prop)}` : String(prop);
-      if (typeof prop === 'string' && state.isTracking) {
-        if (!prop.startsWith('_') && !prop.startsWith('$$'))
-          state.trackedPaths.add(fullPath);
-      }
-      if (isProxyable(value))
-        return createInternal(state, value, fullPath, depth + 1);
-      return value;
-    },
-    has: (obj, prop) => {
-      if (typeof prop === 'string' && state.isTracking) {
-        const fullPath = path ? `${path}.${prop}` : prop;
-        state.trackedPaths.add(fullPath);
-      }
-      return Reflect.has(obj, prop);
-    },
-    ownKeys: (obj) => {
-      if (state.isTracking && path) state.trackedPaths.add(path);
-      return Reflect.ownKeys(obj);
-    },
-  });
-  state.proxyCache.set(target, proxy);
-  return proxy;
-}
-/**
- * Create a proxy for a target with caching
- * @internal
- */
-function createForTarget(state, target) {
-  if (state.lastProxiedState === target && state.lastProxy)
-    return state.lastProxy;
-  state.proxyCache = /* @__PURE__ */ new WeakMap();
-  state.boundFunctionsCache = null;
-  const proxy = createInternal(state, target, '', 0);
-  state.lastProxiedState = target;
-  state.lastProxy = proxy;
-  return proxy;
-}
-function isChildPath(child, parent) {
-  if (child === parent) return false;
-  return child.startsWith(parent + '.') || child.startsWith(parent + '[');
-}
-function getArrayParentPath(path) {
-  if (path.endsWith('.length')) return path.slice(0, -7);
-  const arrayIndexMatch = path.match(/^(.+?)\[\d+\]/);
-  if (arrayIndexMatch) return arrayIndexMatch[1];
-  return null;
-}
-/**
- * @internal
- */
-function optimizeTrackedPaths(paths) {
-  if (paths.size === 0) return /* @__PURE__ */ new Set();
-  if (paths.size === 1) return new Set(paths);
-  const sortedPaths = Array.from(paths).sort((a, b) => b.length - a.length);
-  const optimized = /* @__PURE__ */ new Set();
-  for (const path of sortedPaths) {
-    let hasMoreSpecificChild = false;
-    for (const optimizedPath of optimized)
-      if (isChildPath(optimizedPath, path)) {
-        hasMoreSpecificChild = true;
-        break;
-      }
-    if (!hasMoreSpecificChild) optimized.add(path);
-  }
-  const arrayParents = /* @__PURE__ */ new Set();
-  for (const path of optimized) {
-    const arrayParent = getArrayParentPath(path);
-    if (arrayParent) arrayParents.add(arrayParent);
-  }
-  for (const arrayParent of arrayParents) optimized.add(arrayParent);
-  return optimized;
-}
-/**
- * @internal
- */
-function createDependencyState() {
-  return {
-    proxyState: createProxyState(),
-    previousRenderPaths: /* @__PURE__ */ new Set(),
-    currentRenderPaths: /* @__PURE__ */ new Set(),
-    pathCache: /* @__PURE__ */ new Map(),
-    lastCheckedState: null,
-    lastCheckedValues: /* @__PURE__ */ new Map(),
-  };
-}
-/**
- * @internal
- */
-function startDependency(tracker) {
-  startProxy(tracker.proxyState);
-}
-/**
- * @internal
- */
-function createDependencyProxy(tracker, state) {
-  return createForTarget(tracker.proxyState, state);
-}
-/**
- * @internal
- */
-function capturePaths(tracker, state) {
-  tracker.previousRenderPaths = tracker.currentRenderPaths;
-  tracker.currentRenderPaths = optimizeTrackedPaths(
-    stopProxy(tracker.proxyState),
-  );
-  if (
-    tracker.previousRenderPaths.size === 0 &&
-    tracker.currentRenderPaths.size === 0
-  )
-    return;
-  const trackedPathsUnion = new Set(tracker.previousRenderPaths);
-  for (const path of tracker.currentRenderPaths) trackedPathsUnion.add(path);
-  const canReuseCache = tracker.lastCheckedState === state;
-  for (const path of trackedPathsUnion)
-    if (!tracker.pathCache.has(path)) {
-      const segments = parsePath(path);
-      const value =
-        canReuseCache && tracker.lastCheckedValues.has(path)
-          ? tracker.lastCheckedValues.get(path)
-          : getValueAtPath(state, segments);
-      tracker.pathCache.set(path, {
-        segments,
-        value,
-      });
-    } else {
-      const info = tracker.pathCache.get(path);
-      if (!info) continue;
-      info.value =
-        canReuseCache && tracker.lastCheckedValues.has(path)
-          ? tracker.lastCheckedValues.get(path)
-          : getValueAtPath(state, info.segments);
-    }
-  tracker.lastCheckedValues.clear();
-}
-/**
- * @internal
- */
-function hasDependencyChanges(tracker, state) {
-  if (tracker.pathCache.size === 0) return true;
-  tracker.lastCheckedValues.clear();
-  for (const [path, info] of tracker.pathCache.entries()) {
-    const currentValue = getValueAtPath(state, info.segments);
-    tracker.lastCheckedValues.set(path, currentValue);
-    if (!Object.is(currentValue, info.value)) {
-      tracker.lastCheckedState = state;
-      return true;
-    }
-  }
-  tracker.lastCheckedState = state;
-  return false;
-}
-/**
- * @internal
- */
-function hasTrackedData(tracker) {
-  return (
-    tracker.proxyState.trackedPaths.size > 0 ||
-    tracker.pathCache.size > 0 ||
-    tracker.previousRenderPaths.size > 0
-  );
-}
-const descriptorCache = /* @__PURE__ */ new WeakMap();
-const blocProxyCache = /* @__PURE__ */ new WeakMap();
-const activeTrackerMap = /* @__PURE__ */ new WeakMap();
-const MAX_GETTER_DEPTH = BLAC_DEFAULTS.MAX_GETTER_DEPTH;
-/**
- * @internal
- */
-function getDescriptor(obj, prop) {
-  const constructor = obj.constructor;
-  let constructorCache = descriptorCache.get(constructor);
-  if (constructorCache?.has(prop)) return constructorCache.get(prop);
-  let current = obj;
-  let descriptor;
-  while (current && current !== Object.prototype) {
-    descriptor = Object.getOwnPropertyDescriptor(current, prop);
-    if (descriptor) break;
-    current = Object.getPrototypeOf(current);
-  }
-  if (!constructorCache) {
-    constructorCache = /* @__PURE__ */ new Map();
-    descriptorCache.set(constructor, constructorCache);
-  }
-  constructorCache.set(prop, descriptor);
-  return descriptor;
-}
-/**
- * @internal
- */
-function isGetter(obj, prop) {
-  return getDescriptor(obj, prop)?.get !== void 0;
-}
-/**
- * @internal
- */
-function createGetterState() {
-  return {
-    trackedValues: /* @__PURE__ */ new Map(),
-    currentlyAccessing: /* @__PURE__ */ new Set(),
-    trackedGetters: /* @__PURE__ */ new Set(),
-    isTracking: false,
-    renderCache: /* @__PURE__ */ new Map(),
-    cacheValid: false,
-    depth: 0,
-    visitedBlocs: /* @__PURE__ */ new Set(),
-  };
-}
-/**
- * @internal
- */
-function setActiveTracker(bloc, tracker) {
-  activeTrackerMap.set(bloc, tracker);
-}
-/**
- * @internal
- */
-function clearActiveTracker(bloc) {
-  activeTrackerMap.delete(bloc);
-}
-/**
- * @internal
- */
-function commitTrackedGetters(tracker) {
-  if (tracker.currentlyAccessing.size > 0)
-    tracker.trackedGetters = new Set(tracker.currentlyAccessing);
-  tracker.currentlyAccessing.clear();
-}
-/**
- * Execute a tracked getter with depth/circular dependency checks and context management.
- * @internal
- */
-function executeTrackedGetter(target, prop, tracker) {
-  tracker.currentlyAccessing.add(prop);
-  if (tracker.cacheValid && tracker.renderCache.has(prop)) {
-    const cachedValue = tracker.renderCache.get(prop);
-    tracker.trackedValues.set(prop, cachedValue);
-    return cachedValue;
-  }
-  if (tracker.depth >= MAX_GETTER_DEPTH)
-    throw new Error(
-      `${BLAC_ERROR_PREFIX} Maximum getter depth (${MAX_GETTER_DEPTH}) exceeded. Possible circular dependency in getter "${String(prop)}" on ${target.constructor.name}.`,
-    );
-  if (tracker.visitedBlocs.has(target))
-    throw new Error(
-      `${BLAC_ERROR_PREFIX} Circular dependency detected: getter "${String(prop)}" on ${target.constructor.name}.`,
-    );
-  const prevDepth = tracker.depth;
-  const prevVisited = new Set(tracker.visitedBlocs);
-  tracker.depth++;
-  tracker.visitedBlocs.add(target);
-  try {
-    const descriptor = getDescriptor(target, prop);
-    if (!descriptor?.get) return target[prop];
-    const value = descriptor.get.call(target);
-    tracker.trackedValues.set(prop, value);
-    return value;
-  } catch (error) {
-    tracker.currentlyAccessing.delete(prop);
-    throw error;
-  } finally {
-    tracker.depth = prevDepth;
-    tracker.visitedBlocs = prevVisited;
-  }
-}
-/**
- * @internal
- */
-function createBlocProxy(bloc) {
-  const cached = blocProxyCache.get(bloc);
-  if (cached) return cached;
-  const proxy = new Proxy(bloc, {
-    get(target, prop, receiver) {
-      const tracker = activeTrackerMap.get(target);
-      if (tracker?.isTracking && isGetter(target, prop))
-        return executeTrackedGetter(target, prop, tracker);
-      return Reflect.get(target, prop, receiver);
-    },
-  });
-  blocProxyCache.set(bloc, proxy);
-  return proxy;
-}
-/**
- * @internal
- */
-function hasGetterChanges(bloc, tracker) {
-  if (!tracker || tracker.trackedGetters.size === 0) return false;
-  tracker.renderCache.clear();
-  let hasAnyChange = false;
-  for (const prop of tracker.trackedGetters)
-    try {
-      const descriptor = getDescriptor(bloc, prop);
-      if (!descriptor?.get) continue;
-      const newValue = descriptor.get.call(bloc);
-      const oldValue = tracker.trackedValues.get(prop);
-      tracker.renderCache.set(prop, newValue);
-      tracker.trackedValues.set(prop, newValue);
-      if (!Object.is(newValue, oldValue)) hasAnyChange = true;
-    } catch (error) {
-      console.warn(
-        `${BLAC_ERROR_PREFIX} Getter "${String(prop)}" threw error during change detection. Stopping tracking for this getter.`,
-        error,
-      );
-      tracker.trackedGetters.delete(prop);
-      tracker.trackedValues.delete(prop);
-      tracker.cacheValid = false;
-      return true;
-    }
-  tracker.cacheValid = true;
-  return hasAnyChange;
-}
-/**
- * @internal
- */
-function invalidateRenderCache(tracker) {
-  tracker.cacheValid = false;
-}
-/**
- * Create a new tracking proxy state.
- */
-function createState() {
-  return {
-    dependencyState: createDependencyState(),
-    getterState: createGetterState(),
-    dependencies: /* @__PURE__ */ new Set(),
-    isTracking: false,
-  };
-}
-/**
- * Start tracking on a tracking proxy.
- */
-function startTracking(tracker) {
-  tracker.isTracking = true;
-  tracker.dependencies.clear();
-  tracker.getterState.isTracking = true;
-  startDependency(tracker.dependencyState);
-}
-/**
- * Stop tracking and collect all dependencies.
- */
-function stopTracking(tracker, bloc) {
-  tracker.isTracking = false;
-  tracker.getterState.isTracking = false;
-  capturePaths(tracker.dependencyState, bloc.state);
-  commitTrackedGetters(tracker.getterState);
-  return new Set(tracker.dependencies);
-}
-/**
- * Check if tracked state or getters have changed.
- */
-function hasChanges(tracker, bloc) {
-  invalidateRenderCache(tracker.getterState);
-  const stateChanged = hasDependencyChanges(
-    tracker.dependencyState,
-    bloc.state,
-  );
-  const getterChanged = hasGetterChanges(bloc, tracker.getterState);
-  return stateChanged || getterChanged;
-}
-/**
- * Create a tracking proxy for a bloc instance.
- * Tracks both state property access and getter access.
- */
-function createTrackingProxy(bloc, tracker) {
-  tracker.dependencies.add(bloc);
-  const stateProxyCache = /* @__PURE__ */ new WeakMap();
-  return new Proxy(bloc, {
-    get(target, prop, receiver) {
-      if (prop === 'state') {
-        if (!tracker.isTracking) return target.state;
-        const rawState = target.state;
-        if (rawState === null || typeof rawState !== 'object') return rawState;
-        if (stateProxyCache.has(rawState)) return stateProxyCache.get(rawState);
-        const stateProxy = createDependencyProxy(
-          tracker.dependencyState,
-          rawState,
-        );
-        stateProxyCache.set(rawState, stateProxy);
-        return stateProxy;
-      }
-      if (typeof prop === 'symbol') return Reflect.get(target, prop, receiver);
-      const value = Reflect.get(target, prop, receiver);
-      if (typeof value === 'function') return value.bind(target);
-      if (tracker.isTracking && isGetter(target, prop))
-        return executeTrackedGetter(target, prop, tracker.getterState);
-      return value;
-    },
-  });
-}
-//#endregion
-//#region src/tracking/dependency-manager.ts
-/**
- * Manages subscriptions to state container dependencies.
- * Provides efficient sync mechanism to add/remove subscriptions
- * as dependencies change between callback invocations.
- */
-var DependencyManager = class {
-  constructor() {
-    this.subscriptions = /* @__PURE__ */ new Map();
-    this.currentDeps = /* @__PURE__ */ new Set();
-  }
-  /**
-   * Sync subscriptions with a new set of dependencies.
-   * Adds subscriptions for new deps, removes subscriptions for stale deps.
-   *
-   * @param newDeps - The new set of dependencies to subscribe to
-   * @param onChange - Callback to invoke when any dependency changes
-   * @param exclude - Optional instance to exclude from subscriptions (e.g., primary bloc)
-   * @returns true if the dependency set changed, false if unchanged
-   */
-  sync(newDeps, onChange, exclude) {
-    const filteredNewDeps = /* @__PURE__ */ new Set();
-    for (const dep of newDeps)
-      if (dep !== exclude && !dep.isDisposed) filteredNewDeps.add(dep);
-    if (this.areSetsEqual(this.currentDeps, filteredNewDeps)) return false;
-    for (const dep of this.currentDeps)
-      if (!filteredNewDeps.has(dep)) {
-        const unsub = this.subscriptions.get(dep);
-        if (unsub) {
-          unsub();
-          this.subscriptions.delete(dep);
-        }
-      }
-    for (const dep of filteredNewDeps)
-      if (!this.currentDeps.has(dep) && !this.subscriptions.has(dep)) {
-        const unsub = dep.subscribe(onChange);
-        this.subscriptions.set(dep, unsub);
-      }
-    this.currentDeps = filteredNewDeps;
-    return true;
-  }
-  /**
-   * Add a single dependency subscription.
-   */
-  add(dep, onChange) {
-    if (this.subscriptions.has(dep) || dep.isDisposed) return;
-    const unsub = dep.subscribe(onChange);
-    this.subscriptions.set(dep, unsub);
-    this.currentDeps.add(dep);
-  }
-  /**
-   * Check if a dependency is currently subscribed.
-   */
-  has(dep) {
-    return this.currentDeps.has(dep);
-  }
-  /**
-   * Get the current set of dependencies.
-   */
-  getDependencies() {
-    return new Set(this.currentDeps);
-  }
-  /**
-   * Clean up all active subscriptions.
-   */
-  cleanup() {
-    for (const unsub of this.subscriptions.values()) unsub();
-    this.subscriptions.clear();
-    this.currentDeps.clear();
-  }
-  areSetsEqual(a, b) {
-    if (a.size !== b.size) return false;
-    for (const item of a) if (!b.has(item)) return false;
-    return true;
-  }
-};
-//#endregion
-//#region src/tracking/resolve-dependencies.ts
-/**
- * Resolve all transitive dependencies of a bloc via BFS over `dependencies` maps.
- * Uses cycle detection to avoid infinite loops.
- * @internal
- */
-function resolveDependencies(bloc) {
-  const result = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [bloc];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current) break;
-    for (const [Type, key] of current.dependencies) {
-      const visitKey = `${Type.name}::${key}`;
-      if (visited.has(visitKey)) continue;
-      visited.add(visitKey);
-      const dep = getRegistry().ensure(Type, key);
-      result.add(dep);
-      if (dep.dependencies.size > 0) queue.push(dep);
-    }
-  }
-  result.delete(bloc);
-  return result;
-}
-//#endregion
-export {
-  setActiveTracker as _,
-  commitTrackedGetters as a,
-  stopTracking as b,
-  createDependencyState as c,
-  createTrackingProxy as d,
-  hasChanges as f,
-  invalidateRenderCache as g,
-  hasTrackedData as h,
-  clearActiveTracker as i,
-  createGetterState as l,
-  hasGetterChanges as m,
-  DependencyManager as n,
-  createBlocProxy as o,
-  hasDependencyChanges as p,
-  capturePaths as r,
-  createDependencyProxy as s,
-  resolveDependencies as t,
-  createState as u,
-  startDependency as v,
-  shallowEqual as x,
-  startTracking as y,
-};
-
-//# sourceMappingURL=resolve-dependencies-CTzV1txG.js.map