@blac/react 2.0.0-rc-7 → 2.0.0-rc-10

package/dist/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":["../src/useExternalBlocStore.ts","../src/useBloc.tsx"],"sourcesContent":["import { Blac, BlacObserver, BlocBase, BlocBaseAbstract, BlocConstructor, BlocHookDependencyArrayFn, BlocState, generateUUID } from '@blac/core';\nimport { useCallback, useMemo, useRef } from 'react';\nimport { BlocHookOptions } from './useBloc';\n\nexport interface ExternalStore<\n  B extends BlocConstructor<BlocBase<any>>\n> {\n  /**\n   * Subscribes to changes in the store and returns an unsubscribe function.\n   * @param onStoreChange - Callback function that will be called whenever the store changes\n   * @returns A function that can be called to unsubscribe from store changes\n   */\n  subscribe: (onStoreChange: (state: BlocState<InstanceType<B>>) => void) => () => void;\n\n  /**\n   * Gets the current snapshot of the store state.\n   * @returns The current state of the store\n   */\n  getSnapshot: () => BlocState<InstanceType<B>> | undefined;\n\n  /**\n   * Gets the server snapshot of the store state.\n   * This is optional and defaults to the same value as getSnapshot.\n   * @returns The server state of the store\n   */\n  getServerSnapshot?: () => BlocState<InstanceType<B>> | undefined;\n}\n\nexport interface ExternalBlacStore<\n  B extends BlocConstructor<BlocBase<any>>\n> {\n  usedKeys: React.RefObject<Set<string>>;\n  usedClassPropKeys: React.RefObject<Set<string>>;\n  externalStore: ExternalStore<B>;\n  instance: React.RefObject<InstanceType<B>>;\n  rid: string;\n}\n\n/**\n * Creates an external store that wraps a Bloc instance, providing a React-compatible interface\n * for subscribing to and accessing bloc state.\n */\nconst useExternalBlocStore = <\n  B extends BlocConstructor<BlocBase<any>>\n>(\n  bloc: B,\n  options: BlocHookOptions<InstanceType<B>> | undefined,\n): ExternalBlacStore<B> => {\n  const { id: blocId, props, selector } = options ?? {};\n\n  const rid = useMemo(() => {\n    return generateUUID();\n  }, []);\n\n  const base = bloc as unknown as BlocBaseAbstract;\n\n  const isIsolated = base.isolated;\n  const effectiveBlocId = isIsolated ? rid : blocId;\n\n  const usedKeys = useRef<Set<string>>(new Set());\n  const usedClassPropKeys = useRef<Set<string>>(new Set());\n\n  const getBloc = useCallback(() => {\n    return Blac.getBloc(bloc, {\n      id: effectiveBlocId,\n      props,\n      instanceRef: rid\n    });\n  }, [bloc, effectiveBlocId, props, rid]);\n\n  const blocInstance = useRef<InstanceType<B>>(getBloc());\n\n  // Update the instance when dependencies change\n  useMemo(() => {\n    blocInstance.current = getBloc();\n  }, [getBloc]);\n\n  const dependencyArray: BlocHookDependencyArrayFn<BlocState<InstanceType<B>>> =\n    useMemo(\n      () =>\n        (newState): ReturnType<BlocHookDependencyArrayFn<BlocState<InstanceType<B>>>> => {\n          const instance = blocInstance.current;\n\n          if (!instance) {\n            return [];\n          }\n\n          // Use custom dependency selector if provided\n          if (selector) {\n            return selector(newState);\n          }\n\n          // Fall back to bloc's default dependency selector if available\n          if (instance.defaultDependencySelector) {\n            return instance.defaultDependencySelector(newState);\n          }\n\n          // For primitive states, use default selector\n          if (typeof newState !== 'object') {\n            // Default behavior for primitive states: re-render if the state itself changes.\n            return [[newState]];\n          }\n\n          // For object states, track which properties were actually used\n          const usedStateValues: unknown[] = [];\n          for (const key of usedKeys.current) {\n            if (key in newState) {\n              usedStateValues.push(newState[key as keyof typeof newState]);\n            }\n          }\n\n          // Track used class properties for dependency tracking, this enables rerenders when class getters change\n          const usedClassValues: unknown[] = [];\n          for (const key of usedClassPropKeys.current) {\n            if (key in instance) {\n              try {\n                const value = instance[key as keyof InstanceType<B>];\n                switch (typeof value) {\n                  case 'function':\n                    continue;\n                  default:\n                    usedClassValues.push(value);\n                    continue;\n                }\n              } catch (error) {\n                Blac.instance.log('useBloc Error', error);\n              }\n            }\n          }\n\n          // If no state properties have been accessed, return empty dependencies to prevent re-renders\n          // Class properties can change independently of state\n          if (usedKeys.current.size === 0) {\n            return usedClassPropKeys.current.size > 0 ? [usedClassValues] : [[]];\n          }\n\n          return [usedStateValues, usedClassValues];\n        },\n      [],\n    );\n\n  const state: ExternalStore<B> = useMemo(() => {\n    return {\n      subscribe: (listener: (state: BlocState<InstanceType<B>>) => void) => {\n        const currentInstance = blocInstance.current;\n        if (!currentInstance) {\n          return () => {}; // Return no-op if no instance\n        }\n\n        const observer: BlacObserver<BlocState<InstanceType<B>>> = {\n          fn: () => {\n            try {\n              // Reset dependency tracking before listener is called \n              // This ensures we only track properties accessed during the current render\n              usedKeys.current = new Set();\n              usedClassPropKeys.current = new Set();\n\n              // Only trigger listener if there are actual subscriptions\n              listener(currentInstance.state);\n            } catch (e) {\n              // Log any errors that occur during the listener callback\n              // This ensures errors in listeners don't break the entire application\n              console.error({\n                e,\n                blocInstance: currentInstance,\n                dependencyArray,\n              });\n            }\n          },\n          // Pass the dependency array to control when the subscription is updated\n          dependencyArray,\n          // Use the provided id to identify this subscription\n          id: rid,\n        }\n\n        Blac.activateBloc(currentInstance);\n\n        // Subscribe to the bloc's observer with the provided listener function\n        // This will trigger the callback whenever the bloc's state changes\n        const unSub = currentInstance._observer.subscribe(observer);\n\n        // Return an unsubscribe function that can be called to clean up the subscription\n        return () => {\n          unSub();\n        };\n      },\n      // Return an immutable snapshot of the current bloc state\n      getSnapshot: (): BlocState<InstanceType<B>> | undefined => {\n        const instance = blocInstance.current;\n        if (!instance) {\n          return {} as BlocState<InstanceType<B>>;\n        }\n        return instance.state;\n      },\n      // Server snapshot mirrors the client snapshot in this implementation\n      getServerSnapshot: (): BlocState<InstanceType<B>> | undefined => {\n        const instance = blocInstance.current;\n        if (!instance) {\n          return {} as BlocState<InstanceType<B>>;\n        }\n        return instance.state;\n      },\n    }\n  }, [blocInstance.current?.uid]); // Re-create store when instance changes\n\n  return {\n    usedKeys,\n    usedClassPropKeys,\n    externalStore: state,\n    instance: blocInstance,\n    rid,\n  };\n};\n\nexport default useExternalBlocStore;\n","import {\n  BlocBase,\n  BlocConstructor,\n  BlocHookDependencyArrayFn,\n  BlocState,\n  InferPropsFromGeneric,\n} from '@blac/core';\nimport {\n  useEffect,\n  useMemo,\n  useRef,\n  useSyncExternalStore\n} from 'react';\nimport useExternalBlocStore from './useExternalBlocStore';\n\n/**\n * Type definition for the return type of the useBloc hook\n * @template B - Bloc constructor type\n */\ntype HookTypes<B extends BlocConstructor<BlocBase<any>>> = [\n  BlocState<InstanceType<B>>,\n  InstanceType<B>,\n];\n\n/**\n * Configuration options for the useBloc hook\n */\nexport interface BlocHookOptions<B extends BlocBase<any>> {\n  id?: string;\n  selector?: BlocHookDependencyArrayFn<BlocState<B>>;\n  props?: InferPropsFromGeneric<B>;\n  onMount?: (bloc: B) => void;\n  onUnmount?: (bloc: B) => void;\n}\n\n/**\n * Default dependency selector that wraps the entire state in an array\n * @template T - State type\n * @returns {Array<Array<T>>} Dependency array containing the entire state\n */\n\n/**\n * React hook for integrating with Blac state management\n *\n * This hook connects a React component to a Bloc state container, providing\n * automatic re-rendering when relevant state changes, dependency tracking,\n * and proper lifecycle management.\n *\n * @template B - Bloc constructor type\n * @template O - BlocHookOptions type\n * @param {B} bloc - Bloc constructor class\n * @param {O} [options] - Configuration options for the hook\n * @returns {HookTypes<B>} Tuple containing [state, bloc instance]\n *\n * @example\n * const [state, counterBloc] = useBloc(CounterBloc);\n * // Access state\n * console.log(state.count);\n * // Call bloc methods\n * counterBloc.increment();\n */\nexport default function useBloc<B extends BlocConstructor<BlocBase<any>>>(\n  bloc: B,\n  options?: BlocHookOptions<InstanceType<B>>,\n): HookTypes<B> {\n  // Determine ID for isolated or shared blocs\n  // const base = bloc as unknown as BlocBaseAbstract;\n  // const isIsolated = base.isolated;\n  // const effectiveBlocId = isIsolated ? rid : blocId;\n  const {\n    externalStore,\n    usedKeys,\n    usedClassPropKeys,\n    instance,\n    rid,\n  } = useExternalBlocStore(bloc, options);\n\n  // Subscribe to state changes using React's external store API\n  const state = useSyncExternalStore<BlocState<InstanceType<B>>>(\n    externalStore.subscribe,\n    () => {\n      const snapshot = externalStore.getSnapshot();\n      if (snapshot === undefined) {\n        throw new Error(`[useBloc] State snapshot is undefined for bloc ${bloc.name}. Bloc may not be properly initialized.`);\n      }\n      return snapshot;\n    },\n    externalStore.getServerSnapshot ? () => {\n      const serverSnapshot = externalStore.getServerSnapshot!();\n      if (serverSnapshot === undefined) {\n        throw new Error(`[useBloc] Server state snapshot is undefined for bloc ${bloc.name}. Bloc may not be properly initialized.`);\n      }\n      return serverSnapshot;\n    } : undefined,\n  );\n\n  // Cache proxies to avoid recreation on every render\n  const stateProxyCache = useRef<WeakMap<object, object>>(new WeakMap());\n  const classProxyCache = useRef<WeakMap<object, object>>(new WeakMap());\n\n  const returnState = useMemo(() => {\n    if (typeof state !== 'object' || state === null) {\n      return state;\n    }\n\n    // Check cache first\n    let proxy = stateProxyCache.current.get(state);\n    if (!proxy) {\n      proxy = new Proxy(state, {\n        get(target, prop) {\n          // Use setTimeout to defer dependency tracking until after render\n          setTimeout(() => {\n            usedKeys.current.add(prop as string);\n          }, 0);\n          const value = target[prop as keyof typeof target];\n          return value;\n        },\n        // Handle symbols and non-enumerable properties\n        has(target, prop) {\n          return prop in target;\n        },\n        ownKeys(target) {\n          return Reflect.ownKeys(target);\n        },\n        getOwnPropertyDescriptor(target, prop) {\n          return Reflect.getOwnPropertyDescriptor(target, prop);\n        }\n      });\n      stateProxyCache.current.set(state as object, proxy as object);\n    }\n    return proxy;\n  }, [state]);\n\n  const returnClass = useMemo(() => {\n    if (!instance.current) {\n      throw new Error(`[useBloc] Bloc instance is null for ${bloc.name}. This should never happen - bloc instance must be defined.`);\n    }\n\n    // Check cache first\n    let proxy = classProxyCache.current.get(instance.current);\n    if (!proxy) {\n      proxy = new Proxy(instance.current, {\n        get(target, prop) {\n          if (!target) {\n            throw new Error(`[useBloc] Bloc target is null for ${bloc.name}. This should never happen - bloc target must be defined.`);\n          }\n          const value = target[prop as keyof InstanceType<B>];\n          if (typeof value !== 'function') {\n            usedClassPropKeys.current.add(prop as string);\n          }\n          return value;\n        },\n      });\n      classProxyCache.current.set(instance.current, proxy);\n    }\n    return proxy;\n  }, [instance.current?.uid]);\n\n  // Create a stable reference object for this component\n  const componentRef = useRef({});\n\n  // Set up bloc lifecycle management\n  useEffect(() => {\n    const currentInstance = instance.current;\n    if (!currentInstance) return;\n    \n    // Pass component reference for proper memory management\n    currentInstance._addConsumer(rid, componentRef.current);\n\n    // Call onMount callback if provided\n    options?.onMount?.(currentInstance);\n\n    // Cleanup: remove this component as a consumer using the captured instance\n    return () => {\n      if (!currentInstance) {\n        return;\n      }\n      options?.onUnmount?.(currentInstance);\n      currentInstance._removeConsumer(rid);\n    };\n  }, [instance.current?.uid, rid]); // Use UID to ensure we re-run when instance changes\n\n  // Ensure state and instance are never undefined/null\n  if (returnState === undefined) {\n    throw new Error(`[useBloc] State is undefined for ${bloc.name}. This should never happen - state must be defined.`);\n  }\n  if (!returnClass) {\n    throw new Error(`[useBloc] Instance is null for ${bloc.name}. This should never happen - instance must be defined.`);\n  }\n\n  // Safe return with proper typing\n  return [returnState, returnClass] as [BlocState<InstanceType<B>>, InstanceType<B>];\n}\n"],"names":["useExternalBlocStore","bloc","options","blocId","props","selector","rid","useMemo","generateUUID","effectiveBlocId","usedKeys","useRef","usedClassPropKeys","getBloc","useCallback","Blac","blocInstance","dependencyArray","newState","instance","usedStateValues","key","usedClassValues","value","error","state","listener","currentInstance","observer","e","unSub","_a","useBloc","externalStore","useSyncExternalStore","snapshot","serverSnapshot","stateProxyCache","classProxyCache","returnState","proxy","target","prop","returnClass","componentRef","useEffect","_b"],"mappings":"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"}
+{"version":3,"file":"index.es.js","sources":["../src/useBloc.ts","../src/useExternalBlocStore.ts"],"sourcesContent":["import {\n  AdapterOptions,\n  BlacAdapter,\n  BlocBase,\n  BlocConstructor,\n  BlocState,\n} from '@blac/core';\nimport { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';\n\n/**\n * Type definition for the return type of the useBloc hook\n */\ntype HookTypes<B extends BlocConstructor<BlocBase<any>>> = [\n  BlocState<InstanceType<B>>,\n  InstanceType<B>,\n];\n\n/**\n * React hook for integrating with Blac state management\n */\nfunction useBloc<B extends BlocConstructor<BlocBase<any>>>(\n  blocConstructor: B,\n  options?: AdapterOptions<InstanceType<B>>,\n): HookTypes<B> {\n  // Create a unique identifier for this hook instance\n  const renderCount = useRef(0);\n  renderCount.current++;\n\n  const componentRef = useRef<object>({});\n\n  // Track adapter creation\n  const adapter = useMemo(() => {\n    const newAdapter = new BlacAdapter<B>(\n      {\n        componentRef: componentRef,\n        blocConstructor,\n      },\n      options,\n    );\n    return newAdapter;\n  }, []);\n\n  // Reset tracking at the start of each render to ensure we only track\n  // properties accessed during the current render\n  adapter.resetConsumerTracking();\n\n  // Track options changes\n  const optionsChangeCount = useRef(0);\n  useEffect(() => {\n    optionsChangeCount.current++;\n    adapter.options = options;\n  }, [options]);\n\n  // Register as consumer and handle lifecycle\n  const mountEffectCount = useRef(0);\n  useEffect(() => {\n    mountEffectCount.current++;\n    adapter.mount();\n\n    return () => {\n      adapter.unmount();\n    };\n  }, [adapter.blocInstance]);\n\n  // Subscribe to state changes using useSyncExternalStore\n  const subscribeMemoCount = useRef(0);\n  const subscribe = useMemo(() => {\n    subscribeMemoCount.current++;\n    let subscriptionCount = 0;\n\n    return (onStoreChange: () => void) => {\n      subscriptionCount++;\n      const unsubscribe = adapter.createSubscription({\n        onChange: () => {\n          onStoreChange();\n        },\n      });\n\n      return () => {\n        unsubscribe();\n      };\n    };\n  }, [adapter.blocInstance]);\n\n  const snapshotCount = useRef(0);\n  const serverSnapshotCount = useRef(0);\n\n  const rawState: BlocState<InstanceType<B>> = useSyncExternalStore(\n    subscribe,\n    // Get snapshot\n    () => {\n      snapshotCount.current++;\n      const bloc = adapter.blocInstance;\n      const state = bloc.state;\n      return state;\n    },\n    // Get server snapshot (same as client for now)\n    () => {\n      const bloc = adapter.blocInstance;\n      serverSnapshotCount.current++;\n      const state = bloc.state;\n      return state;\n    },\n  );\n\n  // Create proxies for fine-grained tracking (if enabled)\n  const stateMemoCount = useRef(0);\n  const finalState = useMemo(() => {\n    stateMemoCount.current++;\n    const proxyState = adapter.getProxyState(rawState);\n    return proxyState;\n  }, [rawState]);\n\n  const blocMemoCount = useRef(0);\n  const finalBloc = useMemo(() => {\n    blocMemoCount.current++;\n    const proxyBloc = adapter.getProxyBlocInstance();\n    return proxyBloc;\n  }, [adapter.blocInstance]);\n\n  // Mark consumer as rendered after each render\n  useEffect(() => {\n    adapter.updateLastNotified(componentRef.current);\n  });\n\n  // Log final hook return\n  return [finalState, finalBloc];\n}\n\nexport default useBloc;\n","import {\n  Blac,\n  BlocBase,\n  BlocConstructor,\n  BlocState,\n  InferPropsFromGeneric,\n  generateUUID,\n} from '@blac/core';\nimport { useCallback, useMemo, useRef } from 'react';\n\ninterface ExternalStoreOptions<B extends BlocBase<any>> {\n  id?: string;\n  props?: InferPropsFromGeneric<B>;\n  selector?: (\n    currentState: BlocState<B>,\n    previousState: BlocState<B>,\n    instance: B,\n  ) => any[];\n}\n\ninterface ExternalStore<T> {\n  getSnapshot: () => T | undefined;\n  subscribe: (listener: () => void) => () => void;\n  getServerSnapshot?: () => T | undefined;\n}\n\ninterface ExternalBlocStoreResult<B extends BlocBase<any>> {\n  externalStore: ExternalStore<BlocState<B>>;\n  instance: { current: B | null };\n  usedKeys: { current: Set<string> };\n  usedClassPropKeys: { current: Set<string> };\n  rid: string;\n}\n\n/**\n * Hook for using an external bloc store\n * Provides low-level access to bloc instances for use with React's useSyncExternalStore\n */\nexport default function useExternalBlocStore<\n  B extends BlocConstructor<BlocBase<any>>,\n>(\n  blocConstructor: B,\n  options: ExternalStoreOptions<InstanceType<B>> = {},\n): ExternalBlocStoreResult<InstanceType<B>> {\n  const ridRef = useRef<string>(`external-${generateUUID()}`);\n  const usedKeysRef = useRef<Set<string>>(new Set());\n  const usedClassPropKeysRef = useRef<Set<string>>(new Set());\n  const instanceRef = useRef<InstanceType<B> | null>(null);\n\n  // Get or create bloc instance\n  const bloc = useMemo(() => {\n    const blac = Blac.getInstance();\n    const base = blocConstructor as unknown as BlocBase<any>;\n\n    // For isolated blocs, always create a new instance\n    if (\n      (base.constructor as any).isolated ||\n      (blocConstructor as any).isolated\n    ) {\n      const newBloc = new blocConstructor(options?.props) as InstanceType<B>;\n      const uniqueId =\n        options?.id || `${blocConstructor.name}_${generateUUID()}`;\n      newBloc._updateId(uniqueId);\n      blac.activateBloc(newBloc);\n      return newBloc;\n    }\n\n    // For shared blocs, use the existing getBloc logic\n    return blac.getBloc(blocConstructor, {\n      id: options?.id,\n      props: options?.props,\n    });\n  }, [blocConstructor, options?.id]);\n\n  // Create external store interface\n  const externalStore = useMemo<ExternalStore<BlocState<InstanceType<B>>>>(\n    () => ({\n      getSnapshot: () => {\n        const currentInstance = instanceRef.current;\n        return currentInstance ? currentInstance.state : undefined;\n      },\n      subscribe: (listener: () => void) => {\n        const currentInstance = instanceRef.current;\n        if (!currentInstance) {\n          // Return no-op unsubscribe if no instance\n          return () => {};\n        }\n\n        // Wrap listener to handle errors gracefully\n        const safeListener = (\n          newState: BlocState<InstanceType<B>>,\n          oldState: BlocState<InstanceType<B>>,\n        ) => {\n          try {\n            // Reset tracking keys on each listener call\n            usedKeysRef.current.clear();\n            usedClassPropKeysRef.current.clear();\n\n            // Call selector if provided\n            if (options.selector && currentInstance) {\n              options.selector(newState, oldState, currentInstance);\n            }\n\n            // Call listener with state if it expects it\n            if (listener.length > 0) {\n              (listener as any)(newState);\n            } else {\n              listener();\n            }\n          } catch (error) {\n            console.error('Listener error in useExternalBlocStore:', error);\n            // Don't rethrow to prevent breaking other listeners\n          }\n        };\n\n        const unsubscribe = currentInstance._observer.subscribe({\n          id: ridRef.current,\n          fn: safeListener,\n        });\n        return unsubscribe;\n      },\n      getServerSnapshot: () => {\n        const currentInstance = instanceRef.current;\n        return currentInstance ? currentInstance.state : undefined;\n      },\n    }),\n    [],\n  );\n\n  // Update instance ref\n  instanceRef.current = bloc;\n\n  return {\n    externalStore,\n    instance: instanceRef,\n    usedKeys: usedKeysRef,\n    usedClassPropKeys: usedClassPropKeysRef,\n    rid: ridRef.current,\n  };\n}\n"],"names":["useBloc","blocConstructor","options","renderCount","useRef","componentRef","adapter","useMemo","BlacAdapter","optionsChangeCount","useEffect","mountEffectCount","subscribeMemoCount","subscribe","onStoreChange","unsubscribe","snapshotCount","serverSnapshotCount","rawState","useSyncExternalStore","bloc","stateMemoCount","finalState","blocMemoCount","finalBloc","useExternalBlocStore","ridRef","generateUUID","usedKeysRef","usedClassPropKeysRef","instanceRef","blac","Blac","newBloc","uniqueId","externalStore","currentInstance","listener","safeListener","newState","oldState","error"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blac/react",
-  "version": "2.0.0-rc-7",
+  "version": "2.0.0-rc-10",
   "license": "MIT",
   "author": "Brendan Mullins <jsnanigans@gmail.com>",
   "main": "dist/index.cjs.js",
@@ -30,7 +30,7 @@
     "@types/react-dom": "^18.0.0 || ^19.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@blac/core": "2.0.0-rc-7"
+    "@blac/core": "2.0.0-rc-10"
   },
   "peerDependenciesMeta": {
     "@types/react": {
@@ -41,17 +41,17 @@
     }
   },
   "devDependencies": {
-    "@testing-library/dom": "^10.4.0",
+    "@testing-library/dom": "^10.4.1",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
-    "@types/react": "^19.1.4",
-    "@vitejs/plugin-react": "^4.4.1",
-    "@vitest/browser": "^3.1.3",
-    "@vitest/coverage-v8": "^3.1.3",
-    "happy-dom": "^17.4.7",
+    "@types/react": "^19.1.8",
+    "@vitejs/plugin-react": "^4.7.0",
+    "@vitest/browser": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
+    "happy-dom": "^18.0.1",
     "jsdom": "^24.1.1",
-    "prettier": "^3.5.3",
+    "prettier": "^3.6.2",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "typescript": "^5.8.3",
@@ -61,6 +61,7 @@
   },
   "scripts": {
     "prettier": "prettier --write ./src",
+    "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx}\"",
     "test": "vitest run --config vitest.config.ts",
     "test:watch": "vitest --watch --config vitest.config.ts",
     "typecheck": "tsc --noEmit",

package/src/__tests__/useBloc.tracking.test.tsx

@@ -0,0 +1,198 @@
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { Cubit } from '@blac/core';
+import useBloc from '../useBloc';
+
+interface TestState {
+  count: number;
+  name: string;
+  unused: string;
+}
+
+class TestCubit extends Cubit<TestState> {
+  constructor() {
+    super({ count: 0, name: 'Alice', unused: 'not-used' });
+  }
+
+  increment = () => {
+    this.emit({ ...this.state, count: this.state.count + 1 });
+  };
+
+  changeName = (name: string) => {
+    this.emit({ ...this.state, name });
+  };
+
+  changeUnused = (value: string) => {
+    this.emit({ ...this.state, unused: value });
+  };
+}
+
+describe('useBloc dependency tracking', () => {
+  it('should only track properties accessed during current render', () => {
+    let renderCount = 0;
+    let accessedProperties: string[] = [];
+
+    const { result, rerender } = renderHook(() => {
+      const [state, cubit] = useBloc(TestCubit);
+      renderCount++;
+
+      // Reset tracked properties for this render
+      accessedProperties = [];
+
+      // First few renders: access both count and name
+      if (renderCount <= 2) {
+        // Access count and name
+        void state.count;
+        void state.name;
+        accessedProperties = ['count', 'name'];
+      } else {
+        // Later renders: only access count
+        void state.count;
+        accessedProperties = ['count'];
+      }
+
+      return { state, cubit, accessedProperties };
+    });
+
+    // Initial render - accessing count and name
+    expect(renderCount).toBe(1);
+    expect(result.current.accessedProperties).toEqual(['count', 'name']);
+
+    // Change name - should trigger re-render since we're tracking it
+    act(() => {
+      result.current.cubit.changeName('Bob');
+    });
+    expect(renderCount).toBe(2);
+    expect(result.current.state.name).toBe('Bob');
+
+    // Force a re-render (this will be render #3, where we stop accessing name)
+    rerender();
+    expect(renderCount).toBe(3);
+    expect(result.current.accessedProperties).toEqual(['count']); // Only accessing count now
+
+    // Change name again - should NOT trigger re-render since we're no longer tracking it
+    const prevRenderCount = renderCount;
+    act(() => {
+      result.current.cubit.changeName('Charlie');
+    });
+
+    // Render count should not increase
+    expect(renderCount).toBe(prevRenderCount);
+    // But state should still be updated if we check it
+    expect(result.current.cubit.state.name).toBe('Charlie');
+
+    // Change count - should trigger re-render since we're still tracking it
+    act(() => {
+      result.current.cubit.increment();
+    });
+    expect(renderCount).toBe(prevRenderCount + 1);
+    expect(result.current.state.count).toBe(1);
+  });
+
+  it('should not re-render when non-accessed properties change', () => {
+    let renderCount = 0;
+
+    const { result } = renderHook(() => {
+      const [state, cubit] = useBloc(TestCubit);
+      renderCount++;
+
+      // Only access count, never access unused
+      void state.count;
+
+      return { state, cubit };
+    });
+
+    expect(renderCount).toBe(1);
+
+    // Change unused property - should NOT trigger re-render
+    act(() => {
+      result.current.cubit.changeUnused('changed');
+    });
+
+    // Should not re-render
+    expect(renderCount).toBe(1);
+
+    // But the actual state should be updated
+    expect(result.current.cubit.state.unused).toBe('changed');
+  });
+
+  it('should track nested property access correctly', () => {
+    interface NestedState {
+      user: {
+        profile: {
+          name: string;
+          age: number;
+        };
+      };
+      settings: {
+        theme: string;
+      };
+    }
+
+    class NestedCubit extends Cubit<NestedState> {
+      constructor() {
+        super({
+          user: {
+            profile: {
+              name: 'Alice',
+              age: 25,
+            },
+          },
+          settings: {
+            theme: 'light',
+          },
+        });
+      }
+
+      updateName = (name: string) => {
+        this.emit({
+          ...this.state,
+          user: {
+            ...this.state.user,
+            profile: {
+              ...this.state.user.profile,
+              name,
+            },
+          },
+        });
+      };
+
+      updateTheme = (theme: string) => {
+        this.emit({
+          ...this.state,
+          settings: {
+            ...this.state.settings,
+            theme,
+          },
+        });
+      };
+    }
+
+    let renderCount = 0;
+
+    const { result } = renderHook(() => {
+      const [state, cubit] = useBloc(NestedCubit);
+      renderCount++;
+
+      // Only access user.profile.name
+      void state.user.profile.name;
+
+      return { state, cubit };
+    });
+
+    expect(renderCount).toBe(1);
+
+    // Change theme - should NOT trigger re-render
+    act(() => {
+      result.current.cubit.updateTheme('dark');
+    });
+    expect(renderCount).toBe(1);
+
+    // Change name - should trigger re-render
+    act(() => {
+      result.current.cubit.updateName('Bob');
+    });
+    expect(renderCount).toBe(2);
+    expect(result.current.state.user.profile.name).toBe('Bob');
+  });
+});

package/src/index.ts

@@ -1,4 +1,2 @@
-import useBloc from './useBloc';
-import useExternalBlocStore from './useExternalBlocStore';
-
-export { useExternalBlocStore as externalBlocStore, useBloc };
+export { default as useBloc } from './useBloc';
+export { default as useExternalBlocStore } from './useExternalBlocStore';

package/src/useBloc.ts

@@ -0,0 +1,130 @@
+import {
+  AdapterOptions,
+  BlacAdapter,
+  BlocBase,
+  BlocConstructor,
+  BlocState,
+} from '@blac/core';
+import { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+
+/**
+ * Type definition for the return type of the useBloc hook
+ */
+type HookTypes<B extends BlocConstructor<BlocBase<any>>> = [
+  BlocState<InstanceType<B>>,
+  InstanceType<B>,
+];
+
+/**
+ * React hook for integrating with Blac state management
+ */
+function useBloc<B extends BlocConstructor<BlocBase<any>>>(
+  blocConstructor: B,
+  options?: AdapterOptions<InstanceType<B>>,
+): HookTypes<B> {
+  // Create a unique identifier for this hook instance
+  const renderCount = useRef(0);
+  renderCount.current++;
+
+  const componentRef = useRef<object>({});
+
+  // Track adapter creation
+  const adapter = useMemo(() => {
+    const newAdapter = new BlacAdapter<B>(
+      {
+        componentRef: componentRef,
+        blocConstructor,
+      },
+      options,
+    );
+    return newAdapter;
+  }, []);
+
+  // Reset tracking at the start of each render to ensure we only track
+  // properties accessed during the current render
+  adapter.resetConsumerTracking();
+
+  // Track options changes
+  const optionsChangeCount = useRef(0);
+  useEffect(() => {
+    optionsChangeCount.current++;
+    adapter.options = options;
+  }, [options]);
+
+  // Register as consumer and handle lifecycle
+  const mountEffectCount = useRef(0);
+  useEffect(() => {
+    mountEffectCount.current++;
+    adapter.mount();
+
+    return () => {
+      adapter.unmount();
+    };
+  }, [adapter.blocInstance]);
+
+  // Subscribe to state changes using useSyncExternalStore
+  const subscribeMemoCount = useRef(0);
+  const subscribe = useMemo(() => {
+    subscribeMemoCount.current++;
+    let subscriptionCount = 0;
+
+    return (onStoreChange: () => void) => {
+      subscriptionCount++;
+      const unsubscribe = adapter.createSubscription({
+        onChange: () => {
+          onStoreChange();
+        },
+      });
+
+      return () => {
+        unsubscribe();
+      };
+    };
+  }, [adapter.blocInstance]);
+
+  const snapshotCount = useRef(0);
+  const serverSnapshotCount = useRef(0);
+
+  const rawState: BlocState<InstanceType<B>> = useSyncExternalStore(
+    subscribe,
+    // Get snapshot
+    () => {
+      snapshotCount.current++;
+      const bloc = adapter.blocInstance;
+      const state = bloc.state;
+      return state;
+    },
+    // Get server snapshot (same as client for now)
+    () => {
+      const bloc = adapter.blocInstance;
+      serverSnapshotCount.current++;
+      const state = bloc.state;
+      return state;
+    },
+  );
+
+  // Create proxies for fine-grained tracking (if enabled)
+  const stateMemoCount = useRef(0);
+  const finalState = useMemo(() => {
+    stateMemoCount.current++;
+    const proxyState = adapter.getProxyState(rawState);
+    return proxyState;
+  }, [rawState]);
+
+  const blocMemoCount = useRef(0);
+  const finalBloc = useMemo(() => {
+    blocMemoCount.current++;
+    const proxyBloc = adapter.getProxyBlocInstance();
+    return proxyBloc;
+  }, [adapter.blocInstance]);
+
+  // Mark consumer as rendered after each render
+  useEffect(() => {
+    adapter.updateLastNotified(componentRef.current);
+  });
+
+  // Log final hook return
+  return [finalState, finalBloc];
+}
+
+export default useBloc;