{"version":3,"file":"configurable-features.mjs","sources":["../../../../src/lib/flags/integration/configurable-features.tsx"],"sourcesContent":["/* eslint-disable react-refresh/only-export-components */\nimport React from 'react';\n/**\n * @fileoverview Configurable features system for dynamic feature management.\n *\n * This module provides a comprehensive feature registry that allows any feature\n * in the application to be made toggleable via feature flags. It supports\n * feature discovery, metadata, and runtime configuration.\n *\n * @module flags/integration/configurable-features\n *\n * @example\n * ```typescript\n * import {\n *   FeatureRegistry,\n *   defineFeature,\n *   useConfigurableFeature,\n * } from '@/lib/flags/integration/configurable-features';\n *\n * // Define a feature\n * const darkModeFeature = defineFeature({\n *   id: 'dark-mode',\n *   name: 'Dark Mode',\n *   description: 'Enable dark mode theme',\n *   category: 'ui',\n *   flagKey: 'dark-mode',\n *   defaultEnabled: false,\n * });\n *\n * // Use in component\n * function ThemeToggle() {\n *   const { isEnabled, toggle } = useConfigurableFeature('dark-mode');\n *   return <button onClick={toggle}>{isEnabled ? 'Light' : 'Dark'}</button>;\n * }\n * ```\n */\n\nimport {\n  createContext,\n  useContext,\n  useState,\n  useCallback,\n  useMemo,\n  useEffect,\n  type ReactNode,\n} from 'react';\n\n// =============================================================================\n// Types\n// =============================================================================\n\n/**\n * Feature category for organization\n */\nexport type FeatureCategory =\n  | 'api'\n  | 'routing'\n  | 'ui'\n  | 'performance'\n  | 'auth'\n  | 'monitoring'\n  | 'state'\n  | 'realtime'\n  | 'experimental'\n  | 'beta'\n  | 'deprecated'\n  | string;\n\n/**\n * Feature lifecycle stage\n */\nexport type FeatureStage =\n  | 'development'\n  | 'testing'\n  | 'beta'\n  | 'stable'\n  | 'deprecated'\n  | 'sunset';\n\n/**\n * Feature visibility level\n */\nexport type FeatureVisibility =\n  | 'public'\n  | 'internal'\n  | 'admin'\n  | 'superadmin';\n\n/**\n * Feature rollout configuration\n */\nexport interface FeatureRollout {\n  /** Rollout percentage (0-100) */\n  readonly percentage?: number;\n  /** Specific user IDs to include */\n  readonly includedUsers?: readonly string[];\n  /** Specific user IDs to exclude */\n  readonly excludedUsers?: readonly string[];\n  /** Regions to target */\n  readonly regions?: readonly string[];\n  /** User segments to target */\n  readonly segments?: readonly string[];\n  /** Start date for the rollout */\n  readonly startDate?: Date;\n  /** End date for the rollout */\n  readonly endDate?: Date;\n}\n\n/**\n * Feature dependency definition\n */\nexport interface FeatureDependency {\n  /** Dependent feature ID */\n  readonly featureId: string;\n  /** Dependency type */\n  readonly type: 'requires' | 'conflicts' | 'enhances';\n  /** Optional condition */\n  readonly condition?: (isEnabled: boolean) => boolean;\n}\n\n/**\n * Feature configuration override\n */\nexport interface FeatureOverride {\n  /** Override ID */\n  readonly id: string;\n  /** Target feature ID */\n  readonly featureId: string;\n  /** Override enabled state */\n  readonly enabled: boolean;\n  /** Override priority (higher wins) */\n  readonly priority: number;\n  /** Override reason */\n  readonly reason?: string;\n  /** Override expiration */\n  readonly expiresAt?: Date;\n}\n\n/**\n * Feature definition\n */\nexport interface FeatureDefinition {\n  /** Unique feature identifier */\n  readonly id: string;\n  /** Human-readable name */\n  readonly name: string;\n  /** Feature description */\n  readonly description: string;\n  /** Feature category */\n  readonly category: FeatureCategory;\n  /** Associated flag key */\n  readonly flagKey: string;\n  /** Default enabled state */\n  readonly defaultEnabled: boolean;\n  /** Feature lifecycle stage */\n  readonly stage?: FeatureStage;\n  /** Visibility level */\n  readonly visibility?: FeatureVisibility;\n  /** Feature tags for filtering */\n  readonly tags?: readonly string[];\n  /** Feature dependencies */\n  readonly dependencies?: readonly FeatureDependency[];\n  /** Rollout configuration */\n  readonly rollout?: FeatureRollout;\n  /** Documentation URL */\n  readonly docsUrl?: string;\n  /** Owner team/person */\n  readonly owner?: string;\n  /** Created date */\n  readonly createdAt?: Date;\n  /** Last modified date */\n  readonly modifiedAt?: Date;\n  /** Metadata for custom data */\n  readonly metadata?: Readonly<Record<string, unknown>>;\n}\n\n/**\n * Feature state at runtime\n */\nexport interface FeatureState {\n  /** Whether the feature is enabled */\n  readonly isEnabled: boolean;\n  /** Source of the enabled state */\n  readonly source: 'flag' | 'override' | 'default' | 'dependency';\n  /** Applied override if any */\n  readonly override?: FeatureOverride;\n  /** Unmet dependencies */\n  readonly unmetDependencies?: readonly string[];\n  /** Last evaluated timestamp */\n  readonly evaluatedAt: number;\n}\n\n/**\n * Feature with runtime state\n */\nexport interface ConfigurableFeature extends FeatureDefinition {\n  /** Current runtime state */\n  readonly state: FeatureState;\n}\n\n/**\n * Feature registry interface\n */\nexport interface FeatureRegistryInterface {\n  /** Register a feature definition */\n  register(feature: FeatureDefinition): void;\n  /** Unregister a feature */\n  unregister(featureId: string): void;\n  /** Get a feature by ID */\n  get(featureId: string): ConfigurableFeature | undefined;\n  /** Get all features */\n  getAll(): ConfigurableFeature[];\n  /** Get features by category */\n  getByCategory(category: FeatureCategory): ConfigurableFeature[];\n  /** Get features by tag */\n  getByTag(tag: string): ConfigurableFeature[];\n  /** Get features by stage */\n  getByStage(stage: FeatureStage): ConfigurableFeature[];\n  /** Check if feature is enabled */\n  isEnabled(featureId: string): boolean;\n  /** Add an override */\n  addOverride(override: FeatureOverride): void;\n  /** Remove an override */\n  removeOverride(overrideId: string): void;\n  /** Get all overrides */\n  getOverrides(): FeatureOverride[];\n  /** Update flags */\n  updateFlags(flags: Record<string, boolean>): void;\n  /** Subscribe to changes */\n  subscribe(callback: (features: ConfigurableFeature[]) => void): () => void;\n  /** Export feature configuration */\n  export(): FeatureExport;\n  /** Import feature configuration */\n  import(data: FeatureExport): void;\n  /** Clear registry */\n  clear(): void;\n}\n\n/**\n * Feature export format\n */\nexport interface FeatureExport {\n  readonly version: string;\n  readonly exportedAt: string;\n  readonly features: readonly FeatureDefinition[];\n  readonly overrides: readonly FeatureOverride[];\n}\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/**\n * Feature registry implementation\n */\nclass FeatureRegistryImpl implements FeatureRegistryInterface {\n  private features = new Map<string, FeatureDefinition>();\n  private overrides = new Map<string, FeatureOverride>();\n  private flags: Record<string, boolean> = {};\n  private subscribers = new Set<(features: ConfigurableFeature[]) => void>();\n\n  register(feature: FeatureDefinition): void {\n    this.features.set(feature.id, feature);\n    this.notifySubscribers();\n  }\n\n  unregister(featureId: string): void {\n    this.features.delete(featureId);\n    this.notifySubscribers();\n  }\n\n  get(featureId: string): ConfigurableFeature | undefined {\n    const feature = this.features.get(featureId);\n    return feature ? this.toConfigurableFeature(feature) : undefined;\n  }\n\n  getAll(): ConfigurableFeature[] {\n    return Array.from(this.features.values()).map((f) => this.toConfigurableFeature(f));\n  }\n\n  getByCategory(category: FeatureCategory): ConfigurableFeature[] {\n    return this.getAll().filter((f) => f.category === category);\n  }\n\n  getByTag(tag: string): ConfigurableFeature[] {\n    return this.getAll().filter((f) => f.tags?.includes(tag) === true);\n  }\n\n  getByStage(stage: FeatureStage): ConfigurableFeature[] {\n    return this.getAll().filter((f) => f.stage === stage);\n  }\n\n  isEnabled(featureId: string): boolean {\n    const feature = this.get(featureId);\n    return feature?.state.isEnabled ?? false;\n  }\n\n  addOverride(override: FeatureOverride): void {\n    this.overrides.set(override.id, override);\n    this.notifySubscribers();\n  }\n\n  removeOverride(overrideId: string): void {\n    this.overrides.delete(overrideId);\n    this.notifySubscribers();\n  }\n\n  getOverrides(): FeatureOverride[] {\n    return Array.from(this.overrides.values());\n  }\n\n  updateFlags(flags: Record<string, boolean>): void {\n    this.flags = { ...flags };\n    this.notifySubscribers();\n  }\n\n  subscribe(callback: (features: ConfigurableFeature[]) => void): () => void {\n    this.subscribers.add(callback);\n    return () => {\n      this.subscribers.delete(callback);\n    };\n  }\n\n  export(): FeatureExport {\n    return {\n      version: '1.0.0',\n      exportedAt: new Date().toISOString(),\n      features: Array.from(this.features.values()),\n      overrides: Array.from(this.overrides.values()),\n    };\n  }\n\n  import(data: FeatureExport): void {\n    for (const feature of data.features) {\n      this.features.set(feature.id, feature);\n    }\n    for (const override of data.overrides) {\n      this.overrides.set(override.id, override);\n    }\n    this.notifySubscribers();\n  }\n\n  clear(): void {\n    this.features.clear();\n    this.overrides.clear();\n    this.flags = {};\n    this.notifySubscribers();\n  }\n\n  private evaluateFeature(feature: FeatureDefinition): FeatureState {\n    // Check for active override\n    const activeOverrides = Array.from(this.overrides.values())\n      .filter((o) => o.featureId === feature.id)\n      .filter((o) => !o.expiresAt || o.expiresAt > new Date())\n      .sort((a, b) => b.priority - a.priority);\n\n    if (activeOverrides.length > 0 && activeOverrides[0]) {\n      return {\n        isEnabled: activeOverrides[0].enabled,\n        source: 'override',\n        override: activeOverrides[0],\n        evaluatedAt: Date.now(),\n      };\n    }\n\n    // Check dependencies\n    if (feature.dependencies) {\n      const unmetDependencies: string[] = [];\n\n      for (const dep of feature.dependencies) {\n        const depFeature = this.features.get(dep.featureId);\n        const depEnabled = depFeature ? this.isEnabled(dep.featureId) : false;\n\n        if (dep.type === 'requires' && !depEnabled) {\n          unmetDependencies.push(dep.featureId);\n        }\n\n        if (dep.type === 'conflicts' && depEnabled) {\n          return {\n            isEnabled: false,\n            source: 'dependency',\n            unmetDependencies: [dep.featureId],\n            evaluatedAt: Date.now(),\n          };\n        }\n      }\n\n      if (unmetDependencies.length > 0) {\n        return {\n          isEnabled: false,\n          source: 'dependency',\n          unmetDependencies,\n          evaluatedAt: Date.now(),\n        };\n      }\n    }\n\n    // Check flag\n    const flagValue = this.flags[feature.flagKey];\n    if (flagValue !== undefined) {\n      return {\n        isEnabled: flagValue,\n        source: 'flag',\n        evaluatedAt: Date.now(),\n      };\n    }\n\n    // Default value\n    return {\n      isEnabled: feature.defaultEnabled,\n      source: 'default',\n      evaluatedAt: Date.now(),\n    };\n  }\n\n  private toConfigurableFeature(feature: FeatureDefinition): ConfigurableFeature {\n    return {\n      ...feature,\n      state: this.evaluateFeature(feature),\n    };\n  }\n\n  private notifySubscribers(): void {\n    const allFeatures = this.getAll();\n    for (const callback of this.subscribers) {\n      try {\n        callback(allFeatures);\n      } catch (error) {\n        console.error('[FeatureRegistry] Subscriber error:', error);\n      }\n    }\n  }\n}\n\n/**\n * Global feature registry singleton\n */\nexport const featureRegistry = new FeatureRegistryImpl();\n\n/**\n * Get the global feature registry\n */\nexport function getFeatureRegistry(): FeatureRegistryInterface {\n  return featureRegistry;\n}\n\n// =============================================================================\n// Factory Functions\n// =============================================================================\n\n/**\n * Define a new feature\n */\nexport function defineFeature(\n  config: Omit<FeatureDefinition, 'createdAt' | 'modifiedAt'> & {\n    createdAt?: Date;\n    modifiedAt?: Date;\n  }\n): FeatureDefinition {\n  return {\n    ...config,\n    createdAt: config.createdAt ?? new Date(),\n    modifiedAt: config.modifiedAt ?? new Date(),\n  };\n}\n\n/**\n * Define and register a feature\n */\nexport function registerFeature(\n  config: Omit<FeatureDefinition, 'createdAt' | 'modifiedAt'>\n): FeatureDefinition {\n  const feature = defineFeature(config);\n  featureRegistry.register(feature);\n  return feature;\n}\n\n/**\n * Batch register features\n */\nexport function registerFeatures(\n  features: Omit<FeatureDefinition, 'createdAt' | 'modifiedAt'>[]\n): FeatureDefinition[] {\n  return features.map((f) => registerFeature(f));\n}\n\n/**\n * Create a feature override\n */\nexport function createOverride(\n  config: Omit<FeatureOverride, 'id'> & { id?: string }\n): FeatureOverride {\n  return {\n    id: config.id ?? `override-${Date.now()}-${Math.random().toString(36).slice(2)}`,\n    featureId: config.featureId,\n    enabled: config.enabled,\n    priority: config.priority,\n    reason: config.reason,\n    expiresAt: config.expiresAt,\n  };\n}\n\n// =============================================================================\n// React Integration\n// =============================================================================\n\n/**\n * Configurable features context value\n */\nexport interface ConfigurableFeaturesContextValue {\n  /** Get all features */\n  readonly features: ConfigurableFeature[];\n  /** Check if feature is enabled */\n  isEnabled(featureId: string): boolean;\n  /** Get feature by ID */\n  getFeature(featureId: string): ConfigurableFeature | undefined;\n  /** Get features by category */\n  getByCategory(category: FeatureCategory): ConfigurableFeature[];\n  /** Toggle a feature (adds override) */\n  toggle(featureId: string): void;\n  /** Set feature enabled state (adds override) */\n  setEnabled(featureId: string, enabled: boolean): void;\n  /** Clear feature override */\n  clearOverride(featureId: string): void;\n  /** Refresh features */\n  refresh(): void;\n}\n\n/**\n * Context for configurable features\n */\nconst ConfigurableFeaturesContext = createContext<ConfigurableFeaturesContextValue | null>(null);\n\n/**\n * Props for ConfigurableFeaturesProvider\n */\nexport interface ConfigurableFeaturesProviderProps {\n  readonly children: ReactNode;\n  /** Initial features to register */\n  readonly initialFeatures?: readonly FeatureDefinition[];\n  /** Flag getter function */\n  readonly getFlag?: (flagKey: string) => boolean;\n  /** Current flags */\n  readonly flags?: Record<string, boolean>;\n}\n\n/**\n * Provider component for configurable features\n */\nexport function ConfigurableFeaturesProvider({\n  children,\n  initialFeatures = [],\n  getFlag,\n  flags = {},\n}: ConfigurableFeaturesProviderProps): React.JSX.Element {\n  const [features, setFeatures] = useState<ConfigurableFeature[]>([]);\n\n  // Register initial features\n  useEffect(() => {\n    for (const feature of initialFeatures) {\n      featureRegistry.register(feature);\n    }\n\n    return () => {\n      for (const feature of initialFeatures) {\n        featureRegistry.unregister(feature.id);\n      }\n    };\n  }, [initialFeatures]);\n\n  // Update flags\n  useEffect(() => {\n    const allFlags = { ...flags };\n\n    if (getFlag) {\n      for (const feature of featureRegistry.getAll()) {\n        allFlags[feature.flagKey] = getFlag(feature.flagKey);\n      }\n    }\n\n    featureRegistry.updateFlags(allFlags);\n  }, [flags, getFlag]);\n\n  // Subscribe to changes\n  useEffect(() => {\n    const updateFeatures = (newFeatures: ConfigurableFeature[]): void => {\n      setTimeout(() => {\n        setFeatures(newFeatures);\n      }, 0);\n    };\n\n    // Initial load\n    setTimeout(() => {\n      setFeatures(featureRegistry.getAll());\n    }, 0);\n\n    // Subscribe\n    return featureRegistry.subscribe(updateFeatures);\n  }, []);\n\n  const isEnabled = useCallback((featureId: string): boolean => {\n    return featureRegistry.isEnabled(featureId);\n  }, []);\n\n  const getFeature = useCallback((featureId: string): ConfigurableFeature | undefined => {\n    return featureRegistry.get(featureId);\n  }, []);\n\n  const getByCategory = useCallback((category: FeatureCategory): ConfigurableFeature[] => {\n    return featureRegistry.getByCategory(category);\n  }, []);\n\n  const toggle = useCallback((featureId: string): void => {\n    const current = featureRegistry.isEnabled(featureId);\n    featureRegistry.addOverride(\n      createOverride({\n        featureId,\n        enabled: !current,\n        priority: 100,\n        reason: 'User toggle',\n      })\n    );\n  }, []);\n\n  const setEnabled = useCallback((featureId: string, enabled: boolean): void => {\n    featureRegistry.addOverride(\n      createOverride({\n        featureId,\n        enabled,\n        priority: 100,\n        reason: 'User override',\n      })\n    );\n  }, []);\n\n  const clearOverride = useCallback((featureId: string): void => {\n    const overrides = featureRegistry.getOverrides();\n    for (const override of overrides) {\n      if (override.featureId === featureId) {\n        featureRegistry.removeOverride(override.id);\n      }\n    }\n  }, []);\n\n  const refresh = useCallback((): void => {\n    setFeatures(featureRegistry.getAll());\n  }, []);\n\n  const contextValue = useMemo<ConfigurableFeaturesContextValue>(\n    () => ({\n      features,\n      isEnabled,\n      getFeature,\n      getByCategory,\n      toggle,\n      setEnabled,\n      clearOverride,\n      refresh,\n    }),\n    [features, isEnabled, getFeature, getByCategory, toggle, setEnabled, clearOverride, refresh]\n  );\n\n  return (\n    <ConfigurableFeaturesContext.Provider value={contextValue}>\n      {children}\n    </ConfigurableFeaturesContext.Provider>\n  );\n}\n\n/**\n * Hook to access configurable features context\n */\nexport function useConfigurableFeatures(): ConfigurableFeaturesContextValue {\n  const context = useContext(ConfigurableFeaturesContext);\n  if (!context) {\n    throw new Error(\n      'useConfigurableFeatures must be used within a ConfigurableFeaturesProvider'\n    );\n  }\n  return context;\n}\n\n/**\n * Hook to use a single configurable feature\n */\nexport function useConfigurableFeature(featureId: string): {\n  feature: ConfigurableFeature | undefined;\n  isEnabled: boolean;\n  toggle: () => void;\n  setEnabled: (enabled: boolean) => void;\n  clearOverride: () => void;\n} {\n  const context = useConfigurableFeatures();\n\n  const feature = useMemo(\n    () => context.features.find((f) => f.id === featureId),\n    [context.features, featureId]\n  );\n\n  return {\n    feature,\n    isEnabled: feature?.state.isEnabled ?? false,\n    toggle: () => context.toggle(featureId),\n    setEnabled: (enabled: boolean) => context.setEnabled(featureId, enabled),\n    clearOverride: () => context.clearOverride(featureId),\n  };\n}\n\n/**\n * Hook to get features by category\n */\nexport function useFeaturesByCategory(category: FeatureCategory): ConfigurableFeature[] {\n  const { features } = useConfigurableFeatures();\n  return useMemo(() => features.filter((f) => f.category === category), [features, category]);\n}\n\n/**\n * Hook to get feature counts by stage\n */\nexport function useFeatureStats(): {\n  total: number;\n  enabled: number;\n  disabled: number;\n  byStage: Record<FeatureStage, number>;\n  byCategory: Record<string, number>;\n} {\n  const { features } = useConfigurableFeatures();\n\n  return useMemo(() => {\n    const enabled = features.filter((f) => f.state.isEnabled).length;\n    const byStage: Record<FeatureStage, number> = {\n      development: 0,\n      testing: 0,\n      beta: 0,\n      stable: 0,\n      deprecated: 0,\n      sunset: 0,\n    };\n    const byCategory: Record<string, number> = {};\n\n    for (const feature of features) {\n      if (feature.stage) {\n        byStage[feature.stage]++;\n      }\n      byCategory[feature.category] = (byCategory[feature.category] ?? 0) + 1;\n    }\n\n    return {\n      total: features.length,\n      enabled,\n      disabled: features.length - enabled,\n      byStage,\n      byCategory,\n    };\n  }, [features]);\n}\n\n// =============================================================================\n// Utility Functions\n// =============================================================================\n\n/**\n * Create feature definitions from flag keys\n */\nexport function featuresFromFlagKeys(\n  flagKeys: Record<string, string>,\n  options: Partial<Omit<FeatureDefinition, 'id' | 'flagKey'>> = {}\n): FeatureDefinition[] {\n  return Object.entries(flagKeys).map(([key, flagKey]) => ({\n    id: key.toLowerCase().replace(/_/g, '-'),\n    name: key\n      .split('_')\n      .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())\n      .join(' '),\n    description: `Feature controlled by ${flagKey}`,\n    category: options.category ?? 'experimental',\n    flagKey,\n    defaultEnabled: options.defaultEnabled ?? false,\n    stage: options.stage ?? 'stable',\n    ...options,\n  }));\n}\n\n/**\n * Validate feature definitions\n */\nexport function validateFeatures(features: FeatureDefinition[]): {\n  valid: boolean;\n  errors: string[];\n} {\n  const errors: string[] = [];\n  const ids = new Set<string>();\n  const flagKeys = new Set<string>();\n\n  for (const feature of features) {\n    if (!feature.id) {\n      errors.push(`Feature missing ID`);\n    } else if (ids.has(feature.id)) {\n      errors.push(`Duplicate feature ID: ${feature.id}`);\n    } else {\n      ids.add(feature.id);\n    }\n\n    if (!feature.flagKey) {\n      errors.push(`Feature ${feature.id} missing flagKey`);\n    } else if (flagKeys.has(feature.flagKey)) {\n      errors.push(`Duplicate flag key: ${feature.flagKey}`);\n    } else {\n      flagKeys.add(feature.flagKey);\n    }\n\n    if (feature.dependencies) {\n      for (const dep of feature.dependencies) {\n        if (!features.some((f) => f.id === dep.featureId)) {\n          errors.push(`Feature ${feature.id} depends on unknown feature: ${dep.featureId}`);\n        }\n      }\n    }\n  }\n\n  return {\n    valid: errors.length === 0,\n    errors,\n  };\n}\n\n\n"],"names":["FeatureRegistryImpl","feature","featureId","f","category","tag","stage","override","overrideId","flags","callback","data","activeOverrides","o","a","b","unmetDependencies","dep","depEnabled","flagValue","allFeatures","error","featureRegistry","getFeatureRegistry","defineFeature","config","registerFeature","registerFeatures","features","createOverride","ConfigurableFeaturesContext","createContext","ConfigurableFeaturesProvider","children","initialFeatures","getFlag","setFeatures","useState","useEffect","allFlags","updateFeatures","newFeatures","isEnabled","useCallback","getFeature","getByCategory","toggle","current","setEnabled","enabled","clearOverride","overrides","refresh","contextValue","useMemo","useConfigurableFeatures","context","useContext","useConfigurableFeature","useFeaturesByCategory","useFeatureStats","byStage","byCategory","featuresFromFlagKeys","flagKeys","options","key","flagKey","w","validateFeatures","errors","ids"],"mappings":"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"}