@ponceca/firestore-sdk 0.1.0

package/dist/chunk-2RQUHE2K.js

@@ -0,0 +1,719 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunk57XXMSJAjs = require('./chunk-57XXMSJA.js');
+
+
+var _chunk6J3LNKUQjs = require('./chunk-6J3LNKUQ.js');
+
+
+var _chunkBXV7KTHBjs = require('./chunk-BXV7KTHB.js');
+
+
+var _chunk4CV4JOE5js = require('./chunk-4CV4JOE5.js');
+
+// src/persistence/local-store.ts
+var LocalStore = class {
+  constructor() {
+    /** Cache de documentos indexado por path */
+    this.documents = /* @__PURE__ */ new Map();
+    /** Cache de resultados de queries indexado por key */
+    this.queries = /* @__PURE__ */ new Map();
+  }
+  // ===========================================================================
+  // DOCUMENTOS
+  // ===========================================================================
+  /** Almacena o actualiza un documento en cache */
+  putDocument(path, data, exists, updateTime) {
+    this.documents.set(path, {
+      path,
+      data: data ? structuredClonePolyfill(data) : null,
+      exists,
+      updateTime,
+      cachedAt: Date.now()
+    });
+  }
+  /** Obtiene un documento del cache (undefined si no existe en cache) */
+  getDocument(path) {
+    return this.documents.get(path);
+  }
+  /** Elimina un documento del cache */
+  removeDocument(path) {
+    this.documents.delete(path);
+  }
+  /** Marca un documento como eliminado en cache (sin removerlo del mapa) */
+  markDeleted(path) {
+    this.documents.set(path, {
+      path,
+      data: null,
+      exists: false,
+      cachedAt: Date.now()
+    });
+  }
+  /** Obtiene todos los documentos de una colección desde el cache */
+  getDocumentsByCollection(collectionPath) {
+    const results = [];
+    const prefix = collectionPath + "/";
+    for (const [path, doc] of this.documents) {
+      if (path.startsWith(prefix) && !path.substring(prefix.length).includes("/")) {
+        if (doc.exists) {
+          results.push(doc);
+        }
+      }
+    }
+    return results;
+  }
+  // ===========================================================================
+  // QUERIES
+  // ===========================================================================
+  /** Almacena el resultado de una query */
+  putQuery(key, documentPaths) {
+    this.queries.set(key, {
+      key,
+      documentPaths: [...documentPaths],
+      cachedAt: Date.now()
+    });
+  }
+  /** Obtiene un resultado de query del cache */
+  getQuery(key) {
+    return this.queries.get(key);
+  }
+  // ===========================================================================
+  // MANTENIMIENTO
+  // ===========================================================================
+  /** Limpia todo el cache */
+  clear() {
+    this.documents.clear();
+    this.queries.clear();
+  }
+  /** Número de documentos en cache */
+  get documentCount() {
+    return this.documents.size;
+  }
+  /** Número de queries en cache */
+  get queryCount() {
+    return this.queries.size;
+  }
+};
+function structuredClonePolyfill(obj) {
+  if (typeof globalThis.structuredClone === "function") {
+    try {
+      return globalThis.structuredClone(obj);
+    } catch (e) {
+    }
+  }
+  return JSON.parse(JSON.stringify(obj));
+}
+
+// src/persistence/mutation-queue.ts
+var mutationCounter = 0;
+var MutationQueue = class {
+  constructor() {
+    /** Cola ordenada de mutaciones pendientes */
+    this.queue = [];
+    /** Callbacks que esperan a que la cola se vacíe */
+    this.pendingWaiters = [];
+  }
+  /**
+   * Añade una mutación a la cola
+   * @returns ID de la mutación creada
+   */
+  add(type, path, data, options) {
+    const id = `mutation_${++mutationCounter}_${Date.now()}`;
+    this.queue.push({
+      id,
+      type,
+      path,
+      data: data ? { ...data } : null,
+      options: options ? { ...options } : void 0,
+      timestamp: Date.now()
+    });
+    return id;
+  }
+  /** Obtiene la siguiente mutación sin removerla */
+  peek() {
+    return this.queue[0];
+  }
+  /** Remueve y retorna la primera mutación de la cola */
+  shift() {
+    const mutation = this.queue.shift();
+    if (this.queue.length === 0) {
+      this.notifyWaiters();
+    }
+    return mutation;
+  }
+  /** Remueve una mutación específica por ID */
+  remove(id) {
+    const idx = this.queue.findIndex((m) => m.id === id);
+    if (idx === -1) return false;
+    this.queue.splice(idx, 1);
+    if (this.queue.length === 0) {
+      this.notifyWaiters();
+    }
+    return true;
+  }
+  /** Verifica si hay mutaciones pendientes para un path */
+  hasPendingForPath(path) {
+    return this.queue.some((m) => m.path === path);
+  }
+  /** Obtiene todas las mutaciones pendientes para un path (en orden) */
+  getForPath(path) {
+    return this.queue.filter((m) => m.path === path);
+  }
+  /** Obtiene todas las mutaciones pendientes para una colección */
+  getForCollection(collectionPath) {
+    const prefix = collectionPath + "/";
+    return this.queue.filter((m) => m.path.startsWith(prefix) && !m.path.substring(prefix.length).includes("/"));
+  }
+  /** Retorna todas las mutaciones pendientes (copia) */
+  getAll() {
+    return [...this.queue];
+  }
+  /** Número de mutaciones pendientes */
+  get size() {
+    return this.queue.length;
+  }
+  /** Si la cola está vacía */
+  get isEmpty() {
+    return this.queue.length === 0;
+  }
+  /** Limpia toda la cola */
+  clear() {
+    this.queue.length = 0;
+    this.notifyWaiters();
+  }
+  /**
+   * Espera a que todas las mutaciones pendientes se sincronicen.
+   * Resuelve inmediatamente si la cola ya está vacía.
+   */
+  waitForEmpty() {
+    if (this.queue.length === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.pendingWaiters.push(resolve);
+    });
+  }
+  /** Notifica a todos los waiters que la cola está vacía */
+  notifyWaiters() {
+    const waiters = this.pendingWaiters.splice(0);
+    for (const resolve of waiters) {
+      resolve();
+    }
+  }
+};
+
+// src/persistence/persistence-manager.ts
+var managers = /* @__PURE__ */ new WeakMap();
+function getPersistenceManager(firestore) {
+  return managers.get(firestore);
+}
+function createPersistenceManager(firestore) {
+  if (managers.has(firestore)) {
+    throw new Error("Persistence already enabled for this Firestore instance");
+  }
+  const pm = new PersistenceManager(firestore, new LocalStore(), new MutationQueue());
+  managers.set(firestore, pm);
+  return pm;
+}
+function createPersistenceManagerWithStores(firestore, store, mutations) {
+  if (managers.has(firestore)) {
+    throw new Error("Persistence already enabled for this Firestore instance");
+  }
+  const pm = new PersistenceManager(firestore, store, mutations);
+  managers.set(firestore, pm);
+  return pm;
+}
+async function removePersistenceManager(firestore) {
+  const pm = managers.get(firestore);
+  if (pm) {
+    await pm.destroy();
+    managers.delete(firestore);
+  }
+}
+var PersistenceManager = class {
+  constructor(firestore, store, mutations) {
+    this._networkState = "online";
+    this._flushing = false;
+    this.firestore = firestore;
+    this.store = store;
+    this.mutations = mutations;
+  }
+  // ===========================================================================
+  // ESTADO DE RED
+  // ===========================================================================
+  /** Si la red está habilitada */
+  get isOnline() {
+    return this._networkState === "online";
+  }
+  /** Habilita la red y comienza a sincronizar mutaciones pendientes */
+  async enableNetwork() {
+    this._networkState = "online";
+    await this.flushMutations();
+  }
+  /** Deshabilita la red — toda operación será local */
+  disableNetwork() {
+    this._networkState = "offline";
+  }
+  // ===========================================================================
+  // CACHE DE DOCUMENTOS
+  // ===========================================================================
+  /** Almacena un documento en cache (después de leerlo del servidor) */
+  async cacheDocument(path, data, exists, updateTime) {
+    await this.store.putDocument(path, data, exists, updateTime);
+  }
+  /** Lee un documento del cache */
+  async getCachedDocument(path) {
+    const cached = await this.store.getDocument(path);
+    if (!cached) return void 0;
+    return this.applyPendingMutations(path, cached.data, cached.exists);
+  }
+  /** Lee documentos de una colección del cache */
+  async getCachedCollection(collectionPath) {
+    const docs = await this.store.getDocumentsByCollection(collectionPath);
+    const results = [];
+    const seenPaths = /* @__PURE__ */ new Set();
+    for (const doc of docs) {
+      seenPaths.add(doc.path);
+      const applied = await this.applyPendingMutations(doc.path, doc.data, doc.exists);
+      if (applied.exists && applied.data) {
+        results.push({ path: doc.path, data: applied.data, exists: true });
+      }
+    }
+    const collectionMutations = await this.mutations.getForCollection(collectionPath);
+    for (const mutation of collectionMutations) {
+      if (!seenPaths.has(mutation.path) && mutation.type !== "delete" && mutation.data) {
+        results.push({ path: mutation.path, data: mutation.data, exists: true });
+      }
+    }
+    return results;
+  }
+  /** Almacena resultados de query en cache */
+  async cacheQuery(key, documentPaths) {
+    await this.store.putQuery(key, documentPaths);
+  }
+  /** Lee resultados de query del cache */
+  async getCachedQuery(key) {
+    const cached = await this.store.getQuery(key);
+    return _optionalChain([cached, 'optionalAccess', _ => _.documentPaths]);
+  }
+  // ===========================================================================
+  // COLA DE MUTACIONES
+  // ===========================================================================
+  /** Registra una escritura local (optimistic update + queue) */
+  async addLocalWrite(type, path, data, options) {
+    if (type === "delete") {
+      await this.store.markDeleted(path);
+    } else if (type === "set" && !_optionalChain([options, 'optionalAccess', _2 => _2.merge]) && !_optionalChain([options, 'optionalAccess', _3 => _3.mergeFields])) {
+      await this.store.putDocument(path, data, true);
+    } else {
+      const existing = await this.store.getDocument(path);
+      const mergedData = this.mergeData(_nullishCoalesce(_optionalChain([existing, 'optionalAccess', _4 => _4.data]), () => ( {})), _nullishCoalesce(data, () => ( {})), options);
+      await this.store.putDocument(path, mergedData, true);
+    }
+    await this.mutations.add(type, path, data, options);
+  }
+  /** Remueve una mutación completada de la cola */
+  async completeMutation(id) {
+    await this.mutations.remove(id);
+  }
+  /** Verifica si un documento tiene escrituras pendientes */
+  async hasPendingWrites(path) {
+    return this.mutations.hasPendingForPath(path);
+  }
+  /** Espera a que todas las escrituras pendientes se sincronicen */
+  waitForPendingWrites() {
+    return this.mutations.waitForEmpty();
+  }
+  // ===========================================================================
+  // SINCRONIZACIÓN
+  // ===========================================================================
+  /**
+   * Intenta sincronizar todas las mutaciones pendientes con el servidor.
+   * Procesa en orden FIFO. Si una falla con error de red, para y reintenta después.
+   */
+  async flushMutations() {
+    const empty = await this.mutations.isEmpty;
+    if (this._flushing || !this.isOnline || empty) return;
+    this._flushing = true;
+    try {
+      const client = _chunk6J3LNKUQjs.getHttpClient.call(void 0, this.firestore);
+      let pending = !await this.mutations.isEmpty;
+      while (pending && this.isOnline) {
+        const mutation = await this.mutations.peek();
+        if (!mutation) break;
+        try {
+          await this.executeMutation(client, mutation);
+          await this.mutations.shift();
+        } catch (error) {
+          const code = _optionalChain([error, 'optionalAccess', _5 => _5.code]);
+          if (code === "unavailable" || code === "deadline-exceeded") {
+            break;
+          }
+          await this.mutations.shift();
+          await this.rollbackDocument(mutation.path);
+        }
+      }
+    } finally {
+      this._flushing = false;
+    }
+  }
+  // ===========================================================================
+  // LIMPIEZA
+  // ===========================================================================
+  /** Limpia todo (cache + cola) */
+  async clear() {
+    await this.store.clear();
+    await this.mutations.clear();
+  }
+  /** Destruye el manager */
+  async destroy() {
+    await this.clear();
+    this._networkState = "offline";
+  }
+  // ===========================================================================
+  // HELPERS PRIVADOS
+  // ===========================================================================
+  /**
+   * Aplica mutaciones pendientes a un documento cacheado.
+   * Esto es la "compensación de latencia" — el usuario ve sus cambios inmediatamente.
+   */
+  async applyPendingMutations(path, baseData, baseExists) {
+    const pending = await this.mutations.getForPath(path);
+    if (pending.length === 0) return { data: baseData, exists: baseExists };
+    let data = baseData ? { ...baseData } : null;
+    let exists = baseExists;
+    for (const mutation of pending) {
+      switch (mutation.type) {
+        case "set":
+          if (!_optionalChain([mutation, 'access', _6 => _6.options, 'optionalAccess', _7 => _7.merge]) && !_optionalChain([mutation, 'access', _8 => _8.options, 'optionalAccess', _9 => _9.mergeFields])) {
+            data = mutation.data ? { ...mutation.data } : null;
+          } else {
+            data = this.mergeData(_nullishCoalesce(data, () => ( {})), _nullishCoalesce(mutation.data, () => ( {})), mutation.options);
+          }
+          exists = true;
+          break;
+        case "update":
+          if (exists && data) {
+            data = { ...data, ..._nullishCoalesce(mutation.data, () => ( {})) };
+          }
+          break;
+        case "delete":
+          data = null;
+          exists = false;
+          break;
+      }
+    }
+    return { data, exists };
+  }
+  /** Fusiona datos para set con merge o update */
+  mergeData(existing, incoming, options) {
+    if (_optionalChain([options, 'optionalAccess', _10 => _10.mergeFields])) {
+      const result = { ...existing };
+      for (const field of options.mergeFields) {
+        if (field in incoming) {
+          result[field] = incoming[field];
+        }
+      }
+      return result;
+    }
+    return { ...existing, ...incoming };
+  }
+  /**
+   * Ejecuta una mutación contra el servidor.
+   */
+  async executeMutation(client, mutation) {
+    const fields = mutation.data ? _chunkBXV7KTHBjs.toFirestoreFields.call(void 0, mutation.data) : {};
+    switch (mutation.type) {
+      case "set": {
+        if (_optionalChain([mutation, 'access', _11 => _11.options, 'optionalAccess', _12 => _12.merge]) || _optionalChain([mutation, 'access', _13 => _13.options, 'optionalAccess', _14 => _14.mergeFields])) {
+          const fieldPaths = mutation.options.mergeFields || Object.keys(_nullishCoalesce(mutation.data, () => ( {})));
+          await client.patch(`/documents/${mutation.path}`, {
+            fields,
+            updateMask: { fieldPaths }
+          });
+        } else {
+          const parts = mutation.path.split("/");
+          const parentPath = parts.slice(0, -1).join("/");
+          const documentId = parts[parts.length - 1];
+          await client.post(`/documents/${parentPath}?documentId=${documentId}`, { fields });
+        }
+        break;
+      }
+      case "update": {
+        const fieldPaths = Object.keys(_nullishCoalesce(mutation.data, () => ( {})));
+        await client.patch(`/documents/${mutation.path}`, {
+          fields,
+          updateMask: { fieldPaths }
+        });
+        break;
+      }
+      case "delete": {
+        await client.delete(`/documents/${mutation.path}`);
+        break;
+      }
+    }
+  }
+  /**
+   * Rollback: refresca el documento del servidor para corregir el cache.
+   * Si falla, simplemente remueve del cache.
+   */
+  async rollbackDocument(path) {
+    try {
+      const client = _chunk6J3LNKUQjs.getHttpClient.call(void 0, this.firestore);
+      const doc = await client.get(`/documents/${path}`);
+      if (_optionalChain([doc, 'optionalAccess', _15 => _15.fields])) {
+        await this.store.putDocument(path, doc.fields, true, doc.updateTime);
+      } else {
+        await this.store.removeDocument(path);
+      }
+    } catch (e2) {
+      await this.store.removeDocument(path);
+    }
+  }
+};
+
+// src/firestore/firestore.ts
+var firestoreInstances = /* @__PURE__ */ new Map();
+var authProviders = /* @__PURE__ */ new Map();
+var FirestoreImpl = class {
+  constructor(app, settings) {
+    this.app = app;
+    this.type = "firestore";
+    this._terminated = false;
+    this._emulatorConfig = null;
+    this._authUnsubscribe = null;
+    const defaultHost = app.options.baseUrl ? new URL(app.options.baseUrl).host : "localhost:3000";
+    this._config = {
+      host: _optionalChain([settings, 'optionalAccess', _16 => _16.host]) || defaultHost,
+      ssl: _nullishCoalesce(_optionalChain([settings, 'optionalAccess', _17 => _17.ssl]), () => ( (defaultHost.includes("https") || defaultHost.includes("443")))),
+      timeout: _optionalChain([settings, 'optionalAccess', _18 => _18.timeout]) || 12e3,
+      authToken: _optionalChain([settings, 'optionalAccess', _19 => _19.authToken]),
+      authTokenProvider: _optionalChain([settings, 'optionalAccess', _20 => _20.authTokenProvider]),
+      allowFlexibleQueries: _nullishCoalesce(_optionalChain([settings, 'optionalAccess', _21 => _21.allowFlexibleQueries]), () => ( false)),
+      maxRetries: _nullishCoalesce(_optionalChain([settings, 'optionalAccess', _22 => _22.maxRetries]), () => ( 2)),
+      retryInitialDelayMs: _nullishCoalesce(_optionalChain([settings, 'optionalAccess', _23 => _23.retryInitialDelayMs]), () => ( 150)),
+      retryMaxDelayMs: _nullishCoalesce(_optionalChain([settings, 'optionalAccess', _24 => _24.retryMaxDelayMs]), () => ( 2e3))
+    };
+    this._projectId = app.options.projectId;
+    this._databaseId = app.options.databaseId || "(default)";
+    const provider = authProviders.get(app.name);
+    if (provider) {
+      this._setupAuthProvider(provider);
+    }
+  }
+  /**
+   * Configura un proveedor de autenticación
+   * @internal
+   */
+  _setupAuthProvider(provider) {
+    this._config.authTokenProvider = provider;
+    if (provider.onAuthStateChanged) {
+      this._authUnsubscribe = provider.onAuthStateChanged((token) => {
+        this._config.authToken = _nullishCoalesce(token, () => ( void 0));
+      });
+    }
+  }
+  /**
+   * Configura el emulador
+   * @internal
+   */
+  _useEmulator(host, port) {
+    this._emulatorConfig = { host, port };
+    this._config.host = `${host}:${port}`;
+    this._config.ssl = false;
+  }
+  /**
+   * Obtiene la configuración del emulador
+   */
+  get emulatorConfig() {
+    return this._emulatorConfig;
+  }
+  /**
+   * Obtiene la configuración actual
+   */
+  get settings() {
+    return { ...this._config };
+  }
+  /**
+   * Construye la URL base para peticiones HTTP
+   */
+  get baseUrl() {
+    const protocol = this._config.ssl ? "https" : "http";
+    return `${protocol}://${this._config.host}/v1/projects/${this._projectId}/databases/${this._databaseId}`;
+  }
+  /**
+   * Construye la URL para WebSocket
+   */
+  get wsUrl() {
+    const protocol = this._config.ssl ? "wss" : "ws";
+    return `${protocol}://${this._config.host}/ws/projects/${this._projectId}/databases/${this._databaseId}`;
+  }
+  /**
+   * Token de autenticación actual
+   */
+  get authToken() {
+    return this._config.authToken;
+  }
+  /**
+   * Actualiza el token de autenticación
+   */
+  setAuthToken(token) {
+    this._config.authToken = token;
+  }
+  /**
+   * Verifica si la instancia está terminada
+   */
+  get terminated() {
+    return this._terminated;
+  }
+  /**
+   * Obtiene el token de autenticación actual.
+   * Prioridad: 1) Auth provider (si retorna token), 2) Token estático (setAuthToken).
+   * Compatible con Firebase: auth module y token manual coexisten.
+   */
+  async getToken() {
+    if (this._config.authTokenProvider) {
+      const providerToken = await this._config.authTokenProvider.getToken();
+      if (providerToken) {
+        return providerToken;
+      }
+    }
+    return _nullishCoalesce(this._config.authToken, () => ( null));
+  }
+  /**
+   * Termina la instancia de Firestore
+   */
+  terminate() {
+    if (this._authUnsubscribe) {
+      this._authUnsubscribe();
+      this._authUnsubscribe = null;
+    }
+    this._terminated = true;
+    firestoreInstances.delete(this.app.name);
+  }
+};
+function _registerAuthProvider(app, provider) {
+  authProviders.set(app.name, provider);
+  const instance = firestoreInstances.get(app.name);
+  if (instance) {
+    instance._setupAuthProvider(provider);
+  }
+}
+function getFirestore(app) {
+  if (!app) {
+    const { getApp } = (_chunk57XXMSJAjs.init_app.call(void 0, ), _chunk4CV4JOE5js.__toCommonJS.call(void 0, _chunk57XXMSJAjs.app_exports));
+    app = getApp();
+  }
+  const existing = firestoreInstances.get(app.name);
+  if (existing) {
+    return existing;
+  }
+  const instance = new FirestoreImpl(app);
+  firestoreInstances.set(app.name, instance);
+  return instance;
+}
+function initializeFirestore(app, settings) {
+  if (firestoreInstances.has(app.name)) {
+    throw new Error(
+      `Firestore ya ha sido inicializado para la app '${app.name}'. Usa getFirestore() para obtener la instancia existente.`
+    );
+  }
+  const instance = new FirestoreImpl(app, settings);
+  firestoreInstances.set(app.name, instance);
+  return instance;
+}
+async function terminate(firestore) {
+  firestore.terminate();
+}
+async function clearIndexedDbPersistence(firestore) {
+  await removePersistenceManager(firestore);
+  if (typeof indexedDB !== "undefined") {
+    const projectId = firestore._projectId;
+    const { IndexedDBStore } = await Promise.resolve().then(() => _interopRequireWildcard(require("./indexeddb-store-DNWBZUQE.js")));
+    const { IndexedDBMutationQueue } = await Promise.resolve().then(() => _interopRequireWildcard(require("./indexeddb-mutation-queue-5EB7C2D5.js")));
+    await IndexedDBStore.deleteDatabase(projectId);
+    await IndexedDBMutationQueue.deleteDatabase(projectId);
+  }
+}
+async function enableIndexedDbPersistence(firestore) {
+  if (getPersistenceManager(firestore)) {
+    return;
+  }
+  if (typeof indexedDB !== "undefined") {
+    const { IndexedDBStore } = await Promise.resolve().then(() => _interopRequireWildcard(require("./indexeddb-store-DNWBZUQE.js")));
+    const { IndexedDBMutationQueue } = await Promise.resolve().then(() => _interopRequireWildcard(require("./indexeddb-mutation-queue-5EB7C2D5.js")));
+    const projectId = firestore._projectId;
+    const store = new IndexedDBStore(projectId);
+    const mutations = new IndexedDBMutationQueue(projectId);
+    await store.init();
+    await mutations.init();
+    createPersistenceManagerWithStores(firestore, store, mutations);
+  } else {
+    createPersistenceManager(firestore);
+  }
+}
+async function enableMultiTabIndexedDbPersistence(firestore) {
+  if (getPersistenceManager(firestore)) {
+    return;
+  }
+  createPersistenceManager(firestore);
+}
+async function enableNetwork(firestore) {
+  const pm = getPersistenceManager(firestore);
+  if (pm) {
+    await pm.enableNetwork();
+  }
+}
+async function disableNetwork(firestore) {
+  const pm = getPersistenceManager(firestore);
+  if (pm) {
+    pm.disableNetwork();
+  }
+}
+async function waitForPendingWrites(firestore) {
+  const pm = getPersistenceManager(firestore);
+  if (pm) {
+    await pm.waitForPendingWrites();
+  }
+}
+function connectFirestoreEmulator(firestore, host, port, options) {
+  const impl = firestore;
+  if (impl.terminated) {
+    throw new Error("Firestore has already been terminated.");
+  }
+  if (impl.emulatorConfig) {
+    throw new Error("Firestore emulator has already been connected.");
+  }
+  impl._useEmulator(host, port);
+  if (_optionalChain([options, 'optionalAccess', _25 => _25.mockUserToken])) {
+    const token = typeof options.mockUserToken === "string" ? options.mockUserToken : JSON.stringify(options.mockUserToken);
+    impl.setAuthToken(token);
+  }
+}
+function setAuthToken(firestore, token) {
+  const impl = firestore;
+  impl.setAuthToken(_nullishCoalesce(token, () => ( void 0)));
+}
+function getAuthToken(firestore) {
+  const impl = firestore;
+  return impl.authToken;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.getPersistenceManager = getPersistenceManager; exports._registerAuthProvider = _registerAuthProvider; exports.getFirestore = getFirestore; exports.initializeFirestore = initializeFirestore; exports.terminate = terminate; exports.clearIndexedDbPersistence = clearIndexedDbPersistence; exports.enableIndexedDbPersistence = enableIndexedDbPersistence; exports.enableMultiTabIndexedDbPersistence = enableMultiTabIndexedDbPersistence; exports.enableNetwork = enableNetwork; exports.disableNetwork = disableNetwork; exports.waitForPendingWrites = waitForPendingWrites; exports.connectFirestoreEmulator = connectFirestoreEmulator; exports.setAuthToken = setAuthToken; exports.getAuthToken = getAuthToken;
+//# sourceMappingURL=chunk-2RQUHE2K.js.map