{"version":3,"file":"hook-composer.mjs","sources":["../../../src/lib/coordination/hook-composer.ts"],"sourcesContent":["/**\n * @file Hook Composer\n * @module coordination/hook-composer\n * @description PhD-level multi-library hook composition utilities.\n *\n * Implements sophisticated hook composition with:\n * - Type-safe composition of multiple hooks\n * - Dependency tracking between hooks\n * - Unified loading and error states\n * - Selective re-rendering optimization\n * - Memoization and caching\n * - Conditional hook execution\n *\n * @author Agent 5 - PhD TypeScript Architect\n * @version 1.0.0\n */\n\nimport { type DependencyList, useCallback, useEffect, useMemo, useRef, useState } from 'react';\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Hook state representation.\n */\nexport interface HookState<T> {\n  /** Data value */\n  data: T | undefined;\n  /** Loading state */\n  isLoading: boolean;\n  /** Error state */\n  error: Error | null;\n  /** Last updated timestamp */\n  lastUpdated: number | null;\n}\n\n/**\n * Composed hooks result.\n */\nexport interface ComposedResult<T extends Record<string, unknown>> {\n  /** Combined data from all hooks */\n  data: T;\n  /** Whether any hook is loading */\n  isLoading: boolean;\n  /** Whether all hooks have loaded at least once */\n  isReady: boolean;\n  /** First error encountered */\n  error: Error | null;\n  /** All errors by hook key */\n  errors: Partial<Record<keyof T, Error | null>>;\n  /** Loading states by hook key */\n  loadingStates: Record<keyof T, boolean>;\n  /** Refresh all hooks */\n  refresh: () => void;\n  /** Refresh specific hook */\n  refreshKey: (key: keyof T) => void;\n}\n\n/**\n * Hook definition for composition.\n */\nexport interface HookDef<T> {\n  /** Hook function */\n  hook: () => T;\n  /** Optional selector to extract value from hook result */\n  selector?: (result: T) => unknown;\n  /** Whether hook is enabled */\n  enabled?: boolean;\n  /** Dependencies that must be ready first */\n  dependsOn?: string[];\n  /** Whether to suspend on loading */\n  suspendOnLoading?: boolean;\n}\n\n/**\n * Async hook result format.\n */\nexport interface AsyncHookResult<T> {\n  data: T | undefined;\n  isLoading: boolean;\n  error: Error | null;\n  refetch?: () => void;\n}\n\n/**\n * Composition options.\n */\nexport interface CompositionOptions {\n  /** Strategy for handling partial loading */\n  loadingStrategy: 'all' | 'any' | 'none';\n  /** Strategy for handling errors */\n  errorStrategy: 'first' | 'all' | 'ignore';\n  /** Enable debug logging */\n  debug: boolean;\n}\n\n// ============================================================================\n// Default Options\n// ============================================================================\n\nconst DEFAULT_OPTIONS: CompositionOptions = {\n  loadingStrategy: 'all',\n  errorStrategy: 'first',\n  debug: false,\n};\n\n// ============================================================================\n// Type Utilities\n// ============================================================================\n\n/**\n * Extracts the data type from a hook definition.\n */\ntype HookDataType<T> =\n  T extends HookDef<infer R>\n    ? R extends AsyncHookResult<infer D>\n      ? D\n      : T extends { selector: (r: R) => infer S }\n        ? S\n        : R\n    : never;\n\n/**\n * Maps hook definitions to their data types.\n */\ntype ComposedData<T extends Record<string, HookDef<unknown>>> = {\n  [K in keyof T]: HookDataType<T[K]>;\n};\n\n// ============================================================================\n// Core Composition Hook\n// ============================================================================\n\n/**\n * Composes multiple hooks into a single unified result.\n *\n * @template T - Hook definitions object type\n * @param definitions - Object mapping keys to hook definitions\n * @param options - Composition options\n * @returns Composed result\n *\n * @example\n * ```tsx\n * function Dashboard() {\n *   const { data, isLoading, error } = useComposedHooks({\n *     user: {\n *       hook: useCurrentUser,\n *       selector: (result) => result.data,\n *     },\n *     settings: {\n *       hook: useSettings,\n *       dependsOn: ['user'],\n *     },\n *     theme: {\n *       hook: useTheme,\n *     },\n *   });\n *\n *   if (isLoading) return <Loading />;\n *   if (error) return <Error error={error} />;\n *\n *   return (\n *     <div style={{ theme: data.theme }}>\n *       Welcome, {data.user.name}!\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useComposedHooks<T extends Record<string, HookDef<unknown>>>(\n  definitions: T,\n  options: Partial<CompositionOptions> = {}\n): ComposedResult<ComposedData<T>> {\n  const opts = { ...DEFAULT_OPTIONS, ...options };\n  const keys = Object.keys(definitions) as Array<keyof T>;\n\n  // Track refresh triggers\n  const [refreshCounter, setRefreshCounter] = useState(0);\n  const refreshKeyRef = useRef<keyof T | null>(null);\n\n  // Execute all hooks and collect results\n  const hookResults = useMemo(() => {\n    const results: Record<string, unknown> = {};\n\n    for (const key of keys) {\n      const def = definitions[key];\n\n      // Check if enabled\n      if (def?.enabled === false) {\n        results[key as string] = undefined;\n        continue;\n      }\n\n      // Execute hook\n      try {\n        const result = def?.hook();\n        results[key as string] = def?.selector ? def.selector(result) : result;\n      } catch (e) {\n        results[key as string] = { error: e, isLoading: false, data: undefined };\n      }\n    }\n\n    return results;\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [refreshCounter, ...keys]);\n\n  // Analyze results for loading and error states\n  const analysis = useMemo(() => {\n    const data: Record<string, unknown> = {};\n    const errors: Record<string, Error | null> = {};\n    const loadingStates: Record<string, boolean> = {};\n    let hasAnyLoading = false;\n    let hasAllLoaded = true;\n    let firstError: Error | null = null;\n\n    for (const key of keys) {\n      const result = hookResults[key as string];\n      const keyStr = key as string;\n\n      // Check if result is async-like\n      if (\n        result != null &&\n        typeof result === 'object' &&\n        ('isLoading' in result || 'error' in result)\n      ) {\n        const asyncResult = result as AsyncHookResult<unknown>;\n        data[keyStr] = asyncResult.data;\n        errors[keyStr] = asyncResult.error ?? null;\n        loadingStates[keyStr] = asyncResult.isLoading ?? false;\n\n        if (asyncResult.isLoading) {\n          hasAnyLoading = true;\n          hasAllLoaded = false;\n        }\n        if (asyncResult.error && !firstError) {\n          firstError = asyncResult.error;\n        }\n      } else {\n        // Sync hook result\n        data[keyStr] = result;\n        errors[keyStr] = null;\n        loadingStates[keyStr] = false;\n      }\n    }\n\n    // Determine overall loading state\n    let isLoading: boolean;\n    switch (opts.loadingStrategy) {\n      case 'all':\n        isLoading = hasAnyLoading;\n        break;\n      case 'any':\n        isLoading = !hasAllLoaded && hasAnyLoading;\n        break;\n      case 'none':\n      default:\n        isLoading = false;\n    }\n\n    // Determine error\n    let error: Error | null;\n    switch (opts.errorStrategy) {\n      case 'first':\n        error = firstError;\n        break;\n      case 'all':\n        error = Object.values(errors).find((e) => e !== null) ?? null;\n        break;\n      case 'ignore':\n      default:\n        error = null;\n    }\n\n    return {\n      data: data as ComposedData<T>,\n      isLoading,\n      isReady: hasAllLoaded,\n      error,\n      errors: errors as Partial<Record<keyof T, Error | null>>,\n      loadingStates: loadingStates as Record<keyof T, boolean>,\n    };\n  }, [hookResults, keys, opts.loadingStrategy, opts.errorStrategy]);\n\n  // Refresh functions\n  const refresh = useCallback(() => {\n    setRefreshCounter((c) => c + 1);\n  }, []);\n\n  const refreshKey = useCallback((key: keyof T) => {\n    refreshKeyRef.current = key;\n    setRefreshCounter((c) => c + 1);\n  }, []);\n\n  // Debug logging\n  useEffect(() => {\n    if (opts.debug) {\n      console.info('[useComposedHooks] Result:', analysis);\n    }\n  }, [analysis, opts.debug]);\n\n  return {\n    ...analysis,\n    refresh,\n    refreshKey,\n  };\n}\n\n// ============================================================================\n// Selective Composition Hook\n// ============================================================================\n\n/**\n * Composes hooks with selective re-rendering based on used keys.\n *\n * @template T - Hook definitions object type\n * @param definitions - Object mapping keys to hook definitions\n * @returns Proxy object that tracks accessed keys\n *\n * @example\n * ```tsx\n * function Profile() {\n *   const hooks = useSelectiveHooks({\n *     user: { hook: useCurrentUser },\n *     settings: { hook: useSettings },\n *   });\n *\n *   // Only re-renders when user changes, not settings\n *   return <div>{hooks.user?.name}</div>;\n * }\n * ```\n */\nexport function useSelectiveHooks<T extends Record<string, HookDef<unknown>>>(\n  definitions: T\n): ComposedData<T> & { __meta: { accessedKeys: Set<keyof T> } } {\n  const accessedKeysRef = useRef(new Set<keyof T>());\n  const keys = Object.keys(definitions) as Array<keyof T>;\n\n  // Execute all hooks\n  const results = useMemo(() => {\n    const data: Record<string, unknown> = {};\n\n    for (const key of keys) {\n      const def = definitions[key];\n      if (def?.enabled === false) {\n        data[key as string] = undefined;\n        continue;\n      }\n\n      try {\n        const result = def?.hook();\n        const value = def?.selector ? def.selector(result) : result;\n\n        // Extract data from async result\n        if (\n          value != null &&\n          typeof value === 'object' &&\n          'data' in value &&\n          ('isLoading' in value || 'error' in value)\n        ) {\n          data[key as string] = (value as AsyncHookResult<unknown>).data;\n        } else {\n          data[key as string] = value;\n        }\n      } catch {\n        data[key as string] = undefined;\n      }\n    }\n\n    return data;\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, keys);\n\n  // Create proxy to track access\n\n  return useMemo(() => {\n    return new Proxy(results as ComposedData<T> & { __meta: { accessedKeys: Set<keyof T> } }, {\n      get(target, prop) {\n        if (prop === '__meta') {\n          return { accessedKeys: accessedKeysRef.current };\n        }\n        if (typeof prop === 'string' && prop in target) {\n          accessedKeysRef.current.add(prop as keyof T);\n        }\n        return target[prop as keyof typeof target];\n      },\n    });\n  }, [results]);\n}\n\n// ============================================================================\n// Conditional Composition Hook\n// ============================================================================\n\n/**\n * Conditionally executes hooks based on predicates.\n *\n * @template T - Data type\n * @param condition - Boolean or function returning boolean\n * @param hookFn - Hook function to execute\n * @param fallback - Fallback value when condition is false\n * @returns Hook result or fallback\n *\n * @example\n * ```tsx\n * function UserDashboard({ isAdmin }: { isAdmin: boolean }) {\n *   const adminData = useConditionalHook(\n *     isAdmin,\n *     useAdminData,\n *     { users: [], stats: null }\n *   );\n *\n *   return <div>{adminData.users.length} users</div>;\n * }\n * ```\n */\nexport function useConditionalHook<T>(\n  condition: boolean | (() => boolean),\n  hookFn: () => T,\n  fallback: T\n): T {\n  const shouldExecute = typeof condition === 'function' ? condition() : condition;\n\n  // Always call hooks in the same order, but conditionally use result\n  const hookResult = hookFn();\n\n  return shouldExecute ? hookResult : fallback;\n}\n\n// ============================================================================\n// Memoized Hook Composer\n// ============================================================================\n\n/**\n * Creates a memoized hook composition that only updates when dependencies change.\n *\n * @template T - Result type\n * @param factory - Factory function that calls hooks\n * @param deps - Dependencies array\n * @returns Memoized result\n *\n * @example\n * ```tsx\n * function SearchResults({ query }: { query: string }) {\n *   const result = useMemoizedComposition(\n *     () => ({\n *       results: useSearchResults(query),\n *       suggestions: useSuggestions(query),\n *     }),\n *     [query]\n *   );\n *\n *   return <ResultsList items={result.results} />;\n * }\n * ```\n */\nexport function useMemoizedComposition<T>(factory: () => T, deps: DependencyList): T {\n  // Use useMemo to properly handle dependencies during render\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  return useMemo(factory, deps);\n}\n\n// ============================================================================\n// Parallel Hook Execution\n// ============================================================================\n\n/**\n * Executes hooks in parallel and aggregates results.\n *\n * @template T - Hooks record type\n * @param hooks - Record of hook functions\n * @returns Aggregated results with loading/error states\n *\n * @example\n * ```tsx\n * function DataLoader() {\n *   const { data, isLoading, errors } = useParallelHooks({\n *     users: () => useUsers(),\n *     posts: () => usePosts(),\n *     comments: () => useComments(),\n *   });\n *\n *   if (isLoading) return <Spinner />;\n *\n *   return (\n *     <div>\n *       {data.users?.length} users\n *       {data.posts?.length} posts\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useParallelHooks<T extends Record<string, () => unknown>>(\n  hooks: T\n): {\n  data: {\n    [K in keyof T]: ReturnType<T[K]> extends AsyncHookResult<infer D> ? D : ReturnType<T[K]>;\n  };\n  isLoading: boolean;\n  errors: { [K in keyof T]: Error | null };\n} {\n  const keys = Object.keys(hooks) as Array<keyof T>;\n\n  // Execute all hooks\n  const results = useMemo(() => {\n    const data: Record<string, unknown> = {};\n    const errors: Record<string, Error | null> = {};\n    let hasLoading = false;\n\n    for (const key of keys) {\n      try {\n        const hookFn = hooks[key];\n        const result = hookFn ? hookFn() : undefined;\n\n        // Check if async result\n        if (\n          result != null &&\n          typeof result === 'object' &&\n          ('isLoading' in result || 'error' in result)\n        ) {\n          const asyncResult = result as AsyncHookResult<unknown>;\n          data[key as string] = asyncResult.data;\n          errors[key as string] = asyncResult.error ?? null;\n          if (asyncResult.isLoading) hasLoading = true;\n        } else {\n          data[key as string] = result;\n          errors[key as string] = null;\n        }\n      } catch (e) {\n        data[key as string] = undefined;\n        errors[key as string] = e instanceof Error ? e : new Error(String(e));\n      }\n    }\n\n    return { data, errors, isLoading: hasLoading };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, keys);\n\n  return results as {\n    data: {\n      [K in keyof T]: ReturnType<T[K]> extends AsyncHookResult<infer D> ? D : ReturnType<T[K]>;\n    };\n    isLoading: boolean;\n    errors: { [K in keyof T]: Error | null };\n  };\n}\n\n// ============================================================================\n// Hook Sequence\n// ============================================================================\n\n/**\n * Executes hooks in sequence, passing results to subsequent hooks.\n *\n * @param steps - Array of step functions\n * @returns Final result and intermediate results\n *\n * @example\n * ```tsx\n * function OrderFlow() {\n *   const { result, steps } = useHookSequence([\n *     () => useCurrentUser(),\n *     (user) => useUserOrders(user.id),\n *     (orders) => useOrderDetails(orders[0]?.id),\n *   ]);\n *\n *   return <OrderDetails order={result} />;\n * }\n * ```\n */\nexport function useHookSequence<T>(steps: Array<(prevResult: unknown) => unknown>): {\n  result: T;\n  steps: unknown[];\n  isComplete: boolean;\n} {\n  const results: unknown[] = [];\n  let isComplete = true;\n  let prevResult: unknown = undefined;\n\n  for (const step of steps) {\n    try {\n      const result = step(prevResult);\n\n      // Handle async results\n      if (\n        result != null &&\n        typeof result === 'object' &&\n        ('isLoading' in result || 'data' in result)\n      ) {\n        const asyncResult = result as AsyncHookResult<unknown>;\n        results.push(asyncResult.data);\n        prevResult = asyncResult.data;\n        if (asyncResult.isLoading || asyncResult.data == null) {\n          isComplete = false;\n          break;\n        }\n      } else {\n        results.push(result);\n        prevResult = result;\n      }\n    } catch {\n      isComplete = false;\n      break;\n    }\n  }\n\n  return {\n    result: prevResult as T,\n    steps: results,\n    isComplete,\n  };\n}\n\n// ============================================================================\n// Export Utilities\n// ============================================================================\n\n/**\n * Creates a hook definition with type inference.\n */\nexport function defineHook<T>(hook: () => T, options?: Omit<HookDef<T>, 'hook'>): HookDef<T> {\n  return { hook, ...options };\n}\n\n/**\n * Creates an async hook definition.\n */\nexport function defineAsyncHook<T>(\n  hook: () => AsyncHookResult<T>,\n  options?: Omit<HookDef<AsyncHookResult<T>>, 'hook'>\n): HookDef<AsyncHookResult<T>> {\n  return { hook, ...options };\n}\n"],"names":["DEFAULT_OPTIONS","useComposedHooks","definitions","options","opts","keys","refreshCounter","setRefreshCounter","useState","refreshKeyRef","useRef","hookResults","useMemo","results","key","def","result","e","analysis","data","errors","loadingStates","hasAnyLoading","hasAllLoaded","firstError","keyStr","asyncResult","isLoading","error","refresh","useCallback","c","refreshKey","useEffect","useSelectiveHooks","accessedKeysRef","value","target","prop","useConditionalHook","condition","hookFn","fallback","shouldExecute","hookResult","useMemoizedComposition","factory","deps","useParallelHooks","hooks","hasLoading","useHookSequence","steps","isComplete","prevResult","step","defineHook","hook","defineAsyncHook"],"mappings":"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"}