@blac/react 2.0.0 → 2.0.3

package/dist/index.d.cts

@@ -0,0 +1,100 @@
+import type { ExtractState } from '@blac/core';
+import { ExtractState as ExtractState_2 } from '@blac/adapter';
+import { InstanceReadonlyState } from '@blac/core';
+import type { RefObject } from 'react';
+import { StateContainerConstructor } from '@blac/adapter';
+import type { StateContainerConstructor as StateContainerConstructor_2 } from '@blac/core';
+
+/**
+ * Global configuration for @blac/react
+ */
+export declare interface BlacReactConfig {
+    /** Enable automatic property tracking via Proxy (default: true) */
+    autoTrack: boolean;
+}
+
+/* Excluded from this release type: ComponentRef */
+
+/**
+ * Configure global defaults for @blac/react hooks.
+ *
+ * @example
+ * ```ts
+ * import { configureBlacReact } from '@blac/react';
+ *
+ * // Disable auto-tracking globally
+ * configureBlacReact({
+ *   autoTrack: false
+ * });
+ * ```
+ *
+ * @param config - Partial configuration to merge with defaults
+ */
+export declare function configureBlacReact(config: Partial<BlacReactConfig>): void;
+
+/* Excluded from this release type: resetBlacReactConfig */
+
+/**
+ * React hook that connects a component to a state container with automatic re-render on state changes.
+ *
+ * Supports three tracking modes:
+ * - **Auto-tracking** (default): Automatically detects accessed state properties via Proxy
+ * - **Manual dependencies**: Explicit dependency array like useEffect
+ * - **No tracking**: Returns full state without optimization
+ *
+ * @template T - The state container constructor type (inferred from BlocClass)
+ * @param BlocClass - The state container class to connect to
+ * @param options - Configuration options for tracking mode and instance management
+ * @returns Tuple with [state, bloc instance, ref]
+ *
+ * @example Basic usage
+ * ```ts
+ * const [state, myBloc, ref] = useBloc(MyBloc);
+ * ```
+ *
+ * @example With manual dependencies
+ * ```ts
+ * const [state, myBloc] = useBloc(MyBloc, {
+ *   dependencies: (state) => [state.count]
+ * });
+ * ```
+ *
+ * @example With isolated instance
+ * ```ts
+ * const [state, myBloc] = useBloc(MyBloc, {
+ *   instanceId: 'unique-id'
+ * });
+ * ```
+ */
+export declare function useBloc<T extends StateContainerConstructor = StateContainerConstructor>(BlocClass: T, options?: UseBlocOptions<T>): UseBlocReturn<T, ExtractState_2<T>>;
+
+/**
+ * Configuration options for useBloc hook
+ * @template TBloc - The state container type
+ */
+export declare interface UseBlocOptions<TBloc extends StateContainerConstructor_2> {
+    /** Custom instance identifier for shared or isolated instances */
+    instanceId?: string | number;
+    /** Manual dependency array like useEffect (disables autoTrack) */
+    dependencies?: (state: ExtractState<TBloc>, bloc: InstanceReadonlyState<TBloc>) => unknown[];
+    /** Enable automatic property tracking via Proxy (default: true) */
+    autoTrack?: boolean;
+    /** Disable caching for getter tracking */
+    disableGetterCache?: boolean;
+    /** Callback invoked when bloc instance mounts */
+    onMount?: (bloc: InstanceType<TBloc>) => void;
+    /** Callback invoked when bloc instance unmounts */
+    onUnmount?: (bloc: InstanceType<TBloc>) => void;
+}
+
+/**
+ * Tuple return type from useBloc hook containing state, bloc instance, and ref
+ * - [0] Current state value (with optional state type override)
+ * - [1] State container instance (bloc) for calling actions
+ * - [2] Ref object for accessing component ref (advanced use cases)
+ *
+ * @template TBloc - The state container type
+ */
+export declare type UseBlocReturn<TBloc extends StateContainerConstructor_2, S = ExtractState<TBloc>> = [S, InstanceReadonlyState<TBloc>, RefObject<ComponentRef>];
+
+export { }

package/dist/index.d.ts

@@ -1,99 +1,100 @@
-import { BlocBase } from '@blac/core';
-import { BlocConstructor } from '@blac/core';
-import { BlocHookDependencyArrayFn } from '@blac/core';
-import { BlocState } from '@blac/core';
-import { InferPropsFromGeneric } from '@blac/core';
+import type { ExtractState } from '@blac/core';
+import { ExtractState as ExtractState_2 } from '@blac/adapter';
+import { InstanceReadonlyState } from '@blac/core';
+import type { RefObject } from 'react';
+import { StateContainerConstructor } from '@blac/adapter';
+import type { StateContainerConstructor as StateContainerConstructor_2 } from '@blac/core';
 
 /**
- * Configuration options for the useBloc hook
- * @template B - Bloc generic type
- * @property {string} [id] - Optional identifier for the Bloc instance
- * @property {BlocHookDependencyArrayFn<B>} [dependencySelector] - Function to select dependencies for re-renders
- * @property {InferPropsFromGeneric<B>} [props] - Props to pass to the Bloc
- * @property {(bloc: B) => void} [onMount] - Callback function invoked when the Bloc is mounted
+ * Global configuration for @blac/react
  */
