npm - @blac/react - Versions diffs - 2.0.0-rc.16 → 2.0.0-rc.17 - Mend

@blac/react 2.0.0-rc.16 → 2.0.0-rc.17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/index.cjs CHANGED Viewed

@@ -84,9 +84,11 @@ function determineTrackingMode(options) {
 * - **Manual dependencies**: Explicit dependency array like useEffect
 * - **No tracking**: Returns full state without optimization
 *
-* @template S - Optional state type override for generic StateContainers (defaults to never)
+* **Note:** This hook does NOT support stateless containers (StatelessCubit, StatelessVertex).
+* Use `useBlocActions()` instead for stateless containers.
+*
 * @template T - The state container constructor type (inferred from BlocClass)
-* @param BlocClass - The state container class to connect to
+* @param BlocClass - The state container class to connect to (must not be stateless)
 * @param options - Configuration options for tracking mode and instance management
 * @returns Tuple with [state, bloc instance, ref]
 *
@@ -108,37 +110,44 @@ function determineTrackingMode(options) {
 *   instanceId: 'unique-id'
 * });
 * ```
-*
-* @example With generic bloc and explicit state type
-* ```ts
-* const [state, myBloc] = useBloc<MyStateType>(GenericBloc);
-* // state is typed as MyStateType
-* ```
 */
 function useBloc(BlocClass, options) {
 	const componentRef = (0, react.useRef)({});
-	const isIsolated = (0, __blac_core.isIsolatedClass)(BlocClass);
 	const initialPropsRef = (0, react.useRef)(options?.props);
+	const isStateless = (0, __blac_core.isStatelessClass)(BlocClass);
+	const isIsolated = (0, __blac_core.isIsolatedClass)(BlocClass);
 	const [bloc, subscribe, getSnapshot, instanceKey, adapterState, rawInstance] = (0, react.useMemo)(() => {
+		if (isStateless) {
+			console.error(`[BlaC] useBloc() does not support stateless containers. "${BlocClass.name}" is a StatelessCubit or StatelessVertex. Use useBlocActions() instead for stateless containers.`);
+			const instance$1 = (0, __blac_core.acquire)(BlocClass, "default");
+			return [
+				instance$1,
+				() => () => {},
+				() => ({}),
+				void 0,
+				null,
+				instance$1
+			];
+		}
 		const instanceKey$1 = generateInstanceKey(componentRef.current, isIsolated, options?.instanceId);
-		const instance = BlocClass.resolve(instanceKey$1, { props: initialPropsRef.current });
+		const instance = (0, __blac_core.acquire)(BlocClass, instanceKey$1, { props: initialPropsRef.current });
 		if (initialPropsRef.current !== void 0) instance.updateProps(initialPropsRef.current);
 		const { useManualDeps, autoTrackEnabled } = determineTrackingMode(options);
 		let subscribeFn;
 		let getSnapshotFn;
 		let adapterState$1;
 		if (useManualDeps && options?.dependencies) {
-			adapterState$1 = (0, __blac_core.initManualDepsState)(instance);
-			subscribeFn = (0, __blac_core.createManualDepsSubscribe)(instance, adapterState$1, { dependencies: options.dependencies });
-			getSnapshotFn = (0, __blac_core.createManualDepsSnapshot)(instance, adapterState$1, { dependencies: options.dependencies });
+			adapterState$1 = (0, __blac_core.manualDepsInit)(instance);
+			subscribeFn = (0, __blac_core.manualDepsSubscribe)(instance, adapterState$1, { dependencies: options.dependencies });
+			getSnapshotFn = (0, __blac_core.manualDepsSnapshot)(instance, adapterState$1, { dependencies: options.dependencies });
 		} else if (!autoTrackEnabled) {
-			adapterState$1 = (0, __blac_core.initNoTrackState)(instance);
-			subscribeFn = (0, __blac_core.createNoTrackSubscribe)(instance);
-			getSnapshotFn = (0, __blac_core.createNoTrackSnapshot)(instance);
+			adapterState$1 = (0, __blac_core.noTrackInit)(instance);
+			subscribeFn = (0, __blac_core.noTrackSubscribe)(instance);
+			getSnapshotFn = (0, __blac_core.noTrackSnapshot)(instance);
 		} else {
-			adapterState$1 = (0, __blac_core.initAutoTrackState)(instance);
-			subscribeFn = (0, __blac_core.createAutoTrackSubscribe)(instance, adapterState$1);
-			getSnapshotFn = (0, __blac_core.createAutoTrackSnapshot)(instance, adapterState$1);
+			adapterState$1 = (0, __blac_core.autoTrackInit)(instance);
+			subscribeFn = (0, __blac_core.autoTrackSubscribe)(instance, adapterState$1);
+			getSnapshotFn = (0, __blac_core.autoTrackSnapshot)(instance, adapterState$1);
 		}
 		return [
 			adapterState$1.proxiedBloc,
@@ -148,23 +157,35 @@ function useBloc(BlocClass, options) {
 			adapterState$1,
 			instance
 		];
-	}, [BlocClass, options?.instanceId]);
+	}, [
+		BlocClass,
+		isStateless,
+		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_core.ExternalDependencyManager());
+	const externalDepsManager = (0, react.useRef)(new __blac_core.ExternalDepsManager());
 	(0, react.useEffect)(() => {
+		if (isStateless) return;
 		if (options?.props !== initialPropsRef.current) rawInstance.updateProps(options?.props);
-	}, [options?.props, rawInstance]);
+	}, [
+		options?.props,
+		rawInstance,
+		isStateless
+	]);
 	(0, react.useEffect)(() => {
+		if (isStateless || !adapterState) return;
 		(0, __blac_core.disableGetterTracking)(adapterState, rawInstance);
-		externalDepsManager.current.updateSubscriptions(adapterState.getterTracker, rawInstance, forceUpdate);
+		externalDepsManager.current.updateSubscriptions(adapterState.getterState, rawInstance, forceUpdate);
 	});
 	(0, react.useEffect)(() => {
+		if (isStateless) return;
 		if (options?.onMount) options.onMount(bloc);
 		return () => {
 			externalDepsManager.current.cleanup();
 			if (options?.onUnmount) options.onUnmount(bloc);
-			BlocClass.release(instanceKey);
+			(0, __blac_core.release)(BlocClass, instanceKey);
 			if (isIsolated && !rawInstance.isDisposed) rawInstance.dispose();
 		};
 	}, []);
@@ -181,17 +202,28 @@ function useBloc(BlocClass, options) {
 * React hook that connects to a state container instance without triggering re-renders.
 * Use this when you only need to call actions on the bloc without subscribing to state changes.
 *
-* @template S - Optional state type override for generic StateContainers (defaults to never)
+* **This is the recommended hook for stateless containers** (StatelessCubit, StatelessVertex).
+* It also works with regular Cubit/Vertex when you don't need state subscriptions.
+*
 * @template T - The state container constructor type (inferred from BlocClass)
-* @param BlocClass - The state container class to connect to
+* @param BlocClass - The state container class to connect to (supports both stateful and stateless)
 * @param options - Configuration options for instance management and lifecycle
 * @returns The state container instance for calling actions
 *
-* @example Basic usage
+* @example Basic usage with stateless container
+* ```ts
+* class AnalyticsService extends StatelessCubit {
+*   trackEvent(name: string) { ... }
+* }
+*
+* const analytics = useBlocActions(AnalyticsService);
+* analytics.trackEvent('page_view');
+* ```
+*
+* @example With stateful container (no re-renders)
 * ```ts
 * const myBloc = useBlocActions(MyBloc);
