@progressive-development/pd-spa-helper 0.3.102 → 0.3.104

package/dist/node_modules/@firebase/installations/dist/esm/index.esm2017.js

@@ -0,0 +1,863 @@
+import { registerVersion, _registerComponent, _getProvider } from "../../../app/dist/esm/index.esm2017.js";
+import { Component } from "../../../component/dist/esm/index.esm2017.js";
+import { ErrorFactory, FirebaseError } from "../../../util/dist/index.esm2017.js";
+import { openDB } from "../../../../idb/build/index.js";
+const name = "@firebase/installations";
+const version = "0.6.9";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const PENDING_TIMEOUT_MS = 1e4;
+const PACKAGE_VERSION = `w:${version}`;
+const INTERNAL_AUTH_VERSION = "FIS_v2";
+const INSTALLATIONS_API_URL = "https://firebaseinstallations.googleapis.com/v1";
+const TOKEN_EXPIRATION_BUFFER = 60 * 60 * 1e3;
+const SERVICE = "installations";
+const SERVICE_NAME = "Installations";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ERROR_DESCRIPTION_MAP = {
+  [
+    "missing-app-config-values"
+    /* ErrorCode.MISSING_APP_CONFIG_VALUES */
+  ]: 'Missing App configuration value: "{$valueName}"',
+  [
+    "not-registered"
+    /* ErrorCode.NOT_REGISTERED */
+  ]: "Firebase Installation is not registered.",
+  [
+    "installation-not-found"
+    /* ErrorCode.INSTALLATION_NOT_FOUND */
+  ]: "Firebase Installation not found.",
+  [
+    "request-failed"
+    /* ErrorCode.REQUEST_FAILED */
+  ]: '{$requestName} request failed with error "{$serverCode} {$serverStatus}: {$serverMessage}"',
+  [
+    "app-offline"
+    /* ErrorCode.APP_OFFLINE */
+  ]: "Could not process request. Application offline.",
+  [
+    "delete-pending-registration"
+    /* ErrorCode.DELETE_PENDING_REGISTRATION */
+  ]: "Can't delete installation while there is a pending registration request."
+};
+const ERROR_FACTORY = new ErrorFactory(SERVICE, SERVICE_NAME, ERROR_DESCRIPTION_MAP);
+function isServerError(error) {
+  return error instanceof FirebaseError && error.code.includes(
+    "request-failed"
+    /* ErrorCode.REQUEST_FAILED */
+  );
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getInstallationsEndpoint({ projectId }) {
+  return `${INSTALLATIONS_API_URL}/projects/${projectId}/installations`;
+}
+function extractAuthTokenInfoFromResponse(response) {
+  return {
+    token: response.token,
+    requestStatus: 2,
+    expiresIn: getExpiresInFromResponseExpiresIn(response.expiresIn),
+    creationTime: Date.now()
+  };
+}
+async function getErrorFromResponse(requestName, response) {
+  const responseJson = await response.json();
+  const errorData = responseJson.error;
+  return ERROR_FACTORY.create("request-failed", {
+    requestName,
+    serverCode: errorData.code,
+    serverMessage: errorData.message,
+    serverStatus: errorData.status
+  });
+}
+function getHeaders({ apiKey }) {
+  return new Headers({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-goog-api-key": apiKey
+  });
+}
+function getHeadersWithAuth(appConfig, { refreshToken }) {
+  const headers = getHeaders(appConfig);
+  headers.append("Authorization", getAuthorizationHeader(refreshToken));
+  return headers;
+}
+async function retryIfServerError(fn) {
+  const result = await fn();
+  if (result.status >= 500 && result.status < 600) {
+    return fn();
+  }
+  return result;
+}
+function getExpiresInFromResponseExpiresIn(responseExpiresIn) {
+  return Number(responseExpiresIn.replace("s", "000"));
+}
+function getAuthorizationHeader(refreshToken) {
+  return `${INTERNAL_AUTH_VERSION} ${refreshToken}`;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function createInstallationRequest({ appConfig, heartbeatServiceProvider }, { fid }) {
+  const endpoint = getInstallationsEndpoint(appConfig);
+  const headers = getHeaders(appConfig);
+  const heartbeatService = heartbeatServiceProvider.getImmediate({
+    optional: true
+  });
+  if (heartbeatService) {
+    const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();
+    if (heartbeatsHeader) {
+      headers.append("x-firebase-client", heartbeatsHeader);
+    }
+  }
+  const body = {
+    fid,
+    authVersion: INTERNAL_AUTH_VERSION,
+    appId: appConfig.appId,
+    sdkVersion: PACKAGE_VERSION
+  };
+  const request = {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  };
+  const response = await retryIfServerError(() => fetch(endpoint, request));
+  if (response.ok) {
+    const responseValue = await response.json();
+    const registeredInstallationEntry = {
+      fid: responseValue.fid || fid,
+      registrationStatus: 2,
+      refreshToken: responseValue.refreshToken,
+      authToken: extractAuthTokenInfoFromResponse(responseValue.authToken)
+    };
+    return registeredInstallationEntry;
+  } else {
+    throw await getErrorFromResponse("Create Installation", response);
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function bufferToBase64UrlSafe(array) {
+  const b64 = btoa(String.fromCharCode(...array));
+  return b64.replace(/\+/g, "-").replace(/\//g, "_");
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const VALID_FID_PATTERN = /^[cdef][\w-]{21}$/;
+const INVALID_FID = "";
+function generateFid() {
+  try {
+    const fidByteArray = new Uint8Array(17);
+    const crypto = self.crypto || self.msCrypto;
+    crypto.getRandomValues(fidByteArray);
+    fidByteArray[0] = 112 + fidByteArray[0] % 16;
+    const fid = encode(fidByteArray);
+    return VALID_FID_PATTERN.test(fid) ? fid : INVALID_FID;
+  } catch (_a) {
+    return INVALID_FID;
+  }
+}
+function encode(fidByteArray) {
+  const b64String = bufferToBase64UrlSafe(fidByteArray);
+  return b64String.substr(0, 22);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getKey(appConfig) {
+  return `${appConfig.appName}!${appConfig.appId}`;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fidChangeCallbacks = /* @__PURE__ */ new Map();
+function fidChanged(appConfig, fid) {
+  const key = getKey(appConfig);
+  callFidChangeCallbacks(key, fid);
+  broadcastFidChange(key, fid);
+}
+function callFidChangeCallbacks(key, fid) {
+  const callbacks = fidChangeCallbacks.get(key);
+  if (!callbacks) {
+    return;
+  }
+  for (const callback of callbacks) {
+    callback(fid);
+  }
+}
+function broadcastFidChange(key, fid) {
+  const channel = getBroadcastChannel();
+  if (channel) {
+    channel.postMessage({ key, fid });
+  }
+  closeBroadcastChannel();
+}
+let broadcastChannel = null;
+function getBroadcastChannel() {
+  if (!broadcastChannel && "BroadcastChannel" in self) {
+    broadcastChannel = new BroadcastChannel("[Firebase] FID Change");
+    broadcastChannel.onmessage = (e) => {
+      callFidChangeCallbacks(e.data.key, e.data.fid);
+    };
+  }
+  return broadcastChannel;
+}
+function closeBroadcastChannel() {
+  if (fidChangeCallbacks.size === 0 && broadcastChannel) {
+    broadcastChannel.close();
+    broadcastChannel = null;
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DATABASE_NAME = "firebase-installations-database";
+const DATABASE_VERSION = 1;
+const OBJECT_STORE_NAME = "firebase-installations-store";
+let dbPromise = null;
+function getDbPromise() {
+  if (!dbPromise) {
+    dbPromise = openDB(DATABASE_NAME, DATABASE_VERSION, {
+      upgrade: (db, oldVersion) => {
+        switch (oldVersion) {
+          case 0:
+            db.createObjectStore(OBJECT_STORE_NAME);
+        }
+      }
+    });
+  }
+  return dbPromise;
+}
+async function set(appConfig, value) {
+  const key = getKey(appConfig);
+  const db = await getDbPromise();
+  const tx = db.transaction(OBJECT_STORE_NAME, "readwrite");
+  const objectStore = tx.objectStore(OBJECT_STORE_NAME);
+  const oldValue = await objectStore.get(key);
+  await objectStore.put(value, key);
+  await tx.done;
+  if (!oldValue || oldValue.fid !== value.fid) {
+    fidChanged(appConfig, value.fid);
+  }
+  return value;
+}
+async function remove(appConfig) {
+  const key = getKey(appConfig);
+  const db = await getDbPromise();
+  const tx = db.transaction(OBJECT_STORE_NAME, "readwrite");
+  await tx.objectStore(OBJECT_STORE_NAME).delete(key);
+  await tx.done;
+}
+async function update(appConfig, updateFn) {
+  const key = getKey(appConfig);
+  const db = await getDbPromise();
+  const tx = db.transaction(OBJECT_STORE_NAME, "readwrite");
+  const store = tx.objectStore(OBJECT_STORE_NAME);
+  const oldValue = await store.get(key);
+  const newValue = updateFn(oldValue);
+  if (newValue === void 0) {
+    await store.delete(key);
+  } else {
+    await store.put(newValue, key);
+  }
+  await tx.done;
+  if (newValue && (!oldValue || oldValue.fid !== newValue.fid)) {
+    fidChanged(appConfig, newValue.fid);
+  }
+  return newValue;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function getInstallationEntry(installations) {
+  let registrationPromise;
+  const installationEntry = await update(installations.appConfig, (oldEntry) => {
+    const installationEntry2 = updateOrCreateInstallationEntry(oldEntry);
+    const entryWithPromise = triggerRegistrationIfNecessary(installations, installationEntry2);
+    registrationPromise = entryWithPromise.registrationPromise;
+    return entryWithPromise.installationEntry;
+  });
+  if (installationEntry.fid === INVALID_FID) {
+    return { installationEntry: await registrationPromise };
+  }
+  return {
+    installationEntry,
+    registrationPromise
+  };
+}
+function updateOrCreateInstallationEntry(oldEntry) {
+  const entry = oldEntry || {
+    fid: generateFid(),
+    registrationStatus: 0
+    /* RequestStatus.NOT_STARTED */
+  };
+  return clearTimedOutRequest(entry);
+}
+function triggerRegistrationIfNecessary(installations, installationEntry) {
+  if (installationEntry.registrationStatus === 0) {
+    if (!navigator.onLine) {
+      const registrationPromiseWithError = Promise.reject(ERROR_FACTORY.create(
+        "app-offline"
+        /* ErrorCode.APP_OFFLINE */
+      ));
+      return {
+        installationEntry,
+        registrationPromise: registrationPromiseWithError
+      };
+    }
+    const inProgressEntry = {
+      fid: installationEntry.fid,
+      registrationStatus: 1,
+      registrationTime: Date.now()
+    };
+    const registrationPromise = registerInstallation(installations, inProgressEntry);
+    return { installationEntry: inProgressEntry, registrationPromise };
+  } else if (installationEntry.registrationStatus === 1) {
+    return {
+      installationEntry,
+      registrationPromise: waitUntilFidRegistration(installations)
+    };
+  } else {
+    return { installationEntry };
+  }
+}
+async function registerInstallation(installations, installationEntry) {
+  try {
+    const registeredInstallationEntry = await createInstallationRequest(installations, installationEntry);
+    return set(installations.appConfig, registeredInstallationEntry);
+  } catch (e) {
+    if (isServerError(e) && e.customData.serverCode === 409) {
+      await remove(installations.appConfig);
+    } else {
+      await set(installations.appConfig, {
+        fid: installationEntry.fid,
+        registrationStatus: 0
+        /* RequestStatus.NOT_STARTED */
+      });
+    }
+    throw e;
+  }
+}
+async function waitUntilFidRegistration(installations) {
+  let entry = await updateInstallationRequest(installations.appConfig);
+  while (entry.registrationStatus === 1) {
+    await sleep(100);
+    entry = await updateInstallationRequest(installations.appConfig);
+  }
+  if (entry.registrationStatus === 0) {
+    const { installationEntry, registrationPromise } = await getInstallationEntry(installations);
+    if (registrationPromise) {
+      return registrationPromise;
+    } else {
+      return installationEntry;
+    }
+  }
+  return entry;
+}
+function updateInstallationRequest(appConfig) {
+  return update(appConfig, (oldEntry) => {
+    if (!oldEntry) {
+      throw ERROR_FACTORY.create(
+        "installation-not-found"
+        /* ErrorCode.INSTALLATION_NOT_FOUND */
+      );
+    }
+    return clearTimedOutRequest(oldEntry);
+  });
+}
+function clearTimedOutRequest(entry) {
+  if (hasInstallationRequestTimedOut(entry)) {
+    return {
+      fid: entry.fid,
+      registrationStatus: 0
+      /* RequestStatus.NOT_STARTED */
+    };
+  }
+  return entry;
+}
+function hasInstallationRequestTimedOut(installationEntry) {
+  return installationEntry.registrationStatus === 1 && installationEntry.registrationTime + PENDING_TIMEOUT_MS < Date.now();
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function generateAuthTokenRequest({ appConfig, heartbeatServiceProvider }, installationEntry) {
+  const endpoint = getGenerateAuthTokenEndpoint(appConfig, installationEntry);
+  const headers = getHeadersWithAuth(appConfig, installationEntry);
+  const heartbeatService = heartbeatServiceProvider.getImmediate({
+    optional: true
+  });
+  if (heartbeatService) {
+    const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();
+    if (heartbeatsHeader) {
+      headers.append("x-firebase-client", heartbeatsHeader);
+    }
+  }
+  const body = {
+    installation: {
+      sdkVersion: PACKAGE_VERSION,
+      appId: appConfig.appId
+    }
+  };
+  const request = {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  };
+  const response = await retryIfServerError(() => fetch(endpoint, request));
+  if (response.ok) {
+    const responseValue = await response.json();
+    const completedAuthToken = extractAuthTokenInfoFromResponse(responseValue);
+    return completedAuthToken;
+  } else {
+    throw await getErrorFromResponse("Generate Auth Token", response);
+  }
+}
+function getGenerateAuthTokenEndpoint(appConfig, { fid }) {
+  return `${getInstallationsEndpoint(appConfig)}/${fid}/authTokens:generate`;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function refreshAuthToken(installations, forceRefresh = false) {
+  let tokenPromise;
+  const entry = await update(installations.appConfig, (oldEntry) => {
+    if (!isEntryRegistered(oldEntry)) {
+      throw ERROR_FACTORY.create(
+        "not-registered"
+        /* ErrorCode.NOT_REGISTERED */
+      );
+    }
+    const oldAuthToken = oldEntry.authToken;
+    if (!forceRefresh && isAuthTokenValid(oldAuthToken)) {
+      return oldEntry;
+    } else if (oldAuthToken.requestStatus === 1) {
+      tokenPromise = waitUntilAuthTokenRequest(installations, forceRefresh);
+      return oldEntry;
+    } else {
+      if (!navigator.onLine) {
+        throw ERROR_FACTORY.create(
+          "app-offline"
+          /* ErrorCode.APP_OFFLINE */
+        );
+      }
+      const inProgressEntry = makeAuthTokenRequestInProgressEntry(oldEntry);
+      tokenPromise = fetchAuthTokenFromServer(installations, inProgressEntry);
+      return inProgressEntry;
+    }
+  });
+  const authToken = tokenPromise ? await tokenPromise : entry.authToken;
+  return authToken;
+}
+async function waitUntilAuthTokenRequest(installations, forceRefresh) {
+  let entry = await updateAuthTokenRequest(installations.appConfig);
+  while (entry.authToken.requestStatus === 1) {
+    await sleep(100);
+    entry = await updateAuthTokenRequest(installations.appConfig);
+  }
+  const authToken = entry.authToken;
+  if (authToken.requestStatus === 0) {
+    return refreshAuthToken(installations, forceRefresh);
+  } else {
+    return authToken;
+  }
+}
+function updateAuthTokenRequest(appConfig) {
+  return update(appConfig, (oldEntry) => {
+    if (!isEntryRegistered(oldEntry)) {
+      throw ERROR_FACTORY.create(
+        "not-registered"
+        /* ErrorCode.NOT_REGISTERED */
+      );
+    }
+    const oldAuthToken = oldEntry.authToken;
+    if (hasAuthTokenRequestTimedOut(oldAuthToken)) {
+      return Object.assign(Object.assign({}, oldEntry), { authToken: {
+        requestStatus: 0
+        /* RequestStatus.NOT_STARTED */
+      } });
+    }
+    return oldEntry;
+  });
+}
+async function fetchAuthTokenFromServer(installations, installationEntry) {
+  try {
+    const authToken = await generateAuthTokenRequest(installations, installationEntry);
+    const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), { authToken });
+    await set(installations.appConfig, updatedInstallationEntry);
+    return authToken;
+  } catch (e) {
+    if (isServerError(e) && (e.customData.serverCode === 401 || e.customData.serverCode === 404)) {
+      await remove(installations.appConfig);
+    } else {
+      const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), { authToken: {
+        requestStatus: 0
+        /* RequestStatus.NOT_STARTED */
+      } });
+      await set(installations.appConfig, updatedInstallationEntry);
+    }
+    throw e;
+  }
+}
+function isEntryRegistered(installationEntry) {
+  return installationEntry !== void 0 && installationEntry.registrationStatus === 2;
+}
+function isAuthTokenValid(authToken) {
+  return authToken.requestStatus === 2 && !isAuthTokenExpired(authToken);
+}
+function isAuthTokenExpired(authToken) {
+  const now = Date.now();
+  return now < authToken.creationTime || authToken.creationTime + authToken.expiresIn < now + TOKEN_EXPIRATION_BUFFER;
+}
+function makeAuthTokenRequestInProgressEntry(oldEntry) {
+  const inProgressAuthToken = {
+    requestStatus: 1,
+    requestTime: Date.now()
+  };
+  return Object.assign(Object.assign({}, oldEntry), { authToken: inProgressAuthToken });
+}
+function hasAuthTokenRequestTimedOut(authToken) {
+  return authToken.requestStatus === 1 && authToken.requestTime + PENDING_TIMEOUT_MS < Date.now();
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function getId(installations) {
+  const installationsImpl = installations;
+  const { installationEntry, registrationPromise } = await getInstallationEntry(installationsImpl);
+  if (registrationPromise) {
+    registrationPromise.catch(console.error);
+  } else {
+    refreshAuthToken(installationsImpl).catch(console.error);
+  }
+  return installationEntry.fid;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function getToken(installations, forceRefresh = false) {
+  const installationsImpl = installations;
+  await completeInstallationRegistration(installationsImpl);
+  const authToken = await refreshAuthToken(installationsImpl, forceRefresh);
+  return authToken.token;
+}
+async function completeInstallationRegistration(installations) {
+  const { registrationPromise } = await getInstallationEntry(installations);
+  if (registrationPromise) {
+    await registrationPromise;
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function extractAppConfig(app) {
+  if (!app || !app.options) {
+    throw getMissingValueError("App Configuration");
+  }
+  if (!app.name) {
+    throw getMissingValueError("App Name");
+  }
+  const configKeys = [
+    "projectId",
+    "apiKey",
+    "appId"
+  ];
+  for (const keyName of configKeys) {
+    if (!app.options[keyName]) {
+      throw getMissingValueError(keyName);
+    }
+  }
+  return {
+    appName: app.name,
+    projectId: app.options.projectId,
+    apiKey: app.options.apiKey,
+    appId: app.options.appId
+  };
+}
+function getMissingValueError(valueName) {
+  return ERROR_FACTORY.create("missing-app-config-values", {
+    valueName
+  });
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const INSTALLATIONS_NAME = "installations";
+const INSTALLATIONS_NAME_INTERNAL = "installations-internal";
+const publicFactory = (container) => {
+  const app = container.getProvider("app").getImmediate();
+  const appConfig = extractAppConfig(app);
+  const heartbeatServiceProvider = _getProvider(app, "heartbeat");
+  const installationsImpl = {
+    app,
+    appConfig,
+    heartbeatServiceProvider,
+    _delete: () => Promise.resolve()
+  };
+  return installationsImpl;
+};
+const internalFactory = (container) => {
+  const app = container.getProvider("app").getImmediate();
+  const installations = _getProvider(app, INSTALLATIONS_NAME).getImmediate();
+  const installationsInternal = {
+    getId: () => getId(installations),
+    getToken: (forceRefresh) => getToken(installations, forceRefresh)
+  };
+  return installationsInternal;
+};
+function registerInstallations() {
+  _registerComponent(new Component(
+    INSTALLATIONS_NAME,
+    publicFactory,
+    "PUBLIC"
+    /* ComponentType.PUBLIC */
+  ));
+  _registerComponent(new Component(
+    INSTALLATIONS_NAME_INTERNAL,
+    internalFactory,
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  ));
+}
+registerInstallations();
+registerVersion(name, version);
+registerVersion(name, version, "esm2017");
+export {
+  getId,
+  getToken
+};