flipflag-sdk 1.1.21 → 1.1.22

package/dist/react.mjs

@@ -1,4 +1,4 @@
-import { createContext, useContext, useState, useCallback, useEffect } from 'react';
+import { createContext, useContext, useState, useMemo, useCallback, useEffect } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
 class FlipFlagSDK {
@@ -6,6 +6,9 @@ class FlipFlagSDK {
         this.cache = new Map();
         this.defaultBaseUrl = "https://app.flipflag.ru";
         this.stateListeners = new Set();
+        this.maxListeners = 100; // Maximum number of listeners to prevent memory leaks
+        // Validate required configuration
+        this.validateConfig(config);
         this.config = {
             baseUrl: this.defaultBaseUrl,
             cacheTimeout: 30000, // 30 seconds
@@ -30,6 +33,15 @@ class FlipFlagSDK {
      * Identify user for A/B testing and user-specific flags
      */
     identifyUser(options) {
+        if (!options || typeof options !== "object") {
+            throw new Error("options must be an object");
+        }
+        if (!options.userId || typeof options.userId !== "string") {
+            throw new Error("userId is required and must be a string");
+        }
+        if (options.userProperties && typeof options.userProperties !== "object") {
+            throw new Error("userProperties must be an object");
+        }
         this.config.userId = options.userId;
         // Clear A/B test cache since user changed
         this.clearABTestCache();
@@ -48,6 +60,9 @@ class FlipFlagSDK {
      * Subscribe to state changes
      */
     subscribe(callback) {
+        if (this.stateListeners.size >= this.maxListeners) {
+            console.warn(`Maximum number of listeners (${this.maxListeners}) reached. This may cause memory leaks.`);
+        }
         this.stateListeners.add(callback);
         // Return unsubscribe function
         return () => {
@@ -158,6 +173,8 @@ class FlipFlagSDK {
             }
             catch (error) {
                 console.error("State listener error:", error);
+                // Remove faulty listener to prevent repeated errors
+                this.stateListeners.delete(callback);
             }
         });
     }
@@ -222,6 +239,15 @@ class FlipFlagSDK {
      */
     async getFlag(flagName, projectId = this.config.projectId, environment) {
         var _a, _b;
+        if (!flagName || typeof flagName !== "string") {
+            throw new Error("flagName is required and must be a string");
+        }
+        if (!projectId || typeof projectId !== "string") {
+            throw new Error("projectId must be a string");
+        }
+        if (environment && typeof environment !== "string") {
+            throw new Error("environment must be a string");
+        }
         // If we have the flag in state, return it immediately
         if (this.state.flags[flagName] !== undefined) {
             return {
@@ -233,20 +259,18 @@ class FlipFlagSDK {
             };
         }
         // Check if we're currently loading data (pullData in progress)
-        // In this case, wait a bit and check state again
+        // In this case, wait for loading to complete using Promise
         if (this.state.isLoading) {
-            // Wait up to 5 seconds for loading to complete
-            for (let i = 0; i < 50; i++) {
-                await new Promise((resolve) => setTimeout(resolve, 100));
-                if (!this.state.isLoading && this.state.flags[flagName] !== undefined) {
-                    return {
-                        projectId: this.config.projectId,
-                        flagName,
-                        environment: this.config.environment || "all",
-                        value: this.state.flags[flagName],
-                        timestamp: ((_b = this.state.lastFetch) === null || _b === void 0 ? void 0 : _b.toISOString()) || new Date().toISOString(),
-                    };
-                }
+            await this.waitForLoadingComplete();
+            // After waiting, check state again
+            if (this.state.flags[flagName] !== undefined) {
+                return {
+                    projectId: this.config.projectId,
+                    flagName,
+                    environment: this.config.environment || "all",
+                    value: this.state.flags[flagName],
+                    timestamp: ((_b = this.state.lastFetch) === null || _b === void 0 ? void 0 : _b.toISOString()) || new Date().toISOString(),
+                };
             }
         }
         const cacheKey = `flag:${projectId}:${flagName}:${environment || "all"}`;
@@ -262,10 +286,76 @@ class FlipFlagSDK {
         this.setCache(cacheKey, response, this.config.cacheTimeout);
         return response;
     }
+    /**
+     * Validate configuration
+     */
+    validateConfig(config) {
+        if (!config.apiKey || typeof config.apiKey !== "string") {
+            throw new Error("apiKey is required and must be a string");
+        }
+        if (!config.projectId || typeof config.projectId !== "string") {
+            throw new Error("projectId is required and must be a string");
+        }
+        if (config.baseUrl && typeof config.baseUrl !== "string") {
+            throw new Error("baseUrl must be a string");
+        }
+        if (config.environment && typeof config.environment !== "string") {
+            throw new Error("environment must be a string");
+        }
+        if (config.userId && typeof config.userId !== "string") {
+            throw new Error("userId must be a string");
+        }
+        if (config.cacheTimeout &&
+            (typeof config.cacheTimeout !== "number" || config.cacheTimeout < 0)) {
+            throw new Error("cacheTimeout must be a non-negative number");
+        }
+        if (config.retryAttempts &&
+            (typeof config.retryAttempts !== "number" || config.retryAttempts < 0)) {
+            throw new Error("retryAttempts must be a non-negative number");
+        }
+        if (config.retryDelay &&
+            (typeof config.retryDelay !== "number" || config.retryDelay < 0)) {
+            throw new Error("retryDelay must be a non-negative number");
+        }
+        if (config.pullInterval &&
+            (typeof config.pullInterval !== "number" || config.pullInterval < 0)) {
+            throw new Error("pullInterval must be a non-negative number");
+        }
+    }
+    /**
+     * Wait for loading to complete with timeout
+     */
+    async waitForLoadingComplete(timeout = 5000) {
+        const startTime = Date.now();
+        return new Promise((resolve, reject) => {
+            const checkLoading = () => {
+                if (!this.state.isLoading) {
+                    resolve();
+                    return;
+                }
+                if (Date.now() - startTime > timeout) {
+                    reject(new Error("Timeout waiting for SDK loading to complete"));
+                    return;
+                }
+                // Check again after a short delay
+                setTimeout(checkLoading, 50);
+            };
+            checkLoading();
+        });
+    }
     /**
      * Get A/B test variant for a user
      */
     async getAbTestVariant(testName, userId, projectId = this.config.projectId) {
+        if (!testName || typeof testName !== "string") {
+            throw new Error("testName is required and must be a string");
+        }
+        if (!userId || typeof userId !== "string") {
+            throw new Error("userId is required and must be a string");
+        }
+        if (!projectId || typeof projectId !== "string") {
+            throw new Error("projectId must be a string");
+        }
         // If we have the A/B test in state, return it immediately
         const stateVariant = this.state.abTests[testName];
         if (stateVariant && stateVariant.testName === testName) {
@@ -329,6 +419,34 @@ class FlipFlagSDK {
             this.cache.clear();
         }
     }
+    /**
+     * Clear cache for specific flag
+     */
+    clearFlagCache(flagName, environment) {
+        const cacheKey = `flag:${this.config.projectId}:${flagName}:${environment || "all"}`;
+        this.cache.delete(cacheKey);
+    }
+    /**
+     * Clear cache for all flags
+     */
+    clearFlagsCache(environment) {
+        const cacheKey = `flags:${this.config.projectId}:${environment || "all"}`;
+        this.cache.delete(cacheKey);
+    }
+    /**
+     * Clear cache for A/B test variant
+     */
+    clearABTestCache(testName, userId) {
+        if (testName && userId) {
+            const cacheKey = `abtest:${this.config.projectId}:${testName}:${userId}`;
+            this.cache.delete(cacheKey);
+        }
+        else {
+            // Clear all A/B test cache
+            const abTestKeys = Array.from(this.cache.keys()).filter((key) => key.startsWith("abtest:"));
+            abTestKeys.forEach((key) => this.cache.delete(key));
+        }
+    }
     /**
      * Update configuration
      */
@@ -437,17 +555,18 @@ function useFeatureFlag(flagName, options = {}) {
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
     // Try to get SDK from context, otherwise create new instance
-    let sdk;
-    try {
-        const context = useFeatureFlagContext();
-        sdk = context.sdk;
-    }
-    catch (_b) {
-        if (!options.config) {
-            throw new Error("useFeatureFlag must be used within FeatureFlagProvider or config must be provided");
+    const sdk = useMemo(() => {
+        try {
+            const context = useFeatureFlagContext();
+            return context.sdk;
         }
-        sdk = new FlipFlagSDK(options.config);
-    }
+        catch (_a) {
+            if (!options.config) {
+                throw new Error("useFeatureFlag must be used within FeatureFlagProvider or config must be provided");
+            }
+            return new FlipFlagSDK(options.config);
+        }
+    }, [options.config]);
     const updateFromState = useCallback(() => {
         if (!options.enabled && options.enabled !== undefined) {
             return;
@@ -524,6 +643,27 @@ function useFeatureFlag(flagName, options = {}) {
     };
 }
 
+/**
+ * Wait for SDK loading to complete with timeout
+ */
+function waitForSDKLoading(sdk, timeout = 5000) {
+    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+        const checkLoading = () => {
+            if (!sdk.getState().isLoading) {
+                resolve();
+                return;
+            }
+            if (Date.now() - startTime > timeout) {
+                reject(new Error("Timeout waiting for SDK loading to complete"));
+                return;
+            }
+            // Check again after a short delay
+            setTimeout(checkLoading, 50);
+        };
+        checkLoading();
+    });
+}
 function useFeatureFlags(flagNames, options = {}) {
     const [flags, setFlags] = useState(() => {
         // Initialize with fallback values
@@ -538,17 +678,18 @@ function useFeatureFlags(flagNames, options = {}) {
     const [error, setError] = useState(null);
     const [isInitialized, setIsInitialized] = useState(false);
     // Try to get SDK from context, otherwise create new instance
-    let sdk;
-    try {
-        const context = useFeatureFlagContext();
-        sdk = context.sdk;
-    }
-    catch (_a) {
-        if (!options.config) {
-            throw new Error("useFeatureFlags must be used within FeatureFlagProvider or config must be provided");
+    const sdk = useMemo(() => {
+        try {
+            const context = useFeatureFlagContext();
+            return context.sdk;
         }
-        sdk = new FlipFlagSDK(options.config);
-    }
+        catch (_a) {
+            if (!options.config) {
+                throw new Error("useFeatureFlags must be used within FeatureFlagProvider or config must be provided");
+            }
+            return new FlipFlagSDK(options.config);
+        }
+    }, [options.config]);
     const fetchFlags = useCallback(async () => {
         if (!options.enabled && options.enabled !== undefined) {
             return;
@@ -580,30 +721,29 @@ function useFeatureFlags(flagNames, options = {}) {
             }
             // If SDK is currently loading, wait for it to complete
             if (sdk.getState().isLoading) {
-                // Wait up to 5 seconds for loading to complete
-                for (let i = 0; i < 50; i++) {
-                    await new Promise((resolve) => setTimeout(resolve, 100));
-                    const currentState = sdk.getState();
-                    if (!currentState.isLoading) {
-                        // Check again if we now have all flags
-                        const updatedStateFlags = {};
-                        let updatedHasAllFlags = true;
-                        flagNames.forEach((flagName) => {
-                            const stateValue = sdk.getFlagValue(flagName);
-                            if (stateValue !== undefined) {
-                                updatedStateFlags[flagName] = stateValue;
-                            }
-                            else {
-                                updatedHasAllFlags = false;
-                            }
-                        });
-                        if (updatedHasAllFlags) {
-                            setFlags(updatedStateFlags);
-                            setLoading(false);
-                            return;
+                try {
+                    await waitForSDKLoading(sdk);
+                    // Check again if we now have all flags
+                    const updatedStateFlags = {};
+                    let updatedHasAllFlags = true;
+                    flagNames.forEach((flagName) => {
+                        const stateValue = sdk.getFlagValue(flagName);
+                        if (stateValue !== undefined) {
+                            updatedStateFlags[flagName] = stateValue;
                         }
+                        else {
+                            updatedHasAllFlags = false;
+                        }
+                    });
+                    if (updatedHasAllFlags) {
+                        setFlags(updatedStateFlags);
+                        setLoading(false);
+                        return;
                     }
                 }
+                catch (error) {
+                    console.warn("Timeout waiting for SDK loading, proceeding with API call");
+                }
             }
             // If we still don't have all flags, make HTTP request
             const response = await sdk.getFlags();
@@ -646,7 +786,7 @@ function useFeatureFlags(flagNames, options = {}) {
     }, [sdk, fetchFlags]);
     useEffect(() => {
         fetchFlags();
-    }, []); // Remove fetchFlags dependency to prevent infinite loop
+    }, [fetchFlags]); // Include fetchFlags dependency
     // Subscribe to state changes for automatic updates
     useEffect(() => {
         const unsubscribe = sdk.subscribe((state) => {
@@ -687,17 +827,18 @@ function useABTest(testName, options) {
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
     // Try to get SDK from context, otherwise create new instance
-    let sdk;
-    try {
-        const context = useFeatureFlagContext();
-        sdk = context.sdk;
-    }
-    catch (_a) {
-        if (!options.config) {
-            throw new Error("useABTest must be used within FeatureFlagProvider or config must be provided");
+    const sdk = useMemo(() => {
+        try {
+            const context = useFeatureFlagContext();
+            return context.sdk;
         }
-        sdk = new FlipFlagSDK(options.config);
-    }
+        catch (_a) {
+            if (!options.config) {
+                throw new Error("useABTest must be used within FeatureFlagProvider or config must be provided");
+            }
+            return new FlipFlagSDK(options.config);
+        }
+    }, [options.config]);
     const fetchVariant = useCallback(async () => {
         if (!options.enabled && options.enabled !== undefined) {
             return;