@inovaebiz/inova-feature-flag/dist/esm/providers/InovaFeatureFlagProvider.js

O Inova Feature Flag é uma biblioteca para React e React Native que permite configurar e acessar flags de recursos em seu aplicativo. Com ela, você pode facilmente definir as flags de recursos em um único lugar e acessá-las em todo o seu aplicativo usando

import { __awaiter, __generator } from "tslib";
import React, { createContext, useState, useEffect, useMemo, useCallback } from 'react';
var DEFAULT_API_URL = 'https://inovaebiz.com.br/';
var DEFAULT_CACHE_DURATION = 3600 * 24;
var DEFAULT_CACHE_RESULTS = true;
var DEFAULT_AUTO_REFETCH = false;
var defaultOptions = {
    url: DEFAULT_API_URL,
    autoRefetch: DEFAULT_AUTO_REFETCH,
    cacheResults: DEFAULT_CACHE_RESULTS,
    cacheDataForSeconds: DEFAULT_CACHE_DURATION
};
export var InovaFeatureFlagContext = createContext({});
export var InovaFeatureFlagProvider = function (_a) {
    var children = _a.children, sdkKey = _a.sdkKey, userOptions = _a.options;
    var _b = useState([]), flags = _b[0], setFlags = _b[1];
    var _c = useState(null), lastFetchedAt = _c[0], setLastFetchedAt = _c[1];
    var _d = useState(true), isLoading = _d[0], setIsLoading = _d[1];
    var options = useMemo(function () { return userOptions !== null && userOptions !== void 0 ? userOptions : defaultOptions; }, [userOptions]);
    var headers = new Headers({ Authorization: "Bearer ".concat(sdkKey) });
    var fetchFeatureFlags = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
        var response, data, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    if (!headers) {
                        return [2 /*return*/, new Error('No SDK key provided')];
                    }
                    _b.label = 1;
                case 1:
                    _b.trys.push([1, 4, , 5]);
                    return [4 /*yield*/, fetch(options.url, {
                            method: 'POST',
                            headers: headers
                        })];
                case 2:
                    response = _b.sent();
                    return [4 /*yield*/, response.json()];
                case 3:
                    data = (_b.sent());
                    if (data && data.success && data.data.featureFlags) {
                        setFlags(data.data.featureFlags);
                        setLastFetchedAt(new Date());
                        setIsLoading(false);
                        return [2 /*return*/, data.data.featureFlags];
                    }
                    else {
                        setIsLoading(false);
                        return [2 /*return*/, []];
                    }
                    return [3 /*break*/, 5];
                case 4:
                    _a = _b.sent();
                    setIsLoading(false);
                    return [2 /*return*/, []];
                case 5: return [2 /*return*/];
            }
        });
    }); }, []);
    var useInovaFlag = useCallback(function (key, defaultValue) {
        var _a;
        if (isLoading) {
            return defaultValue;
        }
        var value = (_a = flags.find(function (flag) { return flag.key === key; })) === null || _a === void 0 ? void 0 : _a.value;
        if (typeof value !== 'undefined' && typeof value !== typeof defaultValue && !isLoading && flags.length > 0) {
            console.log(" \u26A0\uFE0F Flag ".concat(key, " is of type ").concat(typeof value, " but you are trying to use it as ").concat(typeof defaultValue));
            return defaultValue;
        }
        return value !== null && value !== void 0 ? value : defaultValue;
    }, [flags, isLoading]);
    useEffect(function () {
        if (options.autoRefetch && lastFetchedAt) {
            var cacheDuration = options.cacheDataForSeconds * 1000;
            var elapsedTime = new Date().getTime() - lastFetchedAt.getTime();
            if (elapsedTime > cacheDuration) {
                fetchFeatureFlags();
            }
        }
        else if (flags.length < 1 && lastFetchedAt === null) {
            fetchFeatureFlags();
        }
    }, [options, lastFetchedAt, fetchFeatureFlags, flags]);
    return React.createElement(InovaFeatureFlagContext.Provider, { value: { useInovaFlag: useInovaFlag } }, children);
};
//# sourceMappingURL=InovaFeatureFlagProvider.js.map