-* // Call methods on the bloc without re-rendering
-* myBloc.someMethod();
+* myBloc.someMethod(); // Won't cause re-renders
 * ```
 *
 * @example With isolated instance
@@ -200,12 +232,6 @@ function useBloc(BlocClass, options) {
 *   instanceId: 'unique-id'
 * });
 * ```
-*
-* @example With generic bloc and explicit state type
-* ```ts
-* const myBloc = useBlocActions<MyStateType>(GenericBloc);
-* // myBloc.state is typed as MyStateType
-* ```
 */
 function useBlocActions(BlocClass, options) {
 	const componentRef = (0, react.useRef)({});
@@ -213,13 +239,13 @@ function useBlocActions(BlocClass, options) {
 	const [bloc, instanceKey] = (0, react.useMemo)(() => {
 		const isIsolated = (0, __blac_core.isIsolatedClass)(BlocClass);
 		const instanceKey$1 = generateInstanceKey(componentRef.current, isIsolated, options?.instanceId);
-		return [BlocClass.resolve(instanceKey$1, { props: initialPropsRef.current }), instanceKey$1];
+		return [(0, __blac_core.acquire)(BlocClass, instanceKey$1, { props: initialPropsRef.current }), instanceKey$1];
 	}, [BlocClass]);
 	(0, react.useEffect)(() => {
 		if (options?.onMount) options.onMount(bloc);
 		return () => {
 			if (options?.onUnmount) options.onUnmount(bloc);
-			BlocClass.release(instanceKey);
+			(0, __blac_core.release)(BlocClass, instanceKey);
 			if ((0, __blac_core.isIsolatedClass)(BlocClass) && !bloc.isDisposed) bloc.dispose();
 		};
 	}, []);

package/dist/index.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.cjs","names":["defaultConfig: BlacReactConfig","globalConfig: BlacReactConfig","globalConfig","instanceKey","subscribeFn: (callback: () => void) => () => void","getSnapshotFn: () => ExtractState<T>","adapterState: AdapterState<T>","adapterState","ExternalDependencyManager","instanceKey"],"sources":["../src/utils/instance-keys.ts","../src/config.ts","../src/useBloc.ts","../src/useBlocActions.ts"],"sourcesContent":["/*\n Instance key generation utilities for React integration\n /\n\nimport { generateIsolatedKey } from '@blac/core';\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 ExternalDependencyManager,\n createAutoTrackSubscribe,\n createManualDepsSubscribe,\n createNoTrackSubscribe,\n createAutoTrackSnapshot,\n createManualDepsSnapshot,\n createNoTrackSnapshot,\n initAutoTrackState,\n initManualDepsState,\n initNoTrackState,\n disableGetterTracking,\n isIsolatedClass,\n StateContainerConstructor,\n InstanceState,\n} from '@blac/core';\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 S - Optional state type override for generic StateContainers (defaults to never)\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 \n @example With generic bloc and explicit state type\n * ```ts\n * const [state, myBloc] = useBloc<MyStateType>(GenericBloc);\n * // state is typed as MyStateType\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 const componentRef = useRef<ComponentRef>({});\n const isIsolated = isIsolatedClass(BlocClass);\n\n const initialPropsRef = useRef(options?.props);\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 = (BlocClass as any).resolve(instanceKey, {\n props: initialPropsRef.current,\n }) as TBloc;\n\n if (initialPropsRef.current !== undefined) {\n instance.updateProps(initialPropsRef.current);\n }\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 = initManualDepsState(instance);\n subscribeFn = createManualDepsSubscribe(instance, adapterState, {\n dependencies: options.dependencies,\n });\n getSnapshotFn = createManualDepsSnapshot(instance, adapterState, {\n dependencies: options.dependencies,\n });\n } else if (!autoTrackEnabled) {\n adapterState = initNoTrackState(instance);\n subscribeFn = createNoTrackSubscribe(instance);\n getSnapshotFn = createNoTrackSnapshot(instance);\n } else {\n adapterState = initAutoTrackState(instance);\n subscribeFn = createAutoTrackSubscribe(instance, adapterState);\n getSnapshotFn = createAutoTrackSnapshot(instance, adapterState);\n }\n\n return [\n adapterState.proxiedBloc!,\n subscribeFn,\n getSnapshotFn,\n instanceKey,\n adapterState,\n instance,\n ];\n }, [BlocClass, 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 ExternalDependencyManager());\n\n useEffect(() => {\n if (options?.props !== initialPropsRef.current) {\n rawInstance.updateProps(options?.props);\n }\n }, [options?.props, rawInstance]);\n\n useEffect(() => {\n disableGetterTracking(adapterState, rawInstance);\n externalDepsManager.current.updateSubscriptions(\n adapterState.getterTracker,\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 (BlocClass as any).release(instanceKey);\n\n if (isIsolated && !rawInstance.isDisposed) {\n rawInstance.dispose();\n }\n };\n }, []);\n\n return [state, bloc, componentRef];\n}\n","import { useMemo, useEffect, useRef } from 'react';\nimport { StateContainerConstructor, isIsolatedClass } from '@blac/core';\nimport type { ComponentRef } from './types';\nimport { generateInstanceKey } from './utils/instance-keys';\n\n/\n Configuration options for useBlocActions hook\n * @template TBloc - The state container type\n * @template TProps - Props type passed to the container\n /\nexport interface UseBlocActionsOptions<TBloc, TProps = any> {\n /* Props passed to bloc constructor or updateProps /\n props?: TProps;\n /* Custom instance identifier for shared or isolated instances /\n instanceId?: string \| number;\n /* Callback invoked when bloc instance mounts /\n onMount?: (bloc: TBloc) => void;\n /* Callback invoked when bloc instance unmounts /\n onUnmount?: (bloc: TBloc) => void;\n}\n\n/\n React hook that connects to a state container instance without triggering re-renders.\n * Use this when you only need to call actions on the bloc without subscribing to state changes.\n \n @template S - Optional state type override for generic StateContainers (defaults to never)\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 instance management and lifecycle\n * @returns The state container instance for calling actions\n \n @example Basic usage\n * ```ts\n * const myBloc = useBlocActions(MyBloc);\n * // Call methods on the bloc without re-rendering\n * myBloc.someMethod();\n * ```\n \n @example With isolated instance\n * ```ts\n * const myBloc = useBlocActions(MyBloc, {\n * instanceId: 'unique-id'\n * });\n * ```\n \n @example With generic bloc and explicit state type\n * ```ts\n * const myBloc = useBlocActions<MyStateType>(GenericBloc);\n * // myBloc.state is typed as MyStateType\n * ```\n */\nexport function useBlocActions<\n T extends StateContainerConstructor = StateContainerConstructor,\n>(\n BlocClass: T,\n options?: UseBlocActionsOptions<InstanceType<T>>,\n): InstanceType<T> {\n const componentRef = useRef<ComponentRef>({});\n const initialPropsRef = useRef(options?.props);\n\n const [bloc, instanceKey] = useMemo(() => {\n const isIsolated = isIsolatedClass(BlocClass);\n\n const instanceKey = generateInstanceKey(\n componentRef.current,\n isIsolated,\n options?.instanceId,\n );\n\n const instance = (BlocClass as any).resolve(instanceKey, {\n props: initialPropsRef.current,\n });\n\n return [instance, instanceKey] as const;\n }, [BlocClass]);\n\n useEffect(() => {\n if (options?.onMount) {\n options.onMount(bloc);\n }\n\n return () => {\n if (options?.onUnmount) {\n options.onUnmount(bloc);\n }\n\n (BlocClass as any).release(instanceKey);\n\n if (isIsolatedClass(BlocClass) && !bloc.isDisposed) {\n bloc.dispose();\n }\n };\n }, []);\n\n return bloc as InstanceType<T>;\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"index.cjs","names":["defaultConfig: BlacReactConfig","globalConfig: BlacReactConfig","globalConfig","instance","instanceKey","subscribeFn: (callback: () => void) => () => void","getSnapshotFn: () => ExtractState<T>","adapterState: AdapterState<T>","adapterState","ExternalDepsManager","instanceKey"],"sources":["../src/utils/instance-keys.ts","../src/config.ts","../src/useBloc.ts","../src/useBlocActions.ts"],"sourcesContent":["/*\n Instance key generation utilities for React integration\n /\n\nimport { generateIsolatedKey } from '@blac/core';\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 type IsStatelessContainer,\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 isStatelessClass,\n StateContainerConstructor,\n InstanceState,\n acquire,\n release,\n} from '@blac/core';\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 Type that produces a TypeScript error when a stateless container is used.\n * Evaluates to `never` for stateless containers, causing a type mismatch.\n /\ntype StatefulContainer<T extends StateContainerConstructor> =\n IsStatelessContainer<T> extends true ? never : T;\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 Note: This hook does NOT support stateless containers (StatelessCubit, StatelessVertex).\n * Use `useBlocActions()` instead for stateless containers.\n \n @template T - The state container constructor type (inferred from BlocClass)\n * @param BlocClass - The state container class to connect to (must not be stateless)\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: StatefulContainer<T>,\n options?: UseBlocOptions<T>,\n): UseBlocReturn<T, ExtractState<T>> {\n type TBloc = InstanceState<T>;\n\n const componentRef = useRef<ComponentRef>({});\n const initialPropsRef = useRef(options?.props);\n const isStateless = isStatelessClass(BlocClass);\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> \| null,\n TBloc,\n ]\n >(() => {\n // Runtime check for stateless containers - log error but don't crash\n if (isStateless) {\n console.error(\n `[BlaC] useBloc() does not support stateless containers. ` +\n `\"${BlocClass.name}\" is a StatelessCubit or StatelessVertex. ` +\n `Use useBlocActions() instead for stateless containers.`,\n );\n const instance = acquire(BlocClass, 'default') as TBloc;\n // Return minimal working functions that won't subscribe to anything\n return [\n instance,\n () => () => {},\n () => ({}) as ExtractState<T>,\n undefined,\n null,\n instance,\n ];\n }\n\n const instanceKey = generateInstanceKey(\n componentRef.current,\n isIsolated,\n options?.instanceId,\n );\n\n const instance = acquire(BlocClass, instanceKey, {\n props: initialPropsRef.current,\n }) as TBloc;\n\n if (initialPropsRef.current !== undefined) {\n instance.updateProps(initialPropsRef.current);\n }\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, isStateless, 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 if (isStateless) return;\n if (options?.props !== initialPropsRef.current) {\n rawInstance.updateProps(options?.props);\n }\n }, [options?.props, rawInstance, isStateless]);\n\n useEffect(() => {\n if (isStateless \|\| !adapterState) return;\n disableGetterTracking(adapterState, rawInstance);\n externalDepsManager.current.updateSubscriptions(\n adapterState.getterState,\n rawInstance,\n forceUpdate,\n );\n });\n\n useEffect(() => {\n if (isStateless) return;\n\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","import { useMemo, useEffect, useRef } from 'react';\nimport {\n StateContainerConstructor,\n isIsolatedClass,\n acquire,\n release,\n} from '@blac/core';\nimport type { ComponentRef } from './types';\nimport { generateInstanceKey } from './utils/instance-keys';\n\n/\n Configuration options for useBlocActions hook\n * @template TBloc - The state container type\n * @template TProps - Props type passed to the container\n /\nexport interface UseBlocActionsOptions<TBloc, TProps = any> {\n /* Props passed to bloc constructor or updateProps /\n props?: TProps;\n /* Custom instance identifier for shared or isolated instances /\n instanceId?: string \| number;\n /* Callback invoked when bloc instance mounts /\n onMount?: (bloc: TBloc) => void;\n /* Callback invoked when bloc instance unmounts /\n onUnmount?: (bloc: TBloc) => void;\n}\n\n/\n React hook that connects to a state container instance without triggering re-renders.\n * Use this when you only need to call actions on the bloc without subscribing to state changes.\n \n This is the recommended hook for stateless containers (StatelessCubit, StatelessVertex).\n * It also works with regular Cubit/Vertex when you don't need state subscriptions.\n \n @template T - The state container constructor type (inferred from BlocClass)\n * @param BlocClass - The state container class to connect to (supports both stateful and stateless)\n * @param options - Configuration options for instance management and lifecycle\n * @returns The state container instance for calling actions\n \n @example Basic usage with stateless container\n * ```ts\n * class AnalyticsService extends StatelessCubit {\n * trackEvent(name: string) { ... }\n * }\n \n const analytics = useBlocActions(AnalyticsService);\n * analytics.trackEvent('page_view');\n * ```\n \n @example With stateful container (no re-renders)\n * ```ts\n * const myBloc = useBlocActions(MyBloc);\n * myBloc.someMethod(); // Won't cause re-renders\n * ```\n \n @example With isolated instance\n * ```ts\n * const myBloc = useBlocActions(MyBloc, {\n * instanceId: 'unique-id'\n * });\n * ```\n */\nexport function useBlocActions<\n T extends StateContainerConstructor = StateContainerConstructor,\n>(\n BlocClass: T,\n options?: UseBlocActionsOptions<InstanceType<T>>,\n): InstanceType<T> {\n const componentRef = useRef<ComponentRef>({});\n const initialPropsRef = useRef(options?.props);\n\n const [bloc, instanceKey] = useMemo(() => {\n const isIsolated = isIsolatedClass(BlocClass);\n\n const instanceKey = generateInstanceKey(\n componentRef.current,\n isIsolated,\n options?.instanceId,\n );\n\n const instance = acquire(BlocClass, instanceKey, {\n props: initialPropsRef.current,\n });\n\n return [instance, instanceKey] as const;\n }, [BlocClass]);\n\n useEffect(() => {\n if (options?.onMount) {\n options.onMount(bloc);\n }\n\n return () => {\n if (options?.onUnmount) {\n options.onUnmount(bloc);\n }\n\n release(BlocClass, instanceKey);\n\n if (isIsolatedClass(BlocClass) && !bloc.isDisposed) {\n bloc.dispose();\n }\n };\n }, []);\n\n return bloc as InstanceType<T>;\n}\n"],"mappings":"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"}

package/dist/index.d.cts CHANGED Viewed

@@ -1,6 +1,7 @@
 import type { ExtractProps } from '@blac/core';
 import { ExtractState } from '@blac/core';
 import { InstanceReadonlyState } from '@blac/core';
+import { IsStatelessContainer } from '@blac/core';
 import type { RefObject } from 'react';
 import { StateContainerConstructor } from '@blac/core';
@@ -33,6 +34,12 @@ export declare function configureBlacReact(config: Partial<BlacReactConfig>): vo
 /* Excluded from this release type: resetBlacReactConfig */
+/**
+ * Type that produces a TypeScript error when a stateless container is used.
+ * Evaluates to `never` for stateless containers, causing a type mismatch.
+ */
+declare type StatefulContainer<T extends StateContainerConstructor> = IsStatelessContainer<T> extends true ? never : T;
 /**
  * React hook that connects a component to a state container with automatic re-render on state changes.
  *
@@ -41,9 +48,11 @@ export declare function configureBlacReact(config: Partial<BlacReactConfig>): vo
  * - **Manual dependencies**: Explicit dependency array like useEffect
  * - **No tracking**: Returns full state without optimization
  *
- * @template S - Optional state type override for generic StateContainers (defaults to never)
+ * **Note:** This hook does NOT support stateless containers (StatelessCubit, StatelessVertex).
+ * Use `useBlocActions()` instead for stateless containers.
+ *
  * @template T - The state container constructor type (inferred from BlocClass)
- * @param BlocClass - The state container class to connect to
+ * @param BlocClass - The state container class to connect to (must not be stateless)
  * @param options - Configuration options for tracking mode and instance management
  * @returns Tuple with [state, bloc instance, ref]
  *
@@ -65,30 +74,35 @@ export declare function configureBlacReact(config: Partial<BlacReactConfig>): vo
  *   instanceId: 'unique-id'
  * });
  * ```
- *
- * @example With generic bloc and explicit state type
- * ```ts
- * const [state, myBloc] = useBloc<MyStateType>(GenericBloc);
- * // state is typed as MyStateType
- * ```
  */
-export declare function useBloc<T extends StateContainerConstructor = StateContainerConstructor>(BlocClass: T, options?: UseBlocOptions<T>): UseBlocReturn<T, ExtractState<T>>;
+export declare function useBloc<T extends StateContainerConstructor = StateContainerConstructor>(BlocClass: StatefulContainer<T>, options?: UseBlocOptions<T>): UseBlocReturn<T, ExtractState<T>>;
 /**
  * React hook that connects to a state container instance without triggering re-renders.
  * Use this when you only need to call actions on the bloc without subscribing to state changes.
  *
- * @template S - Optional state type override for generic StateContainers (defaults to never)
+ * **This is the recommended hook for stateless containers** (StatelessCubit, StatelessVertex).
+ * It also works with regular Cubit/Vertex when you don't need state subscriptions.
+ *
  * @template T - The state container constructor type (inferred from BlocClass)
- * @param BlocClass - The state container class to connect to
+ * @param BlocClass - The state container class to connect to (supports both stateful and stateless)
  * @param options - Configuration options for instance management and lifecycle
  * @returns The state container instance for calling actions
  *
- * @example Basic usage
+ * @example Basic usage with stateless container
+ * ```ts
+ * class AnalyticsService extends StatelessCubit {
+ *   trackEvent(name: string) { ... }
+ * }
+ *
+ * const analytics = useBlocActions(AnalyticsService);
+ * analytics.trackEvent('page_view');
+ * ```
+ *
+ * @example With stateful container (no re-renders)
  * ```ts
  * const myBloc = useBlocActions(MyBloc);
- * // Call methods on the bloc without re-rendering
- * myBloc.someMethod();
+ * myBloc.someMethod(); // Won't cause re-renders
  * ```
  *
  * @example With isolated instance
@@ -97,12 +111,6 @@ export declare function useBloc<T extends StateContainerConstructor = StateConta
  *   instanceId: 'unique-id'
  * });
  * ```
- *
- * @example With generic bloc and explicit state type
- * ```ts
- * const myBloc = useBlocActions<MyStateType>(GenericBloc);
- * // myBloc.state is typed as MyStateType
- * ```
  */
 export declare function useBlocActions<T extends StateContainerConstructor = StateContainerConstructor>(BlocClass: T, options?: UseBlocActionsOptions<InstanceType<T>>): InstanceType<T>;

package/dist/index.d.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import type { ExtractProps } from '@blac/core';
 import { ExtractState } from '@blac/core';
 import { InstanceReadonlyState } from '@blac/core';
+import { IsStatelessContainer } from '@blac/core';
 import type { RefObject } from 'react';
 import { StateContainerConstructor } from '@blac/core';
@@ -33,6 +34,12 @@ export declare function configureBlacReact(config: Partial<BlacReactConfig>): vo
 /* Excluded from this release type: resetBlacReactConfig */
+/**
+ * Type that produces a TypeScript error when a stateless container is used.
+ * Evaluates to `never` for stateless containers, causing a type mismatch.
+ */
+declare type StatefulContainer<T extends StateContainerConstructor> = IsStatelessContainer<T> extends true ? never : T;
 /**
  * React hook that connects a component to a state container with automatic re-render on state changes.
  *
@@ -41,9 +48,11 @@ export declare function configureBlacReact(config: Partial<BlacReactConfig>): vo
  * - **Manual dependencies**: Explicit dependency array like useEffect
  * - **No tracking**: Returns full state without optimization
  *
- * @template S - Optional state type override for generic StateContainers (defaults to never)
+ * **Note:** This hook does NOT support stateless containers (StatelessCubit, StatelessVertex).
+ * Use `useBlocActions()` instead for stateless containers.
+ *
  * @template T - The state container constructor type (inferred from BlocClass)
- * @param BlocClass - The state container class to connect to
+ * @param BlocClass - The state container class to connect to (must not be stateless)
  * @param options - Configuration options for tracking mode and instance management
  * @returns Tuple with [state, bloc instance, ref]
  *
@@ -65,30 +74,35 @@ export declare function configureBlacReact(config: Partial<BlacReactConfig>): vo
  *   instanceId: 'unique-id'
  * });
  * ```
- *
- * @example With generic bloc and explicit state type
- * ```ts
- * const [state, myBloc] = useBloc<MyStateType>(GenericBloc);
- * // state is typed as MyStateType
- * ```
  */
-export declare function useBloc<T extends StateContainerConstructor = StateContainerConstructor>(BlocClass: T, options?: UseBlocOptions<T>): UseBlocReturn<T, ExtractState<T>>;
+export declare function useBloc<T extends StateContainerConstructor = StateContainerConstructor>(BlocClass: StatefulContainer<T>, options?: UseBlocOptions<T>): UseBlocReturn<T, ExtractState<T>>;
 /**
  * React hook that connects to a state container instance without triggering re-renders.
  * Use this when you only need to call actions on the bloc without subscribing to state changes.
  *
- * @template S - Optional state type override for generic StateContainers (defaults to never)
+ * **This is the recommended hook for stateless containers** (StatelessCubit, StatelessVertex).
+ * It also works with regular Cubit/Vertex when you don't need state subscriptions.
+ *
  * @template T - The state container constructor type (inferred from BlocClass)
- * @param BlocClass - The state container class to connect to
+ * @param BlocClass - The state container class to connect to (supports both stateful and stateless)
  * @param options - Configuration options for instance management and lifecycle
  * @returns The state container instance for calling actions
  *
- * @example Basic usage
+ * @example Basic usage with stateless container
+ * ```ts
+ * class AnalyticsService extends StatelessCubit {
+ *   trackEvent(name: string) { ... }
+ * }
+ *
+ * const analytics = useBlocActions(AnalyticsService);
+ * analytics.trackEvent('page_view');
+ * ```
+ *
+ * @example With stateful container (no re-renders)
  * ```ts
  * const myBloc = useBlocActions(MyBloc);
- * // Call methods on the bloc without re-rendering
- * myBloc.someMethod();
+ * myBloc.someMethod(); // Won't cause re-renders
  * ```
  *
  * @example With isolated instance
@@ -97,12 +111,6 @@ export declare function useBloc<T extends StateContainerConstructor = StateConta
  *   instanceId: 'unique-id'
  * });
  * ```
- *
- * @example With generic bloc and explicit state type
- * ```ts
- * const myBloc = useBlocActions<MyStateType>(GenericBloc);
- * // myBloc.state is typed as MyStateType
- * ```
  */
 export declare function useBlocActions<T extends StateContainerConstructor = StateContainerConstructor>(BlocClass: T, options?: UseBlocActionsOptions<InstanceType<T>>): InstanceType<T>;

package/dist/index.js CHANGED Viewed

@@ -1,5 +1,5 @@
 import { useEffect, useMemo, useReducer, useRef, useSyncExternalStore } from "react";
-import { ExternalDependencyManager, createAutoTrackSnapshot, createAutoTrackSubscribe, createManualDepsSnapshot, createManualDepsSubscribe, createNoTrackSnapshot, createNoTrackSubscribe, disableGetterTracking, generateIsolatedKey, initAutoTrackState, initManualDepsState, initNoTrackState, isIsolatedClass } from "@blac/core";
+import { ExternalDepsManager, acquire, autoTrackInit, autoTrackSnapshot, autoTrackSubscribe, disableGetterTracking, generateIsolatedKey, isIsolatedClass, isStatelessClass, manualDepsInit, manualDepsSnapshot, manualDepsSubscribe, noTrackInit, noTrackSnapshot, noTrackSubscribe, release } from "@blac/core";
 //#region src/utils/instance-keys.ts
 /**
@@ -84,9 +84,11 @@ function determineTrackingMode(options) {
 * - **Manual dependencies**: Explicit dependency array like useEffect
 * - **No tracking**: Returns full state without optimization
 *
-* @template S - Optional state type override for generic StateContainers (defaults to never)
+* **Note:** This hook does NOT support stateless containers (StatelessCubit, StatelessVertex).
+* Use `useBlocActions()` instead for stateless containers.
+*
 * @template T - The state container constructor type (inferred from BlocClass)
-* @param BlocClass - The state container class to connect to
+* @param BlocClass - The state container class to connect to (must not be stateless)
 * @param options - Configuration options for tracking mode and instance management
 * @returns Tuple with [state, bloc instance, ref]
 *
@@ -108,37 +110,44 @@ function determineTrackingMode(options) {
 *   instanceId: 'unique-id'
 * });
 * ```
-*
-* @example With generic bloc and explicit state type
-* ```ts
-* const [state, myBloc] = useBloc<MyStateType>(GenericBloc);
-* // state is typed as MyStateType
-* ```
 */
 function useBloc(BlocClass, options) {
 	const componentRef = useRef({});
-	const isIsolated = isIsolatedClass(BlocClass);
 	const initialPropsRef = useRef(options?.props);
+	const isStateless = isStatelessClass(BlocClass);
+	const isIsolated = isIsolatedClass(BlocClass);
 	const [bloc, subscribe, getSnapshot, instanceKey, adapterState, rawInstance] = useMemo(() => {
+		if (isStateless) {
+			console.error(`[BlaC] useBloc() does not support stateless containers. "${BlocClass.name}" is a StatelessCubit or StatelessVertex. Use useBlocActions() instead for stateless containers.`);
+			const instance$1 = acquire(BlocClass, "default");
+			return [
+				instance$1,
+				() => () => {},
+				() => ({}),
+				void 0,
+				null,
+				instance$1
+			];
+		}
 		const instanceKey$1 = generateInstanceKey(componentRef.current, isIsolated, options?.instanceId);
-		const instance = BlocClass.resolve(instanceKey$1, { props: initialPropsRef.current });
+		const instance = acquire(BlocClass, instanceKey$1, { props: initialPropsRef.current });
 		if (initialPropsRef.current !== void 0) instance.updateProps(initialPropsRef.current);
 		const { useManualDeps, autoTrackEnabled } = determineTrackingMode(options);
 		let subscribeFn;
 		let getSnapshotFn;
 		let adapterState$1;
 		if (useManualDeps && options?.dependencies) {
-			adapterState$1 = initManualDepsState(instance);
-			subscribeFn = createManualDepsSubscribe(instance, adapterState$1, { dependencies: options.dependencies });
-			getSnapshotFn = createManualDepsSnapshot(instance, adapterState$1, { dependencies: options.dependencies });
+			adapterState$1 = manualDepsInit(instance);
+			subscribeFn = manualDepsSubscribe(instance, adapterState$1, { dependencies: options.dependencies });
+			getSnapshotFn = manualDepsSnapshot(instance, adapterState$1, { dependencies: options.dependencies });
 		} else if (!autoTrackEnabled) {
-			adapterState$1 = initNoTrackState(instance);
-			subscribeFn = createNoTrackSubscribe(instance);
-			getSnapshotFn = createNoTrackSnapshot(instance);
+			adapterState$1 = noTrackInit(instance);
+			subscribeFn = noTrackSubscribe(instance);
+			getSnapshotFn = noTrackSnapshot(instance);
 		} else {
-			adapterState$1 = initAutoTrackState(instance);
-			subscribeFn = createAutoTrackSubscribe(instance, adapterState$1);
-			getSnapshotFn = createAutoTrackSnapshot(instance, adapterState$1);
+			adapterState$1 = autoTrackInit(instance);
+			subscribeFn = autoTrackSubscribe(instance, adapterState$1);
+			getSnapshotFn = autoTrackSnapshot(instance, adapterState$1);
 		}
 		return [
 			adapterState$1.proxiedBloc,
@@ -148,23 +157,35 @@ function useBloc(BlocClass, options) {
 			adapterState$1,
 			instance
 		];
-	}, [BlocClass, options?.instanceId]);
+	}, [
+		BlocClass,
+		isStateless,
+		isIsolated,
+		options?.instanceId
+	]);
 	const state = useSyncExternalStore(subscribe, getSnapshot);
 	const [, forceUpdate] = useReducer((x) => x + 1, 0);
-	const externalDepsManager = useRef(new ExternalDependencyManager());
+	const externalDepsManager = useRef(new ExternalDepsManager());
 	useEffect(() => {
+		if (isStateless) return;
 		if (options?.props !== initialPropsRef.current) rawInstance.updateProps(options?.props);
-	}, [options?.props, rawInstance]);
+	}, [
+		options?.props,
+		rawInstance,
+		isStateless
+	]);
 	useEffect(() => {
+		if (isStateless || !adapterState) return;
 		disableGetterTracking(adapterState, rawInstance);
-		externalDepsManager.current.updateSubscriptions(adapterState.getterTracker, rawInstance, forceUpdate);
+		externalDepsManager.current.updateSubscriptions(adapterState.getterState, rawInstance, forceUpdate);
 	});
 	useEffect(() => {
+		if (isStateless) return;
 		if (options?.onMount) options.onMount(bloc);
 		return () => {
 			externalDepsManager.current.cleanup();
 			if (options?.onUnmount) options.onUnmount(bloc);
-			BlocClass.release(instanceKey);
+			release(BlocClass, instanceKey);
 			if (isIsolated && !rawInstance.isDisposed) rawInstance.dispose();
 		};
 	}, []);
