@blac/react 2.0.0 → 2.0.3

package/README.md

@@ -1,194 +1,268 @@
 # @blac/react
 
-A powerful React integration for the Blac state management library, providing seamless integration between React components and Blac's reactive state management system.
-
-## Features
-
-- 🔄 Automatic re-rendering when relevant state changes
-- 🎯 Fine-grained dependency tracking
-- 🔍 Property access tracking for optimized updates
-- 🎨 TypeScript support with full type inference
-- ⚡️ Efficient state management with minimal boilerplate
-- 🔄 Support for isolated and shared bloc instances
-- 🎯 Custom dependency selectors for precise control
-
-## Important: Arrow Functions Required
-
-All methods in Bloc or Cubit classes must use arrow function syntax (`method = () => {}`) instead of the traditional method syntax (`method() {}`). This is because arrow functions automatically bind `this` to the class instance. Without this binding, methods called from React components would lose their context and could not access instance properties like `this.state` or `this.emit()`.
-
-```tsx
-// Correct way to define methods in your Bloc/Cubit classes
-class CounterBloc extends Cubit<CounterState> {
-  increment = () => {
-    this.emit({ ...this.state, count: this.state.count + 1 });
-  }
-
-  decrement = () => {
-    this.emit({ ...this.state, count: this.state.count - 1 });
-  }
-}
-
-// Incorrect way (will cause issues when called from React):
-class CounterBloc extends Cubit<CounterState> {
-  increment() { // ❌ Will lose 'this' context when called from components
-    this.emit({ ...this.state, count: this.state.count + 1 });
-  }
-}
-```
+React integration for the BlaC state management library with automatic re-render optimization.
 
 ## Installation
 
 ```bash
-npm install @blac/react
+npm install @blac/react @blac/core
 # or
-yarn add @blac/react
+pnpm add @blac/react @blac/core
 # or
-pnpm add @blac/react
+yarn add @blac/react @blac/core
 ```
 
 ## Quick Start
 
 ```tsx
+import { Cubit } from '@blac/core';
 import { useBloc } from '@blac/react';
-import { CounterBloc } from './CounterBloc';
+
+class CounterCubit extends Cubit<{ count: number }> {
+  constructor() {
+    super({ count: 0 });
+  }
+
+  increment = () => this.emit({ count: this.state.count + 1 });
+  decrement = () => this.emit({ count: this.state.count - 1 });
+}
 
 function Counter() {
-  const [state, counterBloc] = useBloc(CounterBloc);
+  const [state, counter] = useBloc(CounterCubit);
 
   return (
     <div>
       <p>Count: {state.count}</p>
-      <button onClick={() => counterBloc.increment()}>Increment</button>
+      <button onClick={counter.increment}>+</button>
+      <button onClick={counter.decrement}>-</button>
     </div>
   );
 }
 ```
 
-## Usage
+## Hooks
+
+### useBloc
+
+Connects a component to a state container with automatic re-renders on state changes.
+
+```tsx
+const [state, bloc, ref] = useBloc(MyBloc);
+```
+
+**Returns:** `[state, bloc, ref]`
+
+- `state` - Current state (reactive)
+- `bloc` - The bloc instance for calling methods
+- `ref` - Component reference for isolated instances
 
-### Basic Usage
+#### Tracking Modes
 
-The `useBloc` hook provides a simple way to connect your React components to Blac's state management system:
+**Auto-tracking (default):** Automatically detects which properties you access and only re-renders when those change.
 
 ```tsx
-const [state, bloc] = useBloc(YourBloc);
+function UserProfile() {
+  const [state, user] = useBloc(UserBloc);
+
+  // Only re-renders when state.name changes
+  // (state.email changes won't cause re-render)
+  return <h1>{state.name}</h1>;
+}
 ```
 
-### Advanced Configuration
+**Manual dependencies:** Explicit dependency array like `useEffect`.
 
