@react-native-firebase/remote-config/dist/module/web/RNFBConfigModule.js

React Native Firebase - React Native Firebase provides native integration with Remote Config, allowing you to change the appearance and/or functionality of your app without requiring an app update.

"use strict";

import '../polyfills';
import { activate, ensureInitialized, fetchAndActivate, fetchConfig, getAll, getApp, getRemoteConfig, makeIDBAvailable, onConfigUpdate, setCustomSignals } from '@react-native-firebase/app/dist/module/internal/web/firebaseRemoteConfig';
import { emitEvent, getWebError, guard } from '@react-native-firebase/app/dist/module/internal/web/utils';
const DEFAULT_CONFIG_SETTINGS = {
  minimumFetchIntervalMillis: 43200000,
  fetchTimeoutMillis: 60000
};
const configSettingsForInstance = {};
const defaultConfigForInstance = {};
const onConfigUpdateListeners = {};
function makeGlobalsAvailable() {
  navigator.onLine = true;
  makeIDBAvailable();
}
function getRemoteConfigInstanceForApp(appName, overrides = {}) {
  makeGlobalsAvailable();
  const configSettings = {
    ...(configSettingsForInstance[appName] ?? DEFAULT_CONFIG_SETTINGS),
    ...overrides
  };
  const defaultConfig = defaultConfigForInstance[appName] ?? {};
  const app = getApp(appName);
  const instance = getRemoteConfig(app);
  Object.assign(instance.settings, configSettings);
  instance.defaultConfig = defaultConfig;
  return instance;
}
function toLastFetchStatus(status) {
  switch (status) {
    case 'success':
    case 'failure':
    case 'no_fetch_yet':
    case 'throttled':
      return status;
    case 'no-fetch-yet':
      return 'no_fetch_yet';
    case 'throttle':
      return 'throttled';
    default:
      return 'no_fetch_yet';
  }
}
function resultAndConstants(instance, result) {
  const valuesRaw = getAll(instance);
  const values = {};
  for (const key in valuesRaw) {
    const raw = valuesRaw[key];
    if (raw) {
      values[key] = {
        source: raw.getSource(),
        value: raw.asString()
      };
    }
  }
  return {
    result,
    constants: {
      values,
      lastFetchTime: instance.fetchTimeMillis === -1 ? 0 : instance.fetchTimeMillis,
      lastFetchStatus: toLastFetchStatus(instance.lastFetchStatus),
      minimumFetchInterval: instance.settings.minimumFetchIntervalMillis ? instance.settings.minimumFetchIntervalMillis / 1000 : 43200,
      fetchTimeout: instance.settings.fetchTimeoutMillis ? instance.settings.fetchTimeoutMillis / 1000 : 60
    }
  };
}
const remoteConfigWebModule = {
  activate(appName) {
    return guard(async () => {
      const remoteConfig = getRemoteConfigInstanceForApp(appName);
      return resultAndConstants(remoteConfig, await activate(remoteConfig));
    });
  },
  setConfigSettings(appName, settings) {
    return guard(async () => {
      const webSettings = {
        minimumFetchIntervalMillis: settings.minimumFetchInterval * 1000,
        fetchTimeoutMillis: settings.fetchTimeout * 1000
      };
      configSettingsForInstance[appName] = webSettings;
      const remoteConfig = getRemoteConfigInstanceForApp(appName, webSettings);
      return resultAndConstants(remoteConfig, undefined);
    });
  },
  fetch(appName, expirationDurationSeconds) {
    return guard(async () => {
      const overrides = {};
      if (expirationDurationSeconds !== -1) {
        overrides.minimumFetchIntervalMillis = expirationDurationSeconds * 1000;
      }
      const remoteConfig = getRemoteConfigInstanceForApp(appName, overrides);
      await fetchConfig(remoteConfig);
      return resultAndConstants(remoteConfig, undefined);
    });
  },
  fetchAndActivate(appName) {
    return guard(async () => {
      const remoteConfig = getRemoteConfigInstanceForApp(appName);
      return resultAndConstants(remoteConfig, await fetchAndActivate(remoteConfig));
    });
  },
  ensureInitialized(appName) {
    return guard(async () => {
      const remoteConfig = getRemoteConfigInstanceForApp(appName);
      await ensureInitialized(remoteConfig);
      return resultAndConstants(remoteConfig, undefined);
    });
  },
  setDefaults(appName, defaults) {
    return guard(async () => {
      defaultConfigForInstance[appName] = defaults;
      const remoteConfig = getRemoteConfigInstanceForApp(appName);
      return resultAndConstants(remoteConfig, null);
    });
  },
  setCustomSignals(appName, customSignals) {
    return guard(async () => {
      const remoteConfig = getRemoteConfigInstanceForApp(appName);
      await setCustomSignals(remoteConfig, customSignals);
      return resultAndConstants(remoteConfig, undefined);
    });
  },
  onConfigUpdated(appName) {
    if (onConfigUpdateListeners[appName]) {
      return;
    }
    const remoteConfig = getRemoteConfigInstanceForApp(appName);
    const nativeObserver = {
      next(configUpdate) {
        emitEvent('on_config_updated', {
          appName,
          resultType: 'success',
          updatedKeys: Array.from(configUpdate.getUpdatedKeys())
        });
      },
      error(firebaseError) {
        emitEvent('on_config_updated', {
          appName,
          event: getWebError(firebaseError)
        });
      },
      complete() {}
    };
    onConfigUpdateListeners[appName] = onConfigUpdate(remoteConfig, nativeObserver);
  },
  removeConfigUpdateRegistration(appName) {
    const unsubscribe = onConfigUpdateListeners[appName];
    if (!unsubscribe) {
      return;
    }
    unsubscribe();
    delete onConfigUpdateListeners[appName];
  }
};
export default remoteConfigWebModule;
//# sourceMappingURL=RNFBConfigModule.js.map