@@ -181,17 +202,28 @@ function useBloc(BlocClass, options) {
 * React hook that connects to a state container instance without triggering re-renders.
 * Use this when you only need to call actions on the bloc without subscribing to state changes.
 *
-* @template S - Optional state type override for generic StateContainers (defaults to never)
+* **This is the recommended hook for stateless containers** (StatelessCubit, StatelessVertex).
+* It also works with regular Cubit/Vertex when you don't need state subscriptions.
+*
 * @template T - The state container constructor type (inferred from BlocClass)
-* @param BlocClass - The state container class to connect to
+* @param BlocClass - The state container class to connect to (supports both stateful and stateless)
 * @param options - Configuration options for instance management and lifecycle
 * @returns The state container instance for calling actions
 *
-* @example Basic usage
+* @example Basic usage with stateless container
+* ```ts
+* class AnalyticsService extends StatelessCubit {
+*   trackEvent(name: string) { ... }
+* }
+*
+* const analytics = useBlocActions(AnalyticsService);
+* analytics.trackEvent('page_view');
+* ```
+*
+* @example With stateful container (no re-renders)
 * ```ts
 * const myBloc = useBlocActions(MyBloc);
-* // Call methods on the bloc without re-rendering
-* myBloc.someMethod();
+* myBloc.someMethod(); // Won't cause re-renders
 * ```
 *
 * @example With isolated instance
@@ -200,12 +232,6 @@ function useBloc(BlocClass, options) {
 *   instanceId: 'unique-id'
 * });
 * ```
-*
-* @example With generic bloc and explicit state type
-* ```ts
-* const myBloc = useBlocActions<MyStateType>(GenericBloc);
-* // myBloc.state is typed as MyStateType
-* ```
 */
 function useBlocActions(BlocClass, options) {
 	const componentRef = useRef({});
@@ -213,13 +239,13 @@ function useBlocActions(BlocClass, options) {
 	const [bloc, instanceKey] = useMemo(() => {
 		const isIsolated = isIsolatedClass(BlocClass);
 		const instanceKey$1 = generateInstanceKey(componentRef.current, isIsolated, options?.instanceId);
-		return [BlocClass.resolve(instanceKey$1, { props: initialPropsRef.current }), instanceKey$1];
+		return [acquire(BlocClass, instanceKey$1, { props: initialPropsRef.current }), instanceKey$1];
 	}, [BlocClass]);
 	useEffect(() => {
 		if (options?.onMount) options.onMount(bloc);
 		return () => {
 			if (options?.onUnmount) options.onUnmount(bloc);
-			BlocClass.release(instanceKey);
+			release(BlocClass, instanceKey);
 			if (isIsolatedClass(BlocClass) && !bloc.isDisposed) bloc.dispose();
 		};
 	}, []);

package/dist/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.js","names":["defaultConfig: BlacReactConfig","globalConfig: BlacReactConfig","globalConfig","instanceKey","subscribeFn: (callback: () => void) => () => void","getSnapshotFn: () => ExtractState<T>","adapterState: AdapterState<T>","adapterState","instanceKey"],"sources":["../src/utils/instance-keys.ts","../src/config.ts","../src/useBloc.ts","../src/useBlocActions.ts"],"sourcesContent":["/*\n Instance key generation utilities for React integration\n /\n\nimport { generateIsolatedKey } from '@blac/core';\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 ExternalDependencyManager,\n createAutoTrackSubscribe,\n createManualDepsSubscribe,\n createNoTrackSubscribe,\n createAutoTrackSnapshot,\n createManualDepsSnapshot,\n createNoTrackSnapshot,\n initAutoTrackState,\n initManualDepsState,\n initNoTrackState,\n disableGetterTracking,\n isIsolatedClass,\n StateContainerConstructor,\n InstanceState,\n} from '@blac/core';\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 S - Optional state type override for generic StateContainers (defaults to never)\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 \n @example With generic bloc and explicit state type\n * ```ts\n * const [state, myBloc] = useBloc<MyStateType>(GenericBloc);\n * // state is typed as MyStateType\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 const componentRef = useRef<ComponentRef>({});\n const isIsolated = isIsolatedClass(BlocClass);\n\n const initialPropsRef = useRef(options?.props);\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 = (BlocClass as any).resolve(instanceKey, {\n props: initialPropsRef.current,\n }) as TBloc;\n\n if (initialPropsRef.current !== undefined) {\n instance.updateProps(initialPropsRef.current);\n }\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 = initManualDepsState(instance);\n subscribeFn = createManualDepsSubscribe(instance, adapterState, {\n dependencies: options.dependencies,\n });\n getSnapshotFn = createManualDepsSnapshot(instance, adapterState, {\n dependencies: options.dependencies,\n });\n } else if (!autoTrackEnabled) {\n adapterState = initNoTrackState(instance);\n subscribeFn = createNoTrackSubscribe(instance);\n getSnapshotFn = createNoTrackSnapshot(instance);\n } else {\n adapterState = initAutoTrackState(instance);\n subscribeFn = createAutoTrackSubscribe(instance, adapterState);\n getSnapshotFn = createAutoTrackSnapshot(instance, adapterState);\n }\n\n return [\n adapterState.proxiedBloc!,\n subscribeFn,\n getSnapshotFn,\n instanceKey,\n adapterState,\n instance,\n ];\n }, [BlocClass, 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 ExternalDependencyManager());\n\n useEffect(() => {\n if (options?.props !== initialPropsRef.current) {\n rawInstance.updateProps(options?.props);\n }\n }, [options?.props, rawInstance]);\n\n useEffect(() => {\n disableGetterTracking(adapterState, rawInstance);\n externalDepsManager.current.updateSubscriptions(\n adapterState.getterTracker,\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 (BlocClass as any).release(instanceKey);\n\n if (isIsolated && !rawInstance.isDisposed) {\n rawInstance.dispose();\n }\n };\n }, []);\n\n return [state, bloc, componentRef];\n}\n","import { useMemo, useEffect, useRef } from 'react';\nimport { StateContainerConstructor, isIsolatedClass } from '@blac/core';\nimport type { ComponentRef } from './types';\nimport { generateInstanceKey } from './utils/instance-keys';\n\n/\n Configuration options for useBlocActions hook\n * @template TBloc - The state container type\n * @template TProps - Props type passed to the container\n /\nexport interface UseBlocActionsOptions<TBloc, TProps = any> {\n /* Props passed to bloc constructor or updateProps /\n props?: TProps;\n /* Custom instance identifier for shared or isolated instances /\n instanceId?: string \| number;\n /* Callback invoked when bloc instance mounts /\n onMount?: (bloc: TBloc) => void;\n /* Callback invoked when bloc instance unmounts /\n onUnmount?: (bloc: TBloc) => void;\n}\n\n/\n React hook that connects to a state container instance without triggering re-renders.\n * Use this when you only need to call actions on the bloc without subscribing to state changes.\n \n @template S - Optional state type override for generic StateContainers (defaults to never)\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 instance management and lifecycle\n * @returns The state container instance for calling actions\n \n @example Basic usage\n * ```ts\n * const myBloc = useBlocActions(MyBloc);\n * // Call methods on the bloc without re-rendering\n * myBloc.someMethod();\n * ```\n \n @example With isolated instance\n * ```ts\n * const myBloc = useBlocActions(MyBloc, {\n * instanceId: 'unique-id'\n * });\n * ```\n \n @example With generic bloc and explicit state type\n * ```ts\n * const myBloc = useBlocActions<MyStateType>(GenericBloc);\n * // myBloc.state is typed as MyStateType\n * ```\n */\nexport function useBlocActions<\n T extends StateContainerConstructor = StateContainerConstructor,\n>(\n BlocClass: T,\n options?: UseBlocActionsOptions<InstanceType<T>>,\n): InstanceType<T> {\n const componentRef = useRef<ComponentRef>({});\n const initialPropsRef = useRef(options?.props);\n\n const [bloc, instanceKey] = useMemo(() => {\n const isIsolated = isIsolatedClass(BlocClass);\n\n const instanceKey = generateInstanceKey(\n componentRef.current,\n isIsolated,\n options?.instanceId,\n );\n\n const instance = (BlocClass as any).resolve(instanceKey, {\n props: initialPropsRef.current,\n });\n\n return [instance, instanceKey] as const;\n }, [BlocClass]);\n\n useEffect(() => {\n if (options?.onMount) {\n options.onMount(bloc);\n }\n\n return () => {\n if (options?.onUnmount) {\n options.onUnmount(bloc);\n }\n\n (BlocClass as any).release(instanceKey);\n\n if (isIsolatedClass(BlocClass) && !bloc.isDisposed) {\n bloc.dispose();\n }\n };\n }, []);\n\n return bloc as InstanceType<T>;\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"index.js","names":["defaultConfig: BlacReactConfig","globalConfig: BlacReactConfig","globalConfig","instance","instanceKey","subscribeFn: (callback: () => void) => () => void","getSnapshotFn: () => ExtractState<T>","adapterState: AdapterState<T>","adapterState","instanceKey"],"sources":["../src/utils/instance-keys.ts","../src/config.ts","../src/useBloc.ts","../src/useBlocActions.ts"],"sourcesContent":["/*\n Instance key generation utilities for React integration\n /\n\nimport { generateIsolatedKey } from '@blac/core';\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 type IsStatelessContainer,\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 isStatelessClass,\n StateContainerConstructor,\n InstanceState,\n acquire,\n release,\n} from '@blac/core';\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 Type that produces a TypeScript error when a stateless container is used.\n * Evaluates to `never` for stateless containers, causing a type mismatch.\n /\ntype StatefulContainer<T extends StateContainerConstructor> =\n IsStatelessContainer<T> extends true ? never : T;\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 Note: This hook does NOT support stateless containers (StatelessCubit, StatelessVertex).\n * Use `useBlocActions()` instead for stateless containers.\n \n @template T - The state container constructor type (inferred from BlocClass)\n * @param BlocClass - The state container class to connect to (must not be stateless)\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: StatefulContainer<T>,\n options?: UseBlocOptions<T>,\n): UseBlocReturn<T, ExtractState<T>> {\n type TBloc = InstanceState<T>;\n\n const componentRef = useRef<ComponentRef>({});\n const initialPropsRef = useRef(options?.props);\n const isStateless = isStatelessClass(BlocClass);\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> \| null,\n TBloc,\n ]\n >(() => {\n // Runtime check for stateless containers - log error but don't crash\n if (isStateless) {\n console.error(\n `[BlaC] useBloc() does not support stateless containers. ` +\n `\"${BlocClass.name}\" is a StatelessCubit or StatelessVertex. ` +\n `Use useBlocActions() instead for stateless containers.`,\n );\n const instance = acquire(BlocClass, 'default') as TBloc;\n // Return minimal working functions that won't subscribe to anything\n return [\n instance,\n () => () => {},\n () => ({}) as ExtractState<T>,\n undefined,\n null,\n instance,\n ];\n }\n\n const instanceKey = generateInstanceKey(\n componentRef.current,\n isIsolated,\n options?.instanceId,\n );\n\n const instance = acquire(BlocClass, instanceKey, {\n props: initialPropsRef.current,\n }) as TBloc;\n\n if (initialPropsRef.current !== undefined) {\n instance.updateProps(initialPropsRef.current);\n }\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, isStateless, 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 if (isStateless) return;\n if (options?.props !== initialPropsRef.current) {\n rawInstance.updateProps(options?.props);\n }\n }, [options?.props, rawInstance, isStateless]);\n\n useEffect(() => {\n if (isStateless \|\| !adapterState) return;\n disableGetterTracking(adapterState, rawInstance);\n externalDepsManager.current.updateSubscriptions(\n adapterState.getterState,\n rawInstance,\n forceUpdate,\n );\n });\n\n useEffect(() => {\n if (isStateless) return;\n\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","import { useMemo, useEffect, useRef } from 'react';\nimport {\n StateContainerConstructor,\n isIsolatedClass,\n acquire,\n release,\n} from '@blac/core';\nimport type { ComponentRef } from './types';\nimport { generateInstanceKey } from './utils/instance-keys';\n\n/\n Configuration options for useBlocActions hook\n * @template TBloc - The state container type\n * @template TProps - Props type passed to the container\n /\nexport interface UseBlocActionsOptions<TBloc, TProps = any> {\n /* Props passed to bloc constructor or updateProps /\n props?: TProps;\n /* Custom instance identifier for shared or isolated instances /\n instanceId?: string \| number;\n /* Callback invoked when bloc instance mounts /\n onMount?: (bloc: TBloc) => void;\n /* Callback invoked when bloc instance unmounts /\n onUnmount?: (bloc: TBloc) => void;\n}\n\n/\n React hook that connects to a state container instance without triggering re-renders.\n * Use this when you only need to call actions on the bloc without subscribing to state changes.\n \n This is the recommended hook for stateless containers (StatelessCubit, StatelessVertex).\n * It also works with regular Cubit/Vertex when you don't need state subscriptions.\n \n @template T - The state container constructor type (inferred from BlocClass)\n * @param BlocClass - The state container class to connect to (supports both stateful and stateless)\n * @param options - Configuration options for instance management and lifecycle\n * @returns The state container instance for calling actions\n \n @example Basic usage with stateless container\n * ```ts\n * class AnalyticsService extends StatelessCubit {\n * trackEvent(name: string) { ... }\n * }\n \n const analytics = useBlocActions(AnalyticsService);\n * analytics.trackEvent('page_view');\n * ```\n \n @example With stateful container (no re-renders)\n * ```ts\n * const myBloc = useBlocActions(MyBloc);\n * myBloc.someMethod(); // Won't cause re-renders\n * ```\n \n @example With isolated instance\n * ```ts\n * const myBloc = useBlocActions(MyBloc, {\n * instanceId: 'unique-id'\n * });\n * ```\n */\nexport function useBlocActions<\n T extends StateContainerConstructor = StateContainerConstructor,\n>(\n BlocClass: T,\n options?: UseBlocActionsOptions<InstanceType<T>>,\n): InstanceType<T> {\n const componentRef = useRef<ComponentRef>({});\n const initialPropsRef = useRef(options?.props);\n\n const [bloc, instanceKey] = useMemo(() => {\n const isIsolated = isIsolatedClass(BlocClass);\n\n const instanceKey = generateInstanceKey(\n componentRef.current,\n isIsolated,\n options?.instanceId,\n );\n\n const instance = acquire(BlocClass, instanceKey, {\n props: initialPropsRef.current,\n });\n\n return [instance, instanceKey] as const;\n }, [BlocClass]);\n\n useEffect(() => {\n if (options?.onMount) {\n options.onMount(bloc);\n }\n\n return () => {\n if (options?.onUnmount) {\n options.onUnmount(bloc);\n }\n\n release(BlocClass, instanceKey);\n\n if (isIsolatedClass(BlocClass) && !bloc.isDisposed) {\n bloc.dispose();\n }\n };\n }, []);\n\n return bloc as InstanceType<T>;\n}\n"],"mappings":"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"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@blac/react",
-  "version": "2.0.0-rc.16",
+  "version": "2.0.0-rc.17",
   "license": "MIT",
   "author": "Brendan Mullins <jsnanigans@gmail.com>",
   "repository": {
@@ -49,7 +49,7 @@
   "peerDependencies": {
     "@types/react": "^18.0.0 || ^19.0.0",
     "react": "^18.0.0 || ^19.0.0",
-    "@blac/core": "2.0.0-rc.16"
+    "@blac/core": "2.0.0-rc.17"
   },
   "peerDependenciesMeta": {
     "@types/react": {
@@ -78,7 +78,7 @@
     "tsdown": "^0.15.7",
     "typescript": "^5.9.2",
     "vitest": "3.2.4",
-    "@blac/core": "2.0.0-rc.16"
+    "@blac/core": "2.0.0-rc.17"
   },
   "scripts": {
     "dev": "tsdown --watch",