@firebase/remote-config 0.5.0-canary.d8aabaf9e → 0.5.0-canary.dcfb3da2e

package/dist/esm/src/public_types.d.ts

@@ -46,6 +46,58 @@ export interface RemoteConfig {
      */
     lastFetchStatus: FetchStatus;
 }
+/**
+ * Defines a self-descriptive reference for config key-value pairs.
+ */
+export interface FirebaseRemoteConfigObject {
+    [key: string]: string;
+}
+/**
+ * Defines a successful response (200 or 304).
+ *
+ * <p>Modeled after the native `Response` interface, but simplified for Remote Config's
+ * use case.
+ */
+export interface FetchResponse {
+    /**
+     * The HTTP status, which is useful for differentiating success responses with data from
+     * those without.
+     *
+     * <p>The Remote Config client is modeled after the native `Fetch` interface, so
+     * HTTP status is first-class.
+     *
+     * <p>Disambiguation: the fetch response returns a legacy "state" value that is redundant with the
+     * HTTP status code. The former is normalized into the latter.
+     */
+    status: number;
+    /**
+     * Defines the ETag response header value.
+     *
+     * <p>Only defined for 200 and 304 responses.
+     */
+    eTag?: string;
+    /**
+     * Defines the map of parameters returned as "entries" in the fetch response body.
+     *
+     * <p>Only defined for 200 responses.
+     */
+    config?: FirebaseRemoteConfigObject;
+}
+/**
+ * Options for Remote Config initialization.
+ *
+ * @public
+ */
+export interface RemoteConfigOptions {
+    /**
+     * The ID of the template to use. If not provided, defaults to "firebase".
+     */
+    templateId?: string;
+    /**
+     * Hydrates the state with an initial fetch response.
+     */
+    initialFetchResponse?: FetchResponse;
+}
 /**
  * Indicates the source of a value.
  *

package/dist/esm/src/remote_config.d.ts

@@ -23,7 +23,7 @@ import { Logger } from '@firebase/logger';
 /**
  * Encapsulates business logic mapping network and storage dependencies to the public SDK API.
  *
- * See {@link https://github.com/firebase/firebase-js-sdk/blob/main/packages/firebase/index.d.ts|interface documentation} for method descriptions.
+ * See {@link https://github.com/firebase/firebase-js-sdk/blob/main/packages/firebase/compat/index.d.ts|interface documentation} for method descriptions.
  */
 export declare class RemoteConfig implements RemoteConfigType {
     readonly app: FirebaseApp;

package/dist/esm/src/storage/storage.d.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 import { FetchStatus, CustomSignals } from '@firebase/remote-config-types';
-import { FetchResponse, FirebaseRemoteConfigObject } from '../client/remote_config_fetch_client';
+import { FetchResponse, FirebaseRemoteConfigObject } from '../public_types';
 /**
  * A general-purpose store keyed by app + namespace + {@link
  * ProjectNamespaceKeyFieldValue}.
@@ -44,17 +44,7 @@ export declare function openDatabase(): Promise<IDBDatabase>;
 /**
  * Abstracts data persistence.
  */
-export declare class Storage {
-    private readonly appId;
-    private readonly appName;
-    private readonly namespace;
-    private readonly openDbPromise;
-    /**
-     * @param appId enables storage segmentation by app (ID + name).
-     * @param appName enables storage segmentation by app (ID + name).
-     * @param namespace enables storage segmentation by namespace.
-     */
-    constructor(appId: string, appName: string, namespace: string, openDbPromise?: Promise<IDBDatabase>);
+export declare abstract class Storage {
     getLastFetchStatus(): Promise<FetchStatus | undefined>;
     setLastFetchStatus(status: FetchStatus): Promise<void>;
     getLastSuccessfulFetchTimestampMillis(): Promise<number | undefined>;
@@ -69,6 +59,22 @@ export declare class Storage {
     setThrottleMetadata(metadata: ThrottleMetadata): Promise<void>;
     deleteThrottleMetadata(): Promise<void>;
     getCustomSignals(): Promise<CustomSignals | undefined>;
+    abstract setCustomSignals(customSignals: CustomSignals): Promise<CustomSignals>;
+    abstract get<T>(key: ProjectNamespaceKeyFieldValue): Promise<T | undefined>;
+    abstract set<T>(key: ProjectNamespaceKeyFieldValue, value: T): Promise<void>;
+    abstract delete(key: ProjectNamespaceKeyFieldValue): Promise<void>;
+}
+export declare class IndexedDbStorage extends Storage {
+    private readonly appId;
+    private readonly appName;
+    private readonly namespace;
+    private readonly openDbPromise;
+    /**
+     * @param appId enables storage segmentation by app (ID + name).
+     * @param appName enables storage segmentation by app (ID + name).
+     * @param namespace enables storage segmentation by namespace.
+     */
+    constructor(appId: string, appName: string, namespace: string, openDbPromise?: Promise<IDBDatabase>);
     setCustomSignals(customSignals: CustomSignals): Promise<CustomSignals>;
     /**
      * Gets a value from the database using the provided transaction.
@@ -92,4 +98,11 @@ export declare class Storage {
     delete(key: ProjectNamespaceKeyFieldValue): Promise<void>;
     createCompositeKey(key: ProjectNamespaceKeyFieldValue): string;
 }
+export declare class InMemoryStorage extends Storage {
+    private storage;
+    get<T>(key: ProjectNamespaceKeyFieldValue): Promise<T>;
+    set<T>(key: ProjectNamespaceKeyFieldValue, value: T): Promise<void>;
+    delete(key: ProjectNamespaceKeyFieldValue): Promise<void>;
+    setCustomSignals(customSignals: CustomSignals): Promise<CustomSignals>;
+}
 export {};

package/dist/esm/src/storage/storage_cache.d.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 import { FetchStatus, CustomSignals } from '@firebase/remote-config-types';
-import { FirebaseRemoteConfigObject } from '../client/remote_config_fetch_client';
+import { FirebaseRemoteConfigObject } from '../public_types';
 import { Storage } from './storage';
 /**
  * A memory cache layer over storage to support the SDK's synchronous read requirements.

package/dist/index.cjs.js

@@ -9,7 +9,7 @@ var logger = require('@firebase/logger');
 require('@firebase/installations');
 
 const name = "@firebase/remote-config";
-const version = "0.5.0-canary.d8aabaf9e";
+const version = "0.5.0-canary.dcfb3da2e";
 
 /**
  * @license
@@ -85,6 +85,7 @@ const RC_CUSTOM_SIGNAL_VALUE_MAX_LENGTH = 500;
  * limitations under the License.
  */
 const ERROR_DESCRIPTION_MAP = {
+    ["already-initialized" /* ErrorCode.ALREADY_INITIALIZED */]: 'Remote Config already initialized',
     ["registration-window" /* ErrorCode.REGISTRATION_WINDOW */]: 'Undefined window object. This SDK only supports usage in a browser environment.',
     ["registration-project-id" /* ErrorCode.REGISTRATION_PROJECT_ID */]: 'Undefined project identifier. Check Firebase app initialization.',
     ["registration-api-key" /* ErrorCode.REGISTRATION_API_KEY */]: 'Undefined API key. Check Firebase app initialization.',
@@ -180,14 +181,40 @@ class Value {
 /**
  *
  * @param app - The {@link @firebase/app#FirebaseApp} instance.
+ * @param options - Optional. The {@link RemoteConfigOptions} with which to instantiate the
+ *     Remote Config instance.
  * @returns A {@link RemoteConfig} instance.
  *
  * @public
  */
-function getRemoteConfig(app$1 = app.getApp()) {
+function getRemoteConfig(app$1 = app.getApp(), options = {}) {
+    var _a, _b;
     app$1 = util.getModularInstance(app$1);
     const rcProvider = app._getProvider(app$1, RC_COMPONENT_NAME);
-    return rcProvider.getImmediate();
+    if (rcProvider.isInitialized()) {
+        const initialOptions = rcProvider.getOptions();
+        if (util.deepEqual(initialOptions, options)) {
+            return rcProvider.getImmediate();
+        }
+        throw ERROR_FACTORY.create("already-initialized" /* ErrorCode.ALREADY_INITIALIZED */);
+    }
+    rcProvider.initialize({ options });
+    const rc = rcProvider.getImmediate();
+    if (options.initialFetchResponse) {
+        // We use these initial writes as the initialization promise since they will hydrate the same
+        // fields that `storageCache.loadFromStorage` would set.
+        rc._initializePromise = Promise.all([
+            rc._storage.setLastSuccessfulFetchResponse(options.initialFetchResponse),
+            rc._storage.setActiveConfigEtag(((_a = options.initialFetchResponse) === null || _a === void 0 ? void 0 : _a.eTag) || ''),
+            rc._storageCache.setLastSuccessfulFetchTimestampMillis(Date.now()),
+            rc._storageCache.setLastFetchStatus('success'),
+            rc._storageCache.setActiveConfig(((_b = options.initialFetchResponse) === null || _b === void 0 ? void 0 : _b.config) || {})
+        ]).then();
+        // The `storageCache` methods above set their in-memory fields synchronously, so it's
+        // safe to declare our initialization complete at this point.
+        rc._isInitializationComplete = true;
+    }
+    return rc;
 }
 /**
  * Makes the last fetched config available to the getters.
@@ -809,7 +836,7 @@ const DEFAULT_CACHE_MAX_AGE_MILLIS = 12 * 60 * 60 * 1000; // Twelve hours.
 /**
  * Encapsulates business logic mapping network and storage dependencies to the public SDK API.
  *
- * See {@link https://github.com/firebase/firebase-js-sdk/blob/main/packages/firebase/index.d.ts|interface documentation} for method descriptions.
+ * See {@link https://github.com/firebase/firebase-js-sdk/blob/main/packages/firebase/compat/index.d.ts|interface documentation} for method descriptions.
  */
 class RemoteConfig {
     get fetchTimeMillis() {
@@ -933,17 +960,6 @@ function openDatabase() {
  * Abstracts data persistence.
  */
 class Storage {
-    /**
-     * @param appId enables storage segmentation by app (ID + name).
-     * @param appName enables storage segmentation by app (ID + name).
-     * @param namespace enables storage segmentation by namespace.
-     */
-    constructor(appId, appName, namespace, openDbPromise = openDatabase()) {
-        this.appId = appId;
-        this.appName = appName;
-        this.namespace = namespace;
-        this.openDbPromise = openDbPromise;
-    }
     getLastFetchStatus() {
         return this.get('last_fetch_status');
     }
@@ -988,28 +1004,25 @@ class Storage {
     getCustomSignals() {
         return this.get('custom_signals');
     }
+}
+class IndexedDbStorage extends Storage {
+    /**
+     * @param appId enables storage segmentation by app (ID + name).
+     * @param appName enables storage segmentation by app (ID + name).
+     * @param namespace enables storage segmentation by namespace.
+     */
+    constructor(appId, appName, namespace, openDbPromise = openDatabase()) {
+        super();
+        this.appId = appId;
+        this.appName = appName;
+        this.namespace = namespace;
+        this.openDbPromise = openDbPromise;
+    }
     async setCustomSignals(customSignals) {
         const db = await this.openDbPromise;
         const transaction = db.transaction([APP_NAMESPACE_STORE], 'readwrite');
         const storedSignals = await this.getWithTransaction('custom_signals', transaction);
-        const combinedSignals = Object.assign(Object.assign({}, storedSignals), customSignals);
-        // Filter out key-value assignments with null values since they are signals being unset
-        const updatedSignals = Object.fromEntries(Object.entries(combinedSignals)
-            .filter(([_, v]) => v !== null)
-            .map(([k, v]) => {
-            // Stringify numbers to store a map of string keys and values which can be sent
-            // as-is in a fetch call.
-            if (typeof v === 'number') {
-                return [k, v.toString()];
-            }
-            return [k, v];
-        }));
-        // Throw an error if the number of custom signals to be stored exceeds the limit
-        if (Object.keys(updatedSignals).length > RC_CUSTOM_SIGNAL_MAX_ALLOWED_SIGNALS) {
-            throw ERROR_FACTORY.create("custom-signal-max-allowed-signals" /* ErrorCode.CUSTOM_SIGNAL_MAX_ALLOWED_SIGNALS */, {
-                maxSignals: RC_CUSTOM_SIGNAL_MAX_ALLOWED_SIGNALS
-            });
-        }
+        const updatedSignals = mergeCustomSignals(customSignals, storedSignals || {});
         await this.setWithTransaction('custom_signals', updatedSignals, transaction);
         return updatedSignals;
     }
@@ -1114,6 +1127,50 @@ class Storage {
         return [this.appId, this.appName, this.namespace, key].join();
     }
 }
+class InMemoryStorage extends Storage {
+    constructor() {
+        super(...arguments);
+        this.storage = {};
+    }
+    async get(key) {
+        return Promise.resolve(this.storage[key]);
+    }
+    async set(key, value) {
+        this.storage[key] = value;
+        return Promise.resolve(undefined);
+    }
+    async delete(key) {
+        this.storage[key] = undefined;
+        return Promise.resolve();
+    }
+    async setCustomSignals(customSignals) {
+        const storedSignals = (this.storage['custom_signals'] ||
+            {});
+        this.storage['custom_signals'] = mergeCustomSignals(customSignals, storedSignals);
+        return Promise.resolve(this.storage['custom_signals']);
+    }
+}
+function mergeCustomSignals(customSignals, storedSignals) {
+    const combinedSignals = Object.assign(Object.assign({}, storedSignals), customSignals);
+    // Filter out key-value assignments with null values since they are signals being unset
+    const updatedSignals = Object.fromEntries(Object.entries(combinedSignals)
+        .filter(([_, v]) => v !== null)
+        .map(([k, v]) => {
+        // Stringify numbers to store a map of string keys and values which can be sent
+        // as-is in a fetch call.
+        if (typeof v === 'number') {
+            return [k, v.toString()];
+        }
+        return [k, v];
+    }));
+    // Throw an error if the number of custom signals to be stored exceeds the limit
+    if (Object.keys(updatedSignals).length > RC_CUSTOM_SIGNAL_MAX_ALLOWED_SIGNALS) {
+        throw ERROR_FACTORY.create("custom-signal-max-allowed-signals" /* ErrorCode.CUSTOM_SIGNAL_MAX_ALLOWED_SIGNALS */, {
+            maxSignals: RC_CUSTOM_SIGNAL_MAX_ALLOWED_SIGNALS
+        });
+    }
+    return updatedSignals;
+}
 
 /**
  * @license
@@ -1225,7 +1282,7 @@ function registerRemoteConfig() {
     app.registerVersion(name, version);
     // BUILD_TARGET will be replaced by values like esm2017, cjs2017, etc during the compilation
     app.registerVersion(name, version, 'cjs2017');
-    function remoteConfigFactory(container, { instanceIdentifier: namespace }) {
+    function remoteConfigFactory(container, { options }) {
         /* Dependencies */
         // getImmediate for FirebaseApp will always succeed
         const app$1 = container.getProvider('app').getImmediate();
@@ -1233,14 +1290,6 @@ function registerRemoteConfig() {
         const installations = container
             .getProvider('installations-internal')
             .getImmediate();
-        // Guards against the SDK being used in non-browser environments.
-        if (typeof window === 'undefined') {
-            throw ERROR_FACTORY.create("registration-window" /* ErrorCode.REGISTRATION_WINDOW */);
-        }
-        // Guards against the SDK being used when indexedDB is not available.
-        if (!util.isIndexedDBAvailable()) {
-            throw ERROR_FACTORY.create("indexed-db-unavailable" /* ErrorCode.INDEXED_DB_UNAVAILABLE */);
-        }
         // Normalizes optional inputs.
         const { projectId, apiKey, appId } = app$1.options;
         if (!projectId) {
@@ -1252,8 +1301,10 @@ function registerRemoteConfig() {
         if (!appId) {
             throw ERROR_FACTORY.create("registration-app-id" /* ErrorCode.REGISTRATION_APP_ID */);
         }
-        namespace = namespace || 'firebase';
-        const storage = new Storage(appId, app$1.name, namespace);
+        const namespace = (options === null || options === void 0 ? void 0 : options.templateId) || 'firebase';
+        const storage = util.isIndexedDBAvailable()
+            ? new IndexedDbStorage(appId, app$1.name, namespace)
+            : new InMemoryStorage();
         const storageCache = new StorageCache(storage);
         const logger$1 = new logger.Logger(name);
         // Sets ERROR as the default log level.