@blac/core 2.0.13 → 2.0.14

package/dist/tracked-WF6aXuAo.js

@@ -1,199 +1,223 @@
-import { a as BLAC_DEFAULTS } from "./StateContainerRegistry-Yph6UCA_.js";
-import { t as getRegistry } from "./config-BKoaAlmb.js";
-import { b as stopTracking, d as createTrackingProxy, f as hasChanges, n as DependencyManager, t as resolveDependencies, u as createState, y as startTracking } from "./resolve-dependencies-BGafS3Ww.js";
+import { a as BLAC_DEFAULTS } from './StateContainerRegistry-Yph6UCA_.js';
+import { t as getRegistry } from './config-BKoaAlmb.js';
+import {
+  b as stopTracking,
+  d as createTrackingProxy,
+  f as hasChanges,
+  n as DependencyManager,
+  t as resolveDependencies,
+  u as createState,
+  y as startTracking,
+} from './resolve-dependencies-BGafS3Ww.js';
 //#region src/registry/acquire.ts
 function acquire(BlocClass, instanceKey, refId) {
-	return getRegistry().acquire(BlocClass, instanceKey, {
-		canCreate: true,
-		countRef: true,
-		refId
-	});
+  return getRegistry().acquire(BlocClass, instanceKey, {
+    canCreate: true,
+    countRef: true,
+    refId,
+  });
 }
 //#endregion
 //#region src/registry/release.ts
 function release(BlocClass, instanceKey, forceDispose = false, refId) {
-	getRegistry().release(BlocClass, instanceKey, forceDispose, refId);
+  getRegistry().release(BlocClass, instanceKey, forceDispose, refId);
 }
 //#endregion
 //#region src/watch/watch.ts
