@plyaz/core 1.0.0

package/dist/domain/featureFlags/providers/memory.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Memory Feature Flag Provider
+ *
+ * In-memory provider implementation that uses the FEATURES constant for flag data.
+ * This will be moved to @plyaz/core when the package structure is finalized.
+ *
+ * @fileoverview Memory provider implementation for feature flags
+ * @version 1.0.0
+ */
+import type { FeatureFlag, FeatureFlagRule, FeatureFlagConfig, FeatureFlagValue } from '@plyaz/types';
+import { FeatureFlagProvider } from '../provider';
+/**
+ * Memory-based feature flag provider that loads flags from the FEATURES constant.
+ *
+ * @class MemoryFeatureFlagProvider
+ * @extends {FeatureFlagProvider}
+ *
+ * @example
+ * ```typescript
+ * const provider = new MemoryFeatureFlagProvider<FeatureFlagKey>({
+ *   provider: 'memory',
+ *   isCacheEnabled: false,
+ *   isLoggingEnabled: true,
+ * }, FEATURES);
+ *
+ * await provider.initialize();
+ * const isEnabled = await provider.isEnabled('AUTH_GOOGLE');
+ * ```
+ */
+export declare class MemoryFeatureFlagProvider<FeatureFlagKey extends string> extends FeatureFlagProvider<FeatureFlagKey> {
+    private flags;
+    private rules;
+    /**
+     * Creates a new memory feature flag provider.
+     *
+     * @param config - Provider configuration
+     * @param features - Record of feature flag keys to their default values
+     */
+    constructor(config: FeatureFlagConfig<FeatureFlagKey>, features: Record<FeatureFlagKey, FeatureFlagValue>);
+    /**
+     * Fetches flags and rules from memory (FEATURES constant).
+     *
+     * @protected
+     * @returns Promise resolving to flags and rules from memory
+     */
+    protected fetchData(): Promise<{
+        flags: FeatureFlag<FeatureFlagKey>[];
+        rules: FeatureFlagRule<FeatureFlagKey>[];
+    }>;
+    /**
+     * Creates a FeatureFlag object from a FEATURES constant entry.
+     *
+     * @private
+     * @param key - The feature flag key
+     * @param value - The value from FEATURES constant
+     * @param currentTime - Current timestamp
+     * @returns FeatureFlag object
+     */
+    private createFeatureFlagFromConstant;
+    /**
+     * Generates a human-readable name from a flag key.
+     *
+     * @private
+     * @param key - The feature flag key
+     * @returns Human-readable flag name
+     */
+    private generateFlagName;
+    /**
+     * Infers the flag type from its value.
+     *
+     * @private
+     * @param value - The flag value
+     * @returns The inferred type
+     */
+    private inferFlagType;
+    /**
+     * Gets manually added rules for memory provider.
+     *
+     * @private
+     * @returns Array of manually configured rules
+     */
+    private getManualRules;
+    /**
+     * Validates the memory provider configuration.
+     *
+     * @private
+     * @throws Error if configuration is invalid
+     */
+    private validateConfig;
+    /**
+     * Adds a rule to the memory provider at runtime.
+     *
+     * @param rule - The rule to add
+     */
+    addRule(rule: FeatureFlagRule<FeatureFlagKey>): void;
+    /**
+     * Removes a rule from the memory provider.
+     *
+     * @param ruleId - The ID of the rule to remove
+     */
+    removeRule(ruleId: string): void;
+    /**
+     * Updates a flag value in memory.
+     *
+     * @param key - The flag key to update
+     * @param value - The new value
+     * @param updateProps - Optional properties to update
+     */
+    updateFlag(key: FeatureFlagKey, value: FeatureFlagValue, updateProps?: Partial<Pick<FeatureFlag<FeatureFlagKey>, 'name' | 'description' | 'isEnabled' | 'environment' | 'rolloutPercentage' | 'type'>>): void;
+    /**
+     * Adds a new flag to memory at runtime.
+     *
+     * @param key - The flag key
+     * @param value - The flag value
+     * @param props - Optional flag properties
+     */
+    addFlag(key: FeatureFlagKey, value: FeatureFlagValue, props?: Partial<Pick<FeatureFlag<FeatureFlagKey>, 'name' | 'description' | 'isEnabled' | 'environment' | 'rolloutPercentage' | 'type'>>): void;
+    /**
+     * Checks if a flag with the given key exists.
+     */
+    private flagExists;
+    /**
+     * Creates a new flag object.
+     */
+    private createNewFlag;
+    /**
+     * Gets default properties for a new flag.
+     */
+    private getDefaultFlagProperties;
+    /**
+     * Merges default properties with user-provided properties.
+     */
+    private mergeWithUserProps;
+    /**
+     * Adds the flag to the store and notifies systems.
+     */
+    private addFlagToStore;
+    /**
+     * Removes a flag from memory.
+     *
+     * @param key - The flag key to remove
+     */
+    removeFlag(key: FeatureFlagKey): void;
+    /**
+     * Gets all current flags in memory.
+     *
+     * @returns Array of current flags
+     */
+    getCurrentFlags(): FeatureFlag<FeatureFlagKey>[];
+    /**
+     * Gets all current rules in memory.
+     *
+     * @returns Array of current rules
+     */
+    getCurrentRules(): FeatureFlagRule<FeatureFlagKey>[];
+    /**
+     * Resets the memory provider to its initial state.
+     */
+    reset(): Promise<void>;
+    /**
+     * Gets statistics about the memory provider.
+     *
+     * @returns Provider statistics
+     */
+    getStats(): {
+        flagCount: number;
+        ruleCount: number;
+        cacheSize: number;
+        subscriberCount: number;
+        isInitialized: boolean;
+    };
+    /**
+     * Logs messages with MemoryFeatureFlagProvider prefix.
+     *
+     * @param args - Arguments to log
+     */
+    protected log(...args: unknown[]): void;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/domain/featureFlags/providers/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../../src/domain/featureFlags/providers/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,yBAAyB,CACpC,cAAc,SAAS,MAAM,CAC7B,SAAQ,mBAAmB,CAAC,cAAc,CAAC;IAC3C,OAAO,CAAC,KAAK,CAAqC;IAClD,OAAO,CAAC,KAAK,CAAyC;IAEtD;;;;;OAKG;gBAED,MAAM,EAAE,iBAAiB,CAAC,cAAc,CAAC,EACzC,QAAQ,EAAE,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC;IAMpD;;;;;OAKG;cACa,SAAS,IAAI,OAAO,CAAC;QACnC,KAAK,EAAE,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC;QACrC,KAAK,EAAE,eAAe,CAAC,cAAc,CAAC,EAAE,CAAC;KAC1C,CAAC;IAyBF;;;;;;;;OAQG;IACH,OAAO,CAAC,6BAA6B;IAqBrC;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IAOxB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAUtB;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,eAAe,CAAC,cAAc,CAAC,GAAG,IAAI;IAQpD;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAchC;;;;;;OAMG;IACH,UAAU,CACR,GAAG,EAAE,cAAc,EACnB,KAAK,EAAE,gBAAgB,EACvB,WAAW,CAAC,EAAE,OAAO,CACnB,IAAI,CACF,WAAW,CAAC,cAAc,CAAC,EAC3B,MAAM,GAAG,aAAa,GAAG,WAAW,GAAG,aAAa,GAAG,mBAAmB,GAAG,MAAM,CACpF,CACF,GACA,IAAI;IAyBP;;;;;;OAMG;IACH,OAAO,CACL,GAAG,EAAE,cAAc,EACnB,KAAK,EAAE,gBAAgB,EACvB,KAAK,CAAC,EAAE,OAAO,CACb,IAAI,CACF,WAAW,CAAC,cAAc,CAAC,EAC3B,MAAM,GAAG,aAAa,GAAG,WAAW,GAAG,aAAa,GAAG,mBAAmB,GAAG,MAAM,CACpF,CACF,GACA,IAAI;IASP;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAqBhC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAsB1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAYtB;;;;OAIG;IACH,UAAU,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IAcrC;;;;OAIG;IACH,eAAe,IAAI,WAAW,CAAC,cAAc,CAAC,EAAE;IAIhD;;;;OAIG;IACH,eAAe,IAAI,eAAe,CAAC,cAAc,CAAC,EAAE;IAIpD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;;;OAIG;IACH,QAAQ,IAAI;QACV,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,OAAO,CAAC;KACxB;IAUD;;;;OAIG;IACH,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;CAKxC"}

package/dist/domain/featureFlags/providers/redis.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Redis Feature Flag Provider
+ *
+ * Redis-based provider implementation supporting distributed caching and storage.
+ * This will be moved to @plyaz/core when the package structure is finalized.
+ *
+ * @fileoverview Redis provider implementation for feature flags
+ * @version 1.0.0
+ */
+import type { FeatureFlag, FeatureFlagRule, FeatureFlagConfig, FeatureFlagValue } from '@plyaz/types';
+import { FeatureFlagProvider } from '../provider';
+/**
+ * Redis-based feature flag provider supporting distributed caching and storage.
+ *
+ * @class RedisFeatureFlagProvider
+ * @extends {FeatureFlagProvider}
+ *
+ * @example
+ * ```typescript
+ * const provider = new RedisFeatureFlagProvider<FeatureFlagKey>({
+ *   provider: 'redis',
+ *   redisConfig: {
+ *     url: 'redis://localhost:6379',
+ *     keyPrefix: 'feature_flags',
+ *   },
+ *   isCacheEnabled: true,
+ *   cacheTtl: 300,
+ * }, FEATURES);
+ *
+ * await provider.initialize();
+ * const isEnabled = await provider.isEnabled('AUTH_GOOGLE');
+ * ```
+ */
+export declare class RedisFeatureFlagProvider<FeatureFlagKey extends string> extends FeatureFlagProvider<FeatureFlagKey> {
+    /**
+     * Creates a new Redis feature flag provider.
+     *
+     * @param config - Provider configuration with Redis settings
+     * @param features - Record of feature flag keys to their default values
+     */
+    constructor(config: FeatureFlagConfig<FeatureFlagKey>, features: Record<FeatureFlagKey, FeatureFlagValue>);
+    /**
+     * Fetches flags and rules from Redis storage.
+     *
+     * @protected
+     * @returns Promise resolving to flags and rules from Redis
+     */
+    protected fetchData(): Promise<{
+        flags: FeatureFlag<FeatureFlagKey>[];
+        rules: FeatureFlagRule<FeatureFlagKey>[];
+    }>;
+    /**
+     * Validates the Redis provider configuration.
+     *
+     * @private
+     * @throws Error if configuration is invalid
+     */
+    private validateConfig;
+    /**
+     * Validates Redis URL format.
+     *
+     * @private
+     * @param url - URL to validate
+     * @returns True if valid Redis URL
+     */
+    private isValidRedisUrl;
+    /**
+     * Gets Redis provider information.
+     *
+     * @returns Redis provider status information
+     */
+    getRedisInfo(): {
+        url?: string;
+        keyPrefix?: string;
+        isImplemented: boolean;
+        requiredImplementation: string[];
+        recommendedPatterns: string[];
+    };
+}
+//# sourceMappingURL=redis.d.ts.map

package/dist/domain/featureFlags/providers/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../src/domain/featureFlags/providers/redis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,wBAAwB,CACnC,cAAc,SAAS,MAAM,CAC7B,SAAQ,mBAAmB,CAAC,cAAc,CAAC;IAC3C;;;;;OAKG;gBAED,MAAM,EAAE,iBAAiB,CAAC,cAAc,CAAC,EACzC,QAAQ,EAAE,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC;IAOpD;;;;;OAKG;cACa,SAAS,IAAI,OAAO,CAAC;QACnC,KAAK,EAAE,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC;QACrC,KAAK,EAAE,eAAe,CAAC,cAAc,CAAC,EAAE,CAAC;KAC1C,CAAC;IAwCF;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAuBtB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAIvB;;;;OAIG;IACH,YAAY,IAAI;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,OAAO,CAAC;QACvB,sBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,mBAAmB,EAAE,MAAM,EAAE,CAAC;KAC/B;CAoBF"}

package/dist/domain/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Domain Layer Exports
+ */
+export * from './featureFlags';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/domain/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,cAAc,gBAAgB,CAAC;AAG/B,mBAAmB,SAAS,CAAC"}

package/dist/domain/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Feature Flags Domain Types
+ *
+ * Core type definitions for the feature flags domain.
+ * These types will be moved to @plyaz/types when the package structure is finalized.
+ *
+ * @fileoverview Feature flags domain type definitions
+ * @version 1.0.0
+ */
+import type { FeatureFlagValue } from '@plyaz/types';
+import type { FEATURES } from '@plyaz/config';
+/**
+ * Union type of all available feature flag keys.
+ * Automatically derived from the FEATURES constant for type safety.
+ */
+export type FeatureFlagKey = keyof typeof FEATURES;
+export type FeatureFlags = typeof FEATURES extends Record<FeatureFlagKey, FeatureFlagValue> ? typeof FEATURES : never;
+//# sourceMappingURL=types.d.ts.map

package/dist/domain/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/domain/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,QAAQ,CAAC;AAEnD,MAAM,MAAM,YAAY,GACtB,OAAO,QAAQ,SAAS,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC,GAAG,OAAO,QAAQ,GAAG,KAAK,CAAC"}

package/dist/engine/featureFlags/engine.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Feature Flag Evaluation Engine
+ *
+ * Core engine for evaluating feature flags with rules, targeting, and rollouts.
+ * This will be moved to @plyaz/core when the package structure is finalized.
+ *
+ * @fileoverview Core feature flag evaluation engine
+ * @version 1.0.0
+ */
+import type { FeatureFlag, FeatureFlagRule, FeatureFlagContext, FeatureFlagEvaluation, FeatureFlagValue } from '@plyaz/types';
+/**
+ * Core feature flag evaluation engine.
+ * Handles all the logic for evaluating feature flags including rules, targeting, and rollouts.
+ *
+ * @class FeatureFlagEngine
+ *
+ * @example
+ * ```typescript
+ * const engine = new FeatureFlagEngine(defaultFlags, true);
+ * engine.setFlags(flagsFromDatabase);
+ * engine.setRules(rulesFromDatabase);
+ *
+ * const evaluation = engine.evaluate('AUTH_GOOGLE', context);
+ * console.log(evaluation.isEnabled); // true/false
+ * ```
+ */
+export declare class FeatureFlagEngine<FeatureFlagKey extends string> {
+    private defaults;
+    private isLoggingEnabled;
+    /** Storage for active feature flags */
+    private flags;
+    /** Storage for targeting rules, organized by flag key */
+    private rules;
+    /** Storage for manual overrides (useful for testing) */
+    private overrides;
+    /**
+     * Creates a new feature flag evaluation engine.
+     *
+     * @param defaults - Default flag values to fall back to
+     * @param isLoggingEnabled - Whether to enable debug logging
+     */
+    constructor(defaults: Record<FeatureFlagKey, FeatureFlagValue>, isLoggingEnabled?: boolean);
+    /**
+     * Sets the active feature flags for evaluation.
+     * Clears existing flags and rules before setting new ones.
+     *
+     * @param flags - Array of feature flags to activate
+     */
+    setFlags(flags: FeatureFlag<FeatureFlagKey>[]): void;
+    /**
+     * Sets the targeting rules for feature flags.
+     * Rules are automatically sorted by priority (higher numbers first).
+     *
+     * @param rules - Array of feature flag rules
+     */
+    setRules(rules: FeatureFlagRule<FeatureFlagKey>[]): void;
+    /**
+     * Sets a manual override for a specific flag.
+     * Overrides take precedence over all other evaluation logic.
+     *
+     * @param key - The flag key to override
+     * @param value - The value to force for this flag
+     */
+    setOverride(key: FeatureFlagKey, value: FeatureFlagValue): void;
+    /**
+     * Removes a manual override for a specific flag.
+     *
+     * @param key - The flag key to remove override for
+     */
+    removeOverride(key: FeatureFlagKey): void;
+    /**
+     * Clears all manual overrides.
+     */
+    clearOverrides(): void;
+    /**
+     * Gets all current flags.
+     *
+     * @returns Array of all feature flags
+     */
+    getFlags(): FeatureFlag<FeatureFlagKey>[];
+    /**
+     * Evaluates a feature flag and returns the complete evaluation result.
+     *
+     * @param key - The feature flag key to evaluate
+     * @param context - Optional context for targeting
+     * @returns Complete evaluation result with value and metadata
+     */
+    evaluate(key: FeatureFlagKey, context?: FeatureFlagContext): FeatureFlagEvaluation<FeatureFlagKey>;
+    /**
+     * Checks for manual override and returns evaluation if found.
+     *
+     * @private
+     * @param key - The feature flag key
+     * @param evaluatedAt - Evaluation timestamp
+     * @returns Evaluation result or null if no override
+     */
+    private checkOverride;
+    /**
+     * Creates default evaluation result.
+     *
+     * @private
+     * @param key - The feature flag key
+     * @param evaluatedAt - Evaluation timestamp
+     * @returns Default evaluation result
+     */
+    private createDefaultEvaluation;
+    /**
+     * Creates disabled evaluation result.
+     *
+     * @private
+     * @param key - The feature flag key
+     * @param evaluatedAt - Evaluation timestamp
+     * @returns Disabled evaluation result
+     */
+    private createDisabledEvaluation;
+    /**
+     * Creates flag evaluation result.
+     *
+     * @private
+     * @param key - The feature flag key
+     * @param flag - The feature flag
+     * @param evaluatedAt - Evaluation timestamp
+     * @returns Flag evaluation result
+     */
+    private createFlagEvaluation;
+    /**
+     * Checks if environment matches for flag evaluation.
+     *
+     * @private
+     * @param flag - The feature flag
+     * @param context - Evaluation context
+     * @returns true if environment matches
+     */
+    private isEnvironmentMatch;
+    /**
+     * Checks if user is in flag-level rollout.
+     *
+     * @private
+     * @param key - The feature flag key
+     * @param flag - The feature flag
+     * @param context - Evaluation context
+     * @returns true if user is in rollout
+     */
+    private isInFlagRollout;
+    /**
+     * Evaluates all rules for a flag.
+     *
+     * @private
+     * @param key - The feature flag key
+     * @param context - Evaluation context
+     * @param evaluatedAt - Evaluation timestamp
+     * @returns Rule evaluation result or null if no match
+     */
+    private evaluateRules;
+    /**
+     * Evaluates a single matching rule and returns result if it passes.
+     *
+     * @private
+     * @param key - The feature flag key
+     * @param rule - The rule to evaluate
+     * @param context - Evaluation context
+     * @param evaluatedAt - Evaluation timestamp
+     * @returns Rule evaluation result or null if no match
+     */
+    private evaluateMatchingRule;
+    /**
+     * Evaluates a single rule against the provided context.
+     * All conditions in the rule must match (AND logic).
+     *
+     * @private
+     * @param rule - The rule to evaluate
+     * @param context - Context to evaluate against
+     * @returns true if the rule matches the context
+     */
+    private evaluateRule;
+    /**
+     * Evaluates a single condition against the provided context.
+     *
+     * @private
+     * @param condition - The condition to evaluate
+     * @param context - Context to evaluate against
+     * @returns true if the condition matches
+     */
+    private evaluateCondition;
+    /**
+     * Logs debug information if logging is enabled.
+     *
+     * @private
+     * @param args - Arguments to log
+     */
+    private log;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine/featureFlags/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/engine/featureFlags/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EAEf,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAItB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAiB,CAAC,cAAc,SAAS,MAAM;IAexD,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,gBAAgB;IAf1B,uCAAuC;IACvC,OAAO,CAAC,KAAK,CAA+D;IAC5E,yDAAyD;IACzD,OAAO,CAAC,KAAK,CAAqE;IAClF,wDAAwD;IACxD,OAAO,CAAC,SAAS,CAAoD;IAErE;;;;;OAKG;gBAEO,QAAQ,EAAE,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC,EAClD,gBAAgB,UAAQ;IAGlC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,cAAc,CAAC,EAAE,GAAG,IAAI;IAWpD;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC,cAAc,CAAC,EAAE,GAAG,IAAI;IAcxD;;;;;;OAMG;IACH,WAAW,CAAC,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAK/D;;;;OAIG;IACH,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IAKzC;;OAEG;IACH,cAAc,IAAI,IAAI;IAKtB;;;;OAIG;IACH,QAAQ,IAAI,WAAW,CAAC,cAAc,CAAC,EAAE;IAIzC;;;;;;OAMG;IACH,QAAQ,CACN,GAAG,EAAE,cAAc,EACnB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,qBAAqB,CAAC,cAAc,CAAC;IAoCxC;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAgBrB;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAc/B;;;;;;;OAOG;IACH,OAAO,CAAC,wBAAwB;IAahC;;;;;;;;OAQG;IACH,OAAO,CAAC,oBAAoB;IAc5B;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IAUvB;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAiBrB;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IAwB5B;;;;;;;;OAQG;IACH,OAAO,CAAC,YAAY;IAUpB;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;IAYzB;;;;;OAKG;IACH,OAAO,CAAC,GAAG;CAKZ"}

package/dist/engine/featureFlags/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Feature Flags Engine - Main Exports
+ *
+ * Exports the feature flag evaluation engine.
+ *
+ * @fileoverview Feature flags engine exports
+ * @version 1.0.0
+ */
+export { FeatureFlagEngine } from './engine';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/featureFlags/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/featureFlags/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC"}

package/dist/engine/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Engine Layer Exports
+ */
+export * from './featureFlags';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/engine/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,cAAc,gBAAgB,CAAC"}

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

@@ -0,0 +1,103 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,35 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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"}