-The hook accepts configuration options for more control:
+```tsx
+function Counter() {
+  const [state] = useBloc(CounterBloc, {
+    dependencies: (state) => [state.count],
+  });
+
+  return <p>{state.count}</p>;
+}
+```
+
+**No tracking:** Returns full state, re-renders on any change.
 
 ```tsx
-const [state, bloc] = useBloc(YourBloc, {
-  id: 'custom-id', // Optional: Custom identifier for the bloc
-  props: { /* ... */ }, // Optional: Props to pass to the bloc
-  onMount: (bloc) => { /* ... */ }, // Optional: Callback when bloc is mounted (similar to useEffect(<>, []))
-  dependencySelector: (newState, oldState) => [/* ... */], // Optional: Custom dependency tracking
+function FullState() {
+  const [state] = useBloc(MyBloc, { autoTrack: false });
+
+  return <pre>{JSON.stringify(state)}</pre>;
+}
+```
+
+#### Options
+
+```tsx
+useBloc(MyBloc, {
+  // Tracking mode
+  autoTrack: true, // Enable/disable auto-tracking (default: true)
+  dependencies: (state) => [state.prop], // Manual dependencies
+
+  // Instance management
+  instanceId: 'unique-id', // Custom instance identifier
+
+  // Lifecycle callbacks
+  onMount: (bloc) => console.log('Mounted', bloc),
+  onUnmount: (bloc) => console.log('Unmounted', bloc),
 });
 ```
 
-### Dependency Tracking
+### useBlocActions
 
-The hook automatically tracks which state properties are accessed in your component and only triggers re-renders when those specific properties change:
+Connects to a state container without subscribing to state changes. Use for calling actions without re-renders, or for stateless containers.
 
 ```tsx
-function UserProfile() {
-  const [state, userBloc] = useBloc(UserBloc);
+const bloc = useBlocActions(MyBloc);
+```
 
-  // Only re-renders when state.name changes
-  return <h1>{state.name}</h1>;
+**Use cases:**
+
+```tsx
+// Stateless services (analytics, navigation, etc.)
+function TrackButton() {
+  const analytics = useBlocActions(AnalyticsService);
+
+  return (
+    <button onClick={() => analytics.trackClick('button')}>Click me</button>
+  );
+}
+
+// Actions-only (no state subscription)
+function IncrementButton() {
+  const counter = useBlocActions(CounterCubit);
+
+  return <button onClick={counter.increment}>+</button>;
 }
 ```
 
-This also works for getters on the Bloc or Cubit class:
+#### Options
 
 ```tsx
-function UserProfile() {
-  const [, userBloc] = useBloc(UserBloc);
+useBlocActions(MyBloc, {
+  instanceId: 'unique-id', // Custom instance identifier
+  onMount: (bloc) => bloc.initialize(),
+  onUnmount: (bloc) => bloc.cleanup(),
+});
+```
+
+## Instance Management
+
+### Shared Instances (Default)
 
-  // Only re-renders when the return value from the getter formattedName changes
-  return <h1>{userBloc.formattedName}</h1>;
+By default, all components using the same bloc class share one instance:
+
+```tsx
+function ComponentA() {
+  const [state] = useBloc(CounterCubit);
+  // Uses shared instance
+}
+
+function ComponentB() {
+  const [state] = useBloc(CounterCubit);
+  // Uses same shared instance
 }
 ```
 
-### Custom Dependency Selector
+### Isolated Instances
 
-For more control over when your component re-renders, you can provide a custom dependency selector:
+For component-scoped state, use the `@blac({ isolated: true })` decorator:
 
 ```tsx
-const [state, bloc] = useBloc(YourBloc, {
-  dependencySelector: (newState, oldState) => [
-    newState.specificField,
-    newState.anotherField
-  ]
+import { Cubit, blac } from '@blac/core';
+
+@blac({ isolated: true })
+class FormCubit extends Cubit<FormState> {
+  // ...
+}
+
+function FormA() {
+  const [state] = useBloc(FormCubit);
+  // Gets its own instance
+}
+
+function FormB() {
+  const [state] = useBloc(FormCubit);
+  // Gets a different instance
+}
+```
+
+### Named Instances
+
+Share instances across specific components with `instanceId`:
+
+```tsx
+function EditorA() {
+  const [state] = useBloc(EditorCubit, { instanceId: 'editor-1' });
+}
+
+function EditorB() {
+  const [state] = useBloc(EditorCubit, { instanceId: 'editor-1' });
+  // Same instance as EditorA
+}
+
+function EditorC() {
+  const [state] = useBloc(EditorCubit, { instanceId: 'editor-2' });
+  // Different instance
+}
+```
+
+## Configuration
+
+Configure global behavior:
+
+```tsx
+import { configureBlacReact } from '@blac/react';
+
+configureBlacReact({
+  autoTrack: true, // Enable auto-tracking by default (default: true)
 });
 ```
 
 ## API Reference
 
-### useBloc Hook
+### useBloc
 