-const STOP = Symbol("watch.STOP");
-const BLOC_REF_MARKER = Symbol("BlocRef");
+const STOP = Symbol('watch.STOP');
+const BLOC_REF_MARKER = Symbol('BlocRef');
 /**
-* Create a reference to a specific bloc instance.
-*
-* @example
-* ```ts
-* watch(instance(UserBloc, 'user-123'), (userBloc) => {
-*   console.log(userBloc.state.name);
-* });
-* ```
-*/
+ * Create a reference to a specific bloc instance.
+ *
+ * @example
+ * ```ts
+ * watch(instance(UserBloc, 'user-123'), (userBloc) => {
+ *   console.log(userBloc.state.name);
+ * });
+ * ```
+ */
 function instance(BlocClass, instanceId) {
-	return {
-		[BLOC_REF_MARKER]: true,
-		blocClass: BlocClass,
-		instanceId
-	};
+  return {
+    [BLOC_REF_MARKER]: true,
+    blocClass: BlocClass,
+    instanceId,
+  };
 }
 function isBlocRef(input) {
-	return typeof input === "object" && input !== null && BLOC_REF_MARKER in input;
+  return (
+    typeof input === 'object' && input !== null && BLOC_REF_MARKER in input
+  );
 }
 let watchIdCounter = 0;
 function resolveBloc(input, refId) {
-	if (isBlocRef(input)) return acquire(input.blocClass, input.instanceId, refId);
-	return acquire(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, refId);
+  if (isBlocRef(input))
+    return acquire(input.blocClass, input.instanceId, refId);
+  return acquire(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, refId);
 }
 function releaseBloc(input, refId) {
-	if (isBlocRef(input)) release(input.blocClass, input.instanceId, false, refId);
-	else release(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, false, refId);
+  if (isBlocRef(input))
+    release(input.blocClass, input.instanceId, false, refId);
+  else release(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, false, refId);
 }
 function isArray(input) {
-	return Array.isArray(input);
+  return Array.isArray(input);
 }
 function watchImpl(blocsOrBloc, callback) {
-	const isSingle = !isArray(blocsOrBloc);
-	const inputs = isSingle ? [blocsOrBloc] : blocsOrBloc;
-	const refId = `watch-${watchIdCounter++}`;
-	const instances = inputs.map((input) => resolveBloc(input, refId));
-	const tracker = createState();
-	const proxiedInstances = instances.map((inst) => createTrackingProxy(inst, tracker));
-	const externalDepsManager = new DependencyManager();
-	let disposed = false;
-	const primarySubscriptions = [];
-	const cleanup = () => {
-		if (disposed) return;
-		disposed = true;
-		primarySubscriptions.forEach((unsub) => unsub());
-		externalDepsManager.cleanup();
-		inputs.forEach((input) => releaseBloc(input, refId));
-	};
-	const runCallback = () => {
-		if (disposed) return;
-		startTracking(tracker);
-		let result;
-		try {
-			result = callback(isSingle ? proxiedInstances[0] : proxiedInstances);
-		} finally {
-			const externalDeps = /* @__PURE__ */ new Set();
-			for (const inst of instances) {
-				const deps = stopTracking(tracker, inst);
-				for (const dep of deps) externalDeps.add(dep);
-				for (const dep of resolveDependencies(inst)) externalDeps.add(dep);
-			}
-			for (const inst of instances) externalDeps.delete(inst);
-			externalDepsManager.sync(externalDeps, runCallback);
-		}
-		if (result === STOP) cleanup();
-	};
-	const onChange = () => {
-		if (disposed) return;
-		runCallback();
-	};
-	for (const inst of instances) primarySubscriptions.push(inst.subscribe(onChange));
-	runCallback();
-	return cleanup;
+  const isSingle = !isArray(blocsOrBloc);
+  const inputs = isSingle ? [blocsOrBloc] : blocsOrBloc;
+  const refId = `watch-${watchIdCounter++}`;
+  const instances = inputs.map((input) => resolveBloc(input, refId));
+  const tracker = createState();
+  const proxiedInstances = instances.map((inst) =>
+    createTrackingProxy(inst, tracker),
+  );
+  const externalDepsManager = new DependencyManager();
+  let disposed = false;
+  const primarySubscriptions = [];
+  const cleanup = () => {
+    if (disposed) return;
+    disposed = true;
+    primarySubscriptions.forEach((unsub) => unsub());
+    externalDepsManager.cleanup();
+    inputs.forEach((input) => releaseBloc(input, refId));
+  };
+  const runCallback = () => {
+    if (disposed) return;
+    startTracking(tracker);
+    let result;
+    try {
+      result = callback(isSingle ? proxiedInstances[0] : proxiedInstances);
+    } finally {
+      const externalDeps = /* @__PURE__ */ new Set();
+      for (const inst of instances) {
+        const deps = stopTracking(tracker, inst);
+        for (const dep of deps) externalDeps.add(dep);
+        for (const dep of resolveDependencies(inst)) externalDeps.add(dep);
+      }
+      for (const inst of instances) externalDeps.delete(inst);
+      externalDepsManager.sync(externalDeps, runCallback);
+    }
+    if (result === STOP) cleanup();
+  };
+  const onChange = () => {
+    if (disposed) return;
+    runCallback();
+  };
+  for (const inst of instances)
+    primarySubscriptions.push(inst.subscribe(onChange));
+  runCallback();
+  return cleanup;
 }
 const watch = Object.assign(watchImpl, { STOP });
 //#endregion
 //#region src/tracking/tracked.ts
 /**
-* Run a callback while tracking all bloc dependencies accessed.
-* Returns both the result and the set of discovered dependencies.
-*
-* @example
-* ```ts
-* const { result, dependencies } = tracked(() => {
-*   const user = ensure(UserBloc);
-*   return user.fullName; // getter that may access other blocs
-* });
-* // dependencies contains UserBloc + any blocs accessed in fullName getter
-* ```
-*/
+ * Run a callback while tracking all bloc dependencies accessed.
+ * Returns both the result and the set of discovered dependencies.
+ *
+ * @example
+ * ```ts
+ * const { result, dependencies } = tracked(() => {
+ *   const user = ensure(UserBloc);
+ *   return user.fullName; // getter that may access other blocs
+ * });
+ * // dependencies contains UserBloc + any blocs accessed in fullName getter
+ * ```
+ */
 function tracked(callback, options) {
-	const tracker = createState();
-	startTracking(tracker);
-	let result;
-	try {
-		result = callback();
-	} finally {
-		stopTracking(tracker, { state: null });
-	}
-	const dependencies = new Set(tracker.dependencies);
-	if (options?.exclude) dependencies.delete(options.exclude);
-	return {
-		result,
-		dependencies
-	};
+  const tracker = createState();
+  startTracking(tracker);
+  let result;
+  try {
+    result = callback();
+  } finally {
+    stopTracking(tracker, { state: null });
+  }
+  const dependencies = new Set(tracker.dependencies);
+  if (options?.exclude) dependencies.delete(options.exclude);
+  return {
+    result,
+    dependencies,
+  };
 }
 /**
-* Context for running tracked callbacks with bloc proxies.
-* Provides methods to create proxies and check for changes.
-*/
+ * Context for running tracked callbacks with bloc proxies.
+ * Provides methods to create proxies and check for changes.
+ */
 var TrackedContext = class {
-	constructor() {
-		this.proxiedBlocs = /* @__PURE__ */ new WeakMap();
-		this.primaryBlocs = /* @__PURE__ */ new Set();
-		this.tracker = createState();
-	}
-	/**
-	* Get a tracking proxy for a bloc instance.
-	* The proxy will track state and getter accesses.
-	*/
-	proxy(bloc) {
-		const cached = this.proxiedBlocs.get(bloc);
-		if (cached) return cached;
-		const proxied = createTrackingProxy(bloc, this.tracker);
-		this.proxiedBlocs.set(bloc, proxied);
-		this.primaryBlocs.add(bloc);
-		return proxied;
-	}
-	/**
-	* Start tracking for a new callback execution.
-	*/
-	start() {
-		startTracking(this.tracker);
-	}
-	/**
-	* Stop tracking and get discovered dependencies.
-	* Excludes primary blocs (those explicitly proxied via proxy()).
-	*/
-	stop() {
-		const allDeps = /* @__PURE__ */ new Set();
-		for (const bloc of this.primaryBlocs) {
-			const deps = stopTracking(this.tracker, bloc);
-			for (const dep of deps) if (!this.primaryBlocs.has(dep)) allDeps.add(dep);
-		}
-		return allDeps;
-	}
-	/**
-	* Check if any tracked state or getters have changed.
-	*/
-	changed() {
-		for (const bloc of this.primaryBlocs) if (hasChanges(this.tracker, bloc)) return true;
-		return false;
-	}
-	/**
-	* Get all primary blocs (those explicitly proxied).
-	*/
-	getPrimaryBlocs() {
-		return new Set(this.primaryBlocs);
-	}
-	/**
-	* Reset the context for reuse.
-	*/
-	reset() {
-		this.tracker = createState();
-		this.proxiedBlocs = /* @__PURE__ */ new WeakMap();
-		this.primaryBlocs.clear();
-	}
+  constructor() {
+    this.proxiedBlocs = /* @__PURE__ */ new WeakMap();
+    this.primaryBlocs = /* @__PURE__ */ new Set();
+    this.tracker = createState();
+  }
+  /**
+   * Get a tracking proxy for a bloc instance.
+   * The proxy will track state and getter accesses.
+   */
+  proxy(bloc) {
+    const cached = this.proxiedBlocs.get(bloc);
+    if (cached) return cached;
+    const proxied = createTrackingProxy(bloc, this.tracker);
+    this.proxiedBlocs.set(bloc, proxied);
+    this.primaryBlocs.add(bloc);
+    return proxied;
+  }
+  /**
+   * Start tracking for a new callback execution.
+   */
+  start() {
+    startTracking(this.tracker);
+  }
+  /**
+   * Stop tracking and get discovered dependencies.
+   * Excludes primary blocs (those explicitly proxied via proxy()).
+   */
+  stop() {
+    const allDeps = /* @__PURE__ */ new Set();
+    for (const bloc of this.primaryBlocs) {
+      const deps = stopTracking(this.tracker, bloc);
+      for (const dep of deps) if (!this.primaryBlocs.has(dep)) allDeps.add(dep);
+    }
+    return allDeps;
+  }
+  /**
+   * Check if any tracked state or getters have changed.
+   */
+  changed() {
+    for (const bloc of this.primaryBlocs)
+      if (hasChanges(this.tracker, bloc)) return true;
+    return false;
+  }
+  /**
+   * Get all primary blocs (those explicitly proxied).
+   */
+  getPrimaryBlocs() {
+    return new Set(this.primaryBlocs);
+  }
+  /**
+   * Reset the context for reuse.
+   */
+  reset() {
+    this.tracker = createState();
+    this.proxiedBlocs = /* @__PURE__ */ new WeakMap();
+    this.primaryBlocs.clear();
+  }
 };
 /**
-* Create a new tracked context for manual control over tracking.
-*/
+ * Create a new tracked context for manual control over tracking.
+ */
 function createTrackedContext() {
-	return new TrackedContext();
+  return new TrackedContext();
 }
 //#endregion
-export { watch as a, instance as i, createTrackedContext as n, release as o, tracked as r, acquire as s, TrackedContext as t };
+export {
+  watch as a,
+  instance as i,
+  createTrackedContext as n,
+  release as o,
+  tracked as r,
+  acquire as s,
+  TrackedContext as t,
+};
 
-//# sourceMappingURL=tracked-WF6aXuAo.js.map
+//# sourceMappingURL=tracked-WF6aXuAo.js.map