@plyaz/core 1.2.0 → 1.3.0

package/dist/backend/featureFlags/feature-flag.service.d.ts

@@ -1,264 +0,0 @@
-/**
- * Feature Flag Service
- *
- * NestJS service for feature flag business logic.
- * Orchestrates between providers, repositories, and external systems.
- *
- * @fileoverview NestJS service for feature flags
- */
-import type { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
-import { type FeatureFlagValue, type FeatureFlagContext, type FeatureFlagEvaluation, type FeatureFlag, type FeatureFlagRule, type CreateFlagRequest, type ProviderHealthStatus } from '@plyaz/types';
-import type { FeatureFlagRepository } from './feature-flag.repository';
-import type { FeatureFlagKey } from '@domain/types';
-/**
- * Feature Flag Service
- *
- * **MAIN ORCHESTRATOR** - This service coordinates the entire feature flag system.
- *
- * **EXECUTION FLOW:**
- * 1. NestJS Module System → Instantiates this service
- * 2. **onModuleInit()** ← ENTRY POINT - Called automatically by NestJS
- * 3. initializeProvider() → Loads configuration and creates provider
- * 4. Provider.initialize() → Establishes database connection
- * 5. System ready to serve requests
- *
- * **RUNTIME FLOW:**
- * Client Request → Controller → **This Service** → Provider → Database/Cache
- *
- * @example Basic Usage in Controller
- * ```typescript
- * @Controller('features')
- * export class FeatureController {
- *   constructor(private readonly featureFlagService: FeatureFlagService) {}
- *
- *   @Get(':key')
- *   async getFeature(@Param('key') key: string) {
- *     // This calls the service which orchestrates the entire evaluation
- *     return this.featureFlagService.evaluateFlag(key);
- *   }
- * }
- * ```
- *
- * @example Advanced Usage with Context
- * ```typescript
- * // Evaluate flag with user context for targeting rules
- * const evaluation = await this.featureFlagService.evaluateFlag('PREMIUM_FEATURE', {
- *   userId: 'user123',
- *   userRole: 'premium',
- *   environment: 'production'
- * });
- *
- * if (evaluation.isEnabled) {
- *   // Execute premium feature logic
- * }
- * ```
- *
- * Provides business logic for feature flag operations.
- * Manages provider lifecycle, caching, and data persistence.
- */
-export declare class FeatureFlagService implements OnModuleInit, OnModuleDestroy {
-    private readonly featureFlagRepository;
-    [x: string]: unknown;
-    private readonly logger;
-    private provider;
-    constructor(featureFlagRepository: FeatureFlagRepository<FeatureFlagKey>);
-    /**
-     * **FIRST METHOD CALLED** - NestJS lifecycle hook for module initialization
-     *
-     * **EXECUTION ORDER:**
-     * 1. NestJS creates FeatureFlagModule
-     * 2. NestJS instantiates FeatureFlagService
-     * 3. **THIS METHOD CALLED AUTOMATICALLY** ← YOU ARE HERE
-     * 4. → initializeProvider() called
-     * 5. → Configuration loaded from .env.local
-     * 6. → Database provider created and initialized
-     * 7. → Database connection established
-     * 8. → Initial data loaded from database
-     * 9. System ready to serve requests
-     *
-     * @throws {Error} If provider initialization fails
-     *
-     * @example What happens during initialization:
-     * ```typescript
-     * // 1. Load config from environment
-     * const config = FeatureFlagConfigFactory.fromEnvironment();
-     *
-     * // 2. Create database provider
-     * this.provider = FeatureFlagProviderFactory.create(config, FEATURES);
-     *
-     * // 3. Initialize database connection
-     * await this.provider.initialize();
-     *
-     * // 4. Load flags and rules from database
-     * const { flags, rules } = await this.provider.fetchData();
-     * ```
-     */
-    onModuleInit(): Promise<void>;
-    /**
-     * Cleans up resources on module shutdown.
-     */
-    onModuleDestroy(): Promise<void>;
-    /**
-     * **SECOND METHOD CALLED** - Initializes the feature flag provider
-     *
-     * **EXECUTION FLOW:**
-     * 1. onModuleInit() called by NestJS
-     * 2. **THIS METHOD CALLED** ← YOU ARE HERE
-     * 3. → FeatureFlagConfigFactory.fromEnvironment() - Loads .env.local
-     * 4. → FeatureFlagProviderFactory.create() - Creates database provider
-     * 5. → provider.initialize() - Establishes database connection
-     *
-     * @private
-     * @throws {Error} If configuration is invalid or database connection fails
-     *
-     * @example Configuration Loading Process:
-     * ```typescript
-     * // Reads from .env.local:
-     * // SUPABASE_URL=https://your-project.supabase.co
-     * // FEATURE_FLAG_PROVIDER=database
-     * // FEATURE_FLAG_CACHE_ENABLED=true
-     *
-     * const config = {
-     *   provider: 'database',
-     *   isCacheEnabled: true,
-     *   databaseConfig: {
-     *     connectionString: 'https://your-project.supabase.co',
-     *     tableName: 'feature_flags'
-     *   }
-     * };
-     * ```
-     */
-    private initializeProvider;
-    /**
-     * Gets the current provider instance.
-     */
-    private getProvider;
-    /**
-     * **MAIN RUNTIME METHOD** - Evaluates a feature flag for the given context
-     *
-     * **RUNTIME EXECUTION FLOW:**
-     * 1. Client makes HTTP request to controller
-     * 2. Controller calls **THIS METHOD** ← RUNTIME ENTRY POINT
-     * 3. → getProvider() - Gets initialized provider
-     * 4. → provider.getFlag() - Evaluates flag with context
-     * 5. → Provider checks cache, rules, overrides
-     * 6. → Database query if needed
-     * 7. ← Returns evaluation result
-     *
-     * @param key - Feature flag key (e.g., 'PREMIUM_FEATURE', 'NEW_UI')
-     * @param context - Evaluation context for targeting rules
-     * @returns Feature flag evaluation result with value, reason, and metadata
-     *
-     * @example Simple Usage:
-     * ```typescript
-     * const evaluation = await this.featureFlagService.evaluateFlag('NEW_CHECKOUT');
-     * console.log(evaluation.isEnabled); // true/false
-     * console.log(evaluation.reason);    // 'default_value' | 'rule_match' | 'override'
-     * ```
-     *
-     * @example With User Context (for targeting rules):
-     * ```typescript
-     * const evaluation = await this.featureFlagService.evaluateFlag('BETA_FEATURE', {
-     *   userId: 'user123',
-     *   userRole: 'premium',
-     *   environment: 'production',
-     *   customAttributes: {
-     *     subscriptionTier: 'pro',
-     *     region: 'us-east'
-     *   }
-     * });
-     *
-     * // Provider will:
-     * // 1. Check for user-specific overrides
-     * // 2. Evaluate targeting rules against context
-     * // 3. Return appropriate value with reason
-     * ```
-     *
-     * @example Evaluation Result:
-     * ```typescript
-     * {
-     *   key: 'BETA_FEATURE',
-     *   isEnabled: true,
-     *   value: { enabled: true, variant: 'blue' },
-     *   reason: 'rule_match',
-     *   ruleId: 'premium-users-rule',
-     *   evaluatedAt: '2024-01-15T10:30:00Z'
-     * }
-     * ```
-     */
-    evaluateFlag(key: FeatureFlagKey, context?: FeatureFlagContext): Promise<FeatureFlagEvaluation<FeatureFlagKey>>;
-    /**
-     * Checks if a feature flag is enabled.
-     *
-     * @param key - Feature flag key
-     * @param context - Evaluation context
-     * @returns Boolean indicating if flag is enabled
-     */
-    isEnabled(key: FeatureFlagKey, context?: FeatureFlagContext): Promise<boolean>;
-    /**
-     * Gets all feature flags with their evaluations.
-     *
-     * @param context - Evaluation context
-     * @returns All feature flag evaluations
-     */
-    getAllFlags(context?: FeatureFlagContext): Promise<Record<string, FeatureFlagEvaluation<FeatureFlagKey>>>;
-    /**
-     * Creates a new feature flag.
-     *
-     * @param createData - Flag creation data
-     * @returns Created feature flag
-     */
-    createFlag(createData: CreateFlagRequest<FeatureFlagKey>): Promise<FeatureFlag<FeatureFlagKey>>;
-    /**
-     * Updates an existing feature flag.
-     *
-     * @param key - Feature flag key
-     * @param updateData - Flag update data
-     * @returns Updated feature flag
-     */
-    updateFlag(key: FeatureFlagKey, updateData: Partial<CreateFlagRequest<FeatureFlagKey>>): Promise<FeatureFlag<FeatureFlagKey>>;
-    /**
-     * Deletes a feature flag.
-     *
-     * @param key - Feature flag key
-     */
-    deleteFlag(key: FeatureFlagKey): Promise<void>;
-    /**
-     * Sets a manual override for a flag.
-     *
-     * @param key - Feature flag key
-     * @param value - Override value
-     */
-    setOverride(key: FeatureFlagKey, value: FeatureFlagValue): Promise<void>;
-    /**
-     * Removes a manual override for a flag.
-     *
-     * @param key - Feature flag key
-     */
-    removeOverride(key: FeatureFlagKey): Promise<void>;
-    /**
-     * Gets all available feature flags.
-     *
-     * @param environment - Filter by environment
-     * @returns List of feature flags
-     */
-    getAllFeatureFlags(environment?: string): Promise<FeatureFlag<FeatureFlagKey>[]>;
-    /**
-     * Gets all rules for a specific flag.
-     *
-     * @param key - Feature flag key
-     * @returns List of rules for the flag
-     */
-    getFlagRules(key: FeatureFlagKey): Promise<FeatureFlagRule<FeatureFlagKey>[]>;
-    /**
-     * Forces a refresh of the feature flag cache.
-     */
-    refreshCache(): Promise<void>;
-    /**
-     * Gets provider health status.
-     *
-     * @returns Provider health information
-     */
-    getHealthStatus(): Promise<ProviderHealthStatus>;
-}
-//# sourceMappingURL=feature-flag.service.d.ts.map

package/dist/backend/featureFlags/feature-flag.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature-flag.service.d.ts","sourceRoot":"","sources":["../../../src/backend/featureFlags/feature-flag.service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEpE,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,WAAW,EAChB,KAAK,eAAe,EAEpB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAI1B,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAKpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,qBACa,kBAAmB,YAAW,YAAY,EAAE,eAAe;IAK1D,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IAJlD,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAuC;gBAE1B,qBAAqB,EAAE,qBAAqB,CAAC,cAAc,CAAC;IAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAUnC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;YACW,kBAAkB;IAkBhC;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACG,YAAY,CAChB,GAAG,EAAE,cAAc,EACnB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;IAmBjD;;;;;;OAMG;IACG,SAAS,CAAC,GAAG,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAKpF;;;;;OAKG;IACG,WAAW,CACf,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC,CAAC;IAiBjE;;;;;OAKG;IACG,UAAU,CACd,UAAU,EAAE,iBAAiB,CAAC,cAAc,CAAC,GAC5C,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAevC;;;;;;OAMG;IACG,UAAU,CACd,GAAG,EAAE,cAAc,EACnB,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,GACrD,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAevC;;;;OAIG;IACG,UAAU,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAcpD;;;;;OAKG;IACG,WAAW,CAAC,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9E;;;;OAIG;IACG,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAYxD;;;;;OAKG;IACG,kBAAkB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC;IAStF;;;;;OAKG;IACG,YAAY,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE,CAAC;IASnF;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAYnC;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,oBAAoB,CAAC;CAOvD"}

package/dist/frontend/featureFlags/hooks/useFeatureFlag.d.ts

@@ -1,103 +0,0 @@
-/**
- * useFeatureFlag Hook
- *
- * React hook for accessing individual feature flags with caching and real-time updates.
- * This will be moved to @plyaz/core when the package structure is finalized.
- *
- * @fileoverview React hook for feature flag access
- * @version 1.0.0
- */
-import type { FeatureFlagValue, FeatureFlagHook, UseFeatureFlagOptions } from '@plyaz/types';
-/**
- * React hook for accessing a single feature flag.
- * Provides real-time updates and automatic caching.
- *
- * @template T - Expected type of the flag value
- * @param key - Feature flag key to evaluate
- * @param options - Hook configuration options
- * @returns Feature flag hook state
- *
- * @example
- * ```typescript
- * // Basic usage
- * const { value: isEnabled, isLoading, error } = useFeatureFlag<FeatureFlagKey>('AUTH_GOOGLE');
- *
- * // With context and type safety
- * const { value, isLoading, refresh } = useFeatureFlag<FeatureFlagKey, number>(
- *   'ROLLOUT_PERCENTAGE',
- *   {
- *     context: { userId: 'user123', environment: 'production' },
- *     defaultValue: 0
- *   }
- * );
- *
- * // With auto-refresh disabled
- * const { value, refresh } = useFeatureFlag<FeatureFlagKey>('BETA_FEATURE', {
- *   autoRefresh: false,
- *   defaultValue: false
- * });
- * ```
- */
-export declare function useFeatureFlag<FeatureFlagKey extends string, T extends FeatureFlagValue = boolean>(key: FeatureFlagKey, options?: UseFeatureFlagOptions): FeatureFlagHook<T>;
-/**
- * Hook for checking if a feature flag is enabled.
- * Simplified version of useFeatureFlag that returns only boolean state.
- *
- * @param key - Feature flag key to check
- * @param options - Hook configuration options
- * @returns Boolean indicating if flag is enabled
- *
- * @example
- * ```typescript
- * const isGoogleAuthEnabled = useFeatureFlagEnabled<FeatureFlagKey>('AUTH_GOOGLE');
- * const isBetaEnabled = useFeatureFlagEnabled<FeatureFlagKey>('BETA_FEATURE', {
- *   context: { userId: 'user123', environment: 'production' }
- * });
- * ```
- */
-export declare function useFeatureFlagEnabled<FeatureFlagKey extends string>(key: FeatureFlagKey, options?: UseFeatureFlagOptions): boolean;
-/**
- * Hook for getting a feature flag value with type safety.
- * Provides the raw value without the loading state wrapper.
- *
- * @template T - Expected type of the flag value
- * @param key - Feature flag key to get value for
- * @param options - Hook configuration options
- * @returns The flag value with type safety
- *
- * @example
- * ```typescript
- * const rolloutPercentage = useFeatureFlagValue<FeatureFlagKey, number>('ROLLOUT_PERCENTAGE', {
- *   defaultValue: 0
- * });
- *
- * const theme = useFeatureFlagValue<FeatureFlagKey, 'light' | 'dark'>('UI_THEME', {
- *   defaultValue: 'light'
- * });
- * ```
- */
-export declare function useFeatureFlagValue<FeatureFlagKey extends string, T extends FeatureFlagValue = FeatureFlagValue>(key: FeatureFlagKey, options?: UseFeatureFlagOptions): T;
-/**
- * Hook for evaluating multiple feature flags at once.
- * Useful for loading multiple flags with a single provider call.
- *
- * @param keys - Array of feature flag keys to evaluate
- * @param options - Hook configuration options
- * @returns Map of flag keys to their hook states
- *
- * @example
- * ```typescript
- * const flags = useMultipleFeatureFlags<FeatureFlagKey>([
- *   'AUTH_GOOGLE',
- *   'AUTH_GITHUB',
- *   'BETA_FEATURE'
- * ], {
- *   context: { userId: 'user123', environment: 'production' }
- * });
- *
- * const isGoogleEnabled = flags.AUTH_GOOGLE.value;
- * const isGithubEnabled = flags.AUTH_GITHUB.value;
- * ```
- */
-export declare function useMultipleFeatureFlags<FeatureFlagKey extends string>(keys: FeatureFlagKey[], options?: UseFeatureFlagOptions): Record<FeatureFlagKey, FeatureFlagHook<FeatureFlagValue>>;
-//# sourceMappingURL=useFeatureFlag.d.ts.map

package/dist/frontend/featureFlags/hooks/useFeatureFlag.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFeatureFlag.d.ts","sourceRoot":"","sources":["../../../../src/frontend/featureFlags/hooks/useFeatureFlag.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAO7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,cAAc,SAAS,MAAM,EAAE,CAAC,SAAS,gBAAgB,GAAG,OAAO,EAChG,GAAG,EAAE,cAAc,EACnB,OAAO,GAAE,qBAA0B,GAClC,eAAe,CAAC,CAAC,CAAC,CA8CpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,SAAS,MAAM,EACjE,GAAG,EAAE,cAAc,EACnB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAOT;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,SAAS,MAAM,EAC7B,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,EAC7C,GAAG,EAAE,cAAc,EAAE,OAAO,GAAE,qBAA0B,GAAG,CAAC,CAG7D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CAAC,cAAc,SAAS,MAAM,EACnE,IAAI,EAAE,cAAc,EAAE,EACtB,OAAO,GAAE,qBAA0B,GAClC,MAAM,CAAC,cAAc,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAC,CAuB3D"}

package/dist/frontend/featureFlags/hooks/useFeatureFlagActions.d.ts

@@ -1,35 +0,0 @@
-/**
- * useFeatureFlagHelpers Hook
- *
- * React hook providing helper functions for feature flag management.
- * This will be moved to @plyaz/core when the package structure is finalized.
- *
- * @fileoverview Helper functions hook for feature flags
- * @version 1.0.0
- */
-import type { FeatureFlagHelpers } from '@plyaz/types';
-/**
- * Hook that provides helper functions for feature flag operations.
- * Includes override management, bulk operations, and conditional execution.
- *
- * @returns Object containing helper functions
- *
- * @example
- * ```typescript
- * const helpers = useFeatureFlagHelpers<FeatureFlagKey>();
- *
- * // Set override
- * helpers.setOverride('AUTH_GOOGLE', true);
- *
- * // Check multiple flags
- * const anyEnabled = await helpers.isAnyEnabled(['AUTH_GOOGLE', 'AUTH_GITHUB']);
- *
- * // Conditional execution
- * const result = await helpers.whenEnabled('BETA_FEATURE',
- *   () => console.log('Beta feature is enabled'),
- *   () => console.log('Beta feature is disabled')
- * );
- * ```
- */
-export declare function useFeatureFlagHelpers<FeatureFlagKey extends string>(): FeatureFlagHelpers<FeatureFlagKey>;
-//# sourceMappingURL=useFeatureFlagActions.d.ts.map

package/dist/frontend/featureFlags/hooks/useFeatureFlagActions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFeatureFlagActions.d.ts","sourceRoot":"","sources":["../../../../src/frontend/featureFlags/hooks/useFeatureFlagActions.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAwC,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAG7F;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,SAAS,MAAM,KAC1B,kBAAkB,CAAC,cAAc,CAAC,CAsGtC"}

package/dist/frontend/featureFlags/hooks/useFeatureFlagHelpers.d.ts

@@ -1,55 +0,0 @@
-/**
- * Feature Flag Hook Helpers
- *
- * Helper functions for feature flag hooks to reduce function complexity.
- *
- * @fileoverview Helper functions for feature flag hooks
- * @version 1.0.0
- */
-import type * as React from 'react';
-import type { FeatureFlagValue, FeatureFlagContext, FeatureFlagHook, FeatureFlagProvider, FeatureFlagState } from '@plyaz/types';
-/**
- * Creates evaluation function for a feature flag.
- *
- * @template FeatureFlagKey - The type of feature flag keys
- * @template T - The expected type of the flag value
- * @param params - Evaluation parameters
- * @param params.provider - Feature flag provider instance
- * @param params.key - Feature flag key to evaluate
- * @param params.context - Optional evaluation context
- * @param params.defaultValue - Default value if evaluation fails
- * @param setState - React state setter for flag state
- * @returns Async function that evaluates the flag
- */
-export declare function createEvaluationFunction<FeatureFlagKey extends string, T extends FeatureFlagValue = string | number | boolean | Record<string, unknown>>(params: {
-    provider: FeatureFlagProvider<FeatureFlagKey> | null;
-    key: FeatureFlagKey;
-    context: FeatureFlagContext | undefined;
-    defaultValue: T | undefined;
-}, setState: React.Dispatch<React.SetStateAction<FeatureFlagState<FeatureFlagKey, T>>>): () => Promise<void>;
-/**
- * Custom hook for managing feature flag evaluation logic.
- * Handles loading state, error management, and automatic evaluation.
- *
- * @template FeatureFlagKey - The type of feature flag keys
- * @template T - The expected type of the flag value
- * @param key - Feature flag key to evaluate
- * @param context - Optional evaluation context
- * @param defaultValue - Default value if evaluation fails
- * @param provider - Feature flag provider instance
- * @returns Feature flag hook state with value, loading, error, and refresh function
- */
-export declare function useFeatureFlagEvaluation<FeatureFlagKey extends string, T extends FeatureFlagValue = boolean>(key: FeatureFlagKey, context: FeatureFlagContext | undefined, defaultValue: T | undefined, provider: FeatureFlagProvider<FeatureFlagKey> | null): FeatureFlagHook<T>;
-/**
- * Custom hook for managing multiple feature flags evaluation.
- * Returns a record of flag states for multiple flags.
- *
- * @template FeatureFlagKey - The type of feature flag keys
- * @param keys - Array of feature flag keys to evaluate
- * @param context - Optional evaluation context
- * @param defaultValue - Default value for all flags if evaluation fails
- * @param provider - Feature flag provider instance
- * @returns Record mapping flag keys to their hook states
- */
-export declare function useMultipleFeatureFlagsEvaluation<FeatureFlagKey extends string>(keys: FeatureFlagKey[], context: FeatureFlagContext | undefined, defaultValue: FeatureFlagValue, provider: FeatureFlagProvider<FeatureFlagKey> | null): Record<string, FeatureFlagHook<FeatureFlagValue>>;
-//# sourceMappingURL=useFeatureFlagHelpers.d.ts.map

package/dist/frontend/featureFlags/hooks/useFeatureFlagHelpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFeatureFlagHelpers.d.ts","sourceRoot":"","sources":["../../../../src/frontend/featureFlags/hooks/useFeatureFlagHelpers.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,cAAc,SAAS,MAAM,EAC7B,CAAC,SAAS,gBAAgB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAEhF,MAAM,EAAE;IACN,QAAQ,EAAE,mBAAmB,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;IACrD,GAAG,EAAE,cAAc,CAAC;IACpB,OAAO,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACxC,YAAY,EAAE,CAAC,GAAG,SAAS,CAAC;CAC7B,EACD,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,gBAAgB,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC,GAClF,MAAM,OAAO,CAAC,IAAI,CAAC,CA0BrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,cAAc,SAAS,MAAM,EAC7B,CAAC,SAAS,gBAAgB,GAAG,OAAO,EAEpC,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,kBAAkB,GAAG,SAAS,EACvC,YAAY,EAAE,CAAC,GAAG,SAAS,EAC3B,QAAQ,EAAE,mBAAmB,CAAC,cAAc,CAAC,GAAG,IAAI,GACnD,eAAe,CAAC,CAAC,CAAC,CA+BpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iCAAiC,CAAC,cAAc,SAAS,MAAM,EAC7E,IAAI,EAAE,cAAc,EAAE,EACtB,OAAO,EAAE,kBAAkB,GAAG,SAAS,EACvC,YAAY,EAAE,gBAAgB,EAC9B,QAAQ,EAAE,mBAAmB,CAAC,cAAc,CAAC,GAAG,IAAI,GACnD,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAC,CA6InD"}

package/dist/frontend/featureFlags/hooks/useFeatureFlagProvider.d.ts

@@ -1,57 +0,0 @@
-/**
- * useFeatureFlagProvider Hook
- *
- * React hook for accessing the feature flag provider from context.
- * This will be moved to @plyaz/core when the package structure is finalized.
- *
- * @fileoverview Provider access hook for feature flags
- * @version 1.0.0
- */
-import type { FeatureFlagProvider } from '@plyaz/types';
-/**
- * Hook for accessing the feature flag provider from React context.
- * Must be used within a FeatureFlagProvider component.
- *
- * @returns Feature flag provider instance
- * @throws Error if used outside of FeatureFlagProvider
- *
- * @example
- * ```typescript
- * function MyComponent() {
- *   const provider = useFeatureFlagProvider<FeatureFlagKey>();
- *
- *   const handleRefresh = async () => {
- *     await provider.refresh();
- *   };
- *
- *   return <button onClick={handleRefresh}>Refresh Flags</button>;
- * }
- * ```
- */
-export declare function useFeatureFlagProvider<FeatureFlagKey extends string>(): FeatureFlagProvider<FeatureFlagKey>;
-/**
- * Hook for accessing the feature flag provider status.
- * Provides information about provider initialization and health.
- *
- * @returns Provider status information
- *
- * @example
- * ```typescript
- * function StatusComponent() {
- *   const { isInitialized, isLoading, error } = useFeatureFlagProviderStatus<FeatureFlagKey>();
- *
- *   if (isLoading) return <div>Loading feature flags...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
- *   if (!isInitialized) return <div>Initializing...</div>;
- *
- *   return <div>Feature flags ready!</div>;
- * }
- * ```
- */
-export declare function useFeatureFlagProviderStatus<FeatureFlagKey extends string>(): {
-    isInitialized: boolean;
-    isLoading: boolean;
-    error: Error | null;
-    lastUpdated: Date | null | undefined;
-};
-//# sourceMappingURL=useFeatureFlagProvider.d.ts.map

package/dist/frontend/featureFlags/hooks/useFeatureFlagProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFeatureFlagProvider.d.ts","sourceRoot":"","sources":["../../../../src/frontend/featureFlags/hooks/useFeatureFlagProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAA2B,MAAM,cAAc,CAAC;AAEjF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,SAAS,MAAM,KAC1B,mBAAmB,CAAC,cAAc,CAAC,CAWvC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAAC,cAAc,SAAS,MAAM,KAAK;IAC7E,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,WAAW,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;CACtC,CAgBA"}

package/dist/frontend/featureFlags/providers/FeatureFlagProvider.d.ts

@@ -1,99 +0,0 @@
-/**
- * Feature Flag Provider Component
- *
- * React context provider for feature flags system.
- * This will be moved to @plyaz/core when the package structure is finalized.
- *
- * @fileoverview React provider for feature flag context
- * @version 1.0.0
- */
-import React from 'react';
-import type { FeatureFlagConfig, FeatureFlagContextValue, FeatureFlagProviderProps, FeatureFlagValue } from '@plyaz/types';
-import type { FeatureFlagKey } from '@domain/types';
-/**
- * React context for feature flag provider.
- * Using string as the base type to support any feature flag key.
- */
-export declare const FeatureFlagContext: React.Context<FeatureFlagContextValue<"AUTH_GOOGLE" | "AUTH_DISCORD" | "AUTH_FACEBOOK" | "AUTH_GITHUB"> | null>;
-/**
- * Feature Flag Provider component that manages the feature flag system.
- * Provides context for accessing feature flags throughout the React component tree.
- *
- * @param props - Provider configuration and options
- * @returns JSX element providing feature flag context
- *
- * @example
- * ```typescript
- * // Basic usage
- * function App() {
- *   return (
- *     <FeatureFlagAppProvider
- *       config={{
- *         provider: 'memory',
- *         isCacheEnabled: true,
- *         cacheTtl: 300,
- *       }}
- *       features={FEATURES}
- *     >
- *       <MyApplication />
- *     </FeatureFlagAppProvider>
- *   );
- * }
- *
- * // With custom context and callbacks
- * function App() {
- *   const featureFlagConfig = {
- *     provider: 'api' as const,
- *     apiEndpoint: 'https://api.example.com',
- *     apiKey: process.env.REACT_APP_FF_API_KEY,
- *     isCacheEnabled: true,
- *     cacheTtl: 300,
- *   };
- *
- *   const defaultContext = {
- *     environment: 'production' as const,
- *     userId: getCurrentUserId(),
- *     userRole: getCurrentUserRole(),
- *   };
- *
- *   return (
- *     <FeatureFlagAppProvider
- *       config={featureFlagConfig}
- *       features={FEATURES}
- *       defaultContext={defaultContext}
- *       onReady={(provider) => console.log('Feature flags ready!')}
- *       onError={(error) => console.error('Feature flag error:', error)}
- *       showLoading
- *     >
- *       <MyApplication />
- *     </FeatureFlagAppProvider>
- *   );
- * }
- * ```
- */
-export declare function FeatureFlagAppProvider<FeatureFlags extends Record<FeatureFlagKey, FeatureFlagValue>>({ config, children, features, onReady, onError, isShowLoading, loadingComponent, errorComponent, }: FeatureFlagProviderProps<FeatureFlagKey, FeatureFlags>): React.ReactElement;
-export declare namespace FeatureFlagAppProvider {
-    var displayName: string;
-}
-/**
- * Higher-order component for providing feature flag context.
- * Alternative to using the FeatureFlagAppProvider component directly.
- *
- * @param config - Feature flag configuration
- * @param options - Additional provider options
- * @returns HOC function that wraps components with feature flag provider
- *
- * @example
- * ```typescript
- * const withFeatureFlags = createFeatureFlagProvider({
- *   provider: 'memory',
- *   isCacheEnabled: true,
- * }, {
- *   features: FEATURES
- * });
- *
- * const AppWithFeatureFlags = withFeatureFlags(App);
- * ```
- */
-export declare function createFeatureFlagProvider<FeatureFlags extends Record<FeatureFlagKey, FeatureFlagValue>>(config: FeatureFlagConfig<FeatureFlagKey>, options?: Pick<FeatureFlagProviderProps<FeatureFlagKey, FeatureFlags>, 'defaultContext' | 'onReady' | 'onError' | 'features'>): <P extends object>(component: React.ComponentType<P>) => React.ComponentType<P>;
-//# sourceMappingURL=FeatureFlagProvider.d.ts.map

package/dist/frontend/featureFlags/providers/FeatureFlagProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FeatureFlagProvider.d.ts","sourceRoot":"","sources":["../../../../src/frontend/featureFlags/providers/FeatureFlagProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAEV,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,iHAE9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,wBAAgB,sBAAsB,CACpC,YAAY,SAAS,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC,EAC7D,EACA,MAAM,EAEN,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,OAAO,EACP,aAAqB,EACrB,gBAAgB,EAChB,cAAc,GACf,EAAE,wBAAwB,CAAC,cAAc,EAAE,YAAY,CAAC,GAAG,KAAK,CAAC,YAAY,CA0J7E;yBAtKe,sBAAsB;;;AA2KtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CACvC,YAAY,SAAS,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC,EAE7D,MAAM,EAAE,iBAAiB,CAAC,cAAc,CAAC,EACzC,OAAO,CAAC,EAAE,IAAI,CACZ,wBAAwB,CAAC,cAAc,EAAE,YAAY,CAAC,EACtD,gBAAgB,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CACtD,IAEgC,CAAC,SAAS,MAAM,EAC/C,WAAW,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,KAChC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAe1B"}

package/dist/frontend/featureFlags/providers/FeatureFlagProviderHelpers.d.ts

@@ -1,31 +0,0 @@
-/**
- * Feature Flag Provider Helpers
- *
- * Helper functions for the FeatureFlagProvider component to reduce complexity.
- *
- * @fileoverview Helper functions for FeatureFlagProvider
- * @version 1.0.0
- */
-import React from 'react';
-import type { FeatureFlagConfig } from '@plyaz/types';
-import type { ProviderState, UseFeatureFlagProviderState } from './types';
-/**
- * Hook for managing feature flag provider state and initialization.
- */
-export declare function useFeatureFlagProviderState<FeatureFlagKey extends string>(config: FeatureFlagConfig<FeatureFlagKey>, onReady?: () => void, onError?: (error: Error) => void): UseFeatureFlagProviderState<FeatureFlagKey>;
-/**
- * Hook for setting up provider subscription and cleanup.
- */
-export declare function useProviderSubscription<FeatureFlagKey extends string>(state: ProviderState<FeatureFlagKey>, setState: React.Dispatch<React.SetStateAction<ProviderState<FeatureFlagKey>>>): void;
-/**
- * Renders loading state component.
- */
-export declare function renderLoadingState(isShowLoading: boolean, isLoading: boolean, loadingComponent?: React.ComponentType): React.ReactElement | null;
-/**
- * Renders error state component.
- */
-export declare function renderErrorState(error: Error | null, errorComponent?: React.ComponentType<{
-    error: Error;
-    retry: () => void;
-}>, retry?: () => void): React.ReactElement | null;
-//# sourceMappingURL=FeatureFlagProviderHelpers.d.ts.map