@stokr/components-library 3.0.67 → 3.0.68

package/dist/node_modules/@firebase/app/dist/esm/index.esm.js

@@ -1,609 +0,0 @@
-import { ComponentContainer, Component } from "../../../component/dist/esm/index.esm.js";
-import { Logger } from "../../../logger/dist/esm/index.esm.js";
-import { getDefaultAppConfig, ErrorFactory, deepEqual, base64urlEncodeWithoutPadding, isIndexedDBAvailable, validateIndexedDBOpenable, FirebaseError } from "../../../util/dist/index.esm.js";
-import { openDB } from "../../../../idb/build/index.js";
-class PlatformLoggerServiceImpl {
-  constructor(container) {
-    this.container = container;
-  }
-  // In initial implementation, this will be called by installations on
-  // auth token refresh, and installations will send this string.
-  getPlatformInfoString() {
-    const providers = this.container.getProviders();
-    return providers.map((provider) => {
-      if (isVersionServiceProvider(provider)) {
-        const service = provider.getImmediate();
-        return `${service.library}/${service.version}`;
-      } else {
-        return null;
-      }
-    }).filter((logString) => logString).join(" ");
-  }
-}
-function isVersionServiceProvider(provider) {
-  const component = provider.getComponent();
-  return component?.type === "VERSION";
-}
-const name$q = "@firebase/app";
-const version$1 = "0.14.7";
-const logger = new Logger("@firebase/app");
-const name$p = "@firebase/app-compat";
-const name$o = "@firebase/analytics-compat";
-const name$n = "@firebase/analytics";
-const name$m = "@firebase/app-check-compat";
-const name$l = "@firebase/app-check";
-const name$k = "@firebase/auth";
-const name$j = "@firebase/auth-compat";
-const name$i = "@firebase/database";
-const name$h = "@firebase/data-connect";
-const name$g = "@firebase/database-compat";
-const name$f = "@firebase/functions";
-const name$e = "@firebase/functions-compat";
-const name$d = "@firebase/installations";
-const name$c = "@firebase/installations-compat";
-const name$b = "@firebase/messaging";
-const name$a = "@firebase/messaging-compat";
-const name$9 = "@firebase/performance";
-const name$8 = "@firebase/performance-compat";
-const name$7 = "@firebase/remote-config";
-const name$6 = "@firebase/remote-config-compat";
-const name$5 = "@firebase/storage";
-const name$4 = "@firebase/storage-compat";
-const name$3 = "@firebase/firestore";
-const name$2 = "@firebase/ai";
-const name$1 = "@firebase/firestore-compat";
-const name = "firebase";
-const version = "12.8.0";
-const DEFAULT_ENTRY_NAME = "[DEFAULT]";
-const PLATFORM_LOG_STRING = {
-  [name$q]: "fire-core",
-  [name$p]: "fire-core-compat",
-  [name$n]: "fire-analytics",
-  [name$o]: "fire-analytics-compat",
-  [name$l]: "fire-app-check",
-  [name$m]: "fire-app-check-compat",
-  [name$k]: "fire-auth",
-  [name$j]: "fire-auth-compat",
-  [name$i]: "fire-rtdb",
-  [name$h]: "fire-data-connect",
-  [name$g]: "fire-rtdb-compat",
-  [name$f]: "fire-fn",
-  [name$e]: "fire-fn-compat",
-  [name$d]: "fire-iid",
-  [name$c]: "fire-iid-compat",
-  [name$b]: "fire-fcm",
-  [name$a]: "fire-fcm-compat",
-  [name$9]: "fire-perf",
-  [name$8]: "fire-perf-compat",
-  [name$7]: "fire-rc",
-  [name$6]: "fire-rc-compat",
-  [name$5]: "fire-gcs",
-  [name$4]: "fire-gcs-compat",
-  [name$3]: "fire-fst",
-  [name$1]: "fire-fst-compat",
-  [name$2]: "fire-vertex",
-  "fire-js": "fire-js",
-  // Platform identifier for JS SDK.
-  [name]: "fire-js-all"
-};
-const _apps = /* @__PURE__ */ new Map();
-const _serverApps = /* @__PURE__ */ new Map();
-const _components = /* @__PURE__ */ new Map();
-function _addComponent(app, component) {
-  try {
-    app.container.addComponent(component);
-  } catch (e) {
-    logger.debug(`Component ${component.name} failed to register with FirebaseApp ${app.name}`, e);
-  }
-}
-function _registerComponent(component) {
-  const componentName = component.name;
-  if (_components.has(componentName)) {
-    logger.debug(`There were multiple attempts to register component ${componentName}.`);
-    return false;
-  }
-  _components.set(componentName, component);
-  for (const app of _apps.values()) {
-    _addComponent(app, component);
-  }
-  for (const serverApp of _serverApps.values()) {
-    _addComponent(serverApp, component);
-  }
-  return true;
-}
-function _getProvider(app, name2) {
-  const heartbeatController = app.container.getProvider("heartbeat").getImmediate({ optional: true });
-  if (heartbeatController) {
-    void heartbeatController.triggerHeartbeat();
-  }
-  return app.container.getProvider(name2);
-}
-function _isFirebaseServerApp(obj) {
-  if (obj === null || obj === void 0) {
-    return false;
-  }
-  return obj.settings !== void 0;
-}
-const ERRORS = {
-  [
-    "no-app"
-    /* AppError.NO_APP */
-  ]: "No Firebase App '{$appName}' has been created - call initializeApp() first",
-  [
-    "bad-app-name"
-    /* AppError.BAD_APP_NAME */
-  ]: "Illegal App name: '{$appName}'",
-  [
-    "duplicate-app"
-    /* AppError.DUPLICATE_APP */
-  ]: "Firebase App named '{$appName}' already exists with different options or config",
-  [
-    "app-deleted"
-    /* AppError.APP_DELETED */
-  ]: "Firebase App named '{$appName}' already deleted",
-  [
-    "server-app-deleted"
-    /* AppError.SERVER_APP_DELETED */
-  ]: "Firebase Server App has been deleted",
-  [
-    "no-options"
-    /* AppError.NO_OPTIONS */
-  ]: "Need to provide options, when not being deployed to hosting via source.",
-  [
-    "invalid-app-argument"
-    /* AppError.INVALID_APP_ARGUMENT */
-  ]: "firebase.{$appName}() takes either no argument or a Firebase App instance.",
-  [
-    "invalid-log-argument"
-    /* AppError.INVALID_LOG_ARGUMENT */
-  ]: "First argument to `onLog` must be null or a function.",
-  [
-    "idb-open"
-    /* AppError.IDB_OPEN */
-  ]: "Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.",
-  [
-    "idb-get"
-    /* AppError.IDB_GET */
-  ]: "Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.",
-  [
-    "idb-set"
-    /* AppError.IDB_WRITE */
-  ]: "Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.",
-  [
-    "idb-delete"
-    /* AppError.IDB_DELETE */
-  ]: "Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.",
-  [
-    "finalization-registry-not-supported"
-    /* AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED */
-  ]: "FirebaseServerApp deleteOnDeref field defined but the JS runtime does not support FinalizationRegistry.",
-  [
-    "invalid-server-app-environment"
-    /* AppError.INVALID_SERVER_APP_ENVIRONMENT */
-  ]: "FirebaseServerApp is not for use in browser environments."
-};
-const ERROR_FACTORY = new ErrorFactory("app", "Firebase", ERRORS);
-class FirebaseAppImpl {
-  constructor(options, config, container) {
-    this._isDeleted = false;
-    this._options = { ...options };
-    this._config = { ...config };
-    this._name = config.name;
-    this._automaticDataCollectionEnabled = config.automaticDataCollectionEnabled;
-    this._container = container;
-    this.container.addComponent(new Component(
-      "app",
-      () => this,
-      "PUBLIC"
-      /* ComponentType.PUBLIC */
-    ));
-  }
-  get automaticDataCollectionEnabled() {
-    this.checkDestroyed();
-    return this._automaticDataCollectionEnabled;
-  }
-  set automaticDataCollectionEnabled(val) {
-    this.checkDestroyed();
-    this._automaticDataCollectionEnabled = val;
-  }
-  get name() {
-    this.checkDestroyed();
-    return this._name;
-  }
-  get options() {
-    this.checkDestroyed();
-    return this._options;
-  }
-  get config() {
-    this.checkDestroyed();
-    return this._config;
-  }
-  get container() {
-    return this._container;
-  }
-  get isDeleted() {
-    return this._isDeleted;
-  }
-  set isDeleted(val) {
-    this._isDeleted = val;
-  }
-  /**
-   * This function will throw an Error if the App has already been deleted -
-   * use before performing API actions on the App.
-   */
-  checkDestroyed() {
-    if (this.isDeleted) {
-      throw ERROR_FACTORY.create("app-deleted", { appName: this._name });
-    }
-  }
-}
-const SDK_VERSION = version;
-function initializeApp(_options, rawConfig = {}) {
-  let options = _options;
-  if (typeof rawConfig !== "object") {
-    const name3 = rawConfig;
-    rawConfig = { name: name3 };
-  }
-  const config = {
-    name: DEFAULT_ENTRY_NAME,
-    automaticDataCollectionEnabled: true,
-    ...rawConfig
-  };
-  const name2 = config.name;
-  if (typeof name2 !== "string" || !name2) {
-    throw ERROR_FACTORY.create("bad-app-name", {
-      appName: String(name2)
-    });
-  }
-  options || (options = getDefaultAppConfig());
-  if (!options) {
-    throw ERROR_FACTORY.create(
-      "no-options"
-      /* AppError.NO_OPTIONS */
-    );
-  }
-  const existingApp = _apps.get(name2);
-  if (existingApp) {
-    if (deepEqual(options, existingApp.options) && deepEqual(config, existingApp.config)) {
-      return existingApp;
-    } else {
-      throw ERROR_FACTORY.create("duplicate-app", { appName: name2 });
-    }
-  }
-  const container = new ComponentContainer(name2);
-  for (const component of _components.values()) {
-    container.addComponent(component);
-  }
-  const newApp = new FirebaseAppImpl(options, config, container);
-  _apps.set(name2, newApp);
-  return newApp;
-}
-function getApp(name2 = DEFAULT_ENTRY_NAME) {
-  const app = _apps.get(name2);
-  if (!app && name2 === DEFAULT_ENTRY_NAME && getDefaultAppConfig()) {
-    return initializeApp();
-  }
-  if (!app) {
-    throw ERROR_FACTORY.create("no-app", { appName: name2 });
-  }
-  return app;
-}
-function getApps() {
-  return Array.from(_apps.values());
-}
-function registerVersion(libraryKeyOrName, version2, variant) {
-  let library = PLATFORM_LOG_STRING[libraryKeyOrName] ?? libraryKeyOrName;
-  if (variant) {
-    library += `-${variant}`;
-  }
-  const libraryMismatch = library.match(/\s|\//);
-  const versionMismatch = version2.match(/\s|\//);
-  if (libraryMismatch || versionMismatch) {
-    const warning = [
-      `Unable to register library "${library}" with version "${version2}":`
-    ];
-    if (libraryMismatch) {
-      warning.push(`library name "${library}" contains illegal characters (whitespace or "/")`);
-    }
-    if (libraryMismatch && versionMismatch) {
-      warning.push("and");
-    }
-    if (versionMismatch) {
-      warning.push(`version name "${version2}" contains illegal characters (whitespace or "/")`);
-    }
-    logger.warn(warning.join(" "));
-    return;
-  }
-  _registerComponent(new Component(
-    `${library}-version`,
-    () => ({ library, version: version2 }),
-    "VERSION"
-    /* ComponentType.VERSION */
-  ));
-}
-const DB_NAME = "firebase-heartbeat-database";
-const DB_VERSION = 1;
-const STORE_NAME = "firebase-heartbeat-store";
-let dbPromise = null;
-function getDbPromise() {
-  if (!dbPromise) {
-    dbPromise = openDB(DB_NAME, DB_VERSION, {
-      upgrade: (db, oldVersion) => {
-        switch (oldVersion) {
-          case 0:
-            try {
-              db.createObjectStore(STORE_NAME);
-            } catch (e) {
-              console.warn(e);
-            }
-        }
-      }
-    }).catch((e) => {
-      throw ERROR_FACTORY.create("idb-open", {
-        originalErrorMessage: e.message
-      });
-    });
-  }
-  return dbPromise;
-}
-async function readHeartbeatsFromIndexedDB(app) {
-  try {
-    const db = await getDbPromise();
-    const tx = db.transaction(STORE_NAME);
-    const result = await tx.objectStore(STORE_NAME).get(computeKey(app));
-    await tx.done;
-    return result;
-  } catch (e) {
-    if (e instanceof FirebaseError) {
-      logger.warn(e.message);
-    } else {
-      const idbGetError = ERROR_FACTORY.create("idb-get", {
-        originalErrorMessage: e?.message
-      });
-      logger.warn(idbGetError.message);
-    }
-  }
-}
-async function writeHeartbeatsToIndexedDB(app, heartbeatObject) {
-  try {
-    const db = await getDbPromise();
-    const tx = db.transaction(STORE_NAME, "readwrite");
-    const objectStore = tx.objectStore(STORE_NAME);
-    await objectStore.put(heartbeatObject, computeKey(app));
-    await tx.done;
-  } catch (e) {
-    if (e instanceof FirebaseError) {
-      logger.warn(e.message);
-    } else {
-      const idbGetError = ERROR_FACTORY.create("idb-set", {
-        originalErrorMessage: e?.message
-      });
-      logger.warn(idbGetError.message);
-    }
-  }
-}
-function computeKey(app) {
-  return `${app.name}!${app.options.appId}`;
-}
-const MAX_HEADER_BYTES = 1024;
-const MAX_NUM_STORED_HEARTBEATS = 30;
-class HeartbeatServiceImpl {
-  constructor(container) {
-    this.container = container;
-    this._heartbeatsCache = null;
-    const app = this.container.getProvider("app").getImmediate();
-    this._storage = new HeartbeatStorageImpl(app);
-    this._heartbeatsCachePromise = this._storage.read().then((result) => {
-      this._heartbeatsCache = result;
-      return result;
-    });
-  }
-  /**
-   * Called to report a heartbeat. The function will generate
-   * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it
-   * to IndexedDB.
-   * Note that we only store one heartbeat per day. So if a heartbeat for today is
-   * already logged, subsequent calls to this function in the same day will be ignored.
-   */
-  async triggerHeartbeat() {
-    try {
-      const platformLogger = this.container.getProvider("platform-logger").getImmediate();
-      const agent = platformLogger.getPlatformInfoString();
-      const date = getUTCDateString();
-      if (this._heartbeatsCache?.heartbeats == null) {
-        this._heartbeatsCache = await this._heartbeatsCachePromise;
-        if (this._heartbeatsCache?.heartbeats == null) {
-          return;
-        }
-      }
-      if (this._heartbeatsCache.lastSentHeartbeatDate === date || this._heartbeatsCache.heartbeats.some((singleDateHeartbeat) => singleDateHeartbeat.date === date)) {
-        return;
-      } else {
-        this._heartbeatsCache.heartbeats.push({ date, agent });
-        if (this._heartbeatsCache.heartbeats.length > MAX_NUM_STORED_HEARTBEATS) {
-          const earliestHeartbeatIdx = getEarliestHeartbeatIdx(this._heartbeatsCache.heartbeats);
-          this._heartbeatsCache.heartbeats.splice(earliestHeartbeatIdx, 1);
-        }
-      }
-      return this._storage.overwrite(this._heartbeatsCache);
-    } catch (e) {
-      logger.warn(e);
-    }
-  }
-  /**
-   * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
-   * It also clears all heartbeats from memory as well as in IndexedDB.
-   *
-   * NOTE: Consuming product SDKs should not send the header if this method
-   * returns an empty string.
-   */
-  async getHeartbeatsHeader() {
-    try {
-      if (this._heartbeatsCache === null) {
-        await this._heartbeatsCachePromise;
-      }
-      if (this._heartbeatsCache?.heartbeats == null || this._heartbeatsCache.heartbeats.length === 0) {
-        return "";
-      }
-      const date = getUTCDateString();
-      const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);
-      const headerString = base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
-      this._heartbeatsCache.lastSentHeartbeatDate = date;
-      if (unsentEntries.length > 0) {
-        this._heartbeatsCache.heartbeats = unsentEntries;
-        await this._storage.overwrite(this._heartbeatsCache);
-      } else {
-        this._heartbeatsCache.heartbeats = [];
-        void this._storage.overwrite(this._heartbeatsCache);
-      }
-      return headerString;
-    } catch (e) {
-      logger.warn(e);
-      return "";
-    }
-  }
-}
-function getUTCDateString() {
-  const today = /* @__PURE__ */ new Date();
-  return today.toISOString().substring(0, 10);
-}
-function extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) {
-  const heartbeatsToSend = [];
-  let unsentEntries = heartbeatsCache.slice();
-  for (const singleDateHeartbeat of heartbeatsCache) {
-    const heartbeatEntry = heartbeatsToSend.find((hb) => hb.agent === singleDateHeartbeat.agent);
-    if (!heartbeatEntry) {
-      heartbeatsToSend.push({
-        agent: singleDateHeartbeat.agent,
-        dates: [singleDateHeartbeat.date]
-      });
-      if (countBytes(heartbeatsToSend) > maxSize) {
-        heartbeatsToSend.pop();
-        break;
-      }
-    } else {
-      heartbeatEntry.dates.push(singleDateHeartbeat.date);
-      if (countBytes(heartbeatsToSend) > maxSize) {
-        heartbeatEntry.dates.pop();
-        break;
-      }
-    }
-    unsentEntries = unsentEntries.slice(1);
-  }
-  return {
-    heartbeatsToSend,
-    unsentEntries
-  };
-}
-class HeartbeatStorageImpl {
-  constructor(app) {
-    this.app = app;
-    this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
-  }
-  async runIndexedDBEnvironmentCheck() {
-    if (!isIndexedDBAvailable()) {
-      return false;
-    } else {
-      return validateIndexedDBOpenable().then(() => true).catch(() => false);
-    }
-  }
-  /**
-   * Read all heartbeats.
-   */
-  async read() {
-    const canUseIndexedDB = await this._canUseIndexedDBPromise;
-    if (!canUseIndexedDB) {
-      return { heartbeats: [] };
-    } else {
-      const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);
-      if (idbHeartbeatObject?.heartbeats) {
-        return idbHeartbeatObject;
-      } else {
-        return { heartbeats: [] };
-      }
-    }
-  }
-  // overwrite the storage with the provided heartbeats
-  async overwrite(heartbeatsObject) {
-    const canUseIndexedDB = await this._canUseIndexedDBPromise;
-    if (!canUseIndexedDB) {
-      return;
-    } else {
-      const existingHeartbeatsObject = await this.read();
-      return writeHeartbeatsToIndexedDB(this.app, {
-        lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ?? existingHeartbeatsObject.lastSentHeartbeatDate,
-        heartbeats: heartbeatsObject.heartbeats
-      });
-    }
-  }
-  // add heartbeats
-  async add(heartbeatsObject) {
-    const canUseIndexedDB = await this._canUseIndexedDBPromise;
-    if (!canUseIndexedDB) {
-      return;
-    } else {
-      const existingHeartbeatsObject = await this.read();
-      return writeHeartbeatsToIndexedDB(this.app, {
-        lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ?? existingHeartbeatsObject.lastSentHeartbeatDate,
-        heartbeats: [
-          ...existingHeartbeatsObject.heartbeats,
-          ...heartbeatsObject.heartbeats
-        ]
-      });
-    }
-  }
-}
-function countBytes(heartbeatsCache) {
-  return base64urlEncodeWithoutPadding(
-    // heartbeatsCache wrapper properties
-    JSON.stringify({ version: 2, heartbeats: heartbeatsCache })
-  ).length;
-}
-function getEarliestHeartbeatIdx(heartbeats) {
-  if (heartbeats.length === 0) {
-    return -1;
-  }
-  let earliestHeartbeatIdx = 0;
-  let earliestHeartbeatDate = heartbeats[0].date;
-  for (let i = 1; i < heartbeats.length; i++) {
-    if (heartbeats[i].date < earliestHeartbeatDate) {
-      earliestHeartbeatDate = heartbeats[i].date;
-      earliestHeartbeatIdx = i;
-    }
-  }
-  return earliestHeartbeatIdx;
-}
-function registerCoreComponents(variant) {
-  _registerComponent(new Component(
-    "platform-logger",
-    (container) => new PlatformLoggerServiceImpl(container),
-    "PRIVATE"
-    /* ComponentType.PRIVATE */
-  ));
-  _registerComponent(new Component(
-    "heartbeat",
-    (container) => new HeartbeatServiceImpl(container),
-    "PRIVATE"
-    /* ComponentType.PRIVATE */
-  ));
-  registerVersion(name$q, version$1, variant);
-  registerVersion(name$q, version$1, "esm2020");
-  registerVersion("fire-js", "");
-}
-registerCoreComponents("");
-export {
-  FirebaseError,
-  SDK_VERSION,
-  DEFAULT_ENTRY_NAME as _DEFAULT_ENTRY_NAME,
-  _addComponent,
-  _apps,
-  _components,
-  _getProvider,
-  _isFirebaseServerApp,
-  _registerComponent,
-  _serverApps,
-  getApp,
-  getApps,
-  initializeApp,
-  registerVersion
-};