-declare interface BlocHookOptions<B extends BlocBase<any>> {
-    id?: string;
-    dependencySelector?: BlocHookDependencyArrayFn<BlocState<B>>;
-    props?: InferPropsFromGeneric<B>;
-    onMount?: (bloc: B) => void;
+export declare interface BlacReactConfig {
+    /** Enable automatic property tracking via Proxy (default: true) */
+    autoTrack: boolean;
 }
 
+/* Excluded from this release type: ComponentRef */
+
 /**
- * Creates an external store that wraps a Bloc instance, providing a React-compatible interface
- * for subscribing to and accessing bloc state.
+ * Configure global defaults for @blac/react hooks.
+ *
+ * @example
+ * ```ts
+ * import { configureBlacReact } from '@blac/react';
+ *
+ * // Disable auto-tracking globally
+ * configureBlacReact({
+ *   autoTrack: false
+ * });
+ * ```
  *
- * @template B - The type of the Bloc instance
- * @template S - The type of the Bloc state
- * @param bloc - The Bloc instance to wrap
- * @param dependencyArray - Function that returns an array of dependencies for the subscription
- * @param rid - Unique identifier for the subscription
- * @returns An ExternalStore instance that provides methods to subscribe to and access bloc state
+ * @param config - Partial configuration to merge with defaults
  */
-export declare const externalBlocStore: <B extends InstanceType<BlocConstructor<any>>>(resolvedBloc: B, dependencyArray: BlocHookDependencyArrayFn<BlocState<B>>, rid: string) => ExternalStore<B>;
+export declare function configureBlacReact(config: Partial<BlacReactConfig>): void;
+
+/* Excluded from this release type: resetBlacReactConfig */
 
 /**
- * Interface defining an external store that can be used to subscribe to and access bloc state.
- * This interface follows the React external store pattern for state management.
+ * React hook that connects a component to a state container with automatic re-render on state changes.
+ *
+ * Supports three tracking modes:
+ * - **Auto-tracking** (default): Automatically detects accessed state properties via Proxy
+ * - **Manual dependencies**: Explicit dependency array like useEffect
+ * - **No tracking**: Returns full state without optimization
+ *
+ * @template T - The state container constructor type (inferred from BlocClass)
+ * @param BlocClass - The state container class to connect to
+ * @param options - Configuration options for tracking mode and instance management
+ * @returns Tuple with [state, bloc instance, ref]
+ *
+ * @example Basic usage
+ * ```ts
+ * const [state, myBloc, ref] = useBloc(MyBloc);
+ * ```
  *
- * @template B - The type of the Bloc instance
- * @template S - The type of the Bloc state
+ * @example With manual dependencies
+ * ```ts
+ * const [state, myBloc] = useBloc(MyBloc, {
+ *   dependencies: (state) => [state.count]
+ * });
+ * ```
+ *
+ * @example With isolated instance
+ * ```ts
+ * const [state, myBloc] = useBloc(MyBloc, {
+ *   instanceId: 'unique-id'
+ * });
+ * ```
  */
-declare interface ExternalStore<B extends InstanceType<BlocConstructor<any>>> {
-    /**
-     * Subscribes to changes in the store and returns an unsubscribe function.
-     * @param onStoreChange - Callback function that will be called whenever the store changes
-     * @returns A function that can be called to unsubscribe from store changes
-     */
-    subscribe: (onStoreChange: (state: BlocState<B>) => void) => () => void;
-    /**
-     * Gets the current snapshot of the store state.
-     * @returns The current state of the store
-     */
-    getSnapshot: () => BlocState<B>;
-    /**
-     * Gets the server snapshot of the store state.
-     * This is optional and defaults to the same value as getSnapshot.
-     * @returns The server state of the store
-     */
-    getServerSnapshot?: () => BlocState<B>;
-}
+export declare function useBloc<T extends StateContainerConstructor = StateContainerConstructor>(BlocClass: T, options?: UseBlocOptions<T>): UseBlocReturn<T, ExtractState_2<T>>;
 
 /**
- * Type definition for the return type of the useBloc hook
- * @template B - Bloc constructor type
+ * Configuration options for useBloc hook
+ * @template TBloc - The state container type
  */
-declare type HookTypes<B extends BlocConstructor<BlocBase<any>>> = [
-BlocState<InstanceType<B>>,
-InstanceType<B>
-];
+export declare interface UseBlocOptions<TBloc extends StateContainerConstructor_2> {
+    /** Custom instance identifier for shared or isolated instances */
+    instanceId?: string | number;
+    /** Manual dependency array like useEffect (disables autoTrack) */
+    dependencies?: (state: ExtractState<TBloc>, bloc: InstanceReadonlyState<TBloc>) => unknown[];
+    /** Enable automatic property tracking via Proxy (default: true) */
+    autoTrack?: boolean;
+    /** Disable caching for getter tracking */
+    disableGetterCache?: boolean;
+    /** Callback invoked when bloc instance mounts */
+    onMount?: (bloc: InstanceType<TBloc>) => void;
+    /** Callback invoked when bloc instance unmounts */
+    onUnmount?: (bloc: InstanceType<TBloc>) => void;
+}
 
 /**
- * Default dependency selector that wraps the entire state in an array
- * @template T - State type
- * @param {T} s - Current state
- * @returns {Array<Array<T>>} Dependency array containing the entire state
- */
-/**
- * React hook for integrating with Blac state management
- *
- * This hook connects a React component to a Bloc state container, providing
- * automatic re-rendering when relevant state changes, dependency tracking,
- * and proper lifecycle management.
+ * Tuple return type from useBloc hook containing state, bloc instance, and ref
+ * - [0] Current state value (with optional state type override)
+ * - [1] State container instance (bloc) for calling actions
+ * - [2] Ref object for accessing component ref (advanced use cases)
  *
- * @template B - Bloc constructor type
- * @template O - BlocHookOptions type
- * @param {B} bloc - Bloc constructor class
- * @param {O} [options] - Configuration options for the hook
- * @returns {HookTypes<B>} Tuple containing [state, bloc instance]
- *
- * @example
- * const [state, counterBloc] = useBloc(CounterBloc);
- * // Access state
- * console.log(state.count);
- * // Call bloc methods
- * counterBloc.increment();
+ * @template TBloc - The state container type
  */
-export declare function useBloc<B extends BlocConstructor<BlocBase<any>>>(bloc: B, options?: BlocHookOptions<InstanceType<B>>): HookTypes<B>;
+export declare type UseBlocReturn<TBloc extends StateContainerConstructor_2, S = ExtractState<TBloc>> = [S, InstanceReadonlyState<TBloc>, RefObject<ComponentRef>];
 
 export { }

package/dist/index.js

@@ -0,0 +1,172 @@
+import { useEffect, useMemo, useReducer, useRef, useSyncExternalStore } from "react";
+import { ExternalDepsManager, acquire, autoTrackInit, autoTrackSnapshot, autoTrackSubscribe, disableGetterTracking, generateIsolatedKey, isIsolatedClass, manualDepsInit, manualDepsSnapshot, manualDepsSubscribe, noTrackInit, noTrackSnapshot, noTrackSubscribe, release } from "@blac/adapter";
+
+//#region src/utils/instance-keys.ts
+/**
+* Instance key generation utilities for React integration
+*/
+/**
+* Generate an instance key for a bloc
+*
+* Logic:
+* - If user provides instanceId, use it (convert number to string)
+* - If isolated, generate or reuse a unique key for this component
+* - Otherwise, return undefined (use default key)
+*
+* @param componentRef - React component reference (persists across remounts)
+* @param isIsolated - Whether the bloc is isolated
+* @param providedId - User-provided instance ID (from options)
+* @returns Instance key string or undefined for default
+*/
+function generateInstanceKey(componentRef, isIsolated, providedId) {
+	if (providedId !== void 0) return typeof providedId === "number" ? String(providedId) : providedId;
+	if (isIsolated) {
+		if (!componentRef.__blocInstanceId) componentRef.__blocInstanceId = generateIsolatedKey();
+		return componentRef.__blocInstanceId;
+	}
+}
+
+//#endregion
+//#region src/config.ts
+const defaultConfig = { autoTrack: true };
+let globalConfig = { ...defaultConfig };
+/**
+* Configure global defaults for @blac/react hooks.
+*
+* @example
+* ```ts
+* import { configureBlacReact } from '@blac/react';
+*
+* // Disable auto-tracking globally
+* configureBlacReact({
+*   autoTrack: false
+* });
+* ```
+*
+* @param config - Partial configuration to merge with defaults
+*/
+function configureBlacReact(config) {
+	globalConfig = {
+		...globalConfig,
+		...config
+	};
+}
+/**
+* Get the current global configuration.
+* @internal
+*/
+function getBlacReactConfig() {
+	return globalConfig;
+}
+/**
+* Reset configuration to defaults (useful for testing).
+* @internal
+*/
+function resetBlacReactConfig() {
+	globalConfig = { ...defaultConfig };
+}
+
+//#endregion
+//#region src/useBloc.ts
+function determineTrackingMode(options) {
+	const globalConfig = getBlacReactConfig();
+	const autoTrackEnabled = options?.autoTrack !== void 0 ? options.autoTrack : globalConfig.autoTrack;
+	return {
+		useManualDeps: options?.dependencies !== void 0,
+		autoTrackEnabled
+	};
+}
+/**
+* React hook that connects a component to a state container with automatic re-render on state changes.
+*
+* Supports three tracking modes:
+* - **Auto-tracking** (default): Automatically detects accessed state properties via Proxy
+* - **Manual dependencies**: Explicit dependency array like useEffect
+* - **No tracking**: Returns full state without optimization
+*
+* @template T - The state container constructor type (inferred from BlocClass)
+* @param BlocClass - The state container class to connect to
+* @param options - Configuration options for tracking mode and instance management
+* @returns Tuple with [state, bloc instance, ref]
+*
+* @example Basic usage
+* ```ts
+* const [state, myBloc, ref] = useBloc(MyBloc);
+* ```
+*
+* @example With manual dependencies
+* ```ts
+* const [state, myBloc] = useBloc(MyBloc, {
+*   dependencies: (state) => [state.count]
+* });
+* ```
+*
+* @example With isolated instance
+* ```ts
+* const [state, myBloc] = useBloc(MyBloc, {
+*   instanceId: 'unique-id'
+* });
+* ```
+*/
+function useBloc(BlocClass, options) {
+	const componentRef = useRef({});
+	const isIsolated = isIsolatedClass(BlocClass);
+	const [bloc, subscribe, getSnapshot, instanceKey, adapterState, rawInstance] = useMemo(() => {
+		const instanceKey = generateInstanceKey(componentRef.current, isIsolated, options?.instanceId);
+		const instance = acquire(BlocClass, instanceKey);
+		const { useManualDeps, autoTrackEnabled } = determineTrackingMode(options);
+		let subscribeFn;
+		let getSnapshotFn;
+		let adapterState;
+		if (useManualDeps && options?.dependencies) {
+			adapterState = manualDepsInit(instance);
+			subscribeFn = manualDepsSubscribe(instance, adapterState, { dependencies: options.dependencies });
+			getSnapshotFn = manualDepsSnapshot(instance, adapterState, { dependencies: options.dependencies });
+		} else if (!autoTrackEnabled) {
+			adapterState = noTrackInit(instance);
+			subscribeFn = noTrackSubscribe(instance);
+			getSnapshotFn = noTrackSnapshot(instance);
+		} else {
+			adapterState = autoTrackInit(instance);
+			subscribeFn = autoTrackSubscribe(instance, adapterState);
+			getSnapshotFn = autoTrackSnapshot(instance, adapterState);
+		}
+		return [
+			adapterState.proxiedBloc,
+			subscribeFn,
+			getSnapshotFn,
+			instanceKey,
+			adapterState,
+			instance
+		];
+	}, [
+		BlocClass,
+		isIsolated,
+		options?.instanceId
+	]);
+	const state = useSyncExternalStore(subscribe, getSnapshot);
+	const [, forceUpdate] = useReducer((x) => x + 1, 0);
+	const externalDepsManager = useRef(new ExternalDepsManager());
+	useEffect(() => {
+		disableGetterTracking(adapterState, rawInstance);
+		externalDepsManager.current.updateSubscriptions(adapterState.getterState, rawInstance, forceUpdate);
+	});
+	useEffect(() => {
+		if (options?.onMount) options.onMount(bloc);
+		return () => {
+			externalDepsManager.current.cleanup();
+			if (options?.onUnmount) options.onUnmount(bloc);
+			release(BlocClass, instanceKey);
+			if (isIsolated && !rawInstance.isDisposed) rawInstance.dispose();
+		};
+	}, []);
+	return [
+		state,
+		bloc,
+		componentRef
+	];
+}
+
+//#endregion
+export { configureBlacReact, resetBlacReactConfig, useBloc };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/utils/instance-keys.ts","../src/config.ts","../src/useBloc.ts"],"sourcesContent":["/**\n * Instance key generation utilities for React integration\n */\n\nimport { generateIsolatedKey } from '@blac/adapter';\nimport type { ComponentRef } from '../types';\n\n/**\n * Generate an instance key for a bloc\n *\n * Logic:\n * - If user provides instanceId, use it (convert number to string)\n * - If isolated, generate or reuse a unique key for this component\n * - Otherwise, return undefined (use default key)\n *\n * @param componentRef - React component reference (persists across remounts)\n * @param isIsolated - Whether the bloc is isolated\n * @param providedId - User-provided instance ID (from options)\n * @returns Instance key string or undefined for default\n */\nexport function generateInstanceKey(\n  componentRef: ComponentRef,\n  isIsolated: boolean,\n  providedId?: string | number,\n): string | undefined {\n  // User explicitly provided an ID - use it\n  if (providedId !== undefined) {\n    return typeof providedId === 'number' ? String(providedId) : providedId;\n  }\n\n  // Isolated bloc - generate unique key per component\n  if (isIsolated) {\n    if (!componentRef.__blocInstanceId) {\n      componentRef.__blocInstanceId = generateIsolatedKey();\n    }\n    return componentRef.__blocInstanceId;\n  }\n\n  // Shared bloc - use default key (undefined)\n  return undefined;\n}\n","/**\n * Global configuration for @blac/react\n */\n\nexport interface BlacReactConfig {\n  /** Enable automatic property tracking via Proxy (default: true) */\n  autoTrack: boolean;\n}\n\nconst defaultConfig: BlacReactConfig = {\n  autoTrack: true,\n};\n\nlet globalConfig: BlacReactConfig = { ...defaultConfig };\n\n/**\n * Configure global defaults for @blac/react hooks.\n *\n * @example\n * ```ts\n * import { configureBlacReact } from '@blac/react';\n *\n * // Disable auto-tracking globally\n * configureBlacReact({\n *   autoTrack: false\n * });\n * ```\n *\n * @param config - Partial configuration to merge with defaults\n */\nexport function configureBlacReact(config: Partial<BlacReactConfig>): void {\n  globalConfig = { ...globalConfig, ...config };\n}\n\n/**\n * Get the current global configuration.\n * @internal\n */\nexport function getBlacReactConfig(): BlacReactConfig {\n  return globalConfig;\n}\n\n/**\n * Reset configuration to defaults (useful for testing).\n * @internal\n */\nexport function resetBlacReactConfig(): void {\n  globalConfig = { ...defaultConfig };\n}\n","import {\n  useMemo,\n  useSyncExternalStore,\n  useEffect,\n  useRef,\n  useReducer,\n} from 'react';\nimport {\n  type ExtractState,\n  type AdapterState,\n  ExternalDepsManager,\n  autoTrackSubscribe,\n  manualDepsSubscribe,\n  noTrackSubscribe,\n  autoTrackSnapshot,\n  manualDepsSnapshot,\n  noTrackSnapshot,\n  autoTrackInit,\n  manualDepsInit,\n  noTrackInit,\n  disableGetterTracking,\n  isIsolatedClass,\n  type StateContainerConstructor,\n  type InstanceState,\n  acquire,\n  release,\n} from '@blac/adapter';\nimport type { UseBlocOptions, UseBlocReturn, ComponentRef } from './types';\nimport { generateInstanceKey } from './utils/instance-keys';\nimport { getBlacReactConfig } from './config';\n\ninterface TrackingMode {\n  useManualDeps: boolean;\n  autoTrackEnabled: boolean;\n}\n\nfunction determineTrackingMode<TBloc extends StateContainerConstructor>(\n  options?: UseBlocOptions<TBloc>,\n): TrackingMode {\n  const globalConfig = getBlacReactConfig();\n  const autoTrackEnabled =\n    options?.autoTrack !== undefined\n      ? options.autoTrack\n      : globalConfig.autoTrack;\n\n  return {\n    useManualDeps: options?.dependencies !== undefined,\n    autoTrackEnabled,\n  };\n}\n\n/**\n * React hook that connects a component to a state container with automatic re-render on state changes.\n *\n * Supports three tracking modes:\n * - **Auto-tracking** (default): Automatically detects accessed state properties via Proxy\n * - **Manual dependencies**: Explicit dependency array like useEffect\n * - **No tracking**: Returns full state without optimization\n *\n * @template T - The state container constructor type (inferred from BlocClass)\n * @param BlocClass - The state container class to connect to\n * @param options - Configuration options for tracking mode and instance management\n * @returns Tuple with [state, bloc instance, ref]\n *\n * @example Basic usage\n * ```ts\n * const [state, myBloc, ref] = useBloc(MyBloc);\n * ```\n *\n * @example With manual dependencies\n * ```ts\n * const [state, myBloc] = useBloc(MyBloc, {\n *   dependencies: (state) => [state.count]\n * });\n * ```\n *\n * @example With isolated instance\n * ```ts\n * const [state, myBloc] = useBloc(MyBloc, {\n *   instanceId: 'unique-id'\n * });\n * ```\n */\nexport function useBloc<\n  T extends StateContainerConstructor = StateContainerConstructor,\n>(\n  BlocClass: T,\n  options?: UseBlocOptions<T>,\n): UseBlocReturn<T, ExtractState<T>> {\n  type TBloc = InstanceState<T>;\n\n  const componentRef = useRef<ComponentRef>({});\n  const isIsolated = isIsolatedClass(BlocClass);\n\n  const [bloc, subscribe, getSnapshot, instanceKey, adapterState, rawInstance] =\n    useMemo<\n      readonly [\n        TBloc,\n        (callback: () => void) => () => void,\n        () => ExtractState<T>,\n        string | undefined,\n        AdapterState<T>,\n        TBloc,\n      ]\n    >(() => {\n      const instanceKey = generateInstanceKey(\n        componentRef.current,\n        isIsolated,\n        options?.instanceId,\n      );\n\n      const instance = acquire(BlocClass, instanceKey) as TBloc;\n\n      const { useManualDeps, autoTrackEnabled } =\n        determineTrackingMode(options);\n\n      let subscribeFn: (callback: () => void) => () => void;\n      let getSnapshotFn: () => ExtractState<T>;\n      let adapterState: AdapterState<T>;\n\n      if (useManualDeps && options?.dependencies) {\n        adapterState = manualDepsInit(instance);\n        subscribeFn = manualDepsSubscribe(instance, adapterState, {\n          dependencies: options.dependencies,\n        });\n        getSnapshotFn = manualDepsSnapshot(instance, adapterState, {\n          dependencies: options.dependencies,\n        });\n      } else if (!autoTrackEnabled) {\n        adapterState = noTrackInit(instance);\n        subscribeFn = noTrackSubscribe(instance);\n        getSnapshotFn = noTrackSnapshot(instance);\n      } else {\n        adapterState = autoTrackInit(instance);\n        subscribeFn = autoTrackSubscribe(instance, adapterState);\n        getSnapshotFn = autoTrackSnapshot(instance, adapterState);\n      }\n\n      return [\n        adapterState.proxiedBloc as TBloc,\n        subscribeFn,\n        getSnapshotFn,\n        instanceKey,\n        adapterState,\n        instance,\n      ];\n    }, [BlocClass, isIsolated, options?.instanceId]);\n\n  const state = useSyncExternalStore(subscribe, getSnapshot);\n\n  const [, forceUpdate] = useReducer((x: number) => x + 1, 0);\n\n  const externalDepsManager = useRef(new ExternalDepsManager());\n\n  useEffect(() => {\n    disableGetterTracking(adapterState, rawInstance);\n    externalDepsManager.current.updateSubscriptions(\n      adapterState.getterState,\n      rawInstance,\n      forceUpdate,\n    );\n  });\n\n  useEffect(() => {\n    if (options?.onMount) {\n      options.onMount(bloc as InstanceType<T>);\n    }\n\n    return () => {\n      externalDepsManager.current.cleanup();\n\n      if (options?.onUnmount) {\n        options.onUnmount(bloc as InstanceType<T>);\n      }\n\n      release(BlocClass, instanceKey);\n\n      if (isIsolated && !rawInstance.isDisposed) {\n        rawInstance.dispose();\n      }\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return [state, bloc, componentRef] as UseBlocReturn<T, ExtractState<T>>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,oBACd,cACA,YACA,YACoB;AAEpB,KAAI,eAAe,OACjB,QAAO,OAAO,eAAe,WAAW,OAAO,WAAW,GAAG;AAI/D,KAAI,YAAY;AACd,MAAI,CAAC,aAAa,iBAChB,cAAa,mBAAmB,qBAAqB;AAEvD,SAAO,aAAa;;;;;;AC1BxB,MAAM,gBAAiC,EACrC,WAAW,MACZ;AAED,IAAI,eAAgC,EAAE,GAAG,eAAe;;;;;;;;;;;;;;;;AAiBxD,SAAgB,mBAAmB,QAAwC;AACzE,gBAAe;EAAE,GAAG;EAAc,GAAG;EAAQ;;;;;;AAO/C,SAAgB,qBAAsC;AACpD,QAAO;;;;;;AAOT,SAAgB,uBAA6B;AAC3C,gBAAe,EAAE,GAAG,eAAe;;;;;ACXrC,SAAS,sBACP,SACc;CACd,MAAM,eAAe,oBAAoB;CACzC,MAAM,mBACJ,SAAS,cAAc,SACnB,QAAQ,YACR,aAAa;AAEnB,QAAO;EACL,eAAe,SAAS,iBAAiB;EACzC;EACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCH,SAAgB,QAGd,WACA,SACmC;CAGnC,MAAM,eAAe,OAAqB,EAAE,CAAC;CAC7C,MAAM,aAAa,gBAAgB,UAAU;CAE7C,MAAM,CAAC,MAAM,WAAW,aAAa,aAAa,cAAc,eAC9D,cASQ;EACN,MAAM,cAAc,oBAClB,aAAa,SACb,YACA,SAAS,WACV;EAED,MAAM,WAAW,QAAQ,WAAW,YAAY;EAEhD,MAAM,EAAE,eAAe,qBACrB,sBAAsB,QAAQ;EAEhC,IAAI;EACJ,IAAI;EACJ,IAAI;AAEJ,MAAI,iBAAiB,SAAS,cAAc;AAC1C,kBAAe,eAAe,SAAS;AACvC,iBAAc,oBAAoB,UAAU,cAAc,EACxD,cAAc,QAAQ,cACvB,CAAC;AACF,mBAAgB,mBAAmB,UAAU,cAAc,EACzD,cAAc,QAAQ,cACvB,CAAC;aACO,CAAC,kBAAkB;AAC5B,kBAAe,YAAY,SAAS;AACpC,iBAAc,iBAAiB,SAAS;AACxC,mBAAgB,gBAAgB,SAAS;SACpC;AACL,kBAAe,cAAc,SAAS;AACtC,iBAAc,mBAAmB,UAAU,aAAa;AACxD,mBAAgB,kBAAkB,UAAU,aAAa;;AAG3D,SAAO;GACL,aAAa;GACb;GACA;GACA;GACA;GACA;GACD;IACA;EAAC;EAAW;EAAY,SAAS;EAAW,CAAC;CAElD,MAAM,QAAQ,qBAAqB,WAAW,YAAY;CAE1D,MAAM,GAAG,eAAe,YAAY,MAAc,IAAI,GAAG,EAAE;CAE3D,MAAM,sBAAsB,OAAO,IAAI,qBAAqB,CAAC;AAE7D,iBAAgB;AACd,wBAAsB,cAAc,YAAY;AAChD,sBAAoB,QAAQ,oBAC1B,aAAa,aACb,aACA,YACD;GACD;AAEF,iBAAgB;AACd,MAAI,SAAS,QACX,SAAQ,QAAQ,KAAwB;AAG1C,eAAa;AACX,uBAAoB,QAAQ,SAAS;AAErC,OAAI,SAAS,UACX,SAAQ,UAAU,KAAwB;AAG5C,WAAQ,WAAW,YAAY;AAE/B,OAAI,cAAc,CAAC,YAAY,WAC7B,aAAY,SAAS;;IAIxB,EAAE,CAAC;AAEN,QAAO;EAAC;EAAO;EAAM;EAAa"}

package/package.json

@@ -1,15 +1,38 @@
 {
   "name": "@blac/react",
-  "version": "2.0.0",
+  "version": "2.0.3",
   "license": "MIT",
   "author": "Brendan Mullins <jsnanigans@gmail.com>",
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.es.js",
-  "typings": "dist/index.d.ts",
-  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jsnanigans/blac.git",
+    "directory": "packages/blac-react"
+  },
+  "homepage": "https://github.com/jsnanigans/blac#readme",
+  "bugs": {
+    "url": "https://github.com/jsnanigans/blac/issues"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
   "files": [
-    "dist",
-    "src",
+    "dist/index.js",
+    "dist/index.cjs",
+    "dist/index.d.ts",
+    "dist/index.d.cts",
+    "dist/*.map",
     "README.md",
     "LICENSE"
   ],
@@ -17,42 +40,66 @@
   "keywords": [
     "react",
     "typescript",
-    "rxjs",
     "state-management",
     "reactjs",
     "observer-pattern",
     "bloc",
     "bloc-pattern"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "@blac/adapter": "2.0.3"
+  },
   "peerDependencies": {
-    "react": "^18.0.0",
-    "@blac/core": "2.0.0"
+    "@types/react": "^18.0.0 || ^19.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    },
+    "@types/react-dom": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@testing-library/dom": "^10.4.0",
-    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.6.4",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
-    "@types/react": "^18.3.3",
-    "@vitejs/plugin-react": "^4.4.1",
-    "@vitest/browser": "^3.1.3",
-    "@vitest/coverage-v8": "^3.1.3",
-    "happy-dom": "^17.4.7",
-    "jsdom": "^24.1.1",
-    "prettier": "^3.5.3",
-    "react-dom": "^18.0.0",
-    "typescript": "^5.8.3",
-    "vite": "^5.3.1",
-    "vite-plugin-dts": "^4.5.3",
-    "vitest": "^1.6.0"
+    "@types/react": "^19.1.9",
+    "@vitejs/plugin-react": "^4.7.0",
+    "@vitest/browser": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
+    "babel-plugin-react-compiler": "^1.0.0",
+    "eslint-plugin-react-compiler": "19.1.0-rc.2",
+    "happy-dom": "^18.0.1",
+    "jsdom": "^26.1.0",
+    "prettier": "^3.6.2",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "tsdown": "^0.15.7",
+    "typescript": "^5.9.2",
+    "vitest": "3.2.4",
+    "@blac/core": "2.0.3"
   },
   "scripts": {
-    "prettier": "prettier --write ./src",
+    "dev": "tsdown --watch",
+    "build": "pnpm build:js && pnpm build:types && pnpm build:dts",
+    "build:js": "tsdown",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build:dts": "api-extractor run --local && cp dist/index.d.ts dist/index.d.cts && rm -rf dist/.types",
+    "clean": "rm -rf dist",
+    "format": "prettier --write \".\"",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
     "test": "vitest run --config vitest.config.ts",
     "test:watch": "vitest --watch --config vitest.config.ts",
+    "test:memory": "NODE_OPTIONS='--expose-gc' vitest run --config vitest.config.performance.ts",
+    "test:performance": "vitest run --config vitest.config.performance.ts",
+    "test:compiler": "vitest run --config vitest.config.compiler.ts",
+    "test:watch:compiler": "vitest --watch --config vitest.config.compiler.ts",
+    "test:both": "pnpm test && echo '\n\n=== Running tests WITH React Compiler ===\n' && pnpm test:compiler",
     "typecheck": "tsc --noEmit",
-    "build": "vite build",
-    "deploy": "pnpm run build && pnpm publish --access public"
+    "deploy": "pnpm publish --access public"
   }
 }

package/dist/index.cjs.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const S=require("@blac/core"),n=require("react"),E=(u,r,i)=>{const o=u;return{subscribe:B=>{const s=o._observer.subscribe({fn:()=>{try{B(o.state)}catch(l){console.error({e:l,resolvedBloc:u,dependencyArray:r})}},dependencyArray:r,id:i});return()=>{s()}},getSnapshot:()=>o.state,getServerSnapshot:()=>o.state}},M=E;function _(u,r){const{dependencySelector:i,id:o,props:B}=r??{},s=n.useMemo(()=>Math.random().toString(36),[]),l=n.useRef(new Set),g=n.useRef(new Set),R=n.useRef(new Set),h=n.useRef(new Set),I={},m=u.isolated?s:o,b=n.useRef(null);n.useMemo(()=>{b.current=S.Blac.getBloc(u,{id:m,props:B,instanceRef:s})},[u,m,s]);const t=b.current;if(!t)throw new Error(`useBloc: could not resolve bloc: ${u.name||u}`);s===t._instanceRef&&(r!=null&&r.props)&&S.Blac.instance.findRegisteredBlocInstance(u,m)===t&&t.props!==r.props&&(t.props=r.props);const p=(e,c)=>{if(i)return i(e,c);if(t.defaultDependencySelector)return t.defaultDependencySelector(e,c);if(typeof e!="object")return[[e]];const a=[];for(const d of l.current)d in e&&a.push(e[d]);const w=[];for(const d of R.current)if(d in t)try{const y=t[d];switch(typeof y){case"function":continue;default:w.push(y);continue}}catch(y){S.Blac.instance.log("useBloc Error",y)}return setTimeout(()=>{g.current=new Set,h.current=new Set}),[a,w]},v=n.useMemo(()=>M(t,p,s),[t,s]),f=n.useSyncExternalStore(v.subscribe,v.getSnapshot,v.getServerSnapshot),x=n.useMemo(()=>{try{if(typeof f=="object")return new Proxy(f,{get(e,c){return g.current.add(c),l.current.add(c),f[c]}})}catch(e){S.Blac.instance.log("useBloc Error",e)}return f},[f]),C=n.useMemo(()=>new Proxy(t,{get(e,c){const a=t[c];return typeof a!="function"&&h.current.add(c),a}}),[t]);return n.useLayoutEffect(()=>{l.current=new Set(g.current),R.current=new Set(h.current)},[I]),n.useEffect(()=>{var c;const e=b.current;if(e)return e._addConsumer(s),(c=r==null?void 0:r.onMount)==null||c.call(r,e),()=>{e._removeConsumer(s)}},[u,s]),[x,C]}exports.externalBlocStore=M;exports.useBloc=_;
-//# sourceMappingURL=index.cjs.js.map

package/dist/index.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs.js","sources":["../src/externalBlocStore.ts","../src/useBloc.tsx"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { BlocBase, BlocConstructor, BlocHookDependencyArrayFn, BlocState } from '@blac/core';\n\n/**\n * Interface defining an external store that can be used to subscribe to and access bloc state.\n * This interface follows the React external store pattern for state management.\n * \n * @template B - The type of the Bloc instance\n * @template S - The type of the Bloc state\n */\nexport interface ExternalStore<\n  B extends InstanceType<BlocConstructor<any>>\n> {\n  /**\n   * Subscribes to changes in the store and returns an unsubscribe function.\n   * @param onStoreChange - Callback function that will be called whenever the store changes\n   * @returns A function that can be called to unsubscribe from store changes\n   */\n  subscribe: (onStoreChange: (state: BlocState<B>) => void) => () => void;\n\n  /**\n   * Gets the current snapshot of the store state.\n   * @returns The current state of the store\n   */\n  getSnapshot: () => BlocState<B>;\n\n  /**\n   * Gets the server snapshot of the store state.\n   * This is optional and defaults to the same value as getSnapshot.\n   * @returns The server state of the store\n   */\n  getServerSnapshot?: () => BlocState<B>;\n}\n\n/**\n * Creates an external store that wraps a Bloc instance, providing a React-compatible interface\n * for subscribing to and accessing bloc state.\n * \n * @template B - The type of the Bloc instance\n * @template S - The type of the Bloc state\n * @param bloc - The Bloc instance to wrap\n * @param dependencyArray - Function that returns an array of dependencies for the subscription\n * @param rid - Unique identifier for the subscription\n * @returns An ExternalStore instance that provides methods to subscribe to and access bloc state\n */\nconst externalBlocStore = <\n  B extends InstanceType<BlocConstructor<any>>\n>(\n  resolvedBloc: B,\n  dependencyArray: BlocHookDependencyArrayFn<BlocState<B>>,\n  rid: string,\n): ExternalStore<B> => {\n  // TODO: Revisit this type assertion. Ideally, 'resolvedBloc' should conform to a type\n  // that guarantees '_observer' and 'state' properties without needing 'as unknown as ...'.\n  // This might require adjustments in the core @blac/core types.\n  const asBlocBase = resolvedBloc as unknown as BlocBase<BlocState<B>>;\n  return {\n    subscribe: (listener: (state: BlocState<B>) => void) => {\n      // Subscribe to the bloc's observer with the provided listener function\n      // This will trigger the callback whenever the bloc's state changes\n      const unSub = asBlocBase._observer.subscribe({\n        fn: () => {\n          try {\n            listener(asBlocBase.state);\n          } catch (e) {\n            // Log any errors that occur during the listener callback\n            // This ensures errors in listeners don't break the entire application\n            console.error({\n              e,\n              resolvedBloc,\n              dependencyArray,\n            });\n          }\n        },\n        // Pass the dependency array to control when the subscription is updated\n        dependencyArray,\n        // Use the provided id to identify this subscription\n        id: rid,\n      });\n\n      // Return an unsubscribe function that can be called to clean up the subscription\n      return () => {\n        unSub();\n      };\n    },\n    // Return an immutable snapshot of the current bloc state\n    getSnapshot: (): BlocState<B> => asBlocBase.state,\n    // Server snapshot mirrors the client snapshot in this implementation\n    getServerSnapshot: (): BlocState<B> => asBlocBase.state,\n  };\n};\n\nexport default externalBlocStore;\n","/* eslint-disable @typescript-eslint/restrict-template-expressions */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  Blac,\n  BlocBase,\n  BlocBaseAbstract,\n  BlocConstructor,\n  BlocHookDependencyArrayFn,\n  BlocState,\n  InferPropsFromGeneric,\n} from '@blac/core';\nimport {\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport externalBlocStore from './externalBlocStore';\n\n/**\n * Type definition for the return type of the useBloc hook\n * @template B - Bloc constructor type\n */\ntype HookTypes<B extends BlocConstructor<BlocBase<any>>> = [\n  BlocState<InstanceType<B>>,\n  InstanceType<B>,\n];\n\n/**\n * Configuration options for the useBloc hook\n * @template B - Bloc generic type\n * @property {string} [id] - Optional identifier for the Bloc instance\n * @property {BlocHookDependencyArrayFn<B>} [dependencySelector] - Function to select dependencies for re-renders\n * @property {InferPropsFromGeneric<B>} [props] - Props to pass to the Bloc\n * @property {(bloc: B) => void} [onMount] - Callback function invoked when the Bloc is mounted\n */\nexport interface BlocHookOptions<B extends BlocBase<any>> {\n  id?: string;\n  dependencySelector?: BlocHookDependencyArrayFn<BlocState<B>>;\n  props?: InferPropsFromGeneric<B>;\n  onMount?: (bloc: B) => void;\n}\n\n/**\n * Default dependency selector that wraps the entire state in an array\n * @template T - State type\n * @param {T} s - Current state\n * @returns {Array<Array<T>>} Dependency array containing the entire state\n */\n\n/**\n * React hook for integrating with Blac state management\n *\n * This hook connects a React component to a Bloc state container, providing\n * automatic re-rendering when relevant state changes, dependency tracking,\n * and proper lifecycle management.\n *\n * @template B - Bloc constructor type\n * @template O - BlocHookOptions type\n * @param {B} bloc - Bloc constructor class\n * @param {O} [options] - Configuration options for the hook\n * @returns {HookTypes<B>} Tuple containing [state, bloc instance]\n *\n * @example\n * const [state, counterBloc] = useBloc(CounterBloc);\n * // Access state\n * console.log(state.count);\n * // Call bloc methods\n * counterBloc.increment();\n */\nexport default function useBloc<B extends BlocConstructor<BlocBase<any>>>(\n  bloc: B,\n  options?: BlocHookOptions<InstanceType<B>>,\n): HookTypes<B> {\n  const { dependencySelector, id: blocId, props } = options ?? {};\n  const rid = useMemo(() => {\n    return Math.random().toString(36);\n  }, []);\n\n  // Track used state keys\n  const usedKeys = useRef<Set<string>>(new Set());\n  const instanceKeys = useRef<Set<string>>(new Set());\n\n  // Track used class properties\n  const usedClassPropKeys = useRef<Set<string>>(new Set());\n  const instanceClassPropKeys = useRef<Set<string>>(new Set());\n\n  const renderInstance = {};\n\n  // Determine ID for isolated or shared blocs\n  const base = bloc as unknown as BlocBaseAbstract;\n  const isIsolated = base.isolated;\n  const effectiveBlocId = isIsolated ? rid : blocId;\n\n  // Use useRef to hold the bloc instance reference consistently across renders\n  const blocRef = useRef<InstanceType<B> | null>(null);\n\n  // Initialize or get the bloc instance ONCE using useMemo based on the effective ID\n  // This avoids re-running Blac.getBloc on every render.\n  useMemo(() => {\n    blocRef.current = Blac.getBloc(bloc, {\n      id: effectiveBlocId,\n      props,\n      instanceRef: rid, // Pass component ID for consumer tracking\n    });\n  }, [bloc, effectiveBlocId, rid]); // Dependencies ensure this runs only when bloc type or ID changes\n\n  const resolvedBloc = blocRef.current;\n\n  if (!resolvedBloc) {\n    // This should ideally not happen if Blac.getBloc works correctly\n    throw new Error(`useBloc: could not resolve bloc: ${bloc.name || bloc}`);\n  }\n\n  // Update props ONLY if this hook instance created the bloc (or is the designated main instance)\n  // We rely on Blac.getBloc to handle initial props correctly during creation.\n  // Subsequent calls should not overwrite props.\n  // Check if this instanceRef matches the one stored on the bloc when it was created/first retrieved.\n  if (\n    rid === resolvedBloc._instanceRef &&\n    options?.props &&\n    Blac.instance.findRegisteredBlocInstance(bloc, effectiveBlocId) ===\n      resolvedBloc\n  ) {\n    // Avoid double-setting props if Blac.getBloc already set them during creation\n    if (resolvedBloc.props !== options.props) {\n      resolvedBloc.props = options.props;\n    }\n  }\n\n  // Configure dependency tracking for re-renders\n  const dependencyArray: BlocHookDependencyArrayFn<BlocState<InstanceType<B>>> = (\n    newState,\n    oldState,\n  ): ReturnType<BlocHookDependencyArrayFn<BlocState<InstanceType<B>>>> => {\n    // Use custom dependency selector if provided\n    if (dependencySelector) {\n      return dependencySelector(newState, oldState);\n    }\n\n    // Fall back to bloc's default dependency selector if available\n    if (resolvedBloc.defaultDependencySelector) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      return resolvedBloc.defaultDependencySelector(newState, oldState);\n    }\n\n    // For primitive states, use default selector\n    if (typeof newState !== 'object') {\n      // Default behavior for primitive states: re-render if the state itself changes.\n      return [[newState]];\n    }\n\n    // For object states, track which properties were actually used\n    const usedStateValues: string[] = [];\n    for (const key of usedKeys.current) {\n      if (key in newState) {\n        usedStateValues.push(newState[key as keyof typeof newState]);\n      }\n    }\n\n    // Track used class properties for dependency tracking, this enables rerenders when class getters change\n    const usedClassValues: unknown[] = [];\n    for (const key of usedClassPropKeys.current) {\n      if (key in resolvedBloc) {\n        try {\n          const value = resolvedBloc[key as keyof InstanceType<B>];\n          switch (typeof value) {\n            case 'function':\n              continue;\n            default:\n              usedClassValues.push(value);\n              continue;\n          }\n        } catch (error) {\n          Blac.instance.log('useBloc Error', error);\n        }\n      }\n    }\n\n    setTimeout(() => {\n      instanceKeys.current = new Set();\n      instanceClassPropKeys.current = new Set();\n    });\n    return [usedStateValues, usedClassValues];\n  };\n\n  // Set up external store subscription for state updates\n  const store = useMemo(\n    () => externalBlocStore(resolvedBloc, dependencyArray, rid),\n    [resolvedBloc, rid],\n  ); // dependencyArray removed as it changes frequently\n\n  // Subscribe to state changes using React's external store API\n  const state = useSyncExternalStore<BlocState<InstanceType<B>>>(\n    store.subscribe,\n    store.getSnapshot,\n    store.getServerSnapshot,\n  );\n\n  // Create a proxy for state to track property access\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n  const returnState: BlocState<InstanceType<B>> = useMemo(() => {\n    try {\n      if (typeof state === 'object') {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return new Proxy(state as any, {\n          get(_, prop) {\n            instanceKeys.current.add(prop as string);\n            usedKeys.current.add(prop as string);\n            const value = state[prop as keyof typeof state];\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n            return value;\n          },\n        });\n      }\n    } catch (error) {\n      Blac.instance.log('useBloc Error', error);\n    }\n    return state;\n  }, [state]);\n\n  // Create a proxy for the bloc instance to track property access\n  const returnClass = useMemo(() => {\n    return new Proxy(resolvedBloc, {\n      get(_, prop) {\n        const value = resolvedBloc[prop as keyof InstanceType<B>];\n        // Track which class properties are accessed (excluding methods)\n        if (typeof value !== 'function') {\n          instanceClassPropKeys.current.add(prop as string);\n        }\n        return value;\n      },\n    });\n  }, [resolvedBloc]);\n\n  // Clean up tracked keys after each render\n  useLayoutEffect(() => {\n    // inherit the keys from the previous render\n    usedKeys.current = new Set(instanceKeys.current);\n    usedClassPropKeys.current = new Set(instanceClassPropKeys.current);\n  }, [renderInstance]);\n\n  // Set up bloc lifecycle management\n  useEffect(() => {\n    const currentBlocInstance = blocRef.current; // Capture instance for cleanup\n    if (!currentBlocInstance) return;\n\n    currentBlocInstance._addConsumer(rid);\n\n    // Call onMount callback if provided\n    options?.onMount?.(currentBlocInstance);\n\n    // Cleanup: remove this component as a consumer using the captured instance\n    return () => {\n      currentBlocInstance._removeConsumer(rid);\n    };\n  }, [bloc, rid]); // Do not add options.onMount to deps, it will cause a loop\n\n  return [returnState, returnClass];\n}\n"],"names":["externalBlocStore","resolvedBloc","dependencyArray","rid","asBlocBase","listener","unSub","e","externalBlocStore$1","useBloc","bloc","options","dependencySelector","blocId","props","useMemo","usedKeys","useRef","instanceKeys","usedClassPropKeys","instanceClassPropKeys","renderInstance","effectiveBlocId","blocRef","Blac","newState","oldState","usedStateValues","key","usedClassValues","value","error","store","state","useSyncExternalStore","returnState","_","prop","returnClass","useLayoutEffect","useEffect","currentBlocInstance","_a"],"mappings":"iIA6CMA,EAAoB,CAGxBC,EACAC,EACAC,IACqB,CAIrB,MAAMC,EAAaH,EACZ,MAAA,CACL,UAAYI,GAA4C,CAGhD,MAAAC,EAAQF,EAAW,UAAU,UAAU,CAC3C,GAAI,IAAM,CACJ,GAAA,CACFC,EAASD,EAAW,KAAK,QAClBG,EAAG,CAGV,QAAQ,MAAM,CACZ,EAAAA,EACA,aAAAN,EACA,gBAAAC,CAAA,CACD,CACH,CACF,EAEA,gBAAAA,EAEA,GAAIC,CAAA,CACL,EAGD,MAAO,IAAM,CACLG,GAAA,CAEV,EAEA,YAAa,IAAoBF,EAAW,MAE5C,kBAAmB,IAAoBA,EAAW,KAAA,CAEtD,EAEAI,EAAeR,ECrBS,SAAAS,EACtBC,EACAC,EACc,CACd,KAAM,CAAE,mBAAAC,EAAoB,GAAIC,EAAQ,MAAAC,CAAM,EAAIH,GAAW,GACvDR,EAAMY,EAAAA,QAAQ,IACX,KAAK,OAAA,EAAS,SAAS,EAAE,EAC/B,CAAE,CAAA,EAGCC,EAAWC,EAAAA,OAAwB,IAAA,GAAK,EACxCC,EAAeD,EAAAA,OAAwB,IAAA,GAAK,EAG5CE,EAAoBF,EAAAA,OAAwB,IAAA,GAAK,EACjDG,EAAwBH,EAAAA,OAAwB,IAAA,GAAK,EAErDI,EAAiB,CAAA,EAKjBC,EAFOZ,EACW,SACaP,EAAMU,EAGrCU,EAAUN,SAA+B,IAAI,EAInDF,EAAAA,QAAQ,IAAM,CACJQ,EAAA,QAAUC,OAAK,QAAQd,EAAM,CACnC,GAAIY,EACJ,MAAAR,EACA,YAAaX,CAAA,CACd,CACA,EAAA,CAACO,EAAMY,EAAiBnB,CAAG,CAAC,EAE/B,MAAMF,EAAesB,EAAQ,QAE7B,GAAI,CAACtB,EAEH,MAAM,IAAI,MAAM,oCAAoCS,EAAK,MAAQA,CAAI,EAAE,EAQvEP,IAAQF,EAAa,eACrBU,GAAA,MAAAA,EAAS,QACTa,OAAK,SAAS,2BAA2Bd,EAAMY,CAAe,IAC5DrB,GAGEA,EAAa,QAAUU,EAAQ,QACjCV,EAAa,MAAQU,EAAQ,OAK3B,MAAAT,EAAyE,CAC7EuB,EACAC,IACsE,CAEtE,GAAId,EACK,OAAAA,EAAmBa,EAAUC,CAAQ,EAI9C,GAAIzB,EAAa,0BAER,OAAAA,EAAa,0BAA0BwB,EAAUC,CAAQ,EAI9D,GAAA,OAAOD,GAAa,SAEf,MAAA,CAAC,CAACA,CAAQ,CAAC,EAIpB,MAAME,EAA4B,CAAA,EACvB,UAAAC,KAAOZ,EAAS,QACrBY,KAAOH,GACOE,EAAA,KAAKF,EAASG,CAA4B,CAAC,EAK/D,MAAMC,EAA6B,CAAA,EACxB,UAAAD,KAAOT,EAAkB,QAClC,GAAIS,KAAO3B,EACL,GAAA,CACI,MAAA6B,EAAQ7B,EAAa2B,CAA4B,EACvD,OAAQ,OAAOE,EAAO,CACpB,IAAK,WACH,SACF,QACED,EAAgB,KAAKC,CAAK,EAC1B,QACJ,QACOC,EAAO,CACTP,EAAAA,KAAA,SAAS,IAAI,gBAAiBO,CAAK,CAC1C,CAIJ,kBAAW,IAAM,CACFb,EAAA,YAAc,IACLE,EAAA,YAAc,GAAI,CACzC,EACM,CAACO,EAAiBE,CAAe,CAAA,EAIpCG,EAAQjB,EAAA,QACZ,IAAMf,EAAkBC,EAAcC,EAAiBC,CAAG,EAC1D,CAACF,EAAcE,CAAG,CAAA,EAId8B,EAAQC,EAAA,qBACZF,EAAM,UACNA,EAAM,YACNA,EAAM,iBAAA,EAKFG,EAA0CpB,EAAAA,QAAQ,IAAM,CACxD,GAAA,CACE,GAAA,OAAOkB,GAAU,SAEZ,OAAA,IAAI,MAAMA,EAAc,CAC7B,IAAIG,EAAGC,EAAM,CACE,OAAAnB,EAAA,QAAQ,IAAImB,CAAc,EAC9BrB,EAAA,QAAQ,IAAIqB,CAAc,EACrBJ,EAAMI,CAA0B,CAGhD,CAAA,CACD,QAEIN,EAAO,CACTP,EAAAA,KAAA,SAAS,IAAI,gBAAiBO,CAAK,CAC1C,CACO,OAAAE,CAAA,EACN,CAACA,CAAK,CAAC,EAGJK,EAAcvB,EAAAA,QAAQ,IACnB,IAAI,MAAMd,EAAc,CAC7B,IAAImC,EAAGC,EAAM,CACL,MAAAP,EAAQ7B,EAAaoC,CAA6B,EAEpD,OAAA,OAAOP,GAAU,YACGV,EAAA,QAAQ,IAAIiB,CAAc,EAE3CP,CACT,CAAA,CACD,EACA,CAAC7B,CAAY,CAAC,EAGjBsC,OAAAA,EAAAA,gBAAgB,IAAM,CAEpBvB,EAAS,QAAU,IAAI,IAAIE,EAAa,OAAO,EAC/CC,EAAkB,QAAU,IAAI,IAAIC,EAAsB,OAAO,CAAA,EAChE,CAACC,CAAc,CAAC,EAGnBmB,EAAAA,UAAU,IAAM,OACd,MAAMC,EAAsBlB,EAAQ,QACpC,GAAKkB,EAEL,OAAAA,EAAoB,aAAatC,CAAG,GAGpCuC,EAAA/B,GAAA,YAAAA,EAAS,UAAT,MAAA+B,EAAA,KAAA/B,EAAmB8B,GAGZ,IAAM,CACXA,EAAoB,gBAAgBtC,CAAG,CAAA,CACzC,EACC,CAACO,EAAMP,CAAG,CAAC,EAEP,CAACgC,EAAaG,CAAW,CAClC"}