-```typescript
-function useBloc<B extends BlocConstructor<BlocGeneric>>(
-  bloc: B,
-  options?: BlocHookOptions<InstanceType<B>>
-): [BlocState<InstanceType<B>>, InstanceType<B>]
+```tsx
+function useBloc<T extends StateContainerConstructor>(
+  BlocClass: T,
+  options?: UseBlocOptions<T>,
+): [ExtractState<T>, InstanceType<T>, ComponentRef];
 ```
 
-#### Options
+### useBlocActions
+
+```tsx
+function useBlocActions<T extends StateContainerConstructor>(
+  BlocClass: T,
+  options?: UseBlocActionsOptions<InstanceType<T>>,
+): InstanceType<T>;
+```
+
+### UseBlocOptions
+
+| Option         | Type               | Description                          |
+| -------------- | ------------------ | ------------------------------------ |
+| `autoTrack`    | `boolean`          | Enable auto-tracking (default: true) |
+| `dependencies` | `(state) => any[]` | Manual dependency selector           |
+| `instanceId`   | `string \| number` | Custom instance identifier           |
+| `onMount`      | `(bloc) => void`   | Called when component mounts         |
+| `onUnmount`    | `(bloc) => void`   | Called when component unmounts       |
+
+### UseBlocActionsOptions
+
+| Option       | Type               | Description                    |
+| ------------ | ------------------ | ------------------------------ |
+| `instanceId` | `string \| number` | Custom instance identifier     |
+| `onMount`    | `(bloc) => void`   | Called when component mounts   |
+| `onUnmount`  | `(bloc) => void`   | Called when component unmounts |
+
+## Compatibility
 
-- `id?: string` - Custom identifier for the bloc instance
-- `props?: InferPropsFromGeneric<B>` - Props to pass to the bloc
-- `onMount?: (bloc: B) => void` - Callback function invoked when the react component (the consumer) is connected to the bloc instance
-- `dependencySelector?: BlocHookDependencyArrayFn<B>` - Function to select dependencies for re-renders
-
-## Best Practices
-
-1. **Use Isolated Blocs**: When you need component-specific state, use isolated blocs:
-   ```tsx
-   class MyIsolatedBloc extends BlocBase {
-     static isolated = true;
-     // ... rest of your bloc implementation
-   }
-   ```
-
-2. **Use Custom Identifiers**: When you need multiple independent instances of the same Bloc type, use custom identifiers to manage different state contexts:
-   ```tsx
-   // In a chat application with multiple chat rooms
-   function ChatRoom({ roomId }: { roomId: string }) {
-     const [state, chatBloc] = useBloc(ChatBloc, {
-       id: `chat-${roomId}`, // Each room gets its own instance
-       props: { roomId }
-     });
-
-     return (
-       <div>
-         <h2>Room: {roomId}</h2>
-         {state.messages.map(msg => (
-           <Message key={msg.id} message={msg} />
-         ))}
-       </div>
-     );
-   }
-
-   // Usage:
-   function ChatApp() {
-     return (
-       <div>
-         <ChatRoom roomId="general" />
-         <ChatRoom roomId="support" />
-       </div>
-     );
-   }
-   ```
-
-3. **Optimize Re-renders**: Let the hook track dependencies automatically unless you have a specific need for custom dependency tracking.
-
-4. **Type Safety**: Take advantage of TypeScript's type inference for better development experience and catch errors early.
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
+- React 18.0+ or React 19.0+
+- Works with React Compiler
+- Supports concurrent rendering via `useSyncExternalStore`
 
 ## License
 

package/dist/index.cjs

@@ -0,0 +1,174 @@
+let react = require("react");
+let _blac_adapter = require("@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 = (0, _blac_adapter.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 = (0, react.useRef)({});
+	const isIsolated = (0, _blac_adapter.isIsolatedClass)(BlocClass);
+	const [bloc, subscribe, getSnapshot, instanceKey, adapterState, rawInstance] = (0, react.useMemo)(() => {
+		const instanceKey = generateInstanceKey(componentRef.current, isIsolated, options?.instanceId);
+		const instance = (0, _blac_adapter.acquire)(BlocClass, instanceKey);
+		const { useManualDeps, autoTrackEnabled } = determineTrackingMode(options);
+		let subscribeFn;
+		let getSnapshotFn;
+		let adapterState;
+		if (useManualDeps && options?.dependencies) {
+			adapterState = (0, _blac_adapter.manualDepsInit)(instance);
+			subscribeFn = (0, _blac_adapter.manualDepsSubscribe)(instance, adapterState, { dependencies: options.dependencies });
+			getSnapshotFn = (0, _blac_adapter.manualDepsSnapshot)(instance, adapterState, { dependencies: options.dependencies });
+		} else if (!autoTrackEnabled) {
+			adapterState = (0, _blac_adapter.noTrackInit)(instance);
+			subscribeFn = (0, _blac_adapter.noTrackSubscribe)(instance);
+			getSnapshotFn = (0, _blac_adapter.noTrackSnapshot)(instance);
+		} else {
+			adapterState = (0, _blac_adapter.autoTrackInit)(instance);
+			subscribeFn = (0, _blac_adapter.autoTrackSubscribe)(instance, adapterState);
+			getSnapshotFn = (0, _blac_adapter.autoTrackSnapshot)(instance, adapterState);
+		}
+		return [
+			adapterState.proxiedBloc,
+			subscribeFn,
+			getSnapshotFn,
+			instanceKey,
+			adapterState,
+			instance
+		];
+	}, [
+		BlocClass,
+		isIsolated,
+		options?.instanceId
+	]);
+	const state = (0, react.useSyncExternalStore)(subscribe, getSnapshot);
+	const [, forceUpdate] = (0, react.useReducer)((x) => x + 1, 0);
+	const externalDepsManager = (0, react.useRef)(new _blac_adapter.ExternalDepsManager());
+	(0, react.useEffect)(() => {
+		(0, _blac_adapter.disableGetterTracking)(adapterState, rawInstance);
+		externalDepsManager.current.updateSubscriptions(adapterState.getterState, rawInstance, forceUpdate);
+	});
+	(0, react.useEffect)(() => {
+		if (options?.onMount) options.onMount(bloc);
+		return () => {
+			externalDepsManager.current.cleanup();
+			if (options?.onUnmount) options.onUnmount(bloc);
+			(0, _blac_adapter.release)(BlocClass, instanceKey);
+			if (isIsolated && !rawInstance.isDisposed) rawInstance.dispose();
+		};
+	}, []);
+	return [
+		state,
+		bloc,
+		componentRef
+	];
+}
+
+//#endregion
+exports.configureBlacReact = configureBlacReact;
+exports.resetBlacReactConfig = resetBlacReactConfig;
+exports.useBloc = useBloc;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["ExternalDepsManager"],"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,2DAAwC;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,iCAAoC,EAAE,CAAC;CAC7C,MAAM,gDAA6B,UAAU;CAE7C,MAAM,CAAC,MAAM,WAAW,aAAa,aAAa,cAAc,wCAUtD;EACN,MAAM,cAAc,oBAClB,aAAa,SACb,YACA,SAAS,WACV;EAED,MAAM,sCAAmB,WAAW,YAAY;EAEhD,MAAM,EAAE,eAAe,qBACrB,sBAAsB,QAAQ;EAEhC,IAAI;EACJ,IAAI;EACJ,IAAI;AAEJ,MAAI,iBAAiB,SAAS,cAAc;AAC1C,oDAA8B,SAAS;AACvC,wDAAkC,UAAU,cAAc,EACxD,cAAc,QAAQ,cACvB,CAAC;AACF,yDAAmC,UAAU,cAAc,EACzD,cAAc,QAAQ,cACvB,CAAC;aACO,CAAC,kBAAkB;AAC5B,iDAA2B,SAAS;AACpC,qDAA+B,SAAS;AACxC,sDAAgC,SAAS;SACpC;AACL,mDAA6B,SAAS;AACtC,uDAAiC,UAAU,aAAa;AACxD,wDAAkC,UAAU,aAAa;;AAG3D,SAAO;GACL,aAAa;GACb;GACA;GACA;GACA;GACA;GACD;IACA;EAAC;EAAW;EAAY,SAAS;EAAW,CAAC;CAElD,MAAM,wCAA6B,WAAW,YAAY;CAE1D,MAAM,GAAG,sCAA2B,MAAc,IAAI,GAAG,EAAE;CAE3D,MAAM,wCAA6B,IAAIA,mCAAqB,CAAC;AAE7D,4BAAgB;AACd,2CAAsB,cAAc,YAAY;AAChD,sBAAoB,QAAQ,oBAC1B,aAAa,aACb,aACA,YACD;GACD;AAEF,4BAAgB;AACd,MAAI,SAAS,QACX,SAAQ,QAAQ,KAAwB;AAG1C,eAAa;AACX,uBAAoB,QAAQ,SAAS;AAErC,OAAI,SAAS,UACX,SAAQ,UAAU,KAAwB;AAG5C,8BAAQ,WAAW,YAAY;AAE/B,OAAI,cAAc,CAAC,YAAY,WAC7B,aAAY,SAAS;;IAIxB,EAAE,CAAC;AAEN,QAAO;EAAC;EAAO;EAAM;EAAa"}