@flagship.io/react-native-sdk/dist/FlagshipProvider.js

Flagship SDK for React Native

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
import { FlagshipProvider as ReactFlagshipProvider, Flagship, OS_NAME, OS_VERSION_CODE, CacheStrategy } from '@flagship.io/react-sdk';
import React, { useCallback, useEffect, useMemo, useState } from 'react';
import { DefaultHitCache } from './cache/DefaultHitCache';
import { DefaultVisitorCache } from './cache/DefaultVisitorCache';
import AsyncStorage from '@react-native-async-storage/async-storage';
import { Platform } from 'react-native';
import { version as SDK_VERSION } from './sdkVersion';
import { TouchCaptureProvider } from './TouchCaptureProvider';
import { CLIENT_CACHE_KEY, DEFAULT_POOL_MAX_SIZE, DEFAULT_TIME_INTERVAL, SDK_FIRST_TIME_INIT } from './Constant';
const ERROR_MESSAGE_ASYNC_STORAGE = 'Error accessing AsyncStorage';
const CONTEXT_LOAD_PREDEFINED = 'loadPredefinedContext';
const SAVE_VISITOR_PROFILE = 'saveVisitorProfile';
const FlagshipProviderFunc = (_a) => {
    var { children, visitorCacheImplementation, hitCacheImplementation, visitorData } = _a, props = __rest(_a, ["children", "visitorCacheImplementation", "hitCacheImplementation", "visitorData"]);
    const [processedVisitorData, setProcessedVisitorData] = useState(null);
    const firstTimeInitRef = React.useRef();
    const saveVisitorProfile = useCallback((value) => __awaiter(void 0, void 0, void 0, function* () {
        var _a, _b;
        try {
            yield AsyncStorage.setItem(CLIENT_CACHE_KEY, value);
        }
        catch (error) {
            (_b = (_a = Flagship.getConfig()) === null || _a === void 0 ? void 0 : _a.logManager) === null || _b === void 0 ? void 0 : _b.error(ERROR_MESSAGE_ASYNC_STORAGE, SAVE_VISITOR_PROFILE);
        }
    }), []);
    const initializeVisitorProfile = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
        var _a, _b;
        try {
            if (firstTimeInitRef.current !== undefined) {
                return;
            }
            const clientCache = yield AsyncStorage.getItem(CLIENT_CACHE_KEY);
            const augmentedFlagship = Flagship;
            augmentedFlagship.setVisitorProfile(clientCache);
            augmentedFlagship.setOnSaveVisitorProfile(saveVisitorProfile);
            firstTimeInitRef.current = !clientCache;
        }
        catch (error) {
            (_b = (_a = Flagship.getConfig()) === null || _a === void 0 ? void 0 : _a.logManager) === null || _b === void 0 ? void 0 : _b.error(ERROR_MESSAGE_ASYNC_STORAGE, CONTEXT_LOAD_PREDEFINED);
        }
    }), []);
    const updateVisitorData = useCallback((data) => {
        var _a;
        return (Object.assign(Object.assign({}, data), { id: data.id, context: Object.assign(Object.assign({}, data.context), { [OS_NAME]: Platform.OS, [OS_VERSION_CODE]: (_a = Platform.Version) === null || _a === void 0 ? void 0 : _a.toString(), [SDK_FIRST_TIME_INIT]: !!firstTimeInitRef.current }) }));
    }, []);
    useEffect(() => {
        function initialize() {
            return __awaiter(this, void 0, void 0, function* () {
                yield initializeVisitorProfile();
                if (visitorData) {
                    const updatedData = updateVisitorData(visitorData);
                    setProcessedVisitorData(updatedData);
                }
            });
        }
        initialize();
    }, [visitorData, updateVisitorData, initializeVisitorProfile]);
    const visitorCache = useMemo(() => {
        return visitorCacheImplementation || new DefaultVisitorCache();
    }, [visitorCacheImplementation]);
    const hitCache = useMemo(() => {
        return hitCacheImplementation || new DefaultHitCache();
    }, [hitCacheImplementation]);
    const trackingConfig = useMemo(() => {
        return (props.trackingManagerConfig || {
            poolMaxSize: DEFAULT_POOL_MAX_SIZE,
            batchIntervals: DEFAULT_TIME_INTERVAL,
            cacheStrategy: CacheStrategy.CONTINUOUS_CACHING
        });
    }, [props.trackingManagerConfig]);
    return (<ReactFlagshipProvider {...props} trackingManagerConfig={trackingConfig} sdkVersion={SDK_VERSION} language={2} visitorCacheImplementation={visitorCache} hitCacheImplementation={hitCache} visitorData={processedVisitorData} shouldSaveInstance={true}>
            <TouchCaptureProvider>{children}</TouchCaptureProvider>
        </ReactFlagshipProvider>);
};
export const FlagshipProvider = React.memo(FlagshipProviderFunc);