@blinkk/root-cms 1.3.12 → 2.0.0-rc.1

package/dist/core.js

@@ -5,11 +5,63 @@ var __export = (target, all) => {
 };
 
 // core/client.ts
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 import {
   FieldValue,
-  Timestamp
+  Timestamp as Timestamp4
 } from "firebase-admin/firestore";
+
+// core/plugin.ts
+import { promises as fs } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import bodyParser from "body-parser";
+import {
+  applicationDefault,
+  getApp,
+  initializeApp
+} from "firebase-admin/app";
+import { getAuth } from "firebase-admin/auth";
+import { getFirestore } from "firebase-admin/firestore";
+import * as jsonwebtoken from "jsonwebtoken";
+import sirv from "sirv";
+
+// core/api.ts
+import { multipartMiddleware } from "@blinkk/root/middleware";
+
+// core/ai.ts
+import crypto from "node:crypto";
+import { generate } from "@genkit-ai/ai";
+import { configureGenkit } from "@genkit-ai/core";
+import { vertexAI } from "@genkit-ai/vertexai";
+import { gemini15ProPreview, gemini15FlashPreview } from "@genkit-ai/vertexai";
+import { Timestamp } from "firebase-admin/firestore";
+
+// core/versions.ts
+import path from "node:path";
+import { Timestamp as Timestamp2 } from "firebase-admin/firestore";
+import glob from "tiny-glob";
+var DOCUMENT_SAVE_OFFSET = 5 * 60 * 1e3;
+
+// core/csv.ts
+import { parse as csvParse } from "csv-parse/sync";
+import { stringify as csvStringify } from "csv-stringify/sync";
+
+// core/compatibility.ts
+import { Timestamp as Timestamp3 } from "firebase-admin/firestore";
+
+// core/plugin.ts
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+function getCmsPlugin(rootConfig) {
+  const plugins = rootConfig.plugins || [];
+  const plugin = plugins.find((plugin2) => plugin2.name === "root-cms");
+  if (!plugin) {
+    throw new Error("could not find root-cms plugin config in root.config.ts");
+  }
+  return plugin;
+}
+
+// core/client.ts
 var RootCMSClient = class {
   constructor(rootConfig) {
     this.rootConfig = rootConfig;
@@ -35,16 +87,33 @@ var RootCMSClient = class {
    */
   async getRawDoc(collectionId, slug, options) {
     const mode = options.mode;
-    const modeCollection = mode === "draft" ? "Drafts" : "Published";
-    slug = slug.replaceAll("/", "--");
-    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;
-    const docRef = this.db.doc(dbPath);
+    const docRef = this.dbDocRef(collectionId, slug, { mode });
     const doc = await docRef.get();
     if (doc.exists) {
       return doc.data();
     }
     return null;
   }
+  dbCollectionDocsPath(collectionId, options) {
+    let modeCollection = "";
+    if (options.mode === "draft") {
+      modeCollection = "Drafts";
+    } else if (options.mode === "published") {
+      modeCollection = "Published";
+    } else {
+      throw new Error(`unknown mode: ${options.mode}`);
+    }
+    return `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;
+  }
+  dbDocPath(collectionId, slug, options) {
+    const collectionDocsPath = this.dbCollectionDocsPath(collectionId, options);
+    const normalizedSlug = slug.replaceAll("/", "--");
+    return `${collectionDocsPath}/${normalizedSlug}`;
+  }
+  dbDocRef(collectionId, slug, options) {
+    const docPath = this.dbDocPath(collectionId, slug, options);
+    return this.db.doc(docPath);
+  }
   /**
    * Saves draft data to a doc.
    *
@@ -63,9 +132,9 @@ var RootCMSClient = class {
       slug,
       sys: {
         ...draftSys,
-        createdAt: draftSys.createdAt ?? Timestamp.now(),
+        createdAt: draftSys.createdAt ?? Timestamp4.now(),
         createdBy: draftSys.createdBy ?? modifiedBy,
-        modifiedAt: Timestamp.now(),
+        modifiedAt: Timestamp4.now(),
         modifiedBy,
         locales: (options == null ? void 0 : options.locales) ?? draftSys.locales ?? ["en"]
       },
@@ -200,6 +269,8 @@ var RootCMSClient = class {
         "sys.publishedBy": publishedBy
       });
       batchCount += 1;
+      this.publishTranslationsDoc(doc.id, { batch });
+      batchCount += 2;
       publishedDocs.push(doc);
       if (batchCount >= 400) {
         await batch.commit();
@@ -286,6 +357,8 @@ var RootCMSClient = class {
         "sys.publishedBy": scheduledBy || "root-cms-client"
       });
       batchCount += 1;
+      this.publishTranslationsDoc(doc.id, { batch });
+      batchCount += 2;
       publishedDocs.push(doc);
       if (batchCount >= 400) {
         await batch.commit();
@@ -305,14 +378,14 @@ var RootCMSClient = class {
   async publishScheduledReleases() {
     const releasesPath = `Projects/${this.projectId}/Releases`;
     const now = Math.ceil((/* @__PURE__ */ new Date()).getTime());
-    const query = this.db.collection(releasesPath).where("scheduledAt", "<=", Timestamp.fromMillis(now));
+    const query = this.db.collection(releasesPath).where("scheduledAt", "<=", Timestamp4.fromMillis(now));
     const querySnapshot = await query.get();
     for (const snapshot of querySnapshot.docs) {
       const release = snapshot.data();
       const batch = this.db.batch();
       const publishedBy = release.scheduledBy || "root-cms-client";
       batch.update(snapshot.ref, {
-        publishedAt: Timestamp.now(),
+        publishedAt: Timestamp4.now(),
         publishedBy,
         scheduledAt: FieldValue.delete(),
         scheduledBy: FieldValue.delete()
@@ -320,6 +393,37 @@ var RootCMSClient = class {
       await this.publishDocs(release.docIds || [], { publishedBy, batch });
     }
   }
+  async publishTranslationsDoc(translationsId, options) {
+    const docSlug = translationsId.replaceAll("/", "--");
+    const draftRef = this.db.doc(
+      `Projects/${this.projectId}/TranslationsManager/draft/Translations/${docSlug}`
+    );
+    const snapshot = await draftRef.get();
+    if (!snapshot.exists) {
+      console.warn(`translations ${translationsId} does not exist`);
+      return;
+    }
+    const commitBatch = !(options == null ? void 0 : options.batch);
+    const batch = (options == null ? void 0 : options.batch) || this.db.batch();
+    batch.update(draftRef, {
+      "sys.publishedAt": Timestamp4.now(),
+      "sys.publishedBy": (options == null ? void 0 : options.publishedBy) || "root-cms-client"
+    });
+    const publishedRef = this.db.doc(
+      `Projects/${this.projectId}/TranslationsManager/published/Translations/${docSlug}`
+    );
+    const data = { ...snapshot.data() };
+    if (!data.sys) {
+      data.sys = {};
+    }
+    data.sys.publishedAt = Timestamp4.now();
+    data.sys.publishedBy = (options == null ? void 0 : options.publishedBy) || "root-cms-client";
+    batch.set(publishedRef, data);
+    if (commitBatch) {
+      await batch.commit();
+      this.logAction("translations.publish", { metadata: { translationsId } });
+    }
+  }
   /**
    * Checks if a doc is currently "locked" for publishing.
    */
@@ -327,7 +431,7 @@ var RootCMSClient = class {
     var _a;
     if ((_a = doc.sys) == null ? void 0 : _a.publishingLocked) {
       if (doc.sys.publishingLocked.until) {
-        const now = Timestamp.now().toMillis();
+        const now = Timestamp4.now().toMillis();
         const until = doc.sys.publishingLocked.until.toMillis();
         return now < until;
       }
@@ -336,66 +440,67 @@ var RootCMSClient = class {
     return false;
   }
   /**
-   * Loads translations saved in the translations collection, optionally
-   * filtered by tag.
+   * Loads all published strings in the db.
    *
-   * Returns a map like:
    * ```
    * {
    *   "<hash>": {"source": "Hello", "es": "Hola", "fr": "Bonjour"},
    * }
    * ```
+   *
+   * @deprecated Use `createBatchRequest()` to fetch draft/published translations.
    */
   async loadTranslations(options) {
-    const dbPath = `Projects/${this.projectId}/Translations`;
+    const dbPath = `Projects/${this.projectId}/TranslationsManager/published/Translations`;
+    const translationsMap = {};
+    const addTranslations = (hash, translations) => {
+      translationsMap[hash] = Object.assign(
+        translationsMap[hash] || {},
+        translations
+      );
+    };
     let query = this.db.collection(dbPath);
-    if (options == null ? void 0 : options.tags) {
-      query = query.where("tags", "array-contains-any", options.tags);
+    if ((options == null ? void 0 : options.tags) && options.tags.length > 0) {
+      query = query.where("sys.tags", "array-contains-any", options.tags);
     }
-    const querySnapshot = await query.get();
-    const translationsMap = {};
-    querySnapshot.forEach((doc) => {
-      const hash = doc.id;
-      translationsMap[hash] = doc.data();
+    const snapshot = await query.get();
+    snapshot.forEach((doc) => {
+      const data = doc.data();
+      const strings = data.strings || {};
+      Object.entries(strings).forEach(([hash, translations]) => {
+        addTranslations(hash, translations);
+      });
     });
     return translationsMap;
   }
-  /**
-   * Saves a map of translations, e.g.:
-   * ```
-   * await client.saveTranslations({
-   *   "Hello": {"es": "Hola", "fr": "Bonjour"},
-   * });
-   * ```
-   */
-  async saveTranslations(translations, tags) {
-    const translationsPath = `Projects/${this.projectId}/Translations`;
-    const batch = this.db.batch();
-    let batchCount = 0;
-    Object.entries(translations).forEach(([source, sourceTranslations]) => {
-      const hash = this.getTranslationKey(source);
-      const translationRef = this.db.doc(`${translationsPath}/${hash}`);
-      const data = {
-        ...sourceTranslations,
-        source: this.normalizeString(source)
-      };
-      if (tags) {
-        data.tags = tags;
-      }
-      batch.set(translationRef, data, { merge: true });
-      batchCount += 1;
+  async saveDraftTranslations(translationsId, translations, options) {
+    const docSlug = translationsId.replaceAll("/", "--");
+    const docPath = `Projects/${this.projectId}/TranslationsManager/draft/${docSlug}`;
+    const docRef = this.db.doc(docPath);
+    const snapshot = await docRef.get();
+    const data = snapshot.data() || {
+      id: translationsId.replaceAll("--", "/"),
+      sys: {},
+      strings: {}
+    };
+    data.sys.modifiedAt = Timestamp4.now();
+    data.sys.modifiedBy = (options == null ? void 0 : options.modifiedby) || "root-cms-client";
+    const strings = data.strings || {};
+    Object.entries(translations).forEach(([source, row]) => {
+      const normalizedSource = this.normalizeString(source);
+      const hash = this.getTranslationKey(normalizedSource);
+      strings[hash] = { ...strings[hash], ...row, source: normalizedSource };
     });
-    if (batchCount > 500) {
-      throw new Error("up to 500 translations can be saved at a time.");
-    }
-    await batch.commit();
+    data.strings = strings;
+    await docRef.set(data);
+    this.logAction("translations.save", { metadata: { translationsId } });
   }
   /**
    * Returns the "key" used for a translation as stored in the db. Translations
    * are stored under `Projects/<project id>/Translations/<sha1 hash>`.
    */
   getTranslationKey(source) {
-    const sha1 = crypto.createHash("sha1").update(this.normalizeString(source)).digest("hex");
+    const sha1 = crypto2.createHash("sha1").update(this.normalizeString(source)).digest("hex");
     return sha1;
   }
   /**
@@ -451,7 +556,7 @@ var RootCMSClient = class {
     const syncedBy = (options == null ? void 0 : options.syncedBy) || "root-cms-client";
     const updatedDataSource = {
       ...dataSource,
-      syncedAt: Timestamp.now(),
+      syncedAt: Timestamp4.now(),
       syncedBy
     };
     const batch = this.db.batch();
@@ -460,7 +565,7 @@ var RootCMSClient = class {
       data
     });
     batch.update(dataSourceDocRef, {
-      syncedAt: Timestamp.now(),
+      syncedAt: Timestamp4.now(),
       syncedBy
     });
     await batch.commit();
@@ -485,7 +590,7 @@ var RootCMSClient = class {
     const publishedBy = (options == null ? void 0 : options.publishedBy) || "root-cms-client";
     const updatedDataSource = {
       ...dataSource,
-      publishedAt: Timestamp.now(),
+      publishedAt: Timestamp4.now(),
       publishedBy
     };
     const batch = this.db.batch();
@@ -497,7 +602,7 @@ var RootCMSClient = class {
       dataSource: updatedDataSource
     });
     batch.update(dataSourceDocRef, {
-      publishedAt: Timestamp.now(),
+      publishedAt: Timestamp4.now(),
       publishedBy
     });
     await batch.commit();
@@ -536,19 +641,40 @@ var RootCMSClient = class {
    */
   async getFromDataSource(dataSourceId, options) {
     const mode = (options == null ? void 0 : options.mode) || "published";
-    if (!(mode === "draft" || mode === "published")) {
-      throw new Error(`invalid mode: ${mode}`);
+    const docRef = this.dbDataSourceDataRef(dataSourceId, { mode });
+    const doc = await docRef.get();
+    if (doc.exists) {
+      return doc.data();
     }
+    return null;
+  }
+  dbDataSourceDataPath(dataSourceId, options) {
     if (!dataSourceId || dataSourceId.includes("/")) {
       throw new Error(`invalid data source id: ${dataSourceId}`);
     }
+    const mode = options.mode;
+    if (!(mode === "draft" || mode === "published")) {
+      throw new Error(`invalid mode: ${mode}`);
+    }
     const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/${mode}`;
-    const docRef = this.db.doc(dbPath);
-    const doc = await docRef.get();
-    if (doc.exists) {
-      return doc.data();
+    return dbPath;
+  }
+  dbDataSourceDataRef(dataSourceId, options) {
+    const dbPath = this.dbDataSourceDataPath(dataSourceId, options);
+    return this.db.doc(dbPath);
+  }
+  dbTranslationsPath(translationsId, options) {
+    const mode = options.mode;
+    if (!(mode === "draft" || mode === "published")) {
+      throw new Error(`invalid mode: ${mode}`);
     }
-    return null;
+    const slug = translationsId.replaceAll("/", "--");
+    const dbPath = `Projects/${this.projectId}/TranslationsManager/${mode}/Translations/${slug}`;
+    return dbPath;
+  }
+  dbTranslationsRef(translationsId, options) {
+    const dbPath = this.dbTranslationsPath(translationsId, options);
+    return this.db.doc(dbPath);
   }
   /**
    * Gets the user's role from the project's ACL.
@@ -604,7 +730,7 @@ var RootCMSClient = class {
     }
     const data = {
       action,
-      timestamp: Timestamp.now(),
+      timestamp: Timestamp4.now(),
       by: (options == null ? void 0 : options.by) || "system",
       metadata: (options == null ? void 0 : options.metadata) || {}
     };
@@ -621,20 +747,217 @@ var RootCMSClient = class {
       }
     }
   }
+  createBatchRequest(options) {
+    return new BatchRequest(this, options);
+  }
+};
+var BatchRequest = class {
+  constructor(cmsClient, options) {
+    this.docIds = [];
+    this.dataSourceIds = [];
+    this.queries = [];
+    this.translationsIds = [];
+    this.cmsClient = cmsClient;
+    this.db = cmsClient.db;
+    this.options = options;
+  }
+  /**
+   * Adds a doc to the batch request.
+   */
+  addDoc(docId) {
+    this.docIds.push(docId);
+  }
+  /**
+   * Adds a data source to the batch request.
+   */
+  addDataSource(dataSourceId) {
+    this.dataSourceIds.push(dataSourceId);
+  }
+  /**
+   * Adds a collection-based query to the batch request.
+   */
+  addQuery(queryId, collectionId, queryOptions) {
+    this.queries.push({
+      queryId,
+      collectionId,
+      queryOptions
+    });
+  }
+  /**
+   * Adds a translation file to the request.
+   */
+  addTranslations(translationsId) {
+    this.translationsIds.push(translationsId);
+  }
+  /**
+   * Fetches data from the DB.
+   */
+  async fetch() {
+    const res = new BatchResponse();
+    const promises = [
+      this.fetchDocs(res),
+      this.fetchQueries(res),
+      this.fetchDataSources(res)
+    ];
+    if (!this.options.translate && this.translationsIds.length > 0) {
+      promises.push(this.fetchTranslations(res));
+    }
+    await Promise.all(promises);
+    if (this.translationsIds.length > 0) {
+      await this.fetchTranslations(res);
+    }
+    return res;
+  }
+  async fetchDocs(res) {
+    if (this.docIds.length === 0) {
+      return;
+    }
+    const docRefs = this.docIds.map((docId) => {
+      const [collectionId, slug] = docId.split("/");
+      return this.cmsClient.dbDocRef(collectionId, slug, {
+        mode: this.options.mode
+      });
+    });
+    const docs = await this.db.getAll(...docRefs);
+    this.docIds.forEach((docId, i) => {
+      const doc = docs[i];
+      if (!doc.exists) {
+        console.warn(`doc "${docId}" does not exist`);
+        return;
+      }
+      const docData = unmarshalData(doc.data());
+      res.docs[docId] = docData;
+      if (this.options.translate) {
+        this.addTranslations(docId);
+      }
+    });
+  }
+  async fetchQueries(res) {
+    if (this.queries.length === 0) {
+      return;
+    }
+    const mode = this.options.mode;
+    const handleQuery = async (queryItem) => {
+      const docsPath = this.cmsClient.dbCollectionDocsPath(
+        queryItem.collectionId,
+        { mode }
+      );
+      const queryOptions = queryItem.queryOptions || {};
+      let query = this.db.collection(docsPath);
+      if (queryOptions.limit) {
+        query = query.limit(queryOptions.limit);
+      }
+      if (queryOptions.offset) {
+        query = query.offset(queryOptions.offset);
+      }
+      if (queryOptions.orderBy) {
+        query = query.orderBy(
+          queryOptions.orderBy,
+          queryOptions.orderByDirection
+        );
+      }
+      if (queryOptions.query) {
+        query = queryOptions.query(query);
+      }
+      const results = await query.get();
+      const docs = [];
+      results.forEach((result) => {
+        const doc = unmarshalData(result.data());
+        docs.push(doc);
+      });
+      res.queries[queryItem.queryId] = docs;
+    };
+    await Promise.all(this.queries.map((queryItem) => handleQuery(queryItem)));
+  }
+  async fetchDataSources(res) {
+    if (this.dataSourceIds.length === 0) {
+      return;
+    }
+    const docRefs = this.dataSourceIds.map((dataSourceId) => {
+      return this.cmsClient.dbDataSourceDataRef(dataSourceId, {
+        mode: this.options.mode
+      });
+    });
+    const docs = await this.db.getAll(...docRefs);
+    this.dataSourceIds.forEach((dataSourceId, i) => {
+      const doc = docs[i];
+      if (!doc.exists) {
+        console.warn(`"data source "${dataSourceId}" does not exist`);
+        return;
+      }
+      res.dataSources[dataSourceId] = doc.data();
+    });
+  }
+  async fetchTranslations(res) {
+    if (this.translationsIds.length === 0) {
+      return;
+    }
+    const docRefs = this.translationsIds.map((translationsId) => {
+      return this.cmsClient.dbTranslationsRef(translationsId, {
+        mode: this.options.mode
+      });
+    });
+    const docs = await this.db.getAll(...docRefs);
+    this.translationsIds.forEach((translationsId, i) => {
+      const doc = docs[i];
+      if (!doc.exists) {
+        return;
+      }
+      res.translations[translationsId] = doc.data();
+    });
+  }
+};
+var BatchResponse = class {
+  constructor() {
+    this.docs = {};
+    this.queries = {};
+    this.dataSources = {};
+    this.translations = {};
+  }
+  /**
+   * Returns a map of translations for a given locale or locale fallbacks.
+   *
+   * The input is either a single locale (e.g. "de") or an array of locales
+   * representing the fallback tree, e.g. ["en-CA", "en-GB", "en"].
+   *
+   * The returned value is a flat map of source string to translated string,
+   * e.g.:
+   * {"<source>": "<translation>"}
+   */
+  getTranslations(locale) {
+    const translationsMap = this.getTranslationsMap();
+    const translations = translationsForLocale(translationsMap, locale);
+    return translations;
+  }
+  /**
+   * Merges the strings from all translations files retrieved in the request.
+   * The returned value is a map of string to translations, e.g.:
+   *
+   * {"<hash>": {"source": "<source>", "<locale>": "<translation>"}}
+   */
+  getTranslationsMap() {
+    const translationsDocs = Object.values(this.translations).reverse();
+    const translationsMap = {};
+    for (const translationsDoc of translationsDocs) {
+      const strings = translationsDoc.strings || {};
+      for (const hash in strings) {
+        const translations = strings[hash];
+        translationsMap[hash] ??= { source: translations.source };
+        for (const locale in translations) {
+          if (locale !== "source" && translations[locale]) {
+            translationsMap[hash][locale] = translations[locale];
+          }
+        }
+      }
+    }
+    return translationsMap;
+  }
 };
 function isRichTextData(data) {
   return Boolean(
     isObject(data) && Array.isArray(data.blocks) && data.time && data.version
   );
 }
-function getCmsPlugin(rootConfig) {
-  const plugins = rootConfig.plugins || [];
-  const plugin = plugins.find((plugin2) => plugin2.name === "root-cms");
-  if (!plugin) {
-    throw new Error("could not find root-cms plugin config in root.config.ts");
-  }
-  return plugin;
-}
 function marshalData(data) {
   if (isRichTextData(data)) {
     return data;
@@ -723,9 +1046,19 @@ function randString(len) {
 }
 function translationsForLocale(translationsMap, locale) {
   const localeTranslations = {};
+  const fallbackLocales = Array.isArray(locale) ? locale : [locale];
+  if (!fallbackLocales.includes("en")) {
+    fallbackLocales.push("en");
+  }
   Object.values(translationsMap).forEach((string2) => {
     const source = string2.source;
-    const translation = string2[locale] || string2.en || string2.source;
+    let translation = source;
+    for (const fallbackLocale of fallbackLocales) {
+      if (string2[fallbackLocale]) {
+        translation = string2[fallbackLocale];
+        break;
+      }
+    }
     localeTranslations[source] = translation;
   });
   return localeTranslations;
@@ -767,6 +1100,199 @@ function parseDocId(docId) {
   return { collection: collection2, slug };
 }
 
+// core/cms-route.ts
+function cmsRoute(options) {
+  let cmsClient = null;
+  function getSlug(params) {
+    if (options.slug) {
+      return options.slug;
+    }
+    const slugParam = options.slugParam || "slug";
+    return (params[slugParam] || "index").replaceAll("/", "--");
+  }
+  async function fetchData(fetchOptions) {
+    if (!options.fetchData) {
+      return {};
+    }
+    const promisesMap = options.fetchData(fetchOptions);
+    return resolvePromisesMap(promisesMap);
+  }
+  async function generateProps(routeContext, preferredLocale) {
+    var _a, _b;
+    const { slug, mode } = routeContext;
+    const primaryDocId = `${options.collection}/${slug}`;
+    let batchRequest = routeContext.cmsClient.createBatchRequest({
+      mode,
+      translate: true
+    });
+    batchRequest.addDoc(primaryDocId);
+    if (options.preRequestHook) {
+      const overridedBatchRequest = options.preRequestHook(
+        batchRequest,
+        routeContext
+      );
+      if (overridedBatchRequest) {
+        batchRequest = overridedBatchRequest;
+      }
+    }
+    const [batchRes, data] = await Promise.all([
+      batchRequest.fetch(),
+      fetchData(routeContext)
+    ]);
+    const doc = batchRes.docs[primaryDocId];
+    if (!doc) {
+      return { notFound: true };
+    }
+    let locale;
+    if (typeof preferredLocale === "string") {
+      locale = preferredLocale;
+    } else {
+      locale = preferredLocale(doc);
+    }
+    const docLocales = ((_a = doc.sys) == null ? void 0 : _a.locales) || ["en"];
+    if (!locale || !docLocales.includes(locale)) {
+      return { notFound: true };
+    }
+    const i18nFallbacks = ((_b = routeContext.cmsClient.rootConfig.i18n) == null ? void 0 : _b.fallbacks) || {};
+    const translationFallbackLocales = i18nFallbacks[locale] || [locale];
+    const translations = batchRes.getTranslations(translationFallbackLocales);
+    let props = { ...data, locale, mode, slug, doc };
+    if (routeContext.req) {
+      const country = getFirstQueryParam(routeContext.req, "gl") || routeContext.req.get("x-country-code") || routeContext.req.get("x-appengine-country") || null;
+      props.country = country;
+    }
+    if (options.preRenderHook) {
+      props = await options.preRenderHook(props, routeContext);
+    }
+    return { props, locale, translations };
+  }
+  let getStaticPaths = null;
+  let getStaticProps = null;
+  if (options.enableSSG) {
+    getStaticPaths = async (ctx) => {
+      if (!options.slugParam) {
+        return { paths: [] };
+      }
+      if (!cmsClient) {
+        cmsClient = new RootCMSClient(ctx.rootConfig);
+      }
+      const mode = "published";
+      const res = await cmsClient.listDocs(options.collection, { mode });
+      const ssgPaths = [];
+      res.docs.forEach((doc) => {
+        const params = {};
+        params[options.slugParam] = doc.slug;
+        ssgPaths.push({ params });
+      });
+      return { paths: ssgPaths };
+    };
+    getStaticProps = async (ctx) => {
+      if (!cmsClient) {
+        cmsClient = new RootCMSClient(ctx.rootConfig);
+      }
+      const slug = getSlug(ctx.params);
+      const mode = "published";
+      const routeContext = { slug, mode, cmsClient };
+      return generateProps(routeContext, ctx.params.$locale);
+    };
+  }
+  return {
+    // SSG handlers (only enabled with `{enableSSG: true}`).
+    getStaticPaths,
+    getStaticProps,
+    // SSR handler.
+    handle: async (req, res) => {
+      if (!cmsClient) {
+        cmsClient = new RootCMSClient(req.rootConfig);
+      }
+      req.cmsClient = cmsClient;
+      const ctx = req.handlerContext;
+      const slug = getSlug(ctx.params);
+      if (slug.includes(".")) {
+        res.setHeader("cache-control", "private");
+        return ctx.render404();
+      }
+      const mode = String(req.query.preview) === "true" ? "draft" : "published";
+      const routeContext = { req, slug, mode, cmsClient };
+      function getLocale(doc) {
+        var _a;
+        const docLocales = ((_a = doc.sys) == null ? void 0 : _a.locales) || ["en"];
+        let locale2 = ctx.route.locale;
+        if (ctx.route.isDefaultLocale) {
+          locale2 = ctx.getPreferredLocale(docLocales);
+          if (docLocales.length > 0 && !docLocales.includes(locale2)) {
+            locale2 = docLocales[0];
+          }
+        }
+        return locale2;
+      }
+      const resData = await generateProps(routeContext, getLocale);
+      if (resData.notFound) {
+        res.setHeader("cache-control", "private");
+        return ctx.render404();
+      }
+      const { props, locale, translations } = resData;
+      if (props.$redirect) {
+        const redirectCode = props.$redirectCode || 302;
+        console.log(`redirecting to: ${props.$redirect} (${redirectCode})`);
+        redirectWithQuery(req, res, redirectCode, props.$redirect);
+        return;
+      }
+      if (options.disableCacheControl) {
+        res.setHeader("cache-control", "private");
+      } else if (mode === "published") {
+        res.setHeader("cache-control", "public, max-age=15, s-maxage=30");
+        if (ctx.route.isDefaultLocale) {
+          res.setHeader("vary", "accept-language, x-country-code");
+        }
+      }
+      if (options.setResponseHeaders) {
+        options.setResponseHeaders(req, res);
+      }
+      return ctx.render(props, { locale, translations });
+    }
+  };
+}
+async function resolvePromisesMap(promisesMap) {
+  const keys = Object.keys(promisesMap);
+  const promises = Object.values(promisesMap);
+  const results = await Promise.all(promises);
+  const resultMap = {};
+  keys.forEach((key, index) => {
+    resultMap[key] = results[index];
+  });
+  return resultMap;
+}
+function getFirstQueryParam(req, key) {
+  const val = req.query[key];
+  if (val === null || val === void 0) {
+    return null;
+  }
+  if (Array.isArray(val)) {
+    if (val.length === 0) {
+      return null;
+    }
+    return String(val[0]);
+  }
+  return String(val);
+}
+function redirectWithQuery(req, res, redirectCode, redirectPath) {
+  if (!redirectPath.startsWith("/")) {
+    res.redirect(redirectCode, redirectPath);
+    return;
+  }
+  const queryStr = getQueryStr(req);
+  const redirectUrl = queryStr ? `${redirectPath}?${queryStr}` : redirectPath;
+  res.redirect(redirectCode, redirectUrl);
+}
+function getQueryStr(req) {
+  const qIndex = req.originalUrl.indexOf("?");
+  if (qIndex === -1) {
+    return "";
+  }
+  return req.originalUrl.slice(qIndex + 1);
+}
+
 // core/runtime.ts
 import { FieldValue as FieldValue2 } from "firebase-admin/firestore";
 async function getDoc(rootConfig, collectionId, slug, options) {
@@ -1011,7 +1537,10 @@ function defineCollection(collection2) {
 }
 var collection = defineCollection;
 export {
+  BatchRequest,
+  BatchResponse,
   RootCMSClient,
+  cmsRoute,
   getCmsPlugin,
   getDoc,
   isRichTextData,
@@ -1024,10 +1553,12 @@ export {
   numDocs,
   parseDocId,
   publishScheduledDocs,
+  redirectWithQuery,
+  resolvePromisesMap,
   schema_exports as schema,
   toArrayObject,
   translationsForLocale,
   unmarshalArray,
   unmarshalData
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../core/client.ts", "../core/runtime.ts", "../core/schema.ts"],
  "sourcesContent": ["import crypto from 'node:crypto';\nimport {Plugin, RootConfig} from '@blinkk/root';\nimport {App} from 'firebase-admin/app';\nimport {\n  FieldValue,\n  Firestore,\n  Query,\n  Timestamp,\n  WriteBatch,\n} from 'firebase-admin/firestore';\nimport {CMSPlugin} from './plugin.js';\n\nexport interface Doc<Fields = any> {\n  /** The id of the doc, e.g. \"Pages/foo-bar\". */\n  id: string;\n  /** The collection id of the doc, e.g. \"Pages\". */\n  collection: string;\n  /** The slug of the doc, e.g. \"foo-bar\". */\n  slug: string;\n  sys: {\n    createdAt: number;\n    createdBy: string;\n    modifiedAt: number;\n    modifiedBy: string;\n    firstPublishedAt?: number;\n    firstPublishedBy?: string;\n    publishedAt?: number;\n    publishedBy?: string;\n    publishingLocked: {\n      lockedAt: string;\n      lockedBy: string;\n      reason: string;\n      until?: Timestamp;\n    };\n    locales?: string[];\n  };\n  fields: Fields;\n}\n\nexport type DocMode = 'draft' | 'published';\n\nexport type UserRole = 'ADMIN' | 'EDITOR' | 'VIEWER';\n\nexport type HttpMethod = 'GET' | 'POST';\n\nexport interface DataSource {\n  id: string;\n  description?: string;\n  type: 'http' | 'gsheet';\n  url: string;\n  /**\n   * Currently only used by gsheet. `array` returns the sheet as an array of\n   * arrays, `map` returns the sheet as an array of objects.\n   */\n  dataFormat?: 'array' | 'map';\n  /**\n   * Options for HTTP requests.\n   */\n  httpOptions?: {\n    method: HttpMethod;\n    headers?: Record<string, string>;\n    body?: string;\n  };\n  createdAt: Timestamp;\n  createdBy: string;\n  syncedAt?: Timestamp;\n  syncedBy?: string;\n  publishedAt?: Timestamp;\n  publishedBy?: string;\n}\n\nexport interface DataSourceData<T = any> {\n  dataSource: DataSource;\n  data: T;\n}\n\nexport type DataSourceMode = 'draft' | 'published';\n\nexport interface GetDocOptions {\n  /** Mode, either \"draft\" or \"published\". */\n  mode: DocMode;\n}\n\nexport interface SetDocOptions {\n  /** Mode, either \"draft\" or \"published\". */\n  mode: DocMode;\n}\n\nexport interface SaveDraftOptions {\n  /**\n   * Locales to enable.\n   */\n  locales?: string[];\n\n  /**\n   * Email of user modifying the doc. If blank, defaults to `root-cms-client`.\n   */\n  modifiedBy?: string;\n}\n\nexport interface ListDocsOptions {\n  mode: DocMode;\n  offset?: number;\n  limit?: number;\n  orderBy?: string;\n  orderByDirection?: 'asc' | 'desc';\n  query?: (query: Query) => Query;\n  /**\n   * Whether to fetch the \"raw\" version of the doc (for use in conjunction with\n   * `setRawDoc()`).\n   */\n  raw?: boolean;\n}\n\nexport interface GetCountOptions {\n  mode: DocMode;\n  query?: (query: Query) => Query;\n}\n\nexport interface Translation {\n  [locale: string]: string;\n  source: string;\n}\n\nexport interface TranslationsMap {\n  [hash: string]: Translation;\n}\n\nexport interface LocaleTranslations {\n  [source: string]: string;\n}\n\nexport interface LoadTranslationsOptions {\n  tags?: string[];\n}\n\nexport interface Release {\n  id: string;\n  description?: string;\n  docIds?: string[];\n  createdAt?: Timestamp;\n  createdBy?: string;\n  scheduledAt?: Timestamp;\n  scheduledBy?: string;\n  publishedAt?: Timestamp;\n  publishedBy?: string;\n}\n\nexport interface Action<T = any> {\n  /**\n   * The name of the action.\n   */\n  action: string;\n  /**\n   * The user's email that performed the action (or \"system\").\n   */\n  by?: string;\n  /**\n   * Timestamp when the action occurred.\n   */\n  timestamp: Timestamp;\n  /**\n   * Metadata for the action.\n   */\n  metadata?: T;\n}\n\nexport interface ListActionsOptions {\n  /**\n   * Filter by a specific action. Defaults to all actions.\n   */\n  action?: string;\n  /**\n   * Filter by a specific user. Defaults to all users.\n   */\n  by?: string;\n  /**\n   * Max number of actions to return. Defaults to 100.\n   */\n  limit?: number;\n}\n\nexport class RootCMSClient {\n  readonly rootConfig: RootConfig;\n  readonly cmsPlugin: CMSPlugin;\n  readonly projectId: string;\n  readonly app: App;\n  readonly db: Firestore;\n\n  constructor(rootConfig: RootConfig) {\n    this.rootConfig = rootConfig;\n    this.cmsPlugin = getCmsPlugin(this.rootConfig);\n\n    const cmsPluginOptions = this.cmsPlugin.getConfig();\n    this.projectId = cmsPluginOptions.id || 'default';\n    this.app = this.cmsPlugin.getFirebaseApp();\n    this.db = this.cmsPlugin.getFirestore();\n  }\n\n  /**\n   * Retrieves doc data from Root.js CMS.\n   */\n  async getDoc<Fields = any>(\n    collectionId: string,\n    slug: string,\n    options: GetDocOptions\n  ): Promise<Doc<Fields> | null> {\n    const rawData = await this.getRawDoc(collectionId, slug, options);\n    if (rawData) {\n      return unmarshalData(rawData) as Doc<Fields>;\n    }\n    return null;\n  }\n\n  /**\n   * Retrieves raw doc data as stored in the database. Only use this if you know\n   * what you are doing.\n   */\n  async getRawDoc(\n    collectionId: string,\n    slug: string,\n    options: GetDocOptions\n  ): Promise<any | null> {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    // Slugs with slashes are encoded as `--` in the DB.\n    slug = slug.replaceAll('/', '--');\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;\n    const docRef = this.db.doc(dbPath);\n    const doc = await docRef.get();\n    if (doc.exists) {\n      return doc.data();\n    }\n    return null;\n  }\n\n  /**\n   * Saves draft data to a doc.\n   *\n   * Note: this saves data to the \"fields\" attr of the draft doc. If you need to\n   * modify the sys-level attributes of the doc, use `setRawDoc()`.\n   */\n  async saveDraftData(\n    docId: string,\n    fieldsData: any,\n    options?: SaveDraftOptions\n  ) {\n    const {collection, slug} = parseDocId(docId);\n    const draftDoc =\n      (await this.getRawDoc(collection, slug, {mode: 'draft'})) || {};\n    const draftSys = draftDoc.sys || {};\n    const modifiedBy = options?.modifiedBy || 'root-cms-client';\n    const fields = marshalData(fieldsData || {});\n    const data = {\n      id: docId,\n      collection,\n      slug,\n      sys: {\n        ...draftSys,\n        createdAt: draftSys.createdAt ?? Timestamp.now(),\n        createdBy: draftSys.createdBy ?? modifiedBy,\n        modifiedAt: Timestamp.now(),\n        modifiedBy,\n        locales: options?.locales ?? draftSys.locales ?? ['en'],\n      },\n      fields,\n    };\n    await this.setRawDoc(collection, slug, data, {mode: 'draft'});\n  }\n\n  /**\n   * Prefer `saveDraftData('Pages/foo', data)`. Only use this if you know what\n   * you're doing.\n   */\n  async setRawDoc(\n    collectionId: string,\n    slug: string,\n    data: any,\n    options: SetDocOptions\n  ) {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;\n    const docRef = this.db.doc(dbPath);\n    await docRef.set(data);\n  }\n\n  /**\n   * Lists docs from a Root.js CMS collection.\n   */\n  async listDocs<T>(\n    collectionId: string,\n    options: ListDocsOptions\n  ): Promise<{docs: T[]}> {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;\n    let query: Query = this.db.collection(dbPath);\n    if (options.limit) {\n      query = query.limit(options.limit);\n    }\n    if (options.offset) {\n      query = query.offset(options.offset);\n    }\n    if (options.orderBy) {\n      query = query.orderBy(options.orderBy, options.orderByDirection);\n    }\n    if (options.query) {\n      query = options.query(query);\n    }\n    const results = await query.get();\n    const docs: T[] = [];\n    results.forEach((result) => {\n      if (options.raw) {\n        // For callers that wish to modify the raw doc via `setRawDoc()`,\n        // return the unmodified doc as returned from firestore.\n        const rawDoc = result.data() as T;\n        docs.push(rawDoc);\n      } else {\n        const doc = unmarshalData(result.data()) as T;\n        docs.push(doc);\n      }\n    });\n    return {docs};\n  }\n\n  /**\n   * Returns the number of docs in a Root.js CMS collection.\n   */\n  async getDocsCount(collectionId: string, options: GetCountOptions) {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;\n    let query: Query = this.db.collection(dbPath);\n    if (options.query) {\n      query = options.query(query);\n    }\n    const results = await query.count().get();\n    const count = results.data().count;\n    return count;\n  }\n\n  /**\n   * Batch publishes a set of docs by id.\n   */\n  async publishDocs(\n    docIds: string[],\n    options?: {publishedBy: string; batch?: WriteBatch}\n  ) {\n    const projectCollectionsPath = `Projects/${this.projectId}/Collections`;\n    const publishedBy = options?.publishedBy || 'root-cms-client';\n\n    // Fetch the current draft data for each doc.\n    const docRefs = docIds.map((docId) => {\n      const [collection, slug] = docId.split('/');\n      if (!collection || !slug) {\n        throw new Error(`invalid doc id: ${docId}`);\n      }\n      const docRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n      );\n      return docRef;\n    });\n    const docSnapshots = await this.db.getAll(...docRefs);\n    const docs = docSnapshots\n      // Retrieve snapshot data for each doc.\n      .map((snapshot) => snapshot.data() as Doc)\n      // Remove docs that don't exist.\n      .filter((d) => !!d);\n\n    if (docs.length === 0) {\n      console.log('no docs to publish');\n      return [];\n    }\n\n    // Verify there are no publishing locks on any docs.\n    for (const doc of docs) {\n      if (this.testPublishingLocked(doc)) {\n        throw new Error(`publishing is locked for doc: ${doc.id}`);\n      }\n    }\n\n    // // Each transaction or batch can write a max of 500 ops.\n    // // https://firebase.google.com/docs/firestore/manage-data/transactions\n    let batchCount = 0;\n    const batch = options?.batch || this.db.batch();\n    const publishedDocs: any[] = [];\n    for (const doc of docs) {\n      const {id, collection, slug, sys, fields} = doc;\n      const draftRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n      );\n      const scheduledRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Scheduled/${slug}`\n      );\n      const publishedRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Published/${slug}`\n      );\n\n      // Only update `firstPublished` if it doesn't already exist.\n      const firstPublishedAt =\n        sys.firstPublishedAt ?? FieldValue.serverTimestamp();\n      const firstPublishedBy = sys.firstPublishedBy ?? publishedBy;\n\n      // Save published doc.\n      batch.set(publishedRef, {\n        id,\n        collection,\n        slug,\n        fields: fields || {},\n        sys: {\n          ...sys,\n          firstPublishedAt: firstPublishedAt,\n          firstPublishedBy: firstPublishedBy,\n          publishedAt: FieldValue.serverTimestamp(),\n          publishedBy: publishedBy,\n        },\n      });\n      batchCount += 1;\n\n      // Remove scheduled doc, if any.\n      batch.delete(scheduledRef);\n      batchCount += 1;\n\n      // Update the draft doc to remove `scheduledAt` and `scheduledBy` fields\n      // and update the `publishedAt` and `publishedBy` fields.\n      batch.update(draftRef, {\n        'sys.scheduledAt': FieldValue.delete(),\n        'sys.scheduledBy': FieldValue.delete(),\n        'sys.firstPublishedAt': firstPublishedAt,\n        'sys.firstPublishedBy': firstPublishedBy,\n        'sys.publishedAt': FieldValue.serverTimestamp(),\n        'sys.publishedBy': publishedBy,\n      });\n      batchCount += 1;\n\n      publishedDocs.push(doc);\n\n      if (batchCount >= 400) {\n        await batch.commit();\n        batchCount = 0;\n      }\n    }\n\n    if (batchCount > 0) {\n      await batch.commit();\n    }\n    console.log(`published ${publishedDocs.length} docs!`);\n    return publishedDocs;\n  }\n\n  /**\n   * Publishes scheduled docs.\n   */\n  async publishScheduledDocs() {\n    const projectCollectionsPath = `Projects/${this.projectId}/Collections`;\n    const now = Math.ceil(new Date().getTime());\n\n    const snapshot = await this.db.collectionGroup('Scheduled').get();\n    const docs = snapshot.docs\n      .filter((d) => {\n        // Filter docs by project.\n        if (!d.ref.path.startsWith(projectCollectionsPath)) {\n          return false;\n        }\n        // Filter docs where scheduledAt is in the past.\n        // NOTE(stevenle): the filtering is done manually instead of using a query\n        // to avoid having to create an index in firestore.\n        const data = d.data() || {};\n        const scheduledAt: Timestamp | undefined = data.sys?.scheduledAt;\n        return (\n          scheduledAt && scheduledAt.toMillis && scheduledAt.toMillis() <= now\n        );\n      })\n      .map((d) => {\n        const dbPath = d.ref.path;\n        const segments = dbPath.split('/');\n        const slug = segments.at(-1);\n        const collection = segments.at(-3);\n        const id = `${collection}/${slug}`;\n        return {\n          data: d.data(),\n          id,\n          collection,\n          slug,\n        };\n      });\n\n    if (docs.length === 0) {\n      console.log('no docs to schedule');\n      return [];\n    }\n\n    // Each transaction or batch can write a max of 500 ops.\n    // https://firebase.google.com/docs/firestore/manage-data/transactions\n    let batchCount = 0;\n    const batch = this.db.batch();\n    const publishedDocs: any[] = [];\n    for (const doc of docs) {\n      const {id, collection, slug, data} = doc;\n      const draftRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n      );\n      const scheduledRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Scheduled/${slug}`\n      );\n      const publishedRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Published/${slug}`\n      );\n      const {scheduledAt, scheduledBy, ...sys} = data.sys || {};\n\n      // Only update `firstPublished` if it doesn't already exist.\n      const firstPublishedAt = sys.firstPublishedAt ?? scheduledAt;\n      const firstPublishedBy =\n        sys.firstPublishedBy ?? (scheduledBy || 'root-cms-client');\n\n      // Save published doc.\n      batch.set(publishedRef, {\n        id,\n        collection,\n        slug,\n        fields: data.fields || {},\n        sys: {\n          ...sys,\n          firstPublishedAt: firstPublishedAt,\n          firstPublishedBy: firstPublishedBy,\n          publishedAt: FieldValue.serverTimestamp(),\n          publishedBy: scheduledBy || '',\n        },\n      });\n      batchCount += 1;\n\n      // Remove published doc.\n      batch.delete(scheduledRef);\n      batchCount += 1;\n\n      // Update the draft doc to remove `scheduledAt` and `scheduledBy` fields\n      // and update the `publishedAt` and `publishedBy` fields.\n      batch.update(draftRef, {\n        'sys.scheduledAt': FieldValue.delete(),\n        'sys.scheduledBy': FieldValue.delete(),\n        'sys.firstPublishedAt': firstPublishedAt,\n        'sys.firstPublishedBy': firstPublishedBy,\n        'sys.publishedAt': FieldValue.serverTimestamp(),\n        'sys.publishedBy': scheduledBy || 'root-cms-client',\n      });\n      batchCount += 1;\n\n      publishedDocs.push(doc);\n\n      if (batchCount >= 400) {\n        await batch.commit();\n        batchCount = 0;\n        continue;\n      }\n    }\n\n    if (batchCount > 0) {\n      await batch.commit();\n    }\n    console.log(`published ${publishedDocs.length} docs!`);\n    return publishedDocs;\n  }\n\n  /**\n   * Publishes docs in scheduled releases.\n   */\n  async publishScheduledReleases() {\n    const releasesPath = `Projects/${this.projectId}/Releases`;\n    const now = Math.ceil(new Date().getTime());\n    const query: Query = this.db\n      .collection(releasesPath)\n      .where('scheduledAt', '<=', Timestamp.fromMillis(now));\n    const querySnapshot = await query.get();\n\n    for (const snapshot of querySnapshot.docs) {\n      const release = snapshot.data() as Release;\n      const batch = this.db.batch();\n      const publishedBy = release.scheduledBy || 'root-cms-client';\n      batch.update(snapshot.ref, {\n        publishedAt: Timestamp.now(),\n        publishedBy: publishedBy,\n        scheduledAt: FieldValue.delete(),\n        scheduledBy: FieldValue.delete(),\n      });\n      await this.publishDocs(release.docIds || [], {publishedBy, batch});\n    }\n  }\n\n  /**\n   * Checks if a doc is currently \"locked\" for publishing.\n   */\n  testPublishingLocked(doc: Doc) {\n    if (doc.sys?.publishingLocked) {\n      if (doc.sys.publishingLocked.until) {\n        const now = Timestamp.now().toMillis();\n        const until = doc.sys.publishingLocked.until.toMillis();\n        return now < until;\n      }\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Loads translations saved in the translations collection, optionally\n   * filtered by tag.\n   *\n   * Returns a map like:\n   * ```\n   * {\n   *   \"<hash>\": {\"source\": \"Hello\", \"es\": \"Hola\", \"fr\": \"Bonjour\"},\n   * }\n   * ```\n   */\n  async loadTranslations(\n    options?: LoadTranslationsOptions\n  ): Promise<TranslationsMap> {\n    const dbPath = `Projects/${this.projectId}/Translations`;\n    let query: Query = this.db.collection(dbPath);\n    if (options?.tags) {\n      query = query.where('tags', 'array-contains-any', options.tags);\n    }\n\n    const querySnapshot = await query.get();\n    const translationsMap: TranslationsMap = {};\n    querySnapshot.forEach((doc) => {\n      const hash = doc.id;\n      translationsMap[hash] = doc.data() as Translation;\n    });\n    return translationsMap;\n  }\n\n  /**\n   * Saves a map of translations, e.g.:\n   * ```\n   * await client.saveTranslations({\n   *   \"Hello\": {\"es\": \"Hola\", \"fr\": \"Bonjour\"},\n   * });\n   * ```\n   */\n  async saveTranslations(\n    translations: {\n      [source: string]: {[locale: string]: string};\n    },\n    tags?: string[]\n  ) {\n    const translationsPath = `Projects/${this.projectId}/Translations`;\n    const batch = this.db.batch();\n    let batchCount = 0;\n    Object.entries(translations).forEach(([source, sourceTranslations]) => {\n      const hash = this.getTranslationKey(source);\n      const translationRef = this.db.doc(`${translationsPath}/${hash}`);\n      const data: any = {\n        ...sourceTranslations,\n        source: this.normalizeString(source),\n      };\n      if (tags) {\n        data.tags = tags;\n      }\n      batch.set(translationRef, data, {merge: true});\n      batchCount += 1;\n    });\n    if (batchCount > 500) {\n      throw new Error('up to 500 translations can be saved at a time.');\n    }\n    await batch.commit();\n  }\n\n  /**\n   * Returns the \"key\" used for a translation as stored in the db. Translations\n   * are stored under `Projects/<project id>/Translations/<sha1 hash>`.\n   */\n  getTranslationKey(source: string) {\n    const sha1 = crypto\n      .createHash('sha1')\n      .update(this.normalizeString(source))\n      .digest('hex');\n    return sha1;\n  }\n\n  /**\n   * Cleans a string that's used for translations. Performs the following:\n   * - Removes any leading/trailing whitespace\n   * - Removes spaces at the end of any line\n   */\n  normalizeString(str: string) {\n    const lines = String(str)\n      .trim()\n      .split('\\n')\n      .map((line) => line.trimEnd());\n    return lines.join('\\n');\n  }\n\n  /**\n   * Loads translations for a particular locale.\n   *\n   * Returns a map like:\n   * ```\n   * {\n   *   \"Hello\": \"Bonjour\",\n   * }\n   * ```\n   */\n  async loadTranslationsForLocale(\n    locale: string,\n    options?: LoadTranslationsOptions\n  ): Promise<LocaleTranslations> {\n    const translationsMap = await this.loadTranslations(options);\n    return translationsForLocale(translationsMap, locale);\n  }\n\n  /**\n   * Returns a data source configuration object.\n   */\n  async getDataSource(dataSourceId: string) {\n    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}`;\n    const docRef = this.db.doc(dbPath);\n    const doc = await docRef.get();\n    if (doc.exists) {\n      return doc.data() as DataSource;\n    }\n    return null;\n  }\n\n  /**\n   * Syncs a data source to draft state.\n   */\n  async syncDataSource(dataSourceId: string, options?: {syncedBy?: string}) {\n    const dataSource = await this.getDataSource(dataSourceId);\n    if (!dataSource) {\n      throw new Error(`data source not found: ${dataSourceId}`);\n    }\n\n    const data = await this.fetchData(dataSource);\n\n    const dataSourceDocRef = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}`\n    );\n    const dataDocRef = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/draft`\n    );\n    const syncedBy = options?.syncedBy || 'root-cms-client';\n\n    const updatedDataSource: DataSource = {\n      ...dataSource,\n      syncedAt: Timestamp.now(),\n      syncedBy: syncedBy,\n    };\n\n    const batch = this.db.batch();\n    batch.set(dataDocRef, {\n      dataSource: updatedDataSource,\n      data: data,\n    });\n    batch.update(dataSourceDocRef, {\n      syncedAt: Timestamp.now(),\n      syncedBy: syncedBy,\n    });\n    await batch.commit();\n\n    console.log(`synced data source: ${dataSourceId}`);\n    console.log(`synced by: ${syncedBy}`);\n  }\n\n  async publishDataSource(\n    dataSourceId: string,\n    options?: {publishedBy?: string}\n  ) {\n    const dataSource = await this.getDataSource(dataSourceId);\n    if (!dataSource) {\n      throw new Error(`data source not found: ${dataSourceId}`);\n    }\n\n    const dataSourceDocRef = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}`\n    );\n    const dataDocRefDraft = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}/draft`\n    );\n    const dataDocRefPublished = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}/published`\n    );\n\n    const dataRes = await this.getFromDataSource(dataSourceId, {mode: 'draft'});\n\n    const publishedBy = options?.publishedBy || 'root-cms-client';\n\n    const updatedDataSource: DataSource = {\n      ...dataSource,\n      publishedAt: Timestamp.now(),\n      publishedBy: publishedBy,\n    };\n\n    const batch = this.db.batch();\n    batch.set(dataDocRefPublished, {\n      dataSource: updatedDataSource,\n      data: dataRes?.data || null,\n    });\n    batch.update(dataDocRefDraft, {\n      dataSource: updatedDataSource,\n    });\n    batch.update(dataSourceDocRef, {\n      publishedAt: Timestamp.now(),\n      publishedBy: publishedBy,\n    });\n    await batch.commit();\n\n    console.log(`published data ${dataSourceId}`);\n    console.log(`published by: ${publishedBy}`);\n  }\n\n  private async fetchData(dataSource: DataSource) {\n    if (dataSource.type === 'http') {\n      return await this.fetchHttpData(dataSource);\n    }\n    // TODO(stevenle): impl.\n    // if (dataSource.type === 'gsheet') {\n    //   return await fetchGsheetData(dataSource);\n    // }\n    throw new Error(`unsupported data source: ${dataSource.type}`);\n  }\n\n  private async fetchHttpData(dataSource: DataSource) {\n    const url = dataSource.url || '';\n    if (!url.startsWith('https://')) {\n      throw new Error(`url not supported: ${url}`);\n    }\n\n    const res = await fetch(url, {\n      method: dataSource.httpOptions?.method || 'GET',\n      headers: dataSource.httpOptions?.headers || [],\n      body: dataSource.httpOptions?.body || undefined,\n    });\n\n    if (res.status !== 200) {\n      const err = await res.text();\n      throw new Error(`req failed: ${err}`);\n    }\n\n    const contentType = String(res.headers.get('content-type'));\n    if (contentType.includes('application/json')) {\n      return await res.json();\n    }\n    return res.text();\n  }\n\n  /**\n   * Fetches data from a data source.\n   */\n  async getFromDataSource<T = any>(\n    dataSourceId: string,\n    options?: {mode?: 'draft' | 'published'}\n  ): Promise<DataSourceData<T> | null> {\n    const mode = options?.mode || 'published';\n    if (!(mode === 'draft' || mode === 'published')) {\n      throw new Error(`invalid mode: ${mode}`);\n    }\n    if (!dataSourceId || dataSourceId.includes('/')) {\n      throw new Error(`invalid data source id: ${dataSourceId}`);\n    }\n\n    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/${mode}`;\n    const docRef = this.db.doc(dbPath);\n    const doc = await docRef.get();\n    if (doc.exists) {\n      return doc.data() as DataSourceData<T>;\n    }\n    return null;\n  }\n\n  /**\n   * Gets the user's role from the project's ACL.\n   */\n  async getUserRole(email: string): Promise<UserRole | null> {\n    if (!email) {\n      return null;\n    }\n    const docRef = this.db.doc(`Projects/${this.projectId}`);\n    const snapshot = await docRef.get();\n    const data = snapshot.data() || {};\n    const acl = data.roles || {};\n\n    if (email in acl) {\n      return acl[email];\n    }\n\n    // Check wildcard domains, e.g. `*@example.com`.\n    if (!email.includes('@')) {\n      console.warn(`invalid email: ${email}`);\n      return null;\n    }\n    const domain = email.split('@').at(-1);\n    if (domain && `*@${domain}` in acl) {\n      return acl[`*@${domain}`];\n    }\n    return null;\n  }\n\n  /**\n   * Verifies user exists in the ACL list.\n   */\n  async userExistsInAcl(email: string): Promise<boolean> {\n    if (!email) {\n      return false;\n    }\n    const docRef = this.db.doc(`Projects/${this.projectId}`);\n    const snapshot = await docRef.get();\n    const data = snapshot.data() || {};\n    const acl = data.roles || {};\n    if (email in acl) {\n      return true;\n    }\n\n    // Check wildcard domains, e.g. `*@example.com`.\n    if (!email.includes('@')) {\n      console.warn(`invalid email: ${email}`);\n      return false;\n    }\n    const domain = email.split('@').at(-1);\n    if (domain && `*@${domain}` in acl) {\n      return true;\n    }\n    return false;\n  }\n\n  async logAction(action: string, options?: {by?: string; metadata?: any}) {\n    if (!action) {\n      throw new Error('missing required: \"action\"');\n    }\n    const data = {\n      action: action,\n      timestamp: Timestamp.now(),\n      by: options?.by || 'system',\n      metadata: options?.metadata || {},\n    };\n    const colRef = this.db.collection(`Projects/${this.projectId}/ActionLogs`);\n    await colRef.add(data);\n\n    const metaStr = options?.metadata ? stringifyObj(options.metadata) : '';\n    console.log(`[${data.timestamp.toMillis()}] action: ${action} ${metaStr}`);\n\n    // Call the `onAction()` callback from cmsPlugin().\n    const cmsPluginConfig = this.cmsPlugin.getConfig();\n    if (cmsPluginConfig.onAction) {\n      try {\n        cmsPluginConfig.onAction(data);\n      } catch (err) {\n        console.error(err);\n      }\n    }\n  }\n}\n\n/**\n * Returns true if the `data` is a rich text data object.\n */\nexport function isRichTextData(data: any) {\n  // The RichTextEditor uses editorjs under the hood, the data format is\n  // something like:\n  //  {\n  //   \"time\": 1721761211720,\n  //   \"version\": \"2.28.2\",\n  //   \"blocks\": [...]\n  // }\n  return Boolean(\n    isObject(data) && Array.isArray(data.blocks) && data.time && data.version\n  );\n}\n\nexport function getCmsPlugin(rootConfig: RootConfig): CMSPlugin {\n  const plugins: Plugin[] = rootConfig.plugins || [];\n  const plugin = plugins.find((plugin) => plugin.name === 'root-cms');\n  if (!plugin) {\n    throw new Error('could not find root-cms plugin config in root.config.ts');\n  }\n  return plugin as CMSPlugin;\n}\n\n/**\n * Walks the data tree and converts any array of objects into \"array objects\"\n * for storage in firestore.\n */\nexport function marshalData(data: any): any {\n  // Avoid changing the format of rich text data.\n  if (isRichTextData(data)) {\n    return data;\n  }\n\n  const result: any = {};\n  for (const key in data) {\n    const val = data[key];\n    if (isObject(val)) {\n      result[key] = marshalData(val);\n    } else if (Array.isArray(val)) {\n      if (val.length > 0 && val.some((item) => isObject(item))) {\n        const items = val.map((item) => {\n          if (isObject(item)) {\n            return marshalData(item);\n          }\n          return item;\n        });\n        result[key] = toArrayObject(items);\n      } else {\n        result[key] = val;\n      }\n    } else {\n      result[key] = val;\n    }\n  }\n  return result;\n}\n\n/**\n * Walks the data tree and converts any Timestamp objects to millis and any\n * _array maps to normal arrays.\n *\n * E.g.:\n *\n * normalizeData({\n *   sys: {modifiedAt: Timestamp(123)},\n *   fields: {\n *     _array: ['asdf'],\n *     asdf: {title: 'hello'}\n *   }\n * })\n * // => {sys: {modifiedAt: 123}, fields: {foo: [{title: 'hello'}]}}\n */\nexport function unmarshalData(data: any): any {\n  const result: any = {};\n  for (const key in data) {\n    const val = data[key];\n    if (isObject(val)) {\n      if (val.toMillis) {\n        result[key] = val.toMillis();\n      } else if (Object.hasOwn(val, '_array') && Array.isArray(val._array)) {\n        const arr = val._array.map((arrayKey: string) => {\n          return {\n            ...unmarshalData(val[arrayKey] || {}),\n            _arrayKey: arrayKey,\n          };\n        });\n        result[key] = arr;\n      } else {\n        result[key] = unmarshalData(val);\n      }\n    } else {\n      result[key] = val;\n    }\n  }\n  return result;\n}\n\n/** @deprecated Use `unmarshalData()` instead. */\nexport function normalizeData(data: any): any {\n  return unmarshalData(data);\n}\n\nexport interface ArrayObject {\n  [key: string]: any;\n  _array: string[];\n}\n\n/**\n * Serializes an array into an `ArrayObject`, e.g.:\n *\n * ```\n * marshalArray([1, 2, 3])\n * // => {a: 1, b: 2, c: 3, _array: ['a', 'b', 'c']}\n * ```\n *\n * This database storage method makes it easier to update a single field in a\n * deeply nested array object.\n */\nexport function toArrayObject(arr: any[]): ArrayObject {\n  if (!Array.isArray(arr)) {\n    return arr;\n  }\n  const arrObject: ArrayObject = {_array: []};\n  for (const item of arr) {\n    const key = randString(6);\n    arrObject[key] = item;\n    arrObject._array.push(key);\n  }\n  return arrObject;\n}\n\nexport const marshalArray = toArrayObject;\n\n/**\n * Converts an `ArrayObject` to a normal array.\n */\nexport function unmarshalArray(arrObject: ArrayObject): any[] {\n  if (!Array.isArray(arrObject?._array)) {\n    return [];\n  }\n  const arr = arrObject._array.map((k: string) => arrObject[k]);\n  return arr;\n}\n\nfunction isObject(data: any): boolean {\n  return typeof data === 'object' && !Array.isArray(data) && data !== null;\n}\n\nfunction randString(len: number): string {\n  const result = [];\n  const chars =\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n  for (let i = 0; i < len; i++) {\n    const rand = Math.floor(Math.random() * chars.length);\n    result.push(chars.charAt(rand));\n  }\n  return result.join('');\n}\n\n/**\n * Converts a translations map from `loadTranslations()` to a map of source to\n * translated string for a particular locale.\n *\n * Returns a map like:\n * ```\n * {\n *   \"Hello\": \"Bonjour\",\n * }\n * ```\n */\nexport function translationsForLocale(\n  translationsMap: TranslationsMap,\n  locale: string\n) {\n  const localeTranslations: LocaleTranslations = {};\n  Object.values(translationsMap).forEach((string) => {\n    const source = string.source;\n    const translation = string[locale] || string.en || string.source;\n    localeTranslations[source] = translation;\n  });\n  return localeTranslations;\n}\n\n/** A pretty printer for JavaScript objects. */\nfunction stringifyObj(obj: any) {\n  function format(obj: any): string {\n    if (obj === null) {\n      return 'null';\n    }\n    if (typeof obj === 'undefined') {\n      return 'undefined';\n    }\n    if (typeof obj === 'string') {\n      return `\"${obj.replaceAll('\"', '\\\\\"')}\"`;\n    }\n    if (typeof obj !== 'object') {\n      return String(obj);\n    }\n    if (Array.isArray(obj)) {\n      return `[${obj.map(format).join(', ')}]`;\n    }\n    const entries: string[] = Object.entries(obj).map(([key, value]) => {\n      return `${key}: ${format(value)}`;\n    });\n    return `{${entries.join(', ')}}`;\n  }\n  return format(obj);\n}\n\n/**\n * Parses a docId (e.g. `Pages/foo`) and returns the `collection` and `slug`.\n */\nexport function parseDocId(docId: string) {\n  const sepIndex = docId.indexOf('/');\n  if (sepIndex <= 0) {\n    throw new Error(`invalid doc id: ${docId}`);\n  }\n  const collection = docId.slice(0, sepIndex);\n  const slug = docId.slice(sepIndex + 1).replaceAll('/', '--');\n  if (!collection || !slug) {\n    throw new Error(`invalid doc id: ${docId}`);\n  }\n  return {collection, slug};\n}\n", "/** @deprecated Use client.ts instead. */\n\nimport {RootConfig} from '@blinkk/root';\nimport {FieldValue, Query, Timestamp} from 'firebase-admin/firestore';\nimport {\n  LoadTranslationsOptions,\n  LocaleTranslations,\n  Translation,\n  TranslationsMap,\n  getCmsPlugin,\n  translationsForLocale,\n  unmarshalData,\n} from './client.js';\n\n/**\n * Retrieves a doc from Root.js CMS.\n * @deprecated Use RootCMSClient.getDoc() instead.\n */\nexport async function getDoc<T>(\n  rootConfig: RootConfig,\n  collectionId: string,\n  slug: string,\n  options: {\n    mode: 'draft' | 'published';\n  }\n): Promise<T | null> {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const mode = options.mode;\n  const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n  const db = cmsPlugin.getFirestore();\n  // Slugs with slashes are encoded as `--` in the DB.\n  slug = slug.replaceAll('/', '--');\n  const dbPath = `Projects/${projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;\n  const docRef = db.doc(dbPath);\n  const doc = await docRef.get();\n  if (doc.exists) {\n    const data = doc.data();\n    return unmarshalData(data) as T;\n  }\n  console.log(`doc not found: ${dbPath}`);\n  return null;\n}\n\n/**\n * Lists docs from a Root.js CMS collection.\n * @deprecated Use RootCMSClient.listDocs() instead.\n */\nexport async function listDocs<T>(\n  rootConfig: RootConfig,\n  collectionId: string,\n  options: {\n    mode: 'draft' | 'published';\n    offset?: number;\n    limit?: number;\n    orderBy?: string;\n    orderByDirection?: 'asc' | 'desc';\n    query?: (query: Query) => Query;\n  }\n): Promise<{docs: T[]}> {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const mode = options.mode;\n  const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n  const db = cmsPlugin.getFirestore();\n  const dbPath = `Projects/${projectId}/Collections/${collectionId}/${modeCollection}`;\n  let query: Query = db.collection(dbPath);\n  if (options.limit) {\n    query = query.limit(options.limit);\n  }\n  if (options.offset) {\n    query = query.offset(options.offset);\n  }\n  if (options.orderBy) {\n    query = query.orderBy(options.orderBy, options.orderByDirection);\n  }\n  if (options.query) {\n    query = options.query(query);\n  }\n  const results = await query.get();\n  const docs: T[] = [];\n  results.forEach((result) => {\n    const doc = unmarshalData(result.data()) as T;\n    docs.push(doc);\n  });\n  return {docs};\n}\n\n/**\n * Returns the number of docs in a Root.js CMS collection.\n * @deprecated Use RootCMSClient.getDocsCount() instead.\n */\nexport async function numDocs(\n  rootConfig: RootConfig,\n  collectionId: string,\n  options: {\n    mode: 'draft' | 'published';\n    query?: (query: Query) => Query;\n  }\n) {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const mode = options.mode;\n  const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n  const db = cmsPlugin.getFirestore();\n  const dbPath = `Projects/${projectId}/Collections/${collectionId}/${modeCollection}`;\n  let query: Query = db.collection(dbPath);\n  if (options.query) {\n    query = options.query(query);\n  }\n  const results = await query.count().get();\n  const count = results.data().count;\n  return count;\n}\n\n/**\n * Publishes scheduled docs.\n * @deprecated Use RootCMSClient.publishScheduledDocs() instead.\n */\nexport async function publishScheduledDocs(rootConfig: RootConfig) {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const db = cmsPlugin.getFirestore();\n\n  const projectCollectionsPath = `Projects/${projectId}/Collections`;\n  const now = Math.ceil(new Date().getTime());\n\n  const snapshot = await db.collectionGroup('Scheduled').get();\n  const docs = snapshot.docs\n    .filter((d) => {\n      // Filter docs by project.\n      if (!d.ref.path.startsWith(projectCollectionsPath)) {\n        return false;\n      }\n      // Filter docs where scheduledAt is in the past.\n      // NOTE(stevenle): the filtering is done manually instead of using a query\n      // to avoid having to create an index in firestore.\n      const data = d.data() || {};\n      const scheduledAt: Timestamp | undefined = data.sys?.scheduledAt;\n      return (\n        scheduledAt && scheduledAt.toMillis && scheduledAt.toMillis() <= now\n      );\n    })\n    .map((d) => {\n      const dbPath = d.ref.path;\n      const segments = dbPath.split('/');\n      const slug = segments.at(-1);\n      const collection = segments.at(-3);\n      const id = `${collection}/${slug}`;\n      return {\n        data: d.data(),\n        id,\n        collection,\n        slug,\n      };\n    });\n\n  if (docs.length === 0) {\n    return [];\n  }\n\n  // Each transaction or batch can write a max of 500 ops.\n  // https://firebase.google.com/docs/firestore/manage-data/transactions\n  let batchCount = 0;\n  const batch = db.batch();\n  const publishedDocs: any[] = [];\n  for (const doc of docs) {\n    const {id, collection, slug, data} = doc;\n    const draftRef = db.doc(\n      `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n    );\n    const scheduledRef = db.doc(\n      `${projectCollectionsPath}/${collection}/Scheduled/${slug}`\n    );\n    const publishedRef = db.doc(\n      `${projectCollectionsPath}/${collection}/Published/${slug}`\n    );\n    const {scheduledAt, scheduledBy, ...sys} = data.sys || {};\n\n    // Only update `firstPublished` if it doesn't already exist.\n    const firstPublishedAt = sys.firstPublishedAt ?? scheduledAt;\n    const firstPublishedBy = sys.firstPublishedBy ?? (scheduledBy || '');\n\n    // Save published doc.\n    batch.set(publishedRef, {\n      id,\n      collection,\n      slug,\n      fields: data.fields || {},\n      sys: {\n        ...sys,\n        firstPublishedAt: firstPublishedAt,\n        firstPublishedBy: firstPublishedBy,\n        publishedAt: FieldValue.serverTimestamp(),\n        publishedBy: scheduledBy || '',\n      },\n    });\n    batchCount += 1;\n\n    // Remove published doc.\n    batch.delete(scheduledRef);\n    batchCount += 1;\n\n    // Update the draft doc to remove `scheduledAt` and `scheduledBy` fields\n    // and update the `publishedAt` and `publishedBy` fields.\n    batch.update(draftRef, {\n      'sys.scheduledAt': FieldValue.delete(),\n      'sys.scheduledBy': FieldValue.delete(),\n      'sys.firstPublishedAt': firstPublishedAt,\n      'sys.firstPublishedBy': firstPublishedBy,\n      'sys.publishedAt': FieldValue.serverTimestamp(),\n      'sys.publishedBy': scheduledBy || '',\n    });\n    batchCount += 1;\n\n    publishedDocs.push(doc);\n\n    if (batchCount >= 498) {\n      break;\n    }\n  }\n\n  await batch.commit();\n  console.log(`published ${publishedDocs.length} docs!`);\n  return publishedDocs;\n}\n\n/**\n * @deprecated Use `RootCMSClient.loadTranslations()`.\n */\nexport async function loadTranslations(\n  rootConfig: RootConfig,\n  options?: LoadTranslationsOptions\n): Promise<TranslationsMap> {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const db = cmsPlugin.getFirestore();\n\n  const dbPath = `Projects/${projectId}/Translations`;\n  let query: Query = db.collection(dbPath);\n  if (options?.tags) {\n    query = query.where('tags', 'array-contains-any', options.tags);\n  }\n\n  const querySnapshot = await query.get();\n  const translationsMap: TranslationsMap = {};\n  querySnapshot.forEach((doc) => {\n    const hash = doc.id;\n    translationsMap[hash] = doc.data() as Translation;\n  });\n  return translationsMap;\n}\n\n/**\n * @deprecated Use `RootCMSClient.loadTranslationsForLocale()`.\n */\nexport async function loadTranslationsForLocale(\n  rootConfig: RootConfig,\n  locale: string,\n  options?: LoadTranslationsOptions\n): Promise<LocaleTranslations> {\n  const translationsMap = await loadTranslations(rootConfig, options);\n  return translationsForLocale(translationsMap, locale);\n}\n", "import {FunctionalComponent} from 'preact';\n\nexport interface CommonFieldProps {\n  type: string;\n  id?: string;\n  label?: string;\n  help?: string;\n  placeholder?: string;\n  default?: any;\n  hidden?: boolean;\n  deprecated?: boolean;\n  /** Hides the field label in the CMS UI. */\n  hideLabel?: boolean;\n}\n\nexport type StringField = CommonFieldProps & {\n  type: 'string';\n  default?: string;\n  translate?: boolean;\n  variant?: 'input' | 'textarea';\n  /** For textarea variant, the maximum number of rows of text to show. */\n  maxRows?: number;\n};\n\nexport function string(field: Omit<StringField, 'type'>): StringField {\n  return {...field, type: 'string'};\n}\n\nexport type NumberField = CommonFieldProps & {\n  type: 'number';\n  default?: number;\n};\n\nexport function number(field: Omit<NumberField, 'type'>): NumberField {\n  return {...field, type: 'number'};\n}\n\nexport type DateField = CommonFieldProps & {\n  type: 'date';\n  default?: string;\n};\n\nexport function date(field: Omit<DateField, 'type'>): DateField {\n  return {...field, type: 'date'};\n}\n\nexport type DateTimeField = CommonFieldProps & {\n  type: 'datetime';\n  default?: string;\n};\n\nexport function datetime(field: Omit<DateTimeField, 'type'>): DateTimeField {\n  return {...field, type: 'datetime'};\n}\n\nexport type BooleanField = CommonFieldProps & {\n  type: 'boolean';\n  default?: boolean;\n  checkboxLabel?: string;\n};\n\nexport function boolean(field: Omit<BooleanField, 'type'>): BooleanField {\n  return {...field, type: 'boolean'};\n}\n\nexport type SelectField = CommonFieldProps & {\n  type: 'select';\n  default?: string;\n  options?: Array<{value: string; label?: string}> | string[];\n  translate?: boolean;\n};\n\nexport function select(field: Omit<SelectField, 'type'>): SelectField {\n  return {...field, type: 'select'};\n}\n\nexport type MultiSelectField = Omit<SelectField, 'type'> & {\n  type: 'multiselect';\n  /** Set to `true` to allow users to create arbitrary values. */\n  creatable?: boolean;\n  translate?: boolean;\n};\n\nexport function multiselect(\n  field: Omit<MultiSelectField, 'type'>\n): MultiSelectField {\n  return {...field, type: 'multiselect'};\n}\n\nexport type ImageField = CommonFieldProps & {\n  type: 'image';\n  translate?: boolean;\n  /** List of supported exts, e.g. `['.mp4']`. */\n  exts?: string[];\n  /**\n   * Cache-control header to set on the GCS object.\n   */\n  cacheControl?: string;\n};\n\nexport function image(field: Omit<ImageField, 'type'>): ImageField {\n  return {...field, type: 'image'};\n}\n\nexport type FileField = CommonFieldProps & {\n  type: 'file';\n  /** List of supported exts, e.g. `['.mp4']`. */\n  exts?: string[];\n  /**\n   * Whether to preserve the final serving filename when a user uploads a file.\n   * By default, the filename is hashed for obfuscation purposes.\n   */\n  preserveFilename?: boolean;\n  /**\n   * Cache-control header to set on the GCS object.\n   */\n  cacheControl?: string;\n};\n\nexport function file(field: Omit<FileField, 'type'>): FileField {\n  return {...field, type: 'file'};\n}\n\nexport type ObjectField = CommonFieldProps & {\n  type: 'object';\n  fields: FieldWithId[];\n  /** Defaults to \"drawer\". */\n  variant?: 'drawer' | 'inline';\n  /** Options for the \"drawer\" variant. */\n  drawerOptions?: {\n    /** Whether the drawer should initialize to the \"collapsed\" state. */\n    collapsed?: boolean;\n    /**\n     * Whether to render the drawer \"inline\" (this removes borders from the\n     * toggle button).\n     */\n    inline?: boolean;\n  };\n};\n\nexport function object(field: Omit<ObjectField, 'type'>): ObjectField {\n  return {...field, type: 'object'};\n}\n\nexport type ArrayField = CommonFieldProps & {\n  type: 'array';\n  default?: any[];\n  /**\n   * String format for the preview line of an item in the array. Placeholder\n   * values should use brackets, e.g. `m{_index:02}: {_type}`.\n   *\n   * Multiple values can be provided, in which case the first preview line with\n   * no missing placeholder values will be used.\n   *\n   * System added placeholder values:\n   *\n   * - _index: The 0-based index.\n   * - _index:02: A left-padded version of _index to 2 digits.\n   * - _index:03: A left-padded version of _index to 3 digits.\n   * - _type: For array of one-of fields, the type of the selected field.\n   */\n  preview?: string | string[];\n  // NOTE(stevenle): the array field should only accept object values to keep\n  // the schemas future-friendly. For example, if we were to accept primatives\n  // (e.g. Array<string>) and the developer decides in the future that they\n  // need to add extra fields to that array type, they would have to create a\n  // new field, create a new schema field, and then perform a db migration to\n  // update from the old field type to the new field type. But if we enforce\n  // objects here, a developer should technically be able to add fields to the\n  // nested field definition without breaking any existing db entries.\n  of: ObjectLikeField;\n  /**\n   * Label to use for the \"add item\" button. Defaults to `Add`.\n   */\n  buttonLabel?: string;\n};\n\nexport function array(field: Omit<ArrayField, 'type'>): ArrayField {\n  return {...field, type: 'array'};\n}\n\nexport type OneOfField = CommonFieldProps & {\n  type: 'oneof';\n  types: Schema[];\n};\n\nexport function oneOf(field: Omit<OneOfField, 'type'>): OneOfField {\n  return {...field, type: 'oneof'};\n}\n\nexport type RichTextField = CommonFieldProps & {\n  type: 'richtext';\n  translate?: boolean;\n  placeholder?: string;\n};\n\nexport function richtext(field: Omit<RichTextField, 'type'>): RichTextField {\n  return {...field, type: 'richtext'};\n}\n\nexport type ReferenceField = CommonFieldProps & {\n  type: 'reference';\n  /** List of collection ids the reference can be chosen from. */\n  collections?: string[];\n  /** Initial collection to show when picking a reference. */\n  initialCollection?: string;\n  /** Label for the button. Defaults to \"Select\". */\n  buttonLabel?: string;\n};\n\nexport function reference(field: Omit<ReferenceField, 'type'>): ReferenceField {\n  return {...field, type: 'reference'};\n}\n\nexport type Field =\n  | StringField\n  | NumberField\n  | DateField\n  | DateTimeField\n  | BooleanField\n  | SelectField\n  | MultiSelectField\n  | ImageField\n  | FileField\n  | ObjectField\n  | ArrayField\n  | OneOfField\n  | RichTextField\n  | ReferenceField;\n\n/**\n * Similar to {@link Field} but with a required `id`.\n * TODO(stevenle): fix this.\n */\nexport type FieldWithId = Field;\n\nexport type ObjectLikeField =\n  | ImageField\n  | FileField\n  | ObjectField\n  | OneOfField\n  | ReferenceField;\n\nexport interface Schema {\n  name: string;\n  description?: string;\n  fields: FieldWithId[];\n}\n\nexport function defineSchema(schema: Schema): Schema {\n  return schema;\n}\n\n/** Defines the schema for a collection or reusable component. */\nexport const define = defineSchema;\n\nexport type Collection = Schema & {\n  /**\n   * Domain where the collection serves from. Used for multi-domain sites,\n   * defaults to the \"domain\" value `from root.config.ts`.\n   */\n  domain?: string;\n  /**\n   * URL path where the collection serves from. This is what's displayed in the\n   * preview pane in the CMS.\n   */\n  url?: string;\n  /**\n   * URL that can be used to render a preview page. Used by the side-by-side\n   * editor to render instant previews. If blank, defaults to the `url` config.\n   */\n  previewUrl?: string;\n  /** Page component to render the collection for instant previews */\n  Component?: FunctionalComponent;\n  /**\n   * Defines the fields to use for document preview. Defaults to \"title\" and\n   * \"image\". Use dot notation for nested fields, e.g. \"meta.title\".\n   */\n  preview?: {\n    title?: string;\n    image?: string;\n    defaultImage?: {\n      src: string;\n    };\n  };\n};\n\nexport function defineCollection(collection: Collection): Collection {\n  return collection;\n}\n\nexport const collection = defineCollection;\n"],
  "mappings": ";;;;;;;AAAA,OAAO,YAAY;AAGnB;AAAA,EACE;AAAA,EAGA;AAAA,OAEK;AA6KA,IAAM,gBAAN,MAAoB;AAAA,EAOzB,YAAY,YAAwB;AAClC,SAAK,aAAa;AAClB,SAAK,YAAY,aAAa,KAAK,UAAU;AAE7C,UAAM,mBAAmB,KAAK,UAAU,UAAU;AAClD,SAAK,YAAY,iBAAiB,MAAM;AACxC,SAAK,MAAM,KAAK,UAAU,eAAe;AACzC,SAAK,KAAK,KAAK,UAAU,aAAa;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,OACJ,cACA,MACA,SAC6B;AAC7B,UAAM,UAAU,MAAM,KAAK,UAAU,cAAc,MAAM,OAAO;AAChE,QAAI,SAAS;AACX,aAAO,cAAc,OAAO;AAAA,IAC9B;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,UACJ,cACA,MACA,SACqB;AACrB,UAAM,OAAO,QAAQ;AACrB,UAAM,iBAAiB,SAAS,UAAU,WAAW;AAErD,WAAO,KAAK,WAAW,KAAK,IAAI;AAChC,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY,IAAI,cAAc,IAAI,IAAI;AAC/F,UAAM,SAAS,KAAK,GAAG,IAAI,MAAM;AACjC,UAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,QAAI,IAAI,QAAQ;AACd,aAAO,IAAI,KAAK;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,cACJ,OACA,YACA,SACA;AACA,UAAM,EAAC,YAAAA,aAAY,KAAI,IAAI,WAAW,KAAK;AAC3C,UAAM,WACH,MAAM,KAAK,UAAUA,aAAY,MAAM,EAAC,MAAM,QAAO,CAAC,KAAM,CAAC;AAChE,UAAM,WAAW,SAAS,OAAO,CAAC;AAClC,UAAM,cAAa,mCAAS,eAAc;AAC1C,UAAM,SAAS,YAAY,cAAc,CAAC,CAAC;AAC3C,UAAM,OAAO;AAAA,MACX,IAAI;AAAA,MACJ,YAAAA;AAAA,MACA;AAAA,MACA,KAAK;AAAA,QACH,GAAG;AAAA,QACH,WAAW,SAAS,aAAa,UAAU,IAAI;AAAA,QAC/C,WAAW,SAAS,aAAa;AAAA,QACjC,YAAY,UAAU,IAAI;AAAA,QAC1B;AAAA,QACA,UAAS,mCAAS,YAAW,SAAS,WAAW,CAAC,IAAI;AAAA,MACxD;AAAA,MACA;AAAA,IACF;AACA,UAAM,KAAK,UAAUA,aAAY,MAAM,MAAM,EAAC,MAAM,QAAO,CAAC;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,UACJ,cACA,MACA,MACA,SACA;AACA,UAAM,OAAO,QAAQ;AACrB,UAAM,iBAAiB,SAAS,UAAU,WAAW;AACrD,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY,IAAI,cAAc,IAAI,IAAI;AAC/F,UAAM,SAAS,KAAK,GAAG,IAAI,MAAM;AACjC,UAAM,OAAO,IAAI,IAAI;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,SACJ,cACA,SACsB;AACtB,UAAM,OAAO,QAAQ;AACrB,UAAM,iBAAiB,SAAS,UAAU,WAAW;AACrD,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY,IAAI,cAAc;AACvF,QAAI,QAAe,KAAK,GAAG,WAAW,MAAM;AAC5C,QAAI,QAAQ,OAAO;AACjB,cAAQ,MAAM,MAAM,QAAQ,KAAK;AAAA,IACnC;AACA,QAAI,QAAQ,QAAQ;AAClB,cAAQ,MAAM,OAAO,QAAQ,MAAM;AAAA,IACrC;AACA,QAAI,QAAQ,SAAS;AACnB,cAAQ,MAAM,QAAQ,QAAQ,SAAS,QAAQ,gBAAgB;AAAA,IACjE;AACA,QAAI,QAAQ,OAAO;AACjB,cAAQ,QAAQ,MAAM,KAAK;AAAA,IAC7B;AACA,UAAM,UAAU,MAAM,MAAM,IAAI;AAChC,UAAM,OAAY,CAAC;AACnB,YAAQ,QAAQ,CAAC,WAAW;AAC1B,UAAI,QAAQ,KAAK;AAGf,cAAM,SAAS,OAAO,KAAK;AAC3B,aAAK,KAAK,MAAM;AAAA,MAClB,OAAO;AACL,cAAM,MAAM,cAAc,OAAO,KAAK,CAAC;AACvC,aAAK,KAAK,GAAG;AAAA,MACf;AAAA,IACF,CAAC;AACD,WAAO,EAAC,KAAI;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAAa,cAAsB,SAA0B;AACjE,UAAM,OAAO,QAAQ;AACrB,UAAM,iBAAiB,SAAS,UAAU,WAAW;AACrD,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY,IAAI,cAAc;AACvF,QAAI,QAAe,KAAK,GAAG,WAAW,MAAM;AAC5C,QAAI,QAAQ,OAAO;AACjB,cAAQ,QAAQ,MAAM,KAAK;AAAA,IAC7B;AACA,UAAM,UAAU,MAAM,MAAM,MAAM,EAAE,IAAI;AACxC,UAAM,QAAQ,QAAQ,KAAK,EAAE;AAC7B,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,YACJ,QACA,SACA;AACA,UAAM,yBAAyB,YAAY,KAAK,SAAS;AACzD,UAAM,eAAc,mCAAS,gBAAe;AAG5C,UAAM,UAAU,OAAO,IAAI,CAAC,UAAU;AACpC,YAAM,CAACA,aAAY,IAAI,IAAI,MAAM,MAAM,GAAG;AAC1C,UAAI,CAACA,eAAc,CAAC,MAAM;AACxB,cAAM,IAAI,MAAM,mBAAmB,KAAK,EAAE;AAAA,MAC5C;AACA,YAAM,SAAS,KAAK,GAAG;AAAA,QACrB,GAAG,sBAAsB,IAAIA,WAAU,WAAW,IAAI;AAAA,MACxD;AACA,aAAO;AAAA,IACT,CAAC;AACD,UAAM,eAAe,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO;AACpD,UAAM,OAAO,aAEV,IAAI,CAAC,aAAa,SAAS,KAAK,CAAQ,EAExC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;AAEpB,QAAI,KAAK,WAAW,GAAG;AACrB,cAAQ,IAAI,oBAAoB;AAChC,aAAO,CAAC;AAAA,IACV;AAGA,eAAW,OAAO,MAAM;AACtB,UAAI,KAAK,qBAAqB,GAAG,GAAG;AAClC,cAAM,IAAI,MAAM,iCAAiC,IAAI,EAAE,EAAE;AAAA,MAC3D;AAAA,IACF;AAIA,QAAI,aAAa;AACjB,UAAM,SAAQ,mCAAS,UAAS,KAAK,GAAG,MAAM;AAC9C,UAAM,gBAAuB,CAAC;AAC9B,eAAW,OAAO,MAAM;AACtB,YAAM,EAAC,IAAI,YAAAA,aAAY,MAAM,KAAK,OAAM,IAAI;AAC5C,YAAM,WAAW,KAAK,GAAG;AAAA,QACvB,GAAG,sBAAsB,IAAIA,WAAU,WAAW,IAAI;AAAA,MACxD;AACA,YAAM,eAAe,KAAK,GAAG;AAAA,QAC3B,GAAG,sBAAsB,IAAIA,WAAU,cAAc,IAAI;AAAA,MAC3D;AACA,YAAM,eAAe,KAAK,GAAG;AAAA,QAC3B,GAAG,sBAAsB,IAAIA,WAAU,cAAc,IAAI;AAAA,MAC3D;AAGA,YAAM,mBACJ,IAAI,oBAAoB,WAAW,gBAAgB;AACrD,YAAM,mBAAmB,IAAI,oBAAoB;AAGjD,YAAM,IAAI,cAAc;AAAA,QACtB;AAAA,QACA,YAAAA;AAAA,QACA;AAAA,QACA,QAAQ,UAAU,CAAC;AAAA,QACnB,KAAK;AAAA,UACH,GAAG;AAAA,UACH;AAAA,UACA;AAAA,UACA,aAAa,WAAW,gBAAgB;AAAA,UACxC;AAAA,QACF;AAAA,MACF,CAAC;AACD,oBAAc;AAGd,YAAM,OAAO,YAAY;AACzB,oBAAc;AAId,YAAM,OAAO,UAAU;AAAA,QACrB,mBAAmB,WAAW,OAAO;AAAA,QACrC,mBAAmB,WAAW,OAAO;AAAA,QACrC,wBAAwB;AAAA,QACxB,wBAAwB;AAAA,QACxB,mBAAmB,WAAW,gBAAgB;AAAA,QAC9C,mBAAmB;AAAA,MACrB,CAAC;AACD,oBAAc;AAEd,oBAAc,KAAK,GAAG;AAEtB,UAAI,cAAc,KAAK;AACrB,cAAM,MAAM,OAAO;AACnB,qBAAa;AAAA,MACf;AAAA,IACF;AAEA,QAAI,aAAa,GAAG;AAClB,YAAM,MAAM,OAAO;AAAA,IACrB;AACA,YAAQ,IAAI,aAAa,cAAc,MAAM,QAAQ;AACrD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,uBAAuB;AAC3B,UAAM,yBAAyB,YAAY,KAAK,SAAS;AACzD,UAAM,MAAM,KAAK,MAAK,oBAAI,KAAK,GAAE,QAAQ,CAAC;AAE1C,UAAM,WAAW,MAAM,KAAK,GAAG,gBAAgB,WAAW,EAAE,IAAI;AAChE,UAAM,OAAO,SAAS,KACnB,OAAO,CAAC,MAAM;AA5crB;AA8cQ,UAAI,CAAC,EAAE,IAAI,KAAK,WAAW,sBAAsB,GAAG;AAClD,eAAO;AAAA,MACT;AAIA,YAAM,OAAO,EAAE,KAAK,KAAK,CAAC;AAC1B,YAAM,eAAqC,UAAK,QAAL,mBAAU;AACrD,aACE,eAAe,YAAY,YAAY,YAAY,SAAS,KAAK;AAAA,IAErE,CAAC,EACA,IAAI,CAAC,MAAM;AACV,YAAM,SAAS,EAAE,IAAI;AACrB,YAAM,WAAW,OAAO,MAAM,GAAG;AACjC,YAAM,OAAO,SAAS,GAAG,EAAE;AAC3B,YAAMA,cAAa,SAAS,GAAG,EAAE;AACjC,YAAM,KAAK,GAAGA,WAAU,IAAI,IAAI;AAChC,aAAO;AAAA,QACL,MAAM,EAAE,KAAK;AAAA,QACb;AAAA,QACA,YAAAA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAEH,QAAI,KAAK,WAAW,GAAG;AACrB,cAAQ,IAAI,qBAAqB;AACjC,aAAO,CAAC;AAAA,IACV;AAIA,QAAI,aAAa;AACjB,UAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,UAAM,gBAAuB,CAAC;AAC9B,eAAW,OAAO,MAAM;AACtB,YAAM,EAAC,IAAI,YAAAA,aAAY,MAAM,KAAI,IAAI;AACrC,YAAM,WAAW,KAAK,GAAG;AAAA,QACvB,GAAG,sBAAsB,IAAIA,WAAU,WAAW,IAAI;AAAA,MACxD;AACA,YAAM,eAAe,KAAK,GAAG;AAAA,QAC3B,GAAG,sBAAsB,IAAIA,WAAU,cAAc,IAAI;AAAA,MAC3D;AACA,YAAM,eAAe,KAAK,GAAG;AAAA,QAC3B,GAAG,sBAAsB,IAAIA,WAAU,cAAc,IAAI;AAAA,MAC3D;AACA,YAAM,EAAC,aAAa,aAAa,GAAG,IAAG,IAAI,KAAK,OAAO,CAAC;AAGxD,YAAM,mBAAmB,IAAI,oBAAoB;AACjD,YAAM,mBACJ,IAAI,qBAAqB,eAAe;AAG1C,YAAM,IAAI,cAAc;AAAA,QACtB;AAAA,QACA,YAAAA;AAAA,QACA;AAAA,QACA,QAAQ,KAAK,UAAU,CAAC;AAAA,QACxB,KAAK;AAAA,UACH,GAAG;AAAA,UACH;AAAA,UACA;AAAA,UACA,aAAa,WAAW,gBAAgB;AAAA,UACxC,aAAa,eAAe;AAAA,QAC9B;AAAA,MACF,CAAC;AACD,oBAAc;AAGd,YAAM,OAAO,YAAY;AACzB,oBAAc;AAId,YAAM,OAAO,UAAU;AAAA,QACrB,mBAAmB,WAAW,OAAO;AAAA,QACrC,mBAAmB,WAAW,OAAO;AAAA,QACrC,wBAAwB;AAAA,QACxB,wBAAwB;AAAA,QACxB,mBAAmB,WAAW,gBAAgB;AAAA,QAC9C,mBAAmB,eAAe;AAAA,MACpC,CAAC;AACD,oBAAc;AAEd,oBAAc,KAAK,GAAG;AAEtB,UAAI,cAAc,KAAK;AACrB,cAAM,MAAM,OAAO;AACnB,qBAAa;AACb;AAAA,MACF;AAAA,IACF;AAEA,QAAI,aAAa,GAAG;AAClB,YAAM,MAAM,OAAO;AAAA,IACrB;AACA,YAAQ,IAAI,aAAa,cAAc,MAAM,QAAQ;AACrD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,2BAA2B;AAC/B,UAAM,eAAe,YAAY,KAAK,SAAS;AAC/C,UAAM,MAAM,KAAK,MAAK,oBAAI,KAAK,GAAE,QAAQ,CAAC;AAC1C,UAAM,QAAe,KAAK,GACvB,WAAW,YAAY,EACvB,MAAM,eAAe,MAAM,UAAU,WAAW,GAAG,CAAC;AACvD,UAAM,gBAAgB,MAAM,MAAM,IAAI;AAEtC,eAAW,YAAY,cAAc,MAAM;AACzC,YAAM,UAAU,SAAS,KAAK;AAC9B,YAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,YAAM,cAAc,QAAQ,eAAe;AAC3C,YAAM,OAAO,SAAS,KAAK;AAAA,QACzB,aAAa,UAAU,IAAI;AAAA,QAC3B;AAAA,QACA,aAAa,WAAW,OAAO;AAAA,QAC/B,aAAa,WAAW,OAAO;AAAA,MACjC,CAAC;AACD,YAAM,KAAK,YAAY,QAAQ,UAAU,CAAC,GAAG,EAAC,aAAa,MAAK,CAAC;AAAA,IACnE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,qBAAqB,KAAU;AAhlBjC;AAilBI,SAAI,SAAI,QAAJ,mBAAS,kBAAkB;AAC7B,UAAI,IAAI,IAAI,iBAAiB,OAAO;AAClC,cAAM,MAAM,UAAU,IAAI,EAAE,SAAS;AACrC,cAAM,QAAQ,IAAI,IAAI,iBAAiB,MAAM,SAAS;AACtD,eAAO,MAAM;AAAA,MACf;AACA,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,MAAM,iBACJ,SAC0B;AAC1B,UAAM,SAAS,YAAY,KAAK,SAAS;AACzC,QAAI,QAAe,KAAK,GAAG,WAAW,MAAM;AAC5C,QAAI,mCAAS,MAAM;AACjB,cAAQ,MAAM,MAAM,QAAQ,sBAAsB,QAAQ,IAAI;AAAA,IAChE;AAEA,UAAM,gBAAgB,MAAM,MAAM,IAAI;AACtC,UAAM,kBAAmC,CAAC;AAC1C,kBAAc,QAAQ,CAAC,QAAQ;AAC7B,YAAM,OAAO,IAAI;AACjB,sBAAgB,IAAI,IAAI,IAAI,KAAK;AAAA,IACnC,CAAC;AACD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAM,iBACJ,cAGA,MACA;AACA,UAAM,mBAAmB,YAAY,KAAK,SAAS;AACnD,UAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,QAAI,aAAa;AACjB,WAAO,QAAQ,YAAY,EAAE,QAAQ,CAAC,CAAC,QAAQ,kBAAkB,MAAM;AACrE,YAAM,OAAO,KAAK,kBAAkB,MAAM;AAC1C,YAAM,iBAAiB,KAAK,GAAG,IAAI,GAAG,gBAAgB,IAAI,IAAI,EAAE;AAChE,YAAM,OAAY;AAAA,QAChB,GAAG;AAAA,QACH,QAAQ,KAAK,gBAAgB,MAAM;AAAA,MACrC;AACA,UAAI,MAAM;AACR,aAAK,OAAO;AAAA,MACd;AACA,YAAM,IAAI,gBAAgB,MAAM,EAAC,OAAO,KAAI,CAAC;AAC7C,oBAAc;AAAA,IAChB,CAAC;AACD,QAAI,aAAa,KAAK;AACpB,YAAM,IAAI,MAAM,gDAAgD;AAAA,IAClE;AACA,UAAM,MAAM,OAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,kBAAkB,QAAgB;AAChC,UAAM,OAAO,OACV,WAAW,MAAM,EACjB,OAAO,KAAK,gBAAgB,MAAM,CAAC,EACnC,OAAO,KAAK;AACf,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,gBAAgB,KAAa;AAC3B,UAAM,QAAQ,OAAO,GAAG,EACrB,KAAK,EACL,MAAM,IAAI,EACV,IAAI,CAAC,SAAS,KAAK,QAAQ,CAAC;AAC/B,WAAO,MAAM,KAAK,IAAI;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,0BACJ,QACA,SAC6B;AAC7B,UAAM,kBAAkB,MAAM,KAAK,iBAAiB,OAAO;AAC3D,WAAO,sBAAsB,iBAAiB,MAAM;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,cAAc,cAAsB;AACxC,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY;AACrE,UAAM,SAAS,KAAK,GAAG,IAAI,MAAM;AACjC,UAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,QAAI,IAAI,QAAQ;AACd,aAAO,IAAI,KAAK;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,eAAe,cAAsB,SAA+B;AACxE,UAAM,aAAa,MAAM,KAAK,cAAc,YAAY;AACxD,QAAI,CAAC,YAAY;AACf,YAAM,IAAI,MAAM,0BAA0B,YAAY,EAAE;AAAA,IAC1D;AAEA,UAAM,OAAO,MAAM,KAAK,UAAU,UAAU;AAE5C,UAAM,mBAAmB,KAAK,GAAG;AAAA,MAC/B,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AACA,UAAM,aAAa,KAAK,GAAG;AAAA,MACzB,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AACA,UAAM,YAAW,mCAAS,aAAY;AAEtC,UAAM,oBAAgC;AAAA,MACpC,GAAG;AAAA,MACH,UAAU,UAAU,IAAI;AAAA,MACxB;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,UAAM,IAAI,YAAY;AAAA,MACpB,YAAY;AAAA,MACZ;AAAA,IACF,CAAC;AACD,UAAM,OAAO,kBAAkB;AAAA,MAC7B,UAAU,UAAU,IAAI;AAAA,MACxB;AAAA,IACF,CAAC;AACD,UAAM,MAAM,OAAO;AAEnB,YAAQ,IAAI,uBAAuB,YAAY,EAAE;AACjD,YAAQ,IAAI,cAAc,QAAQ,EAAE;AAAA,EACtC;AAAA,EAEA,MAAM,kBACJ,cACA,SACA;AACA,UAAM,aAAa,MAAM,KAAK,cAAc,YAAY;AACxD,QAAI,CAAC,YAAY;AACf,YAAM,IAAI,MAAM,0BAA0B,YAAY,EAAE;AAAA,IAC1D;AAEA,UAAM,mBAAmB,KAAK,GAAG;AAAA,MAC/B,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AACA,UAAM,kBAAkB,KAAK,GAAG;AAAA,MAC9B,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AACA,UAAM,sBAAsB,KAAK,GAAG;AAAA,MAClC,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AAEA,UAAM,UAAU,MAAM,KAAK,kBAAkB,cAAc,EAAC,MAAM,QAAO,CAAC;AAE1E,UAAM,eAAc,mCAAS,gBAAe;AAE5C,UAAM,oBAAgC;AAAA,MACpC,GAAG;AAAA,MACH,aAAa,UAAU,IAAI;AAAA,MAC3B;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,UAAM,IAAI,qBAAqB;AAAA,MAC7B,YAAY;AAAA,MACZ,OAAM,mCAAS,SAAQ;AAAA,IACzB,CAAC;AACD,UAAM,OAAO,iBAAiB;AAAA,MAC5B,YAAY;AAAA,IACd,CAAC;AACD,UAAM,OAAO,kBAAkB;AAAA,MAC7B,aAAa,UAAU,IAAI;AAAA,MAC3B;AAAA,IACF,CAAC;AACD,UAAM,MAAM,OAAO;AAEnB,YAAQ,IAAI,kBAAkB,YAAY,EAAE;AAC5C,YAAQ,IAAI,iBAAiB,WAAW,EAAE;AAAA,EAC5C;AAAA,EAEA,MAAc,UAAU,YAAwB;AAC9C,QAAI,WAAW,SAAS,QAAQ;AAC9B,aAAO,MAAM,KAAK,cAAc,UAAU;AAAA,IAC5C;AAKA,UAAM,IAAI,MAAM,4BAA4B,WAAW,IAAI,EAAE;AAAA,EAC/D;AAAA,EAEA,MAAc,cAAc,YAAwB;AAvzBtD;AAwzBI,UAAM,MAAM,WAAW,OAAO;AAC9B,QAAI,CAAC,IAAI,WAAW,UAAU,GAAG;AAC/B,YAAM,IAAI,MAAM,sBAAsB,GAAG,EAAE;AAAA,IAC7C;AAEA,UAAM,MAAM,MAAM,MAAM,KAAK;AAAA,MAC3B,UAAQ,gBAAW,gBAAX,mBAAwB,WAAU;AAAA,MAC1C,WAAS,gBAAW,gBAAX,mBAAwB,YAAW,CAAC;AAAA,MAC7C,QAAM,gBAAW,gBAAX,mBAAwB,SAAQ;AAAA,IACxC,CAAC;AAED,QAAI,IAAI,WAAW,KAAK;AACtB,YAAM,MAAM,MAAM,IAAI,KAAK;AAC3B,YAAM,IAAI,MAAM,eAAe,GAAG,EAAE;AAAA,IACtC;AAEA,UAAM,cAAc,OAAO,IAAI,QAAQ,IAAI,cAAc,CAAC;AAC1D,QAAI,YAAY,SAAS,kBAAkB,GAAG;AAC5C,aAAO,MAAM,IAAI,KAAK;AAAA,IACxB;AACA,WAAO,IAAI,KAAK;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,kBACJ,cACA,SACmC;AACnC,UAAM,QAAO,mCAAS,SAAQ;AAC9B,QAAI,EAAE,SAAS,WAAW,SAAS,cAAc;AAC/C,YAAM,IAAI,MAAM,iBAAiB,IAAI,EAAE;AAAA,IACzC;AACA,QAAI,CAAC,gBAAgB,aAAa,SAAS,GAAG,GAAG;AAC/C,YAAM,IAAI,MAAM,2BAA2B,YAAY,EAAE;AAAA,IAC3D;AAEA,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY,SAAS,IAAI;AAClF,UAAM,SAAS,KAAK,GAAG,IAAI,MAAM;AACjC,UAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,QAAI,IAAI,QAAQ;AACd,aAAO,IAAI,KAAK;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,YAAY,OAAyC;AACzD,QAAI,CAAC,OAAO;AACV,aAAO;AAAA,IACT;AACA,UAAM,SAAS,KAAK,GAAG,IAAI,YAAY,KAAK,SAAS,EAAE;AACvD,UAAM,WAAW,MAAM,OAAO,IAAI;AAClC,UAAM,OAAO,SAAS,KAAK,KAAK,CAAC;AACjC,UAAM,MAAM,KAAK,SAAS,CAAC;AAE3B,QAAI,SAAS,KAAK;AAChB,aAAO,IAAI,KAAK;AAAA,IAClB;AAGA,QAAI,CAAC,MAAM,SAAS,GAAG,GAAG;AACxB,cAAQ,KAAK,kBAAkB,KAAK,EAAE;AACtC,aAAO;AAAA,IACT;AACA,UAAM,SAAS,MAAM,MAAM,GAAG,EAAE,GAAG,EAAE;AACrC,QAAI,UAAU,KAAK,MAAM,MAAM,KAAK;AAClC,aAAO,IAAI,KAAK,MAAM,EAAE;AAAA,IAC1B;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,gBAAgB,OAAiC;AACrD,QAAI,CAAC,OAAO;AACV,aAAO;AAAA,IACT;AACA,UAAM,SAAS,KAAK,GAAG,IAAI,YAAY,KAAK,SAAS,EAAE;AACvD,UAAM,WAAW,MAAM,OAAO,IAAI;AAClC,UAAM,OAAO,SAAS,KAAK,KAAK,CAAC;AACjC,UAAM,MAAM,KAAK,SAAS,CAAC;AAC3B,QAAI,SAAS,KAAK;AAChB,aAAO;AAAA,IACT;AAGA,QAAI,CAAC,MAAM,SAAS,GAAG,GAAG;AACxB,cAAQ,KAAK,kBAAkB,KAAK,EAAE;AACtC,aAAO;AAAA,IACT;AACA,UAAM,SAAS,MAAM,MAAM,GAAG,EAAE,GAAG,EAAE;AACrC,QAAI,UAAU,KAAK,MAAM,MAAM,KAAK;AAClC,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,UAAU,QAAgB,SAAyC;AACvE,QAAI,CAAC,QAAQ;AACX,YAAM,IAAI,MAAM,4BAA4B;AAAA,IAC9C;AACA,UAAM,OAAO;AAAA,MACX;AAAA,MACA,WAAW,UAAU,IAAI;AAAA,MACzB,KAAI,mCAAS,OAAM;AAAA,MACnB,WAAU,mCAAS,aAAY,CAAC;AAAA,IAClC;AACA,UAAM,SAAS,KAAK,GAAG,WAAW,YAAY,KAAK,SAAS,aAAa;AACzE,UAAM,OAAO,IAAI,IAAI;AAErB,UAAM,WAAU,mCAAS,YAAW,aAAa,QAAQ,QAAQ,IAAI;AACrE,YAAQ,IAAI,IAAI,KAAK,UAAU,SAAS,CAAC,aAAa,MAAM,IAAI,OAAO,EAAE;AAGzE,UAAM,kBAAkB,KAAK,UAAU,UAAU;AACjD,QAAI,gBAAgB,UAAU;AAC5B,UAAI;AACF,wBAAgB,SAAS,IAAI;AAAA,MAC/B,SAAS,KAAK;AACZ,gBAAQ,MAAM,GAAG;AAAA,MACnB;AAAA,IACF;AAAA,EACF;AACF;AAKO,SAAS,eAAe,MAAW;AAQxC,SAAO;AAAA,IACL,SAAS,IAAI,KAAK,MAAM,QAAQ,KAAK,MAAM,KAAK,KAAK,QAAQ,KAAK;AAAA,EACpE;AACF;AAEO,SAAS,aAAa,YAAmC;AAC9D,QAAM,UAAoB,WAAW,WAAW,CAAC;AACjD,QAAM,SAAS,QAAQ,KAAK,CAACC,YAAWA,QAAO,SAAS,UAAU;AAClE,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AACA,SAAO;AACT;AAMO,SAAS,YAAY,MAAgB;AAE1C,MAAI,eAAe,IAAI,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,SAAc,CAAC;AACrB,aAAW,OAAO,MAAM;AACtB,UAAM,MAAM,KAAK,GAAG;AACpB,QAAI,SAAS,GAAG,GAAG;AACjB,aAAO,GAAG,IAAI,YAAY,GAAG;AAAA,IAC/B,WAAW,MAAM,QAAQ,GAAG,GAAG;AAC7B,UAAI,IAAI,SAAS,KAAK,IAAI,KAAK,CAAC,SAAS,SAAS,IAAI,CAAC,GAAG;AACxD,cAAM,QAAQ,IAAI,IAAI,CAAC,SAAS;AAC9B,cAAI,SAAS,IAAI,GAAG;AAClB,mBAAO,YAAY,IAAI;AAAA,UACzB;AACA,iBAAO;AAAA,QACT,CAAC;AACD,eAAO,GAAG,IAAI,cAAc,KAAK;AAAA,MACnC,OAAO;AACL,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,IACF,OAAO;AACL,aAAO,GAAG,IAAI;AAAA,IAChB;AAAA,EACF;AACA,SAAO;AACT;AAiBO,SAAS,cAAc,MAAgB;AAC5C,QAAM,SAAc,CAAC;AACrB,aAAW,OAAO,MAAM;AACtB,UAAM,MAAM,KAAK,GAAG;AACpB,QAAI,SAAS,GAAG,GAAG;AACjB,UAAI,IAAI,UAAU;AAChB,eAAO,GAAG,IAAI,IAAI,SAAS;AAAA,MAC7B,WAAW,OAAO,OAAO,KAAK,QAAQ,KAAK,MAAM,QAAQ,IAAI,MAAM,GAAG;AACpE,cAAM,MAAM,IAAI,OAAO,IAAI,CAAC,aAAqB;AAC/C,iBAAO;AAAA,YACL,GAAG,cAAc,IAAI,QAAQ,KAAK,CAAC,CAAC;AAAA,YACpC,WAAW;AAAA,UACb;AAAA,QACF,CAAC;AACD,eAAO,GAAG,IAAI;AAAA,MAChB,OAAO;AACL,eAAO,GAAG,IAAI,cAAc,GAAG;AAAA,MACjC;AAAA,IACF,OAAO;AACL,aAAO,GAAG,IAAI;AAAA,IAChB;AAAA,EACF;AACA,SAAO;AACT;AAGO,SAAS,cAAc,MAAgB;AAC5C,SAAO,cAAc,IAAI;AAC3B;AAkBO,SAAS,cAAc,KAAyB;AACrD,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACvB,WAAO;AAAA,EACT;AACA,QAAM,YAAyB,EAAC,QAAQ,CAAC,EAAC;AAC1C,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,WAAW,CAAC;AACxB,cAAU,GAAG,IAAI;AACjB,cAAU,OAAO,KAAK,GAAG;AAAA,EAC3B;AACA,SAAO;AACT;AAEO,IAAM,eAAe;AAKrB,SAAS,eAAe,WAA+B;AAC5D,MAAI,CAAC,MAAM,QAAQ,uCAAW,MAAM,GAAG;AACrC,WAAO,CAAC;AAAA,EACV;AACA,QAAM,MAAM,UAAU,OAAO,IAAI,CAAC,MAAc,UAAU,CAAC,CAAC;AAC5D,SAAO;AACT;AAEA,SAAS,SAAS,MAAoB;AACpC,SAAO,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI,KAAK,SAAS;AACtE;AAEA,SAAS,WAAW,KAAqB;AACvC,QAAM,SAAS,CAAC;AAChB,QAAM,QACJ;AACF,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,UAAM,OAAO,KAAK,MAAM,KAAK,OAAO,IAAI,MAAM,MAAM;AACpD,WAAO,KAAK,MAAM,OAAO,IAAI,CAAC;AAAA,EAChC;AACA,SAAO,OAAO,KAAK,EAAE;AACvB;AAaO,SAAS,sBACd,iBACA,QACA;AACA,QAAM,qBAAyC,CAAC;AAChD,SAAO,OAAO,eAAe,EAAE,QAAQ,CAACC,YAAW;AACjD,UAAM,SAASA,QAAO;AACtB,UAAM,cAAcA,QAAO,MAAM,KAAKA,QAAO,MAAMA,QAAO;AAC1D,uBAAmB,MAAM,IAAI;AAAA,EAC/B,CAAC;AACD,SAAO;AACT;AAGA,SAAS,aAAa,KAAU;AAC9B,WAAS,OAAOC,MAAkB;AAChC,QAAIA,SAAQ,MAAM;AAChB,aAAO;AAAA,IACT;AACA,QAAI,OAAOA,SAAQ,aAAa;AAC9B,aAAO;AAAA,IACT;AACA,QAAI,OAAOA,SAAQ,UAAU;AAC3B,aAAO,IAAIA,KAAI,WAAW,KAAK,KAAK,CAAC;AAAA,IACvC;AACA,QAAI,OAAOA,SAAQ,UAAU;AAC3B,aAAO,OAAOA,IAAG;AAAA,IACnB;AACA,QAAI,MAAM,QAAQA,IAAG,GAAG;AACtB,aAAO,IAAIA,KAAI,IAAI,MAAM,EAAE,KAAK,IAAI,CAAC;AAAA,IACvC;AACA,UAAM,UAAoB,OAAO,QAAQA,IAAG,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM;AAClE,aAAO,GAAG,GAAG,KAAK,OAAO,KAAK,CAAC;AAAA,IACjC,CAAC;AACD,WAAO,IAAI,QAAQ,KAAK,IAAI,CAAC;AAAA,EAC/B;AACA,SAAO,OAAO,GAAG;AACnB;AAKO,SAAS,WAAW,OAAe;AACxC,QAAM,WAAW,MAAM,QAAQ,GAAG;AAClC,MAAI,YAAY,GAAG;AACjB,UAAM,IAAI,MAAM,mBAAmB,KAAK,EAAE;AAAA,EAC5C;AACA,QAAMH,cAAa,MAAM,MAAM,GAAG,QAAQ;AAC1C,QAAM,OAAO,MAAM,MAAM,WAAW,CAAC,EAAE,WAAW,KAAK,IAAI;AAC3D,MAAI,CAACA,eAAc,CAAC,MAAM;AACxB,UAAM,IAAI,MAAM,mBAAmB,KAAK,EAAE;AAAA,EAC5C;AACA,SAAO,EAAC,YAAAA,aAAY,KAAI;AAC1B;;;ACxpCA,SAAQ,cAAAI,mBAAmC;AAe3C,eAAsB,OACpB,YACA,cACA,MACA,SAGmB;AACnB,QAAM,YAAY,aAAa,UAAU;AACzC,QAAM,mBAAmB,UAAU,UAAU;AAC7C,QAAM,YAAY,iBAAiB,MAAM;AACzC,QAAM,OAAO,QAAQ;AACrB,QAAM,iBAAiB,SAAS,UAAU,WAAW;AACrD,QAAM,KAAK,UAAU,aAAa;AAElC,SAAO,KAAK,WAAW,KAAK,IAAI;AAChC,QAAM,SAAS,YAAY,SAAS,gBAAgB,YAAY,IAAI,cAAc,IAAI,IAAI;AAC1F,QAAM,SAAS,GAAG,IAAI,MAAM;AAC5B,QAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,MAAI,IAAI,QAAQ;AACd,UAAM,OAAO,IAAI,KAAK;AACtB,WAAO,cAAc,IAAI;AAAA,EAC3B;AACA,UAAQ,IAAI,kBAAkB,MAAM,EAAE;AACtC,SAAO;AACT;AAMA,eAAsB,SACpB,YACA,cACA,SAQsB;AACtB,QAAM,YAAY,aAAa,UAAU;AACzC,QAAM,mBAAmB,UAAU,UAAU;AAC7C,QAAM,YAAY,iBAAiB,MAAM;AACzC,QAAM,OAAO,QAAQ;AACrB,QAAM,iBAAiB,SAAS,UAAU,WAAW;AACrD,QAAM,KAAK,UAAU,aAAa;AAClC,QAAM,SAAS,YAAY,SAAS,gBAAgB,YAAY,IAAI,cAAc;AAClF,MAAI,QAAe,GAAG,WAAW,MAAM;AACvC,MAAI,QAAQ,OAAO;AACjB,YAAQ,MAAM,MAAM,QAAQ,KAAK;AAAA,EACnC;AACA,MAAI,QAAQ,QAAQ;AAClB,YAAQ,MAAM,OAAO,QAAQ,MAAM;AAAA,EACrC;AACA,MAAI,QAAQ,SAAS;AACnB,YAAQ,MAAM,QAAQ,QAAQ,SAAS,QAAQ,gBAAgB;AAAA,EACjE;AACA,MAAI,QAAQ,OAAO;AACjB,YAAQ,QAAQ,MAAM,KAAK;AAAA,EAC7B;AACA,QAAM,UAAU,MAAM,MAAM,IAAI;AAChC,QAAM,OAAY,CAAC;AACnB,UAAQ,QAAQ,CAAC,WAAW;AAC1B,UAAM,MAAM,cAAc,OAAO,KAAK,CAAC;AACvC,SAAK,KAAK,GAAG;AAAA,EACf,CAAC;AACD,SAAO,EAAC,KAAI;AACd;AAMA,eAAsB,QACpB,YACA,cACA,SAIA;AACA,QAAM,YAAY,aAAa,UAAU;AACzC,QAAM,mBAAmB,UAAU,UAAU;AAC7C,QAAM,YAAY,iBAAiB,MAAM;AACzC,QAAM,OAAO,QAAQ;AACrB,QAAM,iBAAiB,SAAS,UAAU,WAAW;AACrD,QAAM,KAAK,UAAU,aAAa;AAClC,QAAM,SAAS,YAAY,SAAS,gBAAgB,YAAY,IAAI,cAAc;AAClF,MAAI,QAAe,GAAG,WAAW,MAAM;AACvC,MAAI,QAAQ,OAAO;AACjB,YAAQ,QAAQ,MAAM,KAAK;AAAA,EAC7B;AACA,QAAM,UAAU,MAAM,MAAM,MAAM,EAAE,IAAI;AACxC,QAAM,QAAQ,QAAQ,KAAK,EAAE;AAC7B,SAAO;AACT;AAMA,eAAsB,qBAAqB,YAAwB;AACjE,QAAM,YAAY,aAAa,UAAU;AACzC,QAAM,mBAAmB,UAAU,UAAU;AAC7C,QAAM,YAAY,iBAAiB,MAAM;AACzC,QAAM,KAAK,UAAU,aAAa;AAElC,QAAM,yBAAyB,YAAY,SAAS;AACpD,QAAM,MAAM,KAAK,MAAK,oBAAI,KAAK,GAAE,QAAQ,CAAC;AAE1C,QAAM,WAAW,MAAM,GAAG,gBAAgB,WAAW,EAAE,IAAI;AAC3D,QAAM,OAAO,SAAS,KACnB,OAAO,CAAC,MAAM;AArInB;AAuIM,QAAI,CAAC,EAAE,IAAI,KAAK,WAAW,sBAAsB,GAAG;AAClD,aAAO;AAAA,IACT;AAIA,UAAM,OAAO,EAAE,KAAK,KAAK,CAAC;AAC1B,UAAM,eAAqC,UAAK,QAAL,mBAAU;AACrD,WACE,eAAe,YAAY,YAAY,YAAY,SAAS,KAAK;AAAA,EAErE,CAAC,EACA,IAAI,CAAC,MAAM;AACV,UAAM,SAAS,EAAE,IAAI;AACrB,UAAM,WAAW,OAAO,MAAM,GAAG;AACjC,UAAM,OAAO,SAAS,GAAG,EAAE;AAC3B,UAAMC,cAAa,SAAS,GAAG,EAAE;AACjC,UAAM,KAAK,GAAGA,WAAU,IAAI,IAAI;AAChC,WAAO;AAAA,MACL,MAAM,EAAE,KAAK;AAAA,MACb;AAAA,MACA,YAAAA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC;AAEH,MAAI,KAAK,WAAW,GAAG;AACrB,WAAO,CAAC;AAAA,EACV;AAIA,MAAI,aAAa;AACjB,QAAM,QAAQ,GAAG,MAAM;AACvB,QAAM,gBAAuB,CAAC;AAC9B,aAAW,OAAO,MAAM;AACtB,UAAM,EAAC,IAAI,YAAAA,aAAY,MAAM,KAAI,IAAI;AACrC,UAAM,WAAW,GAAG;AAAA,MAClB,GAAG,sBAAsB,IAAIA,WAAU,WAAW,IAAI;AAAA,IACxD;AACA,UAAM,eAAe,GAAG;AAAA,MACtB,GAAG,sBAAsB,IAAIA,WAAU,cAAc,IAAI;AAAA,IAC3D;AACA,UAAM,eAAe,GAAG;AAAA,MACtB,GAAG,sBAAsB,IAAIA,WAAU,cAAc,IAAI;AAAA,IAC3D;AACA,UAAM,EAAC,aAAa,aAAa,GAAG,IAAG,IAAI,KAAK,OAAO,CAAC;AAGxD,UAAM,mBAAmB,IAAI,oBAAoB;AACjD,UAAM,mBAAmB,IAAI,qBAAqB,eAAe;AAGjE,UAAM,IAAI,cAAc;AAAA,MACtB;AAAA,MACA,YAAAA;AAAA,MACA;AAAA,MACA,QAAQ,KAAK,UAAU,CAAC;AAAA,MACxB,KAAK;AAAA,QACH,GAAG;AAAA,QACH;AAAA,QACA;AAAA,QACA,aAAaC,YAAW,gBAAgB;AAAA,QACxC,aAAa,eAAe;AAAA,MAC9B;AAAA,IACF,CAAC;AACD,kBAAc;AAGd,UAAM,OAAO,YAAY;AACzB,kBAAc;AAId,UAAM,OAAO,UAAU;AAAA,MACrB,mBAAmBA,YAAW,OAAO;AAAA,MACrC,mBAAmBA,YAAW,OAAO;AAAA,MACrC,wBAAwB;AAAA,MACxB,wBAAwB;AAAA,MACxB,mBAAmBA,YAAW,gBAAgB;AAAA,MAC9C,mBAAmB,eAAe;AAAA,IACpC,CAAC;AACD,kBAAc;AAEd,kBAAc,KAAK,GAAG;AAEtB,QAAI,cAAc,KAAK;AACrB;AAAA,IACF;AAAA,EACF;AAEA,QAAM,MAAM,OAAO;AACnB,UAAQ,IAAI,aAAa,cAAc,MAAM,QAAQ;AACrD,SAAO;AACT;AAKA,eAAsB,iBACpB,YACA,SAC0B;AAC1B,QAAM,YAAY,aAAa,UAAU;AACzC,QAAM,mBAAmB,UAAU,UAAU;AAC7C,QAAM,YAAY,iBAAiB,MAAM;AACzC,QAAM,KAAK,UAAU,aAAa;AAElC,QAAM,SAAS,YAAY,SAAS;AACpC,MAAI,QAAe,GAAG,WAAW,MAAM;AACvC,MAAI,mCAAS,MAAM;AACjB,YAAQ,MAAM,MAAM,QAAQ,sBAAsB,QAAQ,IAAI;AAAA,EAChE;AAEA,QAAM,gBAAgB,MAAM,MAAM,IAAI;AACtC,QAAM,kBAAmC,CAAC;AAC1C,gBAAc,QAAQ,CAAC,QAAQ;AAC7B,UAAM,OAAO,IAAI;AACjB,oBAAgB,IAAI,IAAI,IAAI,KAAK;AAAA,EACnC,CAAC;AACD,SAAO;AACT;AAKA,eAAsB,0BACpB,YACA,QACA,SAC6B;AAC7B,QAAM,kBAAkB,MAAM,iBAAiB,YAAY,OAAO;AAClE,SAAO,sBAAsB,iBAAiB,MAAM;AACtD;;;AC5QA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBO,SAAS,OAAO,OAA+C;AACpE,SAAO,EAAC,GAAG,OAAO,MAAM,SAAQ;AAClC;AAOO,SAAS,OAAO,OAA+C;AACpE,SAAO,EAAC,GAAG,OAAO,MAAM,SAAQ;AAClC;AAOO,SAAS,KAAK,OAA2C;AAC9D,SAAO,EAAC,GAAG,OAAO,MAAM,OAAM;AAChC;AAOO,SAAS,SAAS,OAAmD;AAC1E,SAAO,EAAC,GAAG,OAAO,MAAM,WAAU;AACpC;AAQO,SAAS,QAAQ,OAAiD;AACvE,SAAO,EAAC,GAAG,OAAO,MAAM,UAAS;AACnC;AASO,SAAS,OAAO,OAA+C;AACpE,SAAO,EAAC,GAAG,OAAO,MAAM,SAAQ;AAClC;AASO,SAAS,YACd,OACkB;AAClB,SAAO,EAAC,GAAG,OAAO,MAAM,cAAa;AACvC;AAaO,SAAS,MAAM,OAA6C;AACjE,SAAO,EAAC,GAAG,OAAO,MAAM,QAAO;AACjC;AAiBO,SAAS,KAAK,OAA2C;AAC9D,SAAO,EAAC,GAAG,OAAO,MAAM,OAAM;AAChC;AAmBO,SAAS,OAAO,OAA+C;AACpE,SAAO,EAAC,GAAG,OAAO,MAAM,SAAQ;AAClC;AAmCO,SAAS,MAAM,OAA6C;AACjE,SAAO,EAAC,GAAG,OAAO,MAAM,QAAO;AACjC;AAOO,SAAS,MAAM,OAA6C;AACjE,SAAO,EAAC,GAAG,OAAO,MAAM,QAAO;AACjC;AAQO,SAAS,SAAS,OAAmD;AAC1E,SAAO,EAAC,GAAG,OAAO,MAAM,WAAU;AACpC;AAYO,SAAS,UAAU,OAAqD;AAC7E,SAAO,EAAC,GAAG,OAAO,MAAM,YAAW;AACrC;AAqCO,SAAS,aAAa,QAAwB;AACnD,SAAO;AACT;AAGO,IAAM,SAAS;AAiCf,SAAS,iBAAiBC,aAAoC;AACnE,SAAOA;AACT;AAEO,IAAM,aAAa;",
  "names": ["collection", "plugin", "string", "obj", "FieldValue", "collection", "FieldValue", "collection"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../core/client.ts", "../core/plugin.ts", "../core/api.ts", "../core/ai.ts", "../core/versions.ts", "../core/csv.ts", "../core/compatibility.ts", "../core/cms-route.ts", "../core/runtime.ts", "../core/schema.ts"],
  "sourcesContent": ["import crypto from 'node:crypto';\nimport type {RootConfig} from '@blinkk/root';\nimport {App} from 'firebase-admin/app';\nimport {\n  FieldValue,\n  Firestore,\n  Query,\n  Timestamp,\n  WriteBatch,\n} from 'firebase-admin/firestore';\nimport {CMSPlugin, getCmsPlugin} from './plugin.js';\n\nexport interface Doc<Fields = any> {\n  /** The id of the doc, e.g. \"Pages/foo-bar\". */\n  id: string;\n  /** The collection id of the doc, e.g. \"Pages\". */\n  collection: string;\n  /** The slug of the doc, e.g. \"foo-bar\". */\n  slug: string;\n  sys: {\n    createdAt: number;\n    createdBy: string;\n    modifiedAt: number;\n    modifiedBy: string;\n    firstPublishedAt?: number;\n    firstPublishedBy?: string;\n    publishedAt?: number;\n    publishedBy?: string;\n    publishingLocked: {\n      lockedAt: string;\n      lockedBy: string;\n      reason: string;\n      until?: Timestamp;\n    };\n    locales?: string[];\n  };\n  fields: Fields;\n}\n\nexport interface TranslationsDoc {\n  id: string;\n  sys: {\n    modifiedAt: Timestamp;\n    modifiedBy: string;\n    publishedAt?: Timestamp;\n    publishedBy?: string;\n    linkedSheet?: {\n      spreadsheetId: string;\n      gid: number;\n      linkedAt: Timestamp;\n      linkedBy: string;\n    };\n    tags?: string[];\n  };\n  strings: TranslationsMap;\n}\n\nexport type DocMode = 'draft' | 'published';\n\nexport type UserRole = 'ADMIN' | 'EDITOR' | 'VIEWER';\n\nexport type HttpMethod = 'GET' | 'POST';\n\nexport interface DataSource {\n  id: string;\n  description?: string;\n  type: 'http' | 'gsheet';\n  url: string;\n  /**\n   * Currently only used by gsheet. `array` returns the sheet as an array of\n   * arrays, `map` returns the sheet as an array of objects.\n   */\n  dataFormat?: 'array' | 'map';\n  /**\n   * Options for HTTP requests.\n   */\n  httpOptions?: {\n    method: HttpMethod;\n    headers?: Record<string, string>;\n    body?: string;\n  };\n  createdAt: Timestamp;\n  createdBy: string;\n  syncedAt?: Timestamp;\n  syncedBy?: string;\n  publishedAt?: Timestamp;\n  publishedBy?: string;\n}\n\nexport interface DataSourceData<T = any> {\n  dataSource: DataSource;\n  data: T;\n}\n\nexport type DataSourceMode = 'draft' | 'published';\n\nexport interface GetDocOptions {\n  /** Mode, either \"draft\" or \"published\". */\n  mode: DocMode;\n}\n\nexport interface SetDocOptions {\n  /** Mode, either \"draft\" or \"published\". */\n  mode: DocMode;\n}\n\nexport interface SaveDraftOptions {\n  /**\n   * Locales to enable.\n   */\n  locales?: string[];\n\n  /**\n   * Email of user modifying the doc. If blank, defaults to `root-cms-client`.\n   */\n  modifiedBy?: string;\n}\n\nexport interface ListDocsOptions {\n  mode: DocMode;\n  offset?: number;\n  limit?: number;\n  orderBy?: string;\n  orderByDirection?: 'asc' | 'desc';\n  query?: (query: Query) => Query;\n  /**\n   * Whether to fetch the \"raw\" version of the doc (for use in conjunction with\n   * `setRawDoc()`).\n   */\n  raw?: boolean;\n}\n\nexport interface GetCountOptions {\n  mode: DocMode;\n  query?: (query: Query) => Query;\n}\n\nexport interface Translation {\n  [locale: string]: string;\n  source: string;\n}\n\nexport interface TranslationsMap {\n  [hash: string]: Translation;\n}\n\nexport interface LocaleTranslations {\n  [source: string]: string;\n}\n\nexport interface LoadTranslationsOptions {\n  tags?: string[];\n}\n\nexport interface Release {\n  id: string;\n  description?: string;\n  docIds?: string[];\n  createdAt?: Timestamp;\n  createdBy?: string;\n  scheduledAt?: Timestamp;\n  scheduledBy?: string;\n  publishedAt?: Timestamp;\n  publishedBy?: string;\n}\n\nexport interface Action<T = any> {\n  /**\n   * The name of the action.\n   */\n  action: string;\n  /**\n   * The user's email that performed the action (or \"system\").\n   */\n  by?: string;\n  /**\n   * Timestamp when the action occurred.\n   */\n  timestamp: Timestamp;\n  /**\n   * Metadata for the action.\n   */\n  metadata?: T;\n}\n\nexport interface ListActionsOptions {\n  /**\n   * Filter by a specific action. Defaults to all actions.\n   */\n  action?: string;\n  /**\n   * Filter by a specific user. Defaults to all users.\n   */\n  by?: string;\n  /**\n   * Max number of actions to return. Defaults to 100.\n   */\n  limit?: number;\n}\n\nexport class RootCMSClient {\n  readonly rootConfig: RootConfig;\n  readonly cmsPlugin: CMSPlugin;\n  readonly projectId: string;\n  readonly app: App;\n  readonly db: Firestore;\n\n  constructor(rootConfig: RootConfig) {\n    this.rootConfig = rootConfig;\n    this.cmsPlugin = getCmsPlugin(this.rootConfig);\n\n    const cmsPluginOptions = this.cmsPlugin.getConfig();\n    this.projectId = cmsPluginOptions.id || 'default';\n    this.app = this.cmsPlugin.getFirebaseApp();\n    this.db = this.cmsPlugin.getFirestore();\n  }\n\n  /**\n   * Retrieves doc data from Root.js CMS.\n   */\n  async getDoc<Fields = any>(\n    collectionId: string,\n    slug: string,\n    options: GetDocOptions\n  ): Promise<Doc<Fields> | null> {\n    const rawData = await this.getRawDoc(collectionId, slug, options);\n    if (rawData) {\n      return unmarshalData(rawData) as Doc<Fields>;\n    }\n    return null;\n  }\n\n  /**\n   * Retrieves raw doc data as stored in the database. Only use this if you know\n   * what you are doing.\n   */\n  async getRawDoc(\n    collectionId: string,\n    slug: string,\n    options: GetDocOptions\n  ): Promise<any | null> {\n    const mode = options.mode;\n    const docRef = this.dbDocRef(collectionId, slug, {mode});\n    const doc = await docRef.get();\n    if (doc.exists) {\n      return doc.data();\n    }\n    return null;\n  }\n\n  dbCollectionDocsPath(\n    collectionId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    let modeCollection = '';\n    if (options.mode === 'draft') {\n      modeCollection = 'Drafts';\n    } else if (options.mode === 'published') {\n      modeCollection = 'Published';\n    } else {\n      throw new Error(`unknown mode: ${options.mode}`);\n    }\n    return `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;\n  }\n\n  dbDocPath(\n    collectionId: string,\n    slug: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const collectionDocsPath = this.dbCollectionDocsPath(collectionId, options);\n    // Slugs with slashes are encoded as `--` in the DB.\n    const normalizedSlug = slug.replaceAll('/', '--');\n    return `${collectionDocsPath}/${normalizedSlug}`;\n  }\n\n  dbDocRef(\n    collectionId: string,\n    slug: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const docPath = this.dbDocPath(collectionId, slug, options);\n    return this.db.doc(docPath);\n  }\n\n  /**\n   * Saves draft data to a doc.\n   *\n   * Note: this saves data to the \"fields\" attr of the draft doc. If you need to\n   * modify the sys-level attributes of the doc, use `setRawDoc()`.\n   */\n  async saveDraftData(\n    docId: string,\n    fieldsData: any,\n    options?: SaveDraftOptions\n  ) {\n    const {collection, slug} = parseDocId(docId);\n    const draftDoc =\n      (await this.getRawDoc(collection, slug, {mode: 'draft'})) || {};\n    const draftSys = draftDoc.sys || {};\n    const modifiedBy = options?.modifiedBy || 'root-cms-client';\n    const fields = marshalData(fieldsData || {});\n    const data = {\n      id: docId,\n      collection,\n      slug,\n      sys: {\n        ...draftSys,\n        createdAt: draftSys.createdAt ?? Timestamp.now(),\n        createdBy: draftSys.createdBy ?? modifiedBy,\n        modifiedAt: Timestamp.now(),\n        modifiedBy,\n        locales: options?.locales ?? draftSys.locales ?? ['en'],\n      },\n      fields,\n    };\n    await this.setRawDoc(collection, slug, data, {mode: 'draft'});\n  }\n\n  /**\n   * Prefer `saveDraftData('Pages/foo', data)`. Only use this if you know what\n   * you're doing.\n   */\n  async setRawDoc(\n    collectionId: string,\n    slug: string,\n    data: any,\n    options: SetDocOptions\n  ) {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;\n    const docRef = this.db.doc(dbPath);\n    await docRef.set(data);\n  }\n\n  /**\n   * Lists docs from a Root.js CMS collection.\n   */\n  async listDocs<T>(\n    collectionId: string,\n    options: ListDocsOptions\n  ): Promise<{docs: T[]}> {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;\n    let query: Query = this.db.collection(dbPath);\n    if (options.limit) {\n      query = query.limit(options.limit);\n    }\n    if (options.offset) {\n      query = query.offset(options.offset);\n    }\n    if (options.orderBy) {\n      query = query.orderBy(options.orderBy, options.orderByDirection);\n    }\n    if (options.query) {\n      query = options.query(query);\n    }\n    const results = await query.get();\n    const docs: T[] = [];\n    results.forEach((result) => {\n      if (options.raw) {\n        // For callers that wish to modify the raw doc via `setRawDoc()`,\n        // return the unmodified doc as returned from firestore.\n        const rawDoc = result.data() as T;\n        docs.push(rawDoc);\n      } else {\n        const doc = unmarshalData(result.data()) as T;\n        docs.push(doc);\n      }\n    });\n    return {docs};\n  }\n\n  /**\n   * Returns the number of docs in a Root.js CMS collection.\n   */\n  async getDocsCount(collectionId: string, options: GetCountOptions) {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;\n    let query: Query = this.db.collection(dbPath);\n    if (options.query) {\n      query = options.query(query);\n    }\n    const results = await query.count().get();\n    const count = results.data().count;\n    return count;\n  }\n\n  /**\n   * Batch publishes a set of docs by id.\n   */\n  async publishDocs(\n    docIds: string[],\n    options?: {publishedBy: string; batch?: WriteBatch}\n  ) {\n    const projectCollectionsPath = `Projects/${this.projectId}/Collections`;\n    const publishedBy = options?.publishedBy || 'root-cms-client';\n\n    // Fetch the current draft data for each doc.\n    const docRefs = docIds.map((docId) => {\n      const [collection, slug] = docId.split('/');\n      if (!collection || !slug) {\n        throw new Error(`invalid doc id: ${docId}`);\n      }\n      const docRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n      );\n      return docRef;\n    });\n    const docSnapshots = await this.db.getAll(...docRefs);\n    const docs = docSnapshots\n      // Retrieve snapshot data for each doc.\n      .map((snapshot) => snapshot.data() as Doc)\n      // Remove docs that don't exist.\n      .filter((d) => !!d);\n\n    if (docs.length === 0) {\n      console.log('no docs to publish');\n      return [];\n    }\n\n    // Verify there are no publishing locks on any docs.\n    for (const doc of docs) {\n      if (this.testPublishingLocked(doc)) {\n        throw new Error(`publishing is locked for doc: ${doc.id}`);\n      }\n    }\n\n    // // Each transaction or batch can write a max of 500 ops.\n    // // https://firebase.google.com/docs/firestore/manage-data/transactions\n    let batchCount = 0;\n    const batch = options?.batch || this.db.batch();\n    const publishedDocs: any[] = [];\n    for (const doc of docs) {\n      const {id, collection, slug, sys, fields} = doc;\n      const draftRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n      );\n      const scheduledRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Scheduled/${slug}`\n      );\n      const publishedRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Published/${slug}`\n      );\n\n      // Only update `firstPublished` if it doesn't already exist.\n      const firstPublishedAt =\n        sys.firstPublishedAt ?? FieldValue.serverTimestamp();\n      const firstPublishedBy = sys.firstPublishedBy ?? publishedBy;\n\n      // Save published doc.\n      batch.set(publishedRef, {\n        id,\n        collection,\n        slug,\n        fields: fields || {},\n        sys: {\n          ...sys,\n          firstPublishedAt: firstPublishedAt,\n          firstPublishedBy: firstPublishedBy,\n          publishedAt: FieldValue.serverTimestamp(),\n          publishedBy: publishedBy,\n        },\n      });\n      batchCount += 1;\n\n      // Remove scheduled doc, if any.\n      batch.delete(scheduledRef);\n      batchCount += 1;\n\n      // Update the draft doc to remove `scheduledAt` and `scheduledBy` fields\n      // and update the `publishedAt` and `publishedBy` fields.\n      batch.update(draftRef, {\n        'sys.scheduledAt': FieldValue.delete(),\n        'sys.scheduledBy': FieldValue.delete(),\n        'sys.firstPublishedAt': firstPublishedAt,\n        'sys.firstPublishedBy': firstPublishedBy,\n        'sys.publishedAt': FieldValue.serverTimestamp(),\n        'sys.publishedBy': publishedBy,\n      });\n      batchCount += 1;\n\n      this.publishTranslationsDoc(doc.id, {batch});\n      batchCount += 2;\n\n      publishedDocs.push(doc);\n\n      if (batchCount >= 400) {\n        await batch.commit();\n        batchCount = 0;\n      }\n    }\n\n    if (batchCount > 0) {\n      await batch.commit();\n    }\n    console.log(`published ${publishedDocs.length} docs!`);\n    return publishedDocs;\n  }\n\n  /**\n   * Publishes scheduled docs.\n   */\n  async publishScheduledDocs() {\n    const projectCollectionsPath = `Projects/${this.projectId}/Collections`;\n    const now = Math.ceil(new Date().getTime());\n\n    const snapshot = await this.db.collectionGroup('Scheduled').get();\n    const docs = snapshot.docs\n      .filter((d) => {\n        // Filter docs by project.\n        if (!d.ref.path.startsWith(projectCollectionsPath)) {\n          return false;\n        }\n        // Filter docs where scheduledAt is in the past.\n        // NOTE(stevenle): the filtering is done manually instead of using a query\n        // to avoid having to create an index in firestore.\n        const data = d.data() || {};\n        const scheduledAt: Timestamp | undefined = data.sys?.scheduledAt;\n        return (\n          scheduledAt && scheduledAt.toMillis && scheduledAt.toMillis() <= now\n        );\n      })\n      .map((d) => {\n        const dbPath = d.ref.path;\n        const segments = dbPath.split('/');\n        const slug = segments.at(-1);\n        const collection = segments.at(-3);\n        const id = `${collection}/${slug}`;\n        return {\n          data: d.data(),\n          id,\n          collection,\n          slug,\n        };\n      });\n\n    if (docs.length === 0) {\n      console.log('no docs to schedule');\n      return [];\n    }\n\n    // Each transaction or batch can write a max of 500 ops.\n    // https://firebase.google.com/docs/firestore/manage-data/transactions\n    let batchCount = 0;\n    const batch = this.db.batch();\n    const publishedDocs: any[] = [];\n    for (const doc of docs) {\n      const {id, collection, slug, data} = doc;\n      const draftRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n      );\n      const scheduledRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Scheduled/${slug}`\n      );\n      const publishedRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Published/${slug}`\n      );\n      const {scheduledAt, scheduledBy, ...sys} = data.sys || {};\n\n      // Only update `firstPublished` if it doesn't already exist.\n      const firstPublishedAt = sys.firstPublishedAt ?? scheduledAt;\n      const firstPublishedBy =\n        sys.firstPublishedBy ?? (scheduledBy || 'root-cms-client');\n\n      // Save published doc.\n      batch.set(publishedRef, {\n        id,\n        collection,\n        slug,\n        fields: data.fields || {},\n        sys: {\n          ...sys,\n          firstPublishedAt: firstPublishedAt,\n          firstPublishedBy: firstPublishedBy,\n          publishedAt: FieldValue.serverTimestamp(),\n          publishedBy: scheduledBy || '',\n        },\n      });\n      batchCount += 1;\n\n      // Remove published doc.\n      batch.delete(scheduledRef);\n      batchCount += 1;\n\n      // Update the draft doc to remove `scheduledAt` and `scheduledBy` fields\n      // and update the `publishedAt` and `publishedBy` fields.\n      batch.update(draftRef, {\n        'sys.scheduledAt': FieldValue.delete(),\n        'sys.scheduledBy': FieldValue.delete(),\n        'sys.firstPublishedAt': firstPublishedAt,\n        'sys.firstPublishedBy': firstPublishedBy,\n        'sys.publishedAt': FieldValue.serverTimestamp(),\n        'sys.publishedBy': scheduledBy || 'root-cms-client',\n      });\n      batchCount += 1;\n\n      this.publishTranslationsDoc(doc.id, {batch});\n      batchCount += 2;\n\n      publishedDocs.push(doc);\n\n      if (batchCount >= 400) {\n        await batch.commit();\n        batchCount = 0;\n        continue;\n      }\n    }\n\n    if (batchCount > 0) {\n      await batch.commit();\n    }\n    console.log(`published ${publishedDocs.length} docs!`);\n    return publishedDocs;\n  }\n\n  /**\n   * Publishes docs in scheduled releases.\n   */\n  async publishScheduledReleases() {\n    const releasesPath = `Projects/${this.projectId}/Releases`;\n    const now = Math.ceil(new Date().getTime());\n    const query: Query = this.db\n      .collection(releasesPath)\n      .where('scheduledAt', '<=', Timestamp.fromMillis(now));\n    const querySnapshot = await query.get();\n\n    for (const snapshot of querySnapshot.docs) {\n      const release = snapshot.data() as Release;\n      const batch = this.db.batch();\n      const publishedBy = release.scheduledBy || 'root-cms-client';\n      batch.update(snapshot.ref, {\n        publishedAt: Timestamp.now(),\n        publishedBy: publishedBy,\n        scheduledAt: FieldValue.delete(),\n        scheduledBy: FieldValue.delete(),\n      });\n      await this.publishDocs(release.docIds || [], {publishedBy, batch});\n    }\n  }\n\n  async publishTranslationsDoc(\n    translationsId: string,\n    options?: {batch?: WriteBatch; publishedBy?: string}\n  ) {\n    const docSlug = translationsId.replaceAll('/', '--');\n    const draftRef = this.db.doc(\n      `Projects/${this.projectId}/TranslationsManager/draft/Translations/${docSlug}`\n    );\n    const snapshot = await draftRef.get();\n\n    if (!snapshot.exists) {\n      // Ignore missing translations.\n      console.warn(`translations ${translationsId} does not exist`);\n      return;\n    }\n\n    // If the translations publishing is tied to another batch request (e.g. doc\n    // publishing), the batch request will be committed upstream.\n    const commitBatch = !options?.batch;\n\n    const batch = options?.batch || this.db.batch();\n    batch.update(draftRef, {\n      'sys.publishedAt': Timestamp.now(),\n      'sys.publishedBy': options?.publishedBy || 'root-cms-client',\n    });\n\n    const publishedRef = this.db.doc(\n      `Projects/${this.projectId}/TranslationsManager/published/Translations/${docSlug}`\n    );\n    const data = {...snapshot.data()};\n    if (!data.sys) {\n      data.sys = {};\n    }\n    data.sys.publishedAt = Timestamp.now();\n    data.sys.publishedBy = options?.publishedBy || 'root-cms-client';\n    batch.set(publishedRef, data);\n    if (commitBatch) {\n      await batch.commit();\n      this.logAction('translations.publish', {metadata: {translationsId}});\n    }\n  }\n\n  /**\n   * Checks if a doc is currently \"locked\" for publishing.\n   */\n  testPublishingLocked(doc: Doc) {\n    if (doc.sys?.publishingLocked) {\n      if (doc.sys.publishingLocked.until) {\n        const now = Timestamp.now().toMillis();\n        const until = doc.sys.publishingLocked.until.toMillis();\n        return now < until;\n      }\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Loads all published strings in the db.\n   *\n   * ```\n   * {\n   *   \"<hash>\": {\"source\": \"Hello\", \"es\": \"Hola\", \"fr\": \"Bonjour\"},\n   * }\n   * ```\n   *\n   * @deprecated Use `createBatchRequest()` to fetch draft/published translations.\n   */\n  async loadTranslations(\n    options?: LoadTranslationsOptions\n  ): Promise<TranslationsMap> {\n    const dbPath = `Projects/${this.projectId}/TranslationsManager/published/Translations`;\n    const translationsMap: TranslationsMap = {};\n\n    const addTranslations = (hash: string, translations: Translation) => {\n      translationsMap[hash] = Object.assign(\n        translationsMap[hash] || {},\n        translations\n      );\n    };\n\n    let query: Query = this.db.collection(dbPath);\n    if (options?.tags && options.tags.length > 0) {\n      query = query.where('sys.tags', 'array-contains-any', options.tags);\n    }\n    const snapshot = await query.get();\n    snapshot.forEach((doc) => {\n      const data = doc.data();\n      const strings = (data.strings || {}) as Record<string, Translation>;\n      Object.entries(strings).forEach(([hash, translations]) => {\n        addTranslations(hash, translations);\n      });\n    });\n\n    return translationsMap;\n  }\n\n  async saveDraftTranslations(\n    translationsId: string,\n    translations: {[source: string]: {[locale: string]: string}},\n    options?: {modifiedby?: string}\n  ) {\n    const docSlug = translationsId.replaceAll('/', '--');\n    const docPath = `Projects/${this.projectId}/TranslationsManager/draft/${docSlug}`;\n    const docRef = this.db.doc(docPath);\n\n    const snapshot = await docRef.get();\n    const data = snapshot.data() || {\n      id: translationsId.replaceAll('--', '/'),\n      sys: {},\n      strings: {},\n    };\n    data.sys.modifiedAt = Timestamp.now();\n    data.sys.modifiedBy = options?.modifiedby || 'root-cms-client';\n\n    const strings = data.strings || {};\n    Object.entries(translations).forEach(([source, row]) => {\n      const normalizedSource = this.normalizeString(source);\n      const hash = this.getTranslationKey(normalizedSource);\n      strings[hash] = {...strings[hash], ...row, source: normalizedSource};\n    });\n    data.strings = strings;\n    await docRef.set(data);\n    this.logAction('translations.save', {metadata: {translationsId}});\n  }\n\n  /**\n   * Returns the \"key\" used for a translation as stored in the db. Translations\n   * are stored under `Projects/<project id>/Translations/<sha1 hash>`.\n   */\n  getTranslationKey(source: string) {\n    const sha1 = crypto\n      .createHash('sha1')\n      .update(this.normalizeString(source))\n      .digest('hex');\n    return sha1;\n  }\n\n  /**\n   * Cleans a string that's used for translations. Performs the following:\n   * - Removes any leading/trailing whitespace\n   * - Removes spaces at the end of any line\n   */\n  normalizeString(str: string) {\n    const lines = String(str)\n      .trim()\n      .split('\\n')\n      .map((line) => line.trimEnd());\n    return lines.join('\\n');\n  }\n\n  /**\n   * Loads translations for a particular locale.\n   *\n   * Returns a map like:\n   * ```\n   * {\n   *   \"Hello\": \"Bonjour\",\n   * }\n   * ```\n   */\n  async loadTranslationsForLocale(\n    locale: string,\n    options?: LoadTranslationsOptions\n  ): Promise<LocaleTranslations> {\n    const translationsMap = await this.loadTranslations(options);\n    return translationsForLocale(translationsMap, locale);\n  }\n\n  /**\n   * Returns a data source configuration object.\n   */\n  async getDataSource(dataSourceId: string) {\n    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}`;\n    const docRef = this.db.doc(dbPath);\n    const doc = await docRef.get();\n    if (doc.exists) {\n      return doc.data() as DataSource;\n    }\n    return null;\n  }\n\n  /**\n   * Syncs a data source to draft state.\n   */\n  async syncDataSource(dataSourceId: string, options?: {syncedBy?: string}) {\n    const dataSource = await this.getDataSource(dataSourceId);\n    if (!dataSource) {\n      throw new Error(`data source not found: ${dataSourceId}`);\n    }\n\n    const data = await this.fetchData(dataSource);\n\n    const dataSourceDocRef = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}`\n    );\n    const dataDocRef = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/draft`\n    );\n    const syncedBy = options?.syncedBy || 'root-cms-client';\n\n    const updatedDataSource: DataSource = {\n      ...dataSource,\n      syncedAt: Timestamp.now(),\n      syncedBy: syncedBy,\n    };\n\n    const batch = this.db.batch();\n    batch.set(dataDocRef, {\n      dataSource: updatedDataSource,\n      data: data,\n    });\n    batch.update(dataSourceDocRef, {\n      syncedAt: Timestamp.now(),\n      syncedBy: syncedBy,\n    });\n    await batch.commit();\n\n    console.log(`synced data source: ${dataSourceId}`);\n    console.log(`synced by: ${syncedBy}`);\n  }\n\n  async publishDataSource(\n    dataSourceId: string,\n    options?: {publishedBy?: string}\n  ) {\n    const dataSource = await this.getDataSource(dataSourceId);\n    if (!dataSource) {\n      throw new Error(`data source not found: ${dataSourceId}`);\n    }\n\n    const dataSourceDocRef = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}`\n    );\n    const dataDocRefDraft = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}/draft`\n    );\n    const dataDocRefPublished = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}/published`\n    );\n\n    const dataRes = await this.getFromDataSource(dataSourceId, {mode: 'draft'});\n\n    const publishedBy = options?.publishedBy || 'root-cms-client';\n\n    const updatedDataSource: DataSource = {\n      ...dataSource,\n      publishedAt: Timestamp.now(),\n      publishedBy: publishedBy,\n    };\n\n    const batch = this.db.batch();\n    batch.set(dataDocRefPublished, {\n      dataSource: updatedDataSource,\n      data: dataRes?.data || null,\n    });\n    batch.update(dataDocRefDraft, {\n      dataSource: updatedDataSource,\n    });\n    batch.update(dataSourceDocRef, {\n      publishedAt: Timestamp.now(),\n      publishedBy: publishedBy,\n    });\n    await batch.commit();\n\n    console.log(`published data ${dataSourceId}`);\n    console.log(`published by: ${publishedBy}`);\n  }\n\n  private async fetchData(dataSource: DataSource) {\n    if (dataSource.type === 'http') {\n      return await this.fetchHttpData(dataSource);\n    }\n    // TODO(stevenle): impl.\n    // if (dataSource.type === 'gsheet') {\n    //   return await fetchGsheetData(dataSource);\n    // }\n    throw new Error(`unsupported data source: ${dataSource.type}`);\n  }\n\n  private async fetchHttpData(dataSource: DataSource) {\n    const url = dataSource.url || '';\n    if (!url.startsWith('https://')) {\n      throw new Error(`url not supported: ${url}`);\n    }\n\n    const res = await fetch(url, {\n      method: dataSource.httpOptions?.method || 'GET',\n      headers: dataSource.httpOptions?.headers || [],\n      body: dataSource.httpOptions?.body || undefined,\n    });\n\n    if (res.status !== 200) {\n      const err = await res.text();\n      throw new Error(`req failed: ${err}`);\n    }\n\n    const contentType = String(res.headers.get('content-type'));\n    if (contentType.includes('application/json')) {\n      return await res.json();\n    }\n    return res.text();\n  }\n\n  /**\n   * Fetches data from a data source.\n   */\n  async getFromDataSource<T = any>(\n    dataSourceId: string,\n    options?: {mode?: 'draft' | 'published'}\n  ): Promise<DataSourceData<T> | null> {\n    const mode = options?.mode || 'published';\n\n    const docRef = this.dbDataSourceDataRef(dataSourceId, {mode});\n    const doc = await docRef.get();\n    if (doc.exists) {\n      return doc.data() as DataSourceData<T>;\n    }\n    return null;\n  }\n\n  dbDataSourceDataPath(\n    dataSourceId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    if (!dataSourceId || dataSourceId.includes('/')) {\n      throw new Error(`invalid data source id: ${dataSourceId}`);\n    }\n    const mode = options.mode;\n    if (!(mode === 'draft' || mode === 'published')) {\n      throw new Error(`invalid mode: ${mode}`);\n    }\n    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/${mode}`;\n    return dbPath;\n  }\n\n  dbDataSourceDataRef(\n    dataSourceId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const dbPath = this.dbDataSourceDataPath(dataSourceId, options);\n    return this.db.doc(dbPath);\n  }\n\n  dbTranslationsPath(\n    translationsId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const mode = options.mode;\n    if (!(mode === 'draft' || mode === 'published')) {\n      throw new Error(`invalid mode: ${mode}`);\n    }\n    const slug = translationsId.replaceAll('/', '--');\n    const dbPath = `Projects/${this.projectId}/TranslationsManager/${mode}/Translations/${slug}`;\n    return dbPath;\n  }\n\n  dbTranslationsRef(\n    translationsId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const dbPath = this.dbTranslationsPath(translationsId, options);\n    return this.db.doc(dbPath);\n  }\n\n  /**\n   * Gets the user's role from the project's ACL.\n   */\n  async getUserRole(email: string): Promise<UserRole | null> {\n    if (!email) {\n      return null;\n    }\n    const docRef = this.db.doc(`Projects/${this.projectId}`);\n    const snapshot = await docRef.get();\n    const data = snapshot.data() || {};\n    const acl = data.roles || {};\n\n    if (email in acl) {\n      return acl[email];\n    }\n\n    // Check wildcard domains, e.g. `*@example.com`.\n    if (!email.includes('@')) {\n      console.warn(`invalid email: ${email}`);\n      return null;\n    }\n    const domain = email.split('@').at(-1);\n    if (domain && `*@${domain}` in acl) {\n      return acl[`*@${domain}`];\n    }\n    return null;\n  }\n\n  /**\n   * Verifies user exists in the ACL list.\n   */\n  async userExistsInAcl(email: string): Promise<boolean> {\n    if (!email) {\n      return false;\n    }\n    const docRef = this.db.doc(`Projects/${this.projectId}`);\n    const snapshot = await docRef.get();\n    const data = snapshot.data() || {};\n    const acl = data.roles || {};\n    if (email in acl) {\n      return true;\n    }\n\n    // Check wildcard domains, e.g. `*@example.com`.\n    if (!email.includes('@')) {\n      console.warn(`invalid email: ${email}`);\n      return false;\n    }\n    const domain = email.split('@').at(-1);\n    if (domain && `*@${domain}` in acl) {\n      return true;\n    }\n    return false;\n  }\n\n  async logAction(action: string, options?: {by?: string; metadata?: any}) {\n    if (!action) {\n      throw new Error('missing required: \"action\"');\n    }\n    const data = {\n      action: action,\n      timestamp: Timestamp.now(),\n      by: options?.by || 'system',\n      metadata: options?.metadata || {},\n    };\n    const colRef = this.db.collection(`Projects/${this.projectId}/ActionLogs`);\n    await colRef.add(data);\n\n    const metaStr = options?.metadata ? stringifyObj(options.metadata) : '';\n    console.log(`[${data.timestamp.toMillis()}] action: ${action} ${metaStr}`);\n\n    // Call the `onAction()` callback from cmsPlugin().\n    const cmsPluginConfig = this.cmsPlugin.getConfig();\n    if (cmsPluginConfig.onAction) {\n      try {\n        cmsPluginConfig.onAction(data);\n      } catch (err) {\n        console.error(err);\n      }\n    }\n  }\n\n  createBatchRequest(options: BatchRequestOptions): BatchRequest {\n    return new BatchRequest(this, options);\n  }\n}\n\nexport interface BatchRequestOptions {\n  mode: 'draft' | 'published';\n  /**\n   * Whether to automatically fetch translations for the docs retrieved in the\n   * request.\n   */\n  translate?: boolean;\n}\n\nexport interface BatchRequestQuery {\n  queryId: string;\n  collectionId: string;\n  queryOptions?: BatchRequestQueryOptions;\n}\n\nexport interface BatchRequestQueryOptions {\n  offset?: number;\n  limit?: number;\n  orderBy?: string;\n  orderByDirection?: 'asc' | 'desc';\n  query?: (query: Query) => Query;\n}\n\nexport class BatchRequest {\n  cmsClient: RootCMSClient;\n  private options: BatchRequestOptions;\n  private db: Firestore;\n  private docIds: string[] = [];\n  private dataSourceIds: string[] = [];\n  private queries: BatchRequestQuery[] = [];\n  private translationsIds: string[] = [];\n\n  constructor(cmsClient: RootCMSClient, options: BatchRequestOptions) {\n    this.cmsClient = cmsClient;\n    this.db = cmsClient.db;\n    this.options = options;\n  }\n\n  /**\n   * Adds a doc to the batch request.\n   */\n  addDoc(docId: string) {\n    this.docIds.push(docId);\n  }\n\n  /**\n   * Adds a data source to the batch request.\n   */\n  addDataSource(dataSourceId: string) {\n    this.dataSourceIds.push(dataSourceId);\n  }\n\n  /**\n   * Adds a collection-based query to the batch request.\n   */\n  addQuery(\n    queryId: string,\n    collectionId: string,\n    queryOptions?: BatchRequestQueryOptions\n  ) {\n    this.queries.push({\n      queryId: queryId,\n      collectionId: collectionId,\n      queryOptions: queryOptions,\n    });\n  }\n\n  /**\n   * Adds a translation file to the request.\n   */\n  addTranslations(translationsId: string) {\n    this.translationsIds.push(translationsId);\n  }\n\n  /**\n   * Fetches data from the DB.\n   */\n  async fetch(): Promise<BatchResponse> {\n    const res = new BatchResponse();\n\n    const promises = [\n      this.fetchDocs(res),\n      this.fetchQueries(res),\n      this.fetchDataSources(res),\n    ];\n    // If `options.translate` is disabled and translations are requested,\n    // fetch the translations in parallel with the other docs.\n    if (!this.options.translate && this.translationsIds.length > 0) {\n      promises.push(this.fetchTranslations(res));\n    }\n\n    await Promise.all(promises);\n\n    // If `options.translate` is enabled, the fetchX() methods will\n    // automatically add each doc's translations id to the request, so\n    // translations should be fetched after all the other docs are fetched.\n    if (this.translationsIds.length > 0) {\n      await this.fetchTranslations(res);\n    }\n\n    return res;\n  }\n\n  private async fetchDocs(res: BatchResponse) {\n    if (this.docIds.length === 0) {\n      return;\n    }\n    const docRefs = this.docIds.map((docId) => {\n      const [collectionId, slug] = docId.split('/');\n      return this.cmsClient.dbDocRef(collectionId, slug, {\n        mode: this.options.mode,\n      });\n    });\n    const docs = await this.db.getAll(...docRefs);\n    this.docIds.forEach((docId, i) => {\n      const doc = docs[i];\n      if (!doc.exists) {\n        console.warn(`doc \"${docId}\" does not exist`);\n        return;\n      }\n      const docData = unmarshalData(doc.data()) as Doc;\n      res.docs[docId] = docData;\n\n      if (this.options.translate) {\n        this.addTranslations(docId);\n      }\n    });\n  }\n\n  private async fetchQueries(res: BatchResponse) {\n    if (this.queries.length === 0) {\n      return;\n    }\n    const mode = this.options.mode;\n\n    const handleQuery = async (queryItem: BatchRequestQuery) => {\n      const docsPath = this.cmsClient.dbCollectionDocsPath(\n        queryItem.collectionId,\n        {mode}\n      );\n      const queryOptions = queryItem.queryOptions || {};\n      let query: Query = this.db.collection(docsPath);\n      if (queryOptions.limit) {\n        query = query.limit(queryOptions.limit);\n      }\n      if (queryOptions.offset) {\n        query = query.offset(queryOptions.offset);\n      }\n      if (queryOptions.orderBy) {\n        query = query.orderBy(\n          queryOptions.orderBy,\n          queryOptions.orderByDirection\n        );\n      }\n      if (queryOptions.query) {\n        query = queryOptions.query(query);\n      }\n      const results = await query.get();\n      const docs: Doc[] = [];\n      results.forEach((result) => {\n        const doc = unmarshalData(result.data()) as Doc;\n        docs.push(doc);\n      });\n      res.queries[queryItem.queryId] = docs;\n    };\n\n    await Promise.all(this.queries.map((queryItem) => handleQuery(queryItem)));\n  }\n\n  private async fetchDataSources(res: BatchResponse) {\n    if (this.dataSourceIds.length === 0) {\n      return;\n    }\n    const docRefs = this.dataSourceIds.map((dataSourceId) => {\n      return this.cmsClient.dbDataSourceDataRef(dataSourceId, {\n        mode: this.options.mode,\n      });\n    });\n    const docs = await this.db.getAll(...docRefs);\n    this.dataSourceIds.forEach((dataSourceId, i) => {\n      const doc = docs[i];\n      if (!doc.exists) {\n        console.warn(`\"data source \"${dataSourceId}\" does not exist`);\n        return;\n      }\n      res.dataSources[dataSourceId] = doc.data() as DataSourceData;\n    });\n  }\n\n  private async fetchTranslations(res: BatchResponse) {\n    if (this.translationsIds.length === 0) {\n      return;\n    }\n\n    const docRefs = this.translationsIds.map((translationsId) => {\n      return this.cmsClient.dbTranslationsRef(translationsId, {\n        mode: this.options.mode,\n      });\n    });\n    const docs = await this.db.getAll(...docRefs);\n    this.translationsIds.forEach((translationsId, i) => {\n      const doc = docs[i];\n      if (!doc.exists) {\n        // console.warn(`translations \"${translationsId}\" does not exist`);\n        return;\n      }\n      res.translations[translationsId] = doc.data() as TranslationsDoc;\n    });\n  }\n}\n\nexport class BatchResponse {\n  docs: Record<string, Doc> = {};\n  queries: Record<string, Doc[]> = {};\n  dataSources: Record<string, DataSourceData> = {};\n  translations: Record<string, TranslationsDoc> = {};\n\n  /**\n   * Returns a map of translations for a given locale or locale fallbacks.\n   *\n   * The input is either a single locale (e.g. \"de\") or an array of locales\n   * representing the fallback tree, e.g. [\"en-CA\", \"en-GB\", \"en\"].\n   *\n   * The returned value is a flat map of source string to translated string,\n   * e.g.:\n   * {\"<source>\": \"<translation>\"}\n   */\n  getTranslations(locale: string | string[]): LocaleTranslations {\n    const translationsMap = this.getTranslationsMap();\n    const translations = translationsForLocale(translationsMap, locale);\n    return translations;\n  }\n\n  /**\n   * Merges the strings from all translations files retrieved in the request.\n   * The returned value is a map of string to translations, e.g.:\n   *\n   * {\"<hash>\": {\"source\": \"<source>\", \"<locale>\": \"<translation>\"}}\n   */\n  private getTranslationsMap(): TranslationsMap {\n    // Load translations in the following order:\n    // - generic translations (e.g. \"global\")\n    // - docs returned from queries (e.g. \"list all blog posts\")\n    // - specific docs (e.g. \"Pages/index\")\n    const translationsDocs = Object.values(this.translations).reverse();\n\n    // Consolidate the strings from all of the translations files.\n    // {\"<hash>\": {\"source\": \"<source>\", \"<locale>\": \"<translation>\"}}\n    const translationsMap: TranslationsMap = {};\n    for (const translationsDoc of translationsDocs) {\n      const strings = translationsDoc.strings || {};\n      for (const hash in strings) {\n        const translations = strings[hash];\n        translationsMap[hash] ??= {source: translations.source};\n        for (const locale in translations) {\n          if (locale !== 'source' && translations[locale]) {\n            translationsMap[hash][locale] = translations[locale];\n          }\n        }\n      }\n    }\n\n    return translationsMap;\n  }\n}\n\n/**\n * Returns true if the `data` is a rich text data object.\n */\nexport function isRichTextData(data: any) {\n  // The RichTextEditor uses editorjs under the hood, the data format is\n  // something like:\n  //  {\n  //   \"time\": 1721761211720,\n  //   \"version\": \"2.28.2\",\n  //   \"blocks\": [...]\n  // }\n  return Boolean(\n    isObject(data) && Array.isArray(data.blocks) && data.time && data.version\n  );\n}\n\n/**\n * Walks the data tree and converts any array of objects into \"array objects\"\n * for storage in firestore.\n */\nexport function marshalData(data: any): any {\n  // Avoid changing the format of rich text data.\n  if (isRichTextData(data)) {\n    return data;\n  }\n\n  const result: any = {};\n  for (const key in data) {\n    const val = data[key];\n    if (isObject(val)) {\n      result[key] = marshalData(val);\n    } else if (Array.isArray(val)) {\n      if (val.length > 0 && val.some((item) => isObject(item))) {\n        const items = val.map((item) => {\n          if (isObject(item)) {\n            return marshalData(item);\n          }\n          return item;\n        });\n        result[key] = toArrayObject(items);\n      } else {\n        result[key] = val;\n      }\n    } else {\n      result[key] = val;\n    }\n  }\n  return result;\n}\n\n/**\n * Walks the data tree and converts any Timestamp objects to millis and any\n * _array maps to normal arrays.\n *\n * E.g.:\n *\n * normalizeData({\n *   sys: {modifiedAt: Timestamp(123)},\n *   fields: {\n *     _array: ['asdf'],\n *     asdf: {title: 'hello'}\n *   }\n * })\n * // => {sys: {modifiedAt: 123}, fields: {foo: [{title: 'hello'}]}}\n */\nexport function unmarshalData(data: any): any {\n  const result: any = {};\n  for (const key in data) {\n    const val = data[key];\n    if (isObject(val)) {\n      if (val.toMillis) {\n        result[key] = val.toMillis();\n      } else if (Object.hasOwn(val, '_array') && Array.isArray(val._array)) {\n        const arr = val._array.map((arrayKey: string) => {\n          return {\n            ...unmarshalData(val[arrayKey] || {}),\n            _arrayKey: arrayKey,\n          };\n        });\n        result[key] = arr;\n      } else {\n        result[key] = unmarshalData(val);\n      }\n    } else {\n      result[key] = val;\n    }\n  }\n  return result;\n}\n\n/** @deprecated Use `unmarshalData()` instead. */\nexport function normalizeData(data: any): any {\n  return unmarshalData(data);\n}\n\nexport interface ArrayObject {\n  [key: string]: any;\n  _array: string[];\n}\n\n/**\n * Serializes an array into an `ArrayObject`, e.g.:\n *\n * ```\n * marshalArray([1, 2, 3])\n * // => {a: 1, b: 2, c: 3, _array: ['a', 'b', 'c']}\n * ```\n *\n * This database storage method makes it easier to update a single field in a\n * deeply nested array object.\n */\nexport function toArrayObject(arr: any[]): ArrayObject {\n  if (!Array.isArray(arr)) {\n    return arr;\n  }\n  const arrObject: ArrayObject = {_array: []};\n  for (const item of arr) {\n    const key = randString(6);\n    arrObject[key] = item;\n    arrObject._array.push(key);\n  }\n  return arrObject;\n}\n\nexport const marshalArray = toArrayObject;\n\n/**\n * Converts an `ArrayObject` to a normal array.\n */\nexport function unmarshalArray(arrObject: ArrayObject): any[] {\n  if (!Array.isArray(arrObject?._array)) {\n    return [];\n  }\n  const arr = arrObject._array.map((k: string) => arrObject[k]);\n  return arr;\n}\n\nfunction isObject(data: any): boolean {\n  return typeof data === 'object' && !Array.isArray(data) && data !== null;\n}\n\nfunction randString(len: number): string {\n  const result = [];\n  const chars =\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n  for (let i = 0; i < len; i++) {\n    const rand = Math.floor(Math.random() * chars.length);\n    result.push(chars.charAt(rand));\n  }\n  return result.join('');\n}\n\n/**\n * Converts a translations map from `loadTranslations()` to a map of source to\n * translated string for a particular locale.\n *\n * Returns a map like:\n * ```\n * {\n *   \"Hello\": \"Bonjour\",\n * }\n * ```\n */\nexport function translationsForLocale(\n  translationsMap: TranslationsMap,\n  locale: string | string[]\n) {\n  const localeTranslations: LocaleTranslations = {};\n\n  const fallbackLocales = Array.isArray(locale) ? locale : [locale];\n  if (!fallbackLocales.includes('en')) {\n    fallbackLocales.push('en');\n  }\n\n  Object.values(translationsMap).forEach((string) => {\n    const source = string.source;\n    let translation = source;\n    for (const fallbackLocale of fallbackLocales) {\n      if (string[fallbackLocale]) {\n        translation = string[fallbackLocale];\n        break;\n      }\n    }\n    localeTranslations[source] = translation;\n  });\n  return localeTranslations;\n}\n\n/** A pretty printer for JavaScript objects. */\nfunction stringifyObj(obj: any) {\n  function format(obj: any): string {\n    if (obj === null) {\n      return 'null';\n    }\n    if (typeof obj === 'undefined') {\n      return 'undefined';\n    }\n    if (typeof obj === 'string') {\n      return `\"${obj.replaceAll('\"', '\\\\\"')}\"`;\n    }\n    if (typeof obj !== 'object') {\n      return String(obj);\n    }\n    if (Array.isArray(obj)) {\n      return `[${obj.map(format).join(', ')}]`;\n    }\n    const entries: string[] = Object.entries(obj).map(([key, value]) => {\n      return `${key}: ${format(value)}`;\n    });\n    return `{${entries.join(', ')}}`;\n  }\n  return format(obj);\n}\n\n/**\n * Parses a docId (e.g. `Pages/foo`) and returns the `collection` and `slug`.\n */\nexport function parseDocId(docId: string) {\n  const sepIndex = docId.indexOf('/');\n  if (sepIndex <= 0) {\n    throw new Error(`invalid doc id: ${docId}`);\n  }\n  const collection = docId.slice(0, sepIndex);\n  const slug = docId.slice(sepIndex + 1).replaceAll('/', '--');\n  if (!collection || !slug) {\n    throw new Error(`invalid doc id: ${docId}`);\n  }\n  return {collection, slug};\n}\n\nexport {getCmsPlugin};\n", "import {promises as fs} from 'node:fs';\nimport path from 'node:path';\nimport {fileURLToPath} from 'node:url';\nimport type {\n  ConfigureServerOptions,\n  NextFunction,\n  Plugin,\n  Request,\n  Response,\n  RootConfig,\n  Server,\n} from '@blinkk/root';\nimport bodyParser from 'body-parser';\nimport {\n  App,\n  applicationDefault,\n  getApp,\n  initializeApp,\n} from 'firebase-admin/app';\nimport {getAuth, DecodedIdToken} from 'firebase-admin/auth';\nimport {Firestore, getFirestore} from 'firebase-admin/firestore';\nimport * as jsonwebtoken from 'jsonwebtoken';\nimport sirv from 'sirv';\nimport {api} from './api.js';\nimport {Action, RootCMSClient} from './client.js';\nimport {runCompatibilityChecks} from './compatibility.js';\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\ntype AppModule = typeof import('./app.js');\n\n// The session key name used for Root CMS authentication.\nconst SESSION_COOKIE_AUTH = 'root-cms-auth';\n\nexport interface CMSUser {\n  email: string;\n}\n\nexport interface CMSAIConfig {\n  /** Custom API endpoint for chat prompts. */\n  endpoint?: string;\n  /** Gen AI model to use. Defaults to 'gemini-1.5-flash'. */\n  model?: 'gemini-1.5-flash' | 'gemini-1.5-pro';\n}\n\nexport interface CMSSidebarTool {\n  /** URL for the sidebar icon image. */\n  icon?: string;\n  /** Label. */\n  label?: string;\n  /** Iframe URL to render for the tool. */\n  iframeUrl?: string;\n}\n\nexport type CMSPluginOptions = {\n  /**\n   * The ID of the project. Data will be stored under the namespace\n   * `Projects/${id}` in firestore.\n   */\n  id?: string;\n\n  /**\n   * The name of the project. Used in the header of the CMS to help identify\n   * the project.\n   */\n  name?: string;\n\n  /**\n   * Firebase config object, which can be obtained in the Firebase Console by\n   * going to \"Project Settings\".\n   */\n  firebaseConfig: {\n    [key: string]: string | undefined;\n    apiKey: string;\n    authDomain: string;\n    projectId: string;\n    storageBucket: string;\n    databaseId?: string;\n  };\n\n  /**\n   * GAPI credentials. Include if using Google Drive and Google Sheets features.\n   * See: https://developers.google.com/sheets/api/quickstart/js\n   */\n  gapi?: {\n    /** https://developers.google.com/sheets/api/quickstart/js#create_an_api_key */\n    apiKey: string;\n    /** https://developers.google.com/sheets/api/quickstart/js#authorize_credentials_for_a_web_application */\n    clientId: string;\n  };\n\n  /**\n   * Secret value(s) used for signing the user authentication cookie.\n   * @deprecated This is now handled directly by root's sessionMiddleware under\n   * `server.sessionCookieSecret` in root.config.ts.\n   */\n  cookieSecret?: string | string[];\n\n  /** Function called to check if a user should have access to the CMS. */\n  isUserAuthorized?: (\n    req: Request,\n    user: CMSUser\n  ) => boolean | Promise<boolean>;\n\n  /**\n   * Function to call to check if login is required for a particular request.\n   */\n  isLoginRequired?: (req: Request) => boolean;\n\n  /**\n   * By default, iframing the CMS is disallowed. Setting this value will allow\n   * iframes from the specified origins. Example:\n   * ```\n   * allowedIframeOrigins: ['https://app.example.com']\n   * ```\n   */\n  allowedIframeOrigins?: string[];\n\n  /**\n   * URL to GCI service for transforming uploaded GCS images to a Google App\n   * Engine Images API serving URL.\n   *\n   * Setting this to `true` uses the default hosted service at\n   * https://gci.rootjs.dev.\n   *\n   * To set up GCI:\n   *\n   * - Create a GCS bucket with fine-grained permissions\n   * - Share owner access to the bucket with the service account returned in\n   *   https://gci.rootjs.dev/_/service_account\n   *\n   * To disable GCI, leave this value empty or set to `false`, which which will\n   * serve images directly from GCS instead.\n   */\n  gci?: string | boolean;\n\n  /**\n   * Customization options for the CMS sidebar.\n   */\n  sidebar?: {\n    /**\n     * Sidebar tools, a map of the sidebar id to config options. The sidebar\n     * tool is url-mapped to `/cms/tools/:id` and displays the tool in an\n     * iframe.\n     */\n    tools?: Record<string, CMSSidebarTool>;\n  };\n\n  /**\n   * Callback when an action occurs.\n   */\n  onAction?: (action: Action) => any;\n\n  /**\n   * Experimental config options. Note: these are subject to change at any time.\n   */\n  experiments?: {\n    ai?: boolean | CMSAIConfig;\n  };\n\n  /**\n   * Adjust console output verbosity. Default is `'info'`.\n   */\n  logLevel?: 'info' | 'warn' | 'error' | 'silent' | 'debug';\n\n  /**\n   * Whether to enable/disable file watching in dev (e.g. for generating\n   * `root-cms.d.ts`). Defaults to `true`.\n   */\n  watch?: boolean;\n};\n\nexport type CMSPlugin = Plugin & {\n  name: 'root-cms';\n  getConfig: () => CMSPluginOptions;\n  getFirebaseApp: () => App;\n  getFirestore: () => Firestore;\n};\n\nfunction isExpired(decodedIdToken: DecodedIdToken) {\n  const ts = Math.floor(new Date().getTime() / 1000);\n  return ts >= decodedIdToken.exp;\n}\n\nfunction getFirebaseApp(gcpProjectId: string): App {\n  const appName = 'root-cms';\n  try {\n    return getApp(appName);\n  } catch (err) {\n    if (err && err.code === 'app/no-app') {\n      return initializeApp(\n        {\n          projectId: gcpProjectId,\n          credential: applicationDefault(),\n        },\n        appName\n      );\n    }\n    throw err;\n  }\n}\n\nexport function cmsPlugin(options: CMSPluginOptions): CMSPlugin {\n  const logLevel = options.logLevel || 'info';\n\n  if (!options.firebaseConfig) {\n    throw new Error(\n      'missing firebaseConfig. create a new app in the firebase admin console and copy the firebase config object to root.config.ts'\n    );\n  }\n\n  const firebaseConfig = options.firebaseConfig || {};\n  const app = getFirebaseApp(firebaseConfig.projectId);\n  const auth = getAuth(app);\n\n  /**\n   * Checks if login is required for the request. Currently returns `true` if\n   * the URL path starts with /cms or if ?preview=true is in the URL.\n   */\n  function loginRequired(req: Request): boolean {\n    const urlPath = String(req.originalUrl).split('?')[0].toLowerCase();\n    // Allow the cron to run unauthenticated. The cron job is responsible\n    // for saving version history.\n    if (urlPath === '/cms/api/cron.run') {\n      return false;\n    }\n    // Allow the signin.css and signin.js files to be rendered without auth.\n    if (\n      urlPath === '/cms/static/signin.css' ||\n      urlPath === '/cms/static/signin.js'\n    ) {\n      return false;\n    }\n    // Require login on all `/cms/` paths.\n    if (urlPath.startsWith('/cms')) {\n      return true;\n    }\n    // Require login on all paths that have `?preview=true`, which is used by\n    // the preview iframe to render the preview for a page.\n    if (String(req.query.preview) === 'true') {\n      return true;\n    }\n    if (options.isLoginRequired && options.isLoginRequired(req)) {\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Verifies a new login request for a user. The request body should contain\n   * an idToken, which is verified on prod using Firebase Admin and Identity\n   * Toolkit. If a `isUserAuthorized()` config is set, this function will also\n   * verify via that function. Returns true if the login verification succeeds.\n   */\n  async function verifyUserLogin(\n    req: Request\n  ): Promise<{authorized: boolean; reason?: string}> {\n    const idToken = req.body?.idToken;\n    if (!idToken) {\n      console.log('login failed: no id token');\n      return {authorized: false, reason: 'no token'};\n    }\n\n    let user: CMSUser;\n\n    // On local dev, simply verify the decoded idToken's email is set. The\n    // identity toolkit that verifies id tokens requires a service account,\n    // which we want to avoid having to set up when users are doing local dev.\n    // Authentication is still required by the frontend using Firebase Auth,\n    // this just bypasses the initial server check before the ui is rendered.\n    try {\n      if (process.env.NODE_ENV === 'development') {\n        const jwt = jsonwebtoken.decode(idToken) as jsonwebtoken.JwtPayload;\n        if (!jwt.email || !jwt.email_verified) {\n          console.log('login failed: email unverified');\n          return {authorized: false, reason: 'login failed'};\n        }\n        user = {email: jwt.email};\n      } else {\n        const jwt = await auth.verifyIdToken(idToken, true);\n        if (isExpired(jwt)) {\n          console.log('login failed: id token is expired');\n          return {authorized: false, reason: 'login failed'};\n        }\n        if (!jwt.email || !jwt.email_verified) {\n          console.log('login failed: email unverified');\n          return {authorized: false, reason: 'login failed'};\n        }\n        user = {email: jwt.email};\n      }\n\n      // Verify the project's `isUserAuthorized()` config option.\n      if (options.isUserAuthorized) {\n        const authorized = await options.isUserAuthorized(req, {\n          email: user.email,\n        });\n        if (!authorized) {\n          console.log('login failed: user is not authorized');\n          return {authorized: false, reason: 'not authorized'};\n        }\n      }\n\n      // Verify the user exists in the DB's ACL list.\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const userHasAccess = await cmsClient.userExistsInAcl(user.email);\n      if (!userHasAccess) {\n        console.log('login failed: user is not in the firestore acl list');\n        return {authorized: false, reason: 'not authorized'};\n      }\n    } catch (err) {\n      console.error('failed to verify jwt token');\n      console.error(err);\n      return {authorized: false, reason: 'unknown error'};\n    }\n\n    return {authorized: true};\n  }\n\n  /**\n   * Returns the current user based on the request's session cookie. The\n   * session cookie is checked for validity through Firebase Auth and the user's\n   * email is verified to have access to Root CMS, otherwise returns `null`.\n   */\n  async function getCurrentUser(req: Request): Promise<CMSUser | null> {\n    const sessionCookie = req.session.getItem(SESSION_COOKIE_AUTH);\n    if (!sessionCookie) {\n      if (logLevel === 'debug') {\n        console.log('no login session cookie');\n      }\n      return null;\n    }\n\n    // On local dev, verify the decoded idToken has a valid email. The firebase\n    // auth verification otherwise would require a service account.\n    if (process.env.NODE_ENV === 'development') {\n      const jwt = jsonwebtoken.decode(sessionCookie) as jsonwebtoken.JwtPayload;\n      if (!jwt?.email || !jwt?.email_verified) {\n        return null;\n      }\n      // Check whether user is authorized.\n      if (options.isUserAuthorized) {\n        const authorized = await options.isUserAuthorized(req, {\n          email: jwt.email,\n        });\n        if (!authorized) {\n          console.log('session failed: not authorized');\n          return null;\n        }\n      }\n      // Verify the user exists in the DB's ACL list.\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const userHasAccess = await cmsClient.userExistsInAcl(jwt.email);\n      if (!userHasAccess) {\n        console.log('session failed: user is not in the firestore acl list');\n        return null;\n      }\n      return {email: jwt.email};\n    }\n\n    try {\n      // Verify the idToken using firebase auth, checking for token revocations.\n      const jwt = await auth.verifySessionCookie(sessionCookie, true);\n      if (isExpired(jwt)) {\n        console.log('session failed: token is expired');\n        return null;\n      }\n      // Verify user's email is verified.\n      if (!jwt.email || !jwt.email_verified) {\n        console.log('session failed: email not verified');\n        return null;\n      }\n      // Check whether user is authorized.\n      if (options.isUserAuthorized) {\n        const authorized = await options.isUserAuthorized(req, {\n          email: jwt.email!,\n        });\n        if (!authorized) {\n          console.log('session failed: not authorized');\n          return null;\n        }\n      }\n      // Verify the user exists in the DB's ACL list.\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const userHasAccess = await cmsClient.userExistsInAcl(jwt.email);\n      if (!userHasAccess) {\n        console.log('session failed: user is not in the firestore acl list');\n        return null;\n      }\n      // JWT verified.\n      return {email: jwt.email!};\n    } catch (err) {\n      console.error('failed to verify jwt token');\n      console.error(err);\n      return null;\n    }\n  }\n\n  function redirectToLogin(req: Request, res: Response) {\n    if (String(req.originalUrl).toLowerCase().startsWith('/cms/api')) {\n      res.status(401).json({success: false, error: 'NOT_AUTHORIZED'});\n      return;\n    }\n    console.log('redirecting to login page');\n    const params = new URLSearchParams({\n      continue: req.originalUrl,\n    });\n    res.redirect(`/cms/login?${params.toString()}`);\n  }\n\n  const plugin: CMSPlugin = {\n    name: 'root-cms',\n\n    /**\n     * Returns the config options passed to the plugin.\n     */\n    getConfig: () => {\n      return options;\n    },\n\n    /**\n     * Returns the Firebase App instance used by the plugin.\n     */\n    getFirebaseApp: () => {\n      return app;\n    },\n\n    /**\n     * Returns the Firestore instance used by the plugin.\n     */\n    getFirestore: () => {\n      const databaseId = firebaseConfig.databaseId || '(default)';\n      return getFirestore(app, databaseId);\n    },\n\n    /**\n     * A map of ssr files to include when running `root build`.\n     */\n    ssrInput: () => ({\n      cms: path.resolve(__dirname, './app.js'),\n    }),\n\n    hooks: {\n      /**\n       * Startup hook. On `dev` and `build` commands, the plugin does\n       * compatibility checks.\n       */\n      startup: async ({command, rootConfig}) => {\n        if (command === 'dev' || command === 'build') {\n          await runCompatibilityChecks(rootConfig);\n        }\n      },\n    },\n\n    /**\n     * Attaches CMS-specific middleware to the Root.js server.\n     */\n    configureServer: async (\n      server: Server,\n      serverOptions: ConfigureServerOptions\n    ) => {\n      server.use(bodyParser.json());\n\n      async function getRenderer(req: Request): Promise<AppModule> {\n        if (serverOptions.type === 'dev') {\n          const appFilePath = path.resolve(__dirname, './app.js');\n          const app = (await req.viteServer!.ssrLoadModule(\n            appFilePath\n          )) as AppModule;\n          return app;\n        }\n\n        const appImportPath = path.resolve(\n          req.rootConfig!.rootDir,\n          'dist/server/cms.js'\n        );\n        if (!(await fileExists(appImportPath))) {\n          throw new Error(\n            'dist/server/cms.js not found. run `root build` to create it.'\n          );\n        }\n        const app = (await import(appImportPath)) as AppModule;\n        return app;\n      }\n\n      // Login handler.\n      server.use('/cms/login', async (req: Request, res: Response) => {\n        if (\n          req.method === 'PUT' &&\n          req.headers['content-type'] === 'application/json'\n        ) {\n          try {\n            const {authorized, reason} = await verifyUserLogin(req);\n            if (!authorized) {\n              res\n                .status(401)\n                .json({success: false, error: 'NOT_AUTHORIZED', reason});\n              return;\n            }\n\n            // Set session expiration to 5 days.\n            const expiresIn = 60 * 60 * 24 * 5 * 1000;\n            const idToken = req.body.idToken!;\n\n            let sessionCookie: string;\n            if (process.env.NODE_ENV === 'development') {\n              sessionCookie = idToken;\n            } else {\n              sessionCookie = await auth.createSessionCookie(idToken, {\n                expiresIn,\n              });\n            }\n            res.session.setItem(SESSION_COOKIE_AUTH, sessionCookie);\n            res.saveSession();\n            res.json({success: true});\n          } catch (err) {\n            console.error(err);\n            if (err.stack) {\n              console.error(err.stack);\n            }\n            res\n              .status(500)\n              .json({success: false, error: 'UNKNOWN_SERVER_ERROR'});\n          }\n          return;\n        }\n\n        try {\n          const app = await getRenderer(req);\n          app.renderSignIn(req, res, {\n            rootConfig: req.rootConfig!,\n            cmsConfig: options,\n          });\n        } catch (err) {\n          console.error(err);\n          if (err.stack) {\n            console.error(err.stack);\n          }\n          res.status(500).send('UNKNOWN SERVER ERROR');\n        }\n      });\n\n      // Logout handler.\n      server.use('/cms/logout', async (req: Request, res: Response) => {\n        res.session.removeItem(SESSION_COOKIE_AUTH);\n        res.saveSession();\n        res.redirect('/cms/login');\n      });\n\n      // Inject the current user into the req object and check if login is\n      // required, sending unauthenticated users to the login page.\n      server.use(async (req: Request, res: Response, next: NextFunction) => {\n        const user = await getCurrentUser(req);\n        if (user) {\n          req.user = user;\n        }\n\n        // If no user and login is required for the given path, redirect to the\n        // login page.\n        if (!user && loginRequired(req)) {\n          redirectToLogin(req, res);\n          return;\n        }\n\n        next();\n      });\n\n      const staticDir = path.resolve(__dirname, 'ui');\n      server.use('/cms/static', sirv(staticDir, {dev: false}));\n\n      // Register API handlers.\n      api(server);\n\n      // Render the CMS SPA.\n      server.use('/cms', async (req: Request, res: Response) => {\n        try {\n          // Enforce login for all CMS paths. The `req.user` would only be\n          // populated if the firebase auth token is valid and the user has\n          // access via the Root CMS sharebox.\n          if (!req.user) {\n            redirectToLogin(req, res);\n            return;\n          }\n          const app = await getRenderer(req);\n          await app.renderApp(req, res, {\n            rootConfig: req.rootConfig!,\n            cmsConfig: options,\n          });\n        } catch (err) {\n          // TODO(stevenle): render a custom error page.\n          console.error(err);\n          res.status(500).send('UNKNOWN SERVER ERROR');\n        }\n      });\n    },\n  };\n\n  if (options.watch !== false) {\n    plugin.onFileChange = (\n      eventName: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir',\n      filepath: string\n    ) => {\n      if (filepath.endsWith('.schema.ts')) {\n        // Avoid loading the `generate-types.js` module if it is not needed.\n        // See: https://github.com/blinkk/rootjs/issues/426\n        import('../cli/generate-types.js').then((generateTypesModule) => {\n          const generateTypes = generateTypesModule.generateTypes;\n          generateTypes();\n        });\n      }\n    };\n  }\n\n  return plugin;\n}\n\nfunction fileExists(filepath: string): Promise<boolean> {\n  return fs\n    .access(filepath)\n    .then(() => true)\n    .catch(() => false);\n}\n\nexport function getCmsPlugin(rootConfig: RootConfig): CMSPlugin {\n  const plugins: Plugin[] = rootConfig.plugins || [];\n  const plugin = plugins.find((plugin) => plugin.name === 'root-cms');\n  if (!plugin) {\n    throw new Error('could not find root-cms plugin config in root.config.ts');\n  }\n  return plugin as CMSPlugin;\n}\n", "import {Server, Request, Response} from '@blinkk/root';\nimport {multipartMiddleware} from '@blinkk/root/middleware';\nimport {Chat, ChatClient} from './ai.js';\nimport {RootCMSClient} from './client.js';\nimport {runCronJobs} from './cron.js';\nimport {arrayToCsv, csvToArray} from './csv.js';\n\n/**\n * Registers API middleware handlers.\n */\nexport function api(server: Server) {\n  /**\n   * Runs CMS cron jobs.\n   */\n  server.use('/cms/api/cron.run', async (req: Request, res: Response) => {\n    try {\n      await runCronJobs(req.rootConfig!);\n      res.status(200).json({success: true});\n    } catch (err) {\n      console.error(err);\n      res.status(500).json({success: false});\n    }\n  });\n\n  /**\n   * Accepts a JSON object containing {headers: [...], rows: [...]} and sends\n   * an HTTP response with a corresponding CSV file as an attachment.\n   *\n   * Sample request:\n   *\n   * ```json\n   * {\n   *   \"headers\": [\"foo\"],\n   *   \"rows\": [\n   *     {\"foo\": \"bar\"},\n   *     {\"foo\": \"baz\"},\n   *   ]\n   * }\n   * ```\n   */\n  server.use('/cms/api/csv.download', (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n\n    try {\n      const body = req.body || {};\n      const headers = body.headers || [];\n      const rows = body.rows || [];\n      const csv = arrayToCsv({headers, rows});\n      res.setHeader('Content-Type', 'text/csv');\n      res.setHeader('Content-Disposition', 'attachment; filename=\"data.csv\"');\n      res.status(200).end(csv);\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n\n  /**\n   * Imports a CSV file and returns a JSON array of objects representing the\n   * CSV.\n   *\n   * Sample response:\n   *\n   * ```json\n   * {\n   *   \"success\": true,\n   *   \"data\": [\n   *     {\"foo\": \"bar\"},\n   *     {\"foo\": \"baz\"},\n   *   ]\n   * }\n   * ```\n   */\n  server.use(\n    '/cms/api/csv.import',\n    multipartMiddleware(),\n    (req: Request, res: Response) => {\n      if (req.method !== 'POST' || !req.files || !req.files.file) {\n        res.status(400).json({success: false, error: 'BAD_REQUEST'});\n        return;\n      }\n\n      try {\n        const file = req.files.file;\n        const csvString = file.buffer.toString('utf8');\n        const rows = csvToArray(csvString);\n        res.status(200).json({success: true, data: rows});\n      } catch (err) {\n        console.error(err.stack || err);\n        res.status(500).json({success: false, error: 'UNKNOWN'});\n      }\n    }\n  );\n\n  /**\n   * Runs a data source sync.\n   */\n  server.use('/cms/api/data.sync', async (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n\n    if (!req.user?.email) {\n      res.status(401).json({success: false, error: 'UNAUTHORIZED'});\n    }\n\n    const reqBody = req.body || {};\n    const dataSourceId = reqBody.id;\n    if (!dataSourceId) {\n      res.status(400).json({success: false, error: 'MISSING_ID'});\n      return;\n    }\n    const cmsClient = new RootCMSClient(req.rootConfig!);\n    try {\n      await cmsClient.syncDataSource(dataSourceId, {syncedBy: req.user.email});\n      res.status(200).json({success: true, id: dataSourceId});\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n\n  /**\n   * Logs an action.\n   */\n  server.use('/cms/api/actions.log', async (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n\n    if (!req.user?.email) {\n      res.status(401).json({success: false, error: 'UNAUTHORIZED'});\n    }\n\n    const reqBody = req.body || {};\n    const action = reqBody.action;\n    if (!action) {\n      res.status(400).json({\n        success: false,\n        error: 'MISSING_REQUIRED_FIELD',\n        field: 'action',\n      });\n    }\n    const metadata = reqBody.metadata || {};\n\n    const cmsClient = new RootCMSClient(req.rootConfig!);\n    try {\n      await cmsClient.logAction(action, {\n        by: req.user?.email,\n        metadata: metadata,\n      });\n      res.status(200).json({success: true});\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n\n  /**\n   * AI chatbot.\n   */\n  server.use('/cms/api/ai.chat', async (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n    if (!req.user?.email) {\n      res.status(401).json({success: false, error: 'UNAUTHORIZED'});\n      return;\n    }\n    const reqBody = req.body || {};\n    if (!reqBody.prompt) {\n      res.status(400).json({success: false, error: 'MISSING_PROMPT'});\n      return;\n    }\n    const prompt = reqBody.prompt;\n\n    try {\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const chatClient = new ChatClient(cmsClient, req.user.email);\n      let chat: Chat;\n      if (reqBody.chatId) {\n        chat = await chatClient.getChat(reqBody.chatId);\n      } else {\n        chat = await chatClient.createChat();\n      }\n      const chatResponse = await chat.sendPrompt(prompt);\n      res\n        .status(200)\n        .json({success: true, chatId: chat.id, response: chatResponse});\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n\n  server.use('/cms/api/ai.list_chats', async (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n    if (!req.user?.email) {\n      res.status(401).json({success: false, error: 'UNAUTHORIZED'});\n      return;\n    }\n    const reqBody = req.body || {};\n    const limit = reqBody.limit;\n\n    try {\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const chatClient = new ChatClient(cmsClient, req.user.email);\n      const chats = await chatClient.listChats({limit});\n      res.status(200).json({success: true, chats});\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n}\n", "import crypto from 'node:crypto';\nimport {generate} from '@genkit-ai/ai';\nimport {configureGenkit} from '@genkit-ai/core';\nimport {vertexAI} from '@genkit-ai/vertexai';\nimport {gemini15ProPreview, gemini15FlashPreview} from '@genkit-ai/vertexai';\nimport {Timestamp} from 'firebase-admin/firestore';\nimport {RootCMSClient} from './client.js';\nimport {CMSPluginOptions} from './plugin.js';\n\nlet genkitIsConfigured = false;\n\ninterface ChatPrompt {\n  text?: string;\n  media?: {\n    url: string;\n    contentType: string;\n  };\n}\n\nexport class Chat {\n  chatClient: ChatClient;\n  cmsClient: RootCMSClient;\n  cmsPluginOptions: CMSPluginOptions;\n  id: string;\n  history?: any;\n  model?: string;\n\n  constructor(\n    chatClient: ChatClient,\n    id: string,\n    options?: {history?: any; model?: string}\n  ) {\n    this.chatClient = chatClient;\n    this.cmsClient = chatClient.cmsClient;\n    this.cmsPluginOptions = this.cmsClient.cmsPlugin.getConfig();\n    this.id = id;\n    this.history = options?.history;\n    this.model = options?.model;\n    if (!this.model) {\n      if (typeof this.cmsPluginOptions.experiments?.ai === 'object') {\n        if (this.cmsPluginOptions.experiments.ai.model) {\n          this.model = this.cmsPluginOptions.experiments.ai.model;\n        }\n      }\n    }\n  }\n\n  async sendPrompt(prompt: string | ChatPrompt | ChatPrompt[]): Promise<any> {\n    if (!genkitIsConfigured) {\n      const firebaseConfig = this.cmsPluginOptions.firebaseConfig;\n      configureGenkit({\n        plugins: [\n          vertexAI({\n            projectId: firebaseConfig.projectId,\n            // TODO(stevenle): figure out where to get this.\n            location: firebaseConfig.location || 'us-central1',\n          }),\n        ],\n      });\n      genkitIsConfigured = true;\n    }\n\n    let model = gemini15FlashPreview;\n    if (this.model === 'gemini-1.5-pro') {\n      model = gemini15ProPreview;\n    }\n\n    if (!this.history) {\n      // Seed the AI with information.\n      await this.initHistory();\n    }\n\n    // console.log('prompt:', prompt);\n    // if (this.history) {\n    //   console.log('history:', this.history);\n    // }\n    const res = await generate({\n      model: model,\n      prompt: prompt as any,\n      history: this.history,\n    });\n    console.log(res.text());\n    const history = res.toHistory();\n    this.history = history;\n    await this.dbDoc().update({history, modifiedAt: Timestamp.now()});\n    return res.text();\n  }\n\n  dbDoc() {\n    return this.chatClient.dbCollection().doc(this.id);\n  }\n\n  async initHistory() {\n    const systemText = [\n      `You are an assistant for a headless CMS called Root CMS which is used on a website called ${\n        this.cmsPluginOptions.name || this.cmsPluginOptions.id\n      }. Your job is to answer questions about the docs in the system, and if requested, help suggest changes to the JSON data in the docs. If you don't know the answer, just say that you don't know, don't try to make up an answer. Be friendly and playful with your messaging.`,\n      '',\n      'Here is the root.config.ts file for the site:',\n      '```',\n      JSON.stringify(this.cmsClient.rootConfig, null, 2),\n      '```',\n      '',\n      'Here are the docs that exist in the system:',\n    ];\n\n    // TODO(stevenle): read from all the collections in the system.\n    const pages = await this.cmsClient.listDocs('Pages', {mode: 'draft'});\n    pages.docs.forEach((doc: any) => {\n      systemText.push(JSON.stringify(doc));\n    });\n\n    this.history = [{role: 'system', content: [{text: systemText.join('\\n')}]}];\n    console.log(this.history);\n  }\n}\n\nexport class ChatClient {\n  cmsClient: RootCMSClient;\n  user: string;\n\n  constructor(cmsClient: RootCMSClient, user: string) {\n    this.cmsClient = cmsClient;\n    this.user = user;\n  }\n\n  async createChat(options?: {model?: string}): Promise<Chat> {\n    const chatId = crypto.randomUUID();\n    // Save chat to db so that user has a chat history and can enable \"sharing\"\n    // with others. Store the model used with the metadata.\n    const docRef = this.dbCollection().doc(chatId);\n    await docRef.set({\n      id: chatId,\n      createdBy: this.user,\n      createdAt: Timestamp.now(),\n      modifiedAt: Timestamp.now(),\n      model: options?.model || 'gemini-1.5-flash',\n    });\n    return new Chat(this, chatId);\n  }\n\n  async getChat(chatId: string): Promise<Chat> {\n    // Fetch chat from db to preserve the conversation's history.\n    const docRef = this.dbCollection().doc(chatId);\n    const chatDoc = await docRef.get();\n    if (!chatDoc.exists) {\n      throw new Error(`${chatId} does not exist`);\n    }\n    const chatData = chatDoc.data() || {};\n    return new Chat(this, chatId, {\n      history: chatData.history,\n      model: chatData.model,\n    });\n  }\n\n  async listChats(options?: {limit?: number}): Promise<any[]> {\n    const limit = options?.limit || 20;\n    const query = this.dbCollection()\n      .where('createdBy', '==', this.user)\n      .limit(limit)\n      .orderBy('createdAt', 'desc');\n    const res = await query.get();\n    return res.docs.map((doc) => doc.data());\n  }\n\n  dbCollection() {\n    return this.cmsClient.db.collection(\n      `Projects/${this.cmsClient.projectId}/Experiments/ai/Chat`\n    );\n  }\n}\n", "/**\n * Document verion history.\n *\n * Verions save the state of a document at different moments in time, allowing\n * users to revert back to a version if/when needed.\n *\n * The saveVersions() function is meant to be run within a cron job (e.g using\n * firebase functions). Every minute, the runner checks for all documents that\n * have been edited since the last run. To avoid saving \"partial\" versions\n * (when the user might be in the middle of editing a document), versions only\n * run on documents that haven't been edited within the last 5 mins to ensure\n * that version is \"stable\".\n *\n * In the database, versions are stored as:\n * /Projects/<projectId>/Collections/<collectionId>/Drafts/<docId>/Versions/<timestamp>\n *\n * Where <timestamp> is the unix timestamp (millis) that the document was last\n * edited.\n */\n\nimport path from 'node:path';\nimport {RootConfig} from '@blinkk/root';\nimport {Firestore, Query, Timestamp} from 'firebase-admin/firestore';\nimport glob from 'tiny-glob';\nimport {getCmsPlugin} from './client.js';\n\n// To avoid saving \"partial\" versions (when the user might be in the middle of\n// editing a document), versions only run on documents that haven't been edited\n// within the last 5 mins to ensure that version is \"stable\".\nconst DOCUMENT_SAVE_OFFSET = 5 * 60 * 1000;\n\ninterface PartialCMSDoc {\n  [key: string]: any;\n  id: string;\n  collection: string;\n  slug: string;\n  sys: {\n    modifiedAt: Timestamp;\n    modifiedBy: string;\n  };\n}\n\nexport class VersionsService {\n  private readonly rootConfig: RootConfig;\n  private readonly projectId: string;\n  private readonly db: Firestore;\n\n  constructor(rootConfig: RootConfig) {\n    this.rootConfig = rootConfig;\n    const cmsPlugin = getCmsPlugin(rootConfig);\n    const cmsPluginOptions = cmsPlugin.getConfig();\n    const projectId = cmsPluginOptions.id || 'default';\n    this.projectId = projectId;\n    this.db = cmsPlugin.getFirestore();\n  }\n\n  /**\n   * Saves a version of all documents that have been edited since the last run.\n   */\n  async saveVersions() {\n    // Offset the \"last run\" time by 5 mins. Versions ignore docs that were\n    // edited within the last 5 mins to avoid potential \"partial\" versions when\n    // user is in the middle of editing a document.\n    const lastRun = await this.getLastRun();\n    const lastRunWithOffset =\n      lastRun === 0 ? lastRun : lastRun - DOCUMENT_SAVE_OFFSET;\n    const changedDocs = await this.getDocsModifiedAfter(lastRunWithOffset);\n    const now = Timestamp.now().toMillis();\n    const versions = changedDocs.filter((doc) => {\n      const modifiedAt = doc.sys.modifiedAt.toMillis();\n      return modifiedAt <= now - DOCUMENT_SAVE_OFFSET;\n    });\n    if (versions.length > 0) {\n      this.saveVersionsToFirestore(versions);\n    }\n    this.saveLastRun(now);\n  }\n\n  private async saveVersionsToFirestore(versions: PartialCMSDoc[]) {\n    const batch = this.db.batch();\n    versions.forEach((version) => {\n      if (!version.collection || !version.slug || !version.sys?.modifiedAt) {\n        return;\n      }\n      const modifiedAtMillis = version.sys.modifiedAt.toMillis();\n      const versionPath = `Projects/${this.projectId}/Collections/${version.collection}/Drafts/${version.slug}/Versions/${modifiedAtMillis}`;\n      console.log(versionPath);\n      const versionRef = this.db.doc(versionPath);\n      batch.set(versionRef, version);\n    });\n    await batch.commit();\n    console.log(`versions: saved ${versions.length} versions`);\n  }\n\n  /**\n   * Returns the last time (in millis) saveVersions() was run, or 0 if has\n   * never been run.\n   */\n  private async getLastRun(): Promise<number> {\n    const projectDocRef = this.db.collection('Projects').doc(this.projectId);\n    const projectDoc = await projectDocRef.get();\n    if (projectDoc.exists) {\n      const data = projectDoc.data() || {};\n      const ts = data.versionsLastRun as Timestamp;\n      if (ts) {\n        return ts.toMillis();\n      }\n    }\n    return 0;\n  }\n\n  /**\n   * Saves {versionLastRun: <timestamp>} to the Projects/<projectId> doc.\n   */\n  private async saveLastRun(millis: number) {\n    const ts = Timestamp.fromMillis(millis);\n    const projectDocRef = this.db.collection('Projects').doc(this.projectId);\n    await projectDocRef.set({versionsLastRun: ts}, {merge: true});\n  }\n\n  /**\n   * Returns a list of all docs that were edited after a certain time.\n   */\n  private async getDocsModifiedAfter(millis: number): Promise<PartialCMSDoc[]> {\n    const ts = Timestamp.fromMillis(millis);\n    const results: PartialCMSDoc[] = [];\n    const collectionIds = await this.listCollections();\n    // NOTE: Individual collections are queried instead of using a\n    // collectionGroup query because the latter requires a firestore index to be\n    // set up.\n    for (const collectionId of collectionIds) {\n      const collectionPath = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;\n      const query: Query = this.db\n        .collection(collectionPath)\n        .where('sys.modifiedAt', '>=', ts);\n      const querySnapshot = await query.get();\n      querySnapshot.forEach((doc) => {\n        results.push(doc.data() as PartialCMSDoc);\n      });\n    }\n    return results;\n  }\n\n  /**\n   * Returns a list of collection ids for the Root project.\n   */\n  private async listCollections(): Promise<string[]> {\n    const collectionIds: string[] = [];\n    const collectionFileNames = await glob('*.schema.ts', {\n      cwd: path.join(this.rootConfig.rootDir, 'collections'),\n    });\n    collectionFileNames.forEach((filename) => {\n      collectionIds.push(filename.slice(0, -10));\n    });\n    return collectionIds;\n  }\n}\n", "import {parse as csvParse} from 'csv-parse/sync';\nimport {stringify as csvStringify} from 'csv-stringify/sync';\n\nexport function arrayToCsv(req: {\n  headers: string[];\n  rows: Array<Record<string, any>>;\n}): string {\n  const headers = req.headers || [];\n  const rows = req.rows || [];\n  return csvStringify(rows, {\n    header: true,\n    columns: headers,\n  });\n}\n\nexport function csvToArray(csvString: string) {\n  const rows = csvParse(csvString, {\n    columns: true,\n    skip_empty_lines: true,\n  });\n  return rows;\n}\n", "import {RootConfig} from '@blinkk/root';\nimport {Timestamp} from 'firebase-admin/firestore';\nimport {RootCMSClient, Translation, TranslationsDoc} from './client.js';\n\n/**\n * Runs compatibility checks to ensure the current version of root supports\n * any backwards-incompatible db changes.\n *\n * Compatibility versions are stored in the db in Projects/<projectId> under\n * the \"compatibility\" key. If the compatibility version is less than the\n * latest version, a backwards-friendly \"migration\" is done to ensure\n * compatibility on both the old and new versions.\n */\nexport async function runCompatibilityChecks(rootConfig: RootConfig) {\n  const cmsClient = new RootCMSClient(rootConfig);\n  const projectId = cmsClient.projectId;\n  const db = cmsClient.db;\n  const projectConfigDocRef = db.doc(`Projects/${projectId}`);\n  const projectConfigDoc = await projectConfigDocRef.get();\n  const projectConfig = projectConfigDoc.data() || {};\n\n  const compatibilityVersions = projectConfig.compatibility || {};\n  let versionsChanged = false;\n\n  const translationsVersion = compatibilityVersions.translations || 0;\n  if (translationsVersion < 2) {\n    await migrateTranslationsToV2(rootConfig, cmsClient);\n    compatibilityVersions.translations = 2;\n    versionsChanged = true;\n  }\n\n  if (versionsChanged) {\n    await projectConfigDocRef.update({compatibility: compatibilityVersions});\n    console.log('[root cms] updated db compatibility');\n  }\n}\n\n/**\n * Migrates translations from the \"v1\" format to \"v2\".\n */\nasync function migrateTranslationsToV2(\n  rootConfig: RootConfig,\n  cmsClient: RootCMSClient\n) {\n  if (rootConfig.experiments?.rootCmsDisableTranslationsToV2Check) {\n    return;\n  }\n\n  const projectId = cmsClient.projectId;\n  const db = cmsClient.db;\n  const dbPath = `Projects/${projectId}/Translations`;\n  const query = db.collection(dbPath);\n  const querySnapshot = await query.get();\n  if (querySnapshot.size === 0) {\n    return;\n  }\n\n  console.log('[root cms] updating translations v2 compatibility');\n\n  const translationsDocs: Record<string, TranslationsDoc> = {};\n  querySnapshot.forEach((doc) => {\n    const hash = doc.id;\n    const translation = doc.data() as Translation;\n    const tags = (translation.tags || []) as string[];\n    delete translation.tags;\n    for (const tag of tags) {\n      if (tag.includes('/')) {\n        const translationsId = tag.replaceAll('/', '--');\n        translationsDocs[translationsId] ??= {\n          id: translationsId,\n          sys: {\n            modifiedAt: Timestamp.now(),\n            modifiedBy: 'root-cms-client',\n            publishedAt: Timestamp.now(),\n            publishedBy: 'root-cms-client',\n            tags: tags,\n          },\n          strings: {},\n        };\n        translationsDocs[translationsId].strings[hash] = translation;\n      }\n    }\n  });\n\n  if (Object.keys(translationsDocs).length === 0) {\n    console.log('[root cms] no translations to save');\n    return;\n  }\n\n  // Move the doc's \"l10nSheet\" to the translations doc's \"linkedSheet\".\n\n  for (const docId in translationsDocs) {\n    const [collection, slug] = docId.split('/');\n    if (collection && slug) {\n      const doc: any = await cmsClient.getDoc(collection, slug, {\n        mode: 'draft',\n      });\n      const linkedSheet = doc?.sys?.l10nSheet;\n      if (linkedSheet) {\n        translationsDocs[docId].sys.linkedSheet = linkedSheet;\n      }\n    }\n  }\n\n  const batch = db.batch();\n  Object.entries(translationsDocs).forEach(([translationsId, data]) => {\n    const draftRef = db.doc(\n      `Projects/${projectId}/TranslationsManager/draft/Translations/${translationsId}`\n    );\n    const publishedRef = db.doc(\n      `Projects/${projectId}/TranslationsManager/published/Translations/${translationsId}`\n    );\n    batch.set(draftRef, data, {merge: true});\n    batch.set(publishedRef, data, {merge: true});\n    const len = Object.keys(data.strings).length;\n    console.log(`[root cms] saving ${len} string(s) to ${translationsId}...`);\n  });\n  await batch.commit();\n\n  console.log('[root cms] done migrating translations to v2');\n}\n", "import {\n  GetStaticPaths,\n  GetStaticProps,\n  HandlerContext,\n  Request,\n  Response,\n  RouteParams,\n} from '@blinkk/root';\nimport {BatchRequest, RootCMSClient} from './client.js';\n\nexport type CMSRequest = Request & {\n  cmsClient: RootCMSClient;\n};\n\nexport interface CMSRouteContext {\n  /** HTTP request object. Only available in SSR mode. */\n  req?: CMSRequest;\n  slug: string;\n  mode: 'draft' | 'published';\n  cmsClient: RootCMSClient;\n}\n\nexport interface CMSRouteOptions {\n  /**\n   * Collection mapped to the route.\n   */\n  collection: string;\n\n  /**\n   * Route param name used for the slug. Used for dynamic routes, e.g.\n   * `[...slug].tsx`. Defaults to \"slug\".\n   */\n  slugParam?: string;\n\n  /**\n   * Slug to use for the route. Used for non-dynamic, single-document routes.\n   */\n  slug?: string;\n\n  /**\n   * Hook that allows callers to modify the Root CMS `BatchRequest` object. If a\n   * new `BatchRequest` is returned, it will replace the default one created by\n   * `cmsRoute()`.\n   */\n  preRequestHook?: (\n    batchRequest: BatchRequest,\n    context: CMSRouteContext\n  ) => void | BatchRequest;\n\n  /**\n   * Callback function that returns a map of Promises that contain fetched data.\n   * Once the promise is resolved, the values are injected into page's props\n   * for rendering.\n   */\n  fetchData?: (context: CMSRouteContext) => Record<string, Promise<any>>;\n\n  /**\n   * Hook for amending any props values before being passed to the page\n   * component.\n   */\n  preRenderHook?: (props: any, context: CMSRouteContext) => any | Promise<any>;\n\n  /**\n   * Hook for setting any response headers.\n   */\n  setResponseHeaders?: (req: Request, res: Response) => void;\n\n  /**\n   * Sets Cache-Control header to `private`.\n   */\n  disableCacheControl?: boolean;\n\n  /**\n   * Enables SSG mode for sites that serve on SCS or other static servers.\n   */\n  enableSSG?: boolean;\n}\n\nexport interface CMSDoc {\n  id: string;\n  slug: string;\n  sys?: {\n    locales?: string[];\n  };\n}\n\n/**\n * Utility for generating SSR and SSG handlers in a Root route file.\n */\nexport function cmsRoute(options: CMSRouteOptions) {\n  let cmsClient: RootCMSClient | null = null;\n\n  function getSlug(params: RouteParams) {\n    if (options.slug) {\n      return options.slug;\n    }\n    const slugParam = options.slugParam || 'slug';\n    return (params[slugParam] || 'index').replaceAll('/', '--');\n  }\n\n  async function fetchData(\n    fetchOptions: CMSRouteContext\n  ): Promise<Record<string, any>> {\n    if (!options.fetchData) {\n      return {};\n    }\n    const promisesMap = options.fetchData(fetchOptions);\n    return resolvePromisesMap(promisesMap);\n  }\n\n  async function generateProps(\n    routeContext: CMSRouteContext,\n    preferredLocale: string | ((doc: CMSDoc) => string)\n  ) {\n    const {slug, mode} = routeContext;\n\n    const primaryDocId = `${options.collection}/${slug}`;\n    let batchRequest = routeContext.cmsClient.createBatchRequest({\n      mode,\n      translate: true,\n    });\n    batchRequest.addDoc(primaryDocId);\n\n    // Call the pre-request hook to allow users to modify the batch request.\n    if (options.preRequestHook) {\n      const overridedBatchRequest = options.preRequestHook(\n        batchRequest,\n        routeContext\n      );\n      if (overridedBatchRequest) {\n        batchRequest = overridedBatchRequest;\n      }\n    }\n\n    // Fetch the Root CMS BatchRequest in parallel with any other data the\n    // caller needs to fetch to render the route.\n    const [batchRes, data] = await Promise.all([\n      batchRequest.fetch(),\n      fetchData(routeContext),\n    ]);\n    const doc = batchRes.docs[primaryDocId];\n    if (!doc) {\n      return {notFound: true};\n    }\n\n    // Determine the preferred locale to render.\n    let locale: string;\n    if (typeof preferredLocale === 'string') {\n      locale = preferredLocale;\n    } else {\n      locale = preferredLocale(doc);\n    }\n    const docLocales = doc.sys?.locales || ['en'];\n    if (!locale || !docLocales.includes(locale)) {\n      return {notFound: true};\n    }\n\n    // From the preferred locale, generate a translations map.\n    const i18nFallbacks =\n      routeContext.cmsClient.rootConfig.i18n?.fallbacks || {};\n    const translationFallbackLocales = i18nFallbacks[locale] || [locale];\n    const translations = batchRes.getTranslations(translationFallbackLocales);\n\n    let props: any = {...data, locale, mode, slug, doc};\n\n    // For SSR handlers, inject the user's country of origin to props.\n    if (routeContext.req) {\n      const country =\n        getFirstQueryParam(routeContext.req, 'gl') ||\n        routeContext.req.get('x-country-code') ||\n        routeContext.req.get('x-appengine-country') ||\n        null;\n      props.country = country;\n    }\n\n    // Call the pre-render hook which allows a caller to modify props before\n    // it is passed to the route component.\n    if (options.preRenderHook) {\n      props = await options.preRenderHook(props, routeContext);\n    }\n\n    return {props, locale, translations};\n  }\n\n  // SSG handlers are disabled by default. Pass `{enableSSG: true}` to enable.\n  let getStaticPaths: GetStaticPaths | null = null;\n  let getStaticProps: GetStaticProps | null = null;\n\n  if (options.enableSSG) {\n    getStaticPaths = async (ctx) => {\n      if (!options.slugParam) {\n        return {paths: []};\n      }\n      if (!cmsClient) {\n        cmsClient = new RootCMSClient(ctx.rootConfig);\n      }\n      const mode = 'published';\n      const res = await cmsClient.listDocs<CMSDoc>(options.collection, {mode});\n      const ssgPaths: Array<{params: Record<string, string>}> = [];\n      res.docs.forEach((doc) => {\n        const params: Record<string, string> = {};\n        params[options.slugParam!] = doc.slug;\n        ssgPaths.push({params});\n      });\n      return {paths: ssgPaths};\n    };\n\n    getStaticProps = async (ctx) => {\n      if (!cmsClient) {\n        cmsClient = new RootCMSClient(ctx.rootConfig);\n      }\n      const slug = getSlug(ctx.params);\n      const mode = 'published';\n      const routeContext: CMSRouteContext = {slug, mode, cmsClient};\n      return generateProps(routeContext, ctx.params.$locale);\n    };\n  }\n\n  return {\n    // SSG handlers (only enabled with `{enableSSG: true}`).\n    getStaticPaths: getStaticPaths,\n    getStaticProps: getStaticProps,\n\n    // SSR handler.\n    handle: async (req: CMSRequest, res: Response) => {\n      if (!cmsClient) {\n        cmsClient = new RootCMSClient(req.rootConfig!);\n      }\n      req.cmsClient = cmsClient;\n      const ctx = req.handlerContext as HandlerContext;\n      const slug = getSlug(ctx.params);\n      if (slug.includes('.')) {\n        res.setHeader('cache-control', 'private');\n        return ctx.render404();\n      }\n      const mode = String(req.query.preview) === 'true' ? 'draft' : 'published';\n      const routeContext: CMSRouteContext = {req, slug, mode, cmsClient};\n\n      function getLocale(doc: CMSDoc) {\n        const docLocales = doc.sys?.locales || ['en'];\n        let locale = ctx.route.locale;\n        if (ctx.route.isDefaultLocale) {\n          locale = ctx.getPreferredLocale(docLocales);\n          if (docLocales.length > 0 && !docLocales.includes(locale)) {\n            locale = docLocales[0];\n          }\n        }\n        return locale;\n      }\n\n      const resData = await generateProps(routeContext, getLocale);\n      if (resData.notFound) {\n        res.setHeader('cache-control', 'private');\n        return ctx.render404();\n      }\n\n      const {props, locale, translations} = resData;\n\n      if (props.$redirect) {\n        const redirectCode = props.$redirectCode || 302;\n        console.log(`redirecting to: ${props.$redirect} (${redirectCode})`);\n        redirectWithQuery(req, res, redirectCode, props.$redirect);\n        return;\n      }\n\n      if (options.disableCacheControl) {\n        res.setHeader('cache-control', 'private');\n      } else if (mode === 'published') {\n        res.setHeader('cache-control', 'public, max-age=15, s-maxage=30');\n        if (ctx.route.isDefaultLocale) {\n          res.setHeader('vary', 'accept-language, x-country-code');\n        }\n      }\n      if (options.setResponseHeaders) {\n        options.setResponseHeaders(req, res);\n      }\n      return ctx.render(props, {locale, translations});\n    },\n  };\n}\n\nexport async function resolvePromisesMap(\n  promisesMap: Record<string, Promise<any>>\n): Promise<Record<string, any>> {\n  const keys = Object.keys(promisesMap);\n  const promises = Object.values(promisesMap);\n  const results = await Promise.all(promises);\n  const resultMap: Record<string, any> = {};\n  keys.forEach((key, index) => {\n    resultMap[key] = results[index];\n  });\n  return resultMap;\n}\n\n/**\n * Returns the first query param value in a given request.\n *\n * For example, for a URL like `/?foo=bar&foo=baz`, calling\n * `getFirstQueryParam(req, 'foo')` would return `\"bar\"`.\n */\nfunction getFirstQueryParam(req: Request, key: string): string | null {\n  const val = req.query[key];\n  if (val === null || val === undefined) {\n    return null;\n  }\n  if (Array.isArray(val)) {\n    if (val.length === 0) {\n      return null;\n    }\n    return String(val[0]);\n  }\n  return String(val);\n}\n\n/**\n * Issues an HTTP redirect, preserving any query params from the original req.\n */\nexport function redirectWithQuery(\n  req: Request,\n  res: Response,\n  redirectCode: number,\n  redirectPath: string\n) {\n  // Only preserve query params for relative urls.\n  if (!redirectPath.startsWith('/')) {\n    res.redirect(redirectCode, redirectPath);\n    return;\n  }\n  const queryStr = getQueryStr(req);\n  const redirectUrl = queryStr ? `${redirectPath}?${queryStr}` : redirectPath;\n  res.redirect(redirectCode, redirectUrl);\n}\n\n/**\n * Returns the query string for a request, or empty string if no query.\n */\nfunction getQueryStr(req: Request): string {\n  const qIndex = req.originalUrl.indexOf('?');\n  if (qIndex === -1) {\n    return '';\n  }\n  return req.originalUrl.slice(qIndex + 1);\n}\n", "/** @deprecated Use client.ts instead. */\n\nimport {RootConfig} from '@blinkk/root';\nimport {FieldValue, Query, Timestamp} from 'firebase-admin/firestore';\nimport {\n  LoadTranslationsOptions,\n  LocaleTranslations,\n  Translation,\n  TranslationsMap,\n  getCmsPlugin,\n  translationsForLocale,\n  unmarshalData,\n} from './client.js';\n\n/**\n * Retrieves a doc from Root.js CMS.\n * @deprecated Use RootCMSClient.getDoc() instead.\n */\nexport async function getDoc<T>(\n  rootConfig: RootConfig,\n  collectionId: string,\n  slug: string,\n  options: {\n    mode: 'draft' | 'published';\n  }\n): Promise<T | null> {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const mode = options.mode;\n  const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n  const db = cmsPlugin.getFirestore();\n  // Slugs with slashes are encoded as `--` in the DB.\n  slug = slug.replaceAll('/', '--');\n  const dbPath = `Projects/${projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;\n  const docRef = db.doc(dbPath);\n  const doc = await docRef.get();\n  if (doc.exists) {\n    const data = doc.data();\n    return unmarshalData(data) as T;\n  }\n  console.log(`doc not found: ${dbPath}`);\n  return null;\n}\n\n/**\n * Lists docs from a Root.js CMS collection.\n * @deprecated Use RootCMSClient.listDocs() instead.\n */\nexport async function listDocs<T>(\n  rootConfig: RootConfig,\n  collectionId: string,\n  options: {\n    mode: 'draft' | 'published';\n    offset?: number;\n    limit?: number;\n    orderBy?: string;\n    orderByDirection?: 'asc' | 'desc';\n    query?: (query: Query) => Query;\n  }\n): Promise<{docs: T[]}> {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const mode = options.mode;\n  const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n  const db = cmsPlugin.getFirestore();\n  const dbPath = `Projects/${projectId}/Collections/${collectionId}/${modeCollection}`;\n  let query: Query = db.collection(dbPath);\n  if (options.limit) {\n    query = query.limit(options.limit);\n  }\n  if (options.offset) {\n    query = query.offset(options.offset);\n  }\n  if (options.orderBy) {\n    query = query.orderBy(options.orderBy, options.orderByDirection);\n  }\n  if (options.query) {\n    query = options.query(query);\n  }\n  const results = await query.get();\n  const docs: T[] = [];\n  results.forEach((result) => {\n    const doc = unmarshalData(result.data()) as T;\n    docs.push(doc);\n  });\n  return {docs};\n}\n\n/**\n * Returns the number of docs in a Root.js CMS collection.\n * @deprecated Use RootCMSClient.getDocsCount() instead.\n */\nexport async function numDocs(\n  rootConfig: RootConfig,\n  collectionId: string,\n  options: {\n    mode: 'draft' | 'published';\n    query?: (query: Query) => Query;\n  }\n) {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const mode = options.mode;\n  const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n  const db = cmsPlugin.getFirestore();\n  const dbPath = `Projects/${projectId}/Collections/${collectionId}/${modeCollection}`;\n  let query: Query = db.collection(dbPath);\n  if (options.query) {\n    query = options.query(query);\n  }\n  const results = await query.count().get();\n  const count = results.data().count;\n  return count;\n}\n\n/**\n * Publishes scheduled docs.\n * @deprecated Use RootCMSClient.publishScheduledDocs() instead.\n */\nexport async function publishScheduledDocs(rootConfig: RootConfig) {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const db = cmsPlugin.getFirestore();\n\n  const projectCollectionsPath = `Projects/${projectId}/Collections`;\n  const now = Math.ceil(new Date().getTime());\n\n  const snapshot = await db.collectionGroup('Scheduled').get();\n  const docs = snapshot.docs\n    .filter((d) => {\n      // Filter docs by project.\n      if (!d.ref.path.startsWith(projectCollectionsPath)) {\n        return false;\n      }\n      // Filter docs where scheduledAt is in the past.\n      // NOTE(stevenle): the filtering is done manually instead of using a query\n      // to avoid having to create an index in firestore.\n      const data = d.data() || {};\n      const scheduledAt: Timestamp | undefined = data.sys?.scheduledAt;\n      return (\n        scheduledAt && scheduledAt.toMillis && scheduledAt.toMillis() <= now\n      );\n    })\n    .map((d) => {\n      const dbPath = d.ref.path;\n      const segments = dbPath.split('/');\n      const slug = segments.at(-1);\n      const collection = segments.at(-3);\n      const id = `${collection}/${slug}`;\n      return {\n        data: d.data(),\n        id,\n        collection,\n        slug,\n      };\n    });\n\n  if (docs.length === 0) {\n    return [];\n  }\n\n  // Each transaction or batch can write a max of 500 ops.\n  // https://firebase.google.com/docs/firestore/manage-data/transactions\n  let batchCount = 0;\n  const batch = db.batch();\n  const publishedDocs: any[] = [];\n  for (const doc of docs) {\n    const {id, collection, slug, data} = doc;\n    const draftRef = db.doc(\n      `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n    );\n    const scheduledRef = db.doc(\n      `${projectCollectionsPath}/${collection}/Scheduled/${slug}`\n    );\n    const publishedRef = db.doc(\n      `${projectCollectionsPath}/${collection}/Published/${slug}`\n    );\n    const {scheduledAt, scheduledBy, ...sys} = data.sys || {};\n\n    // Only update `firstPublished` if it doesn't already exist.\n    const firstPublishedAt = sys.firstPublishedAt ?? scheduledAt;\n    const firstPublishedBy = sys.firstPublishedBy ?? (scheduledBy || '');\n\n    // Save published doc.\n    batch.set(publishedRef, {\n      id,\n      collection,\n      slug,\n      fields: data.fields || {},\n      sys: {\n        ...sys,\n        firstPublishedAt: firstPublishedAt,\n        firstPublishedBy: firstPublishedBy,\n        publishedAt: FieldValue.serverTimestamp(),\n        publishedBy: scheduledBy || '',\n      },\n    });\n    batchCount += 1;\n\n    // Remove published doc.\n    batch.delete(scheduledRef);\n    batchCount += 1;\n\n    // Update the draft doc to remove `scheduledAt` and `scheduledBy` fields\n    // and update the `publishedAt` and `publishedBy` fields.\n    batch.update(draftRef, {\n      'sys.scheduledAt': FieldValue.delete(),\n      'sys.scheduledBy': FieldValue.delete(),\n      'sys.firstPublishedAt': firstPublishedAt,\n      'sys.firstPublishedBy': firstPublishedBy,\n      'sys.publishedAt': FieldValue.serverTimestamp(),\n      'sys.publishedBy': scheduledBy || '',\n    });\n    batchCount += 1;\n\n    publishedDocs.push(doc);\n\n    if (batchCount >= 498) {\n      break;\n    }\n  }\n\n  await batch.commit();\n  console.log(`published ${publishedDocs.length} docs!`);\n  return publishedDocs;\n}\n\n/**\n * @deprecated Use `RootCMSClient.loadTranslations()`.\n */\nexport async function loadTranslations(\n  rootConfig: RootConfig,\n  options?: LoadTranslationsOptions\n): Promise<TranslationsMap> {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const db = cmsPlugin.getFirestore();\n\n  const dbPath = `Projects/${projectId}/Translations`;\n  let query: Query = db.collection(dbPath);\n  if (options?.tags) {\n    query = query.where('tags', 'array-contains-any', options.tags);\n  }\n\n  const querySnapshot = await query.get();\n  const translationsMap: TranslationsMap = {};\n  querySnapshot.forEach((doc) => {\n    const hash = doc.id;\n    translationsMap[hash] = doc.data() as Translation;\n  });\n  return translationsMap;\n}\n\n/**\n * @deprecated Use `RootCMSClient.loadTranslationsForLocale()`.\n */\nexport async function loadTranslationsForLocale(\n  rootConfig: RootConfig,\n  locale: string,\n  options?: LoadTranslationsOptions\n): Promise<LocaleTranslations> {\n  const translationsMap = await loadTranslations(rootConfig, options);\n  return translationsForLocale(translationsMap, locale);\n}\n", "import {FunctionalComponent} from 'preact';\n\nexport interface CommonFieldProps {\n  type: string;\n  id?: string;\n  label?: string;\n  help?: string;\n  placeholder?: string;\n  default?: any;\n  hidden?: boolean;\n  deprecated?: boolean;\n  /** Hides the field label in the CMS UI. */\n  hideLabel?: boolean;\n}\n\nexport type StringField = CommonFieldProps & {\n  type: 'string';\n  default?: string;\n  translate?: boolean;\n  variant?: 'input' | 'textarea';\n  /** For textarea variant, the maximum number of rows of text to show. */\n  maxRows?: number;\n};\n\nexport function string(field: Omit<StringField, 'type'>): StringField {\n  return {...field, type: 'string'};\n}\n\nexport type NumberField = CommonFieldProps & {\n  type: 'number';\n  default?: number;\n};\n\nexport function number(field: Omit<NumberField, 'type'>): NumberField {\n  return {...field, type: 'number'};\n}\n\nexport type DateField = CommonFieldProps & {\n  type: 'date';\n  default?: string;\n};\n\nexport function date(field: Omit<DateField, 'type'>): DateField {\n  return {...field, type: 'date'};\n}\n\nexport type DateTimeField = CommonFieldProps & {\n  type: 'datetime';\n  default?: string;\n};\n\nexport function datetime(field: Omit<DateTimeField, 'type'>): DateTimeField {\n  return {...field, type: 'datetime'};\n}\n\nexport type BooleanField = CommonFieldProps & {\n  type: 'boolean';\n  default?: boolean;\n  checkboxLabel?: string;\n};\n\nexport function boolean(field: Omit<BooleanField, 'type'>): BooleanField {\n  return {...field, type: 'boolean'};\n}\n\nexport type SelectField = CommonFieldProps & {\n  type: 'select';\n  default?: string;\n  options?: Array<{value: string; label?: string}> | string[];\n  translate?: boolean;\n};\n\nexport function select(field: Omit<SelectField, 'type'>): SelectField {\n  return {...field, type: 'select'};\n}\n\nexport type MultiSelectField = Omit<SelectField, 'type'> & {\n  type: 'multiselect';\n  /** Set to `true` to allow users to create arbitrary values. */\n  creatable?: boolean;\n  translate?: boolean;\n};\n\nexport function multiselect(\n  field: Omit<MultiSelectField, 'type'>\n): MultiSelectField {\n  return {...field, type: 'multiselect'};\n}\n\nexport type ImageField = CommonFieldProps & {\n  type: 'image';\n  translate?: boolean;\n  /** List of supported exts, e.g. `['.mp4']`. */\n  exts?: string[];\n  /**\n   * Cache-control header to set on the GCS object.\n   */\n  cacheControl?: string;\n};\n\nexport function image(field: Omit<ImageField, 'type'>): ImageField {\n  return {...field, type: 'image'};\n}\n\nexport type FileField = CommonFieldProps & {\n  type: 'file';\n  /** List of supported exts, e.g. `['.mp4']`. */\n  exts?: string[];\n  /**\n   * Whether to preserve the final serving filename when a user uploads a file.\n   * By default, the filename is hashed for obfuscation purposes.\n   */\n  preserveFilename?: boolean;\n  /**\n   * Cache-control header to set on the GCS object.\n   */\n  cacheControl?: string;\n};\n\nexport function file(field: Omit<FileField, 'type'>): FileField {\n  return {...field, type: 'file'};\n}\n\nexport type ObjectField = CommonFieldProps & {\n  type: 'object';\n  fields: FieldWithId[];\n  /** Defaults to \"drawer\". */\n  variant?: 'drawer' | 'inline';\n  /** Options for the \"drawer\" variant. */\n  drawerOptions?: {\n    /** Whether the drawer should initialize to the \"collapsed\" state. */\n    collapsed?: boolean;\n    /**\n     * Whether to render the drawer \"inline\" (this removes borders from the\n     * toggle button).\n     */\n    inline?: boolean;\n  };\n};\n\nexport function object(field: Omit<ObjectField, 'type'>): ObjectField {\n  return {...field, type: 'object'};\n}\n\nexport type ArrayField = CommonFieldProps & {\n  type: 'array';\n  default?: any[];\n  /**\n   * String format for the preview line of an item in the array. Placeholder\n   * values should use brackets, e.g. `m{_index:02}: {_type}`.\n   *\n   * Multiple values can be provided, in which case the first preview line with\n   * no missing placeholder values will be used.\n   *\n   * System added placeholder values:\n   *\n   * - _index: The 0-based index.\n   * - _index:02: A left-padded version of _index to 2 digits.\n   * - _index:03: A left-padded version of _index to 3 digits.\n   * - _type: For array of one-of fields, the type of the selected field.\n   */\n  preview?: string | string[];\n  // NOTE(stevenle): the array field should only accept object values to keep\n  // the schemas future-friendly. For example, if we were to accept primatives\n  // (e.g. Array<string>) and the developer decides in the future that they\n  // need to add extra fields to that array type, they would have to create a\n  // new field, create a new schema field, and then perform a db migration to\n  // update from the old field type to the new field type. But if we enforce\n  // objects here, a developer should technically be able to add fields to the\n  // nested field definition without breaking any existing db entries.\n  of: ObjectLikeField;\n  /**\n   * Label to use for the \"add item\" button. Defaults to `Add`.\n   */\n  buttonLabel?: string;\n};\n\nexport function array(field: Omit<ArrayField, 'type'>): ArrayField {\n  return {...field, type: 'array'};\n}\n\nexport type OneOfField = CommonFieldProps & {\n  type: 'oneof';\n  types: Schema[];\n};\n\nexport function oneOf(field: Omit<OneOfField, 'type'>): OneOfField {\n  return {...field, type: 'oneof'};\n}\n\nexport type RichTextField = CommonFieldProps & {\n  type: 'richtext';\n  translate?: boolean;\n  placeholder?: string;\n};\n\nexport function richtext(field: Omit<RichTextField, 'type'>): RichTextField {\n  return {...field, type: 'richtext'};\n}\n\nexport type ReferenceField = CommonFieldProps & {\n  type: 'reference';\n  /** List of collection ids the reference can be chosen from. */\n  collections?: string[];\n  /** Initial collection to show when picking a reference. */\n  initialCollection?: string;\n  /** Label for the button. Defaults to \"Select\". */\n  buttonLabel?: string;\n};\n\nexport function reference(field: Omit<ReferenceField, 'type'>): ReferenceField {\n  return {...field, type: 'reference'};\n}\n\nexport type Field =\n  | StringField\n  | NumberField\n  | DateField\n  | DateTimeField\n  | BooleanField\n  | SelectField\n  | MultiSelectField\n  | ImageField\n  | FileField\n  | ObjectField\n  | ArrayField\n  | OneOfField\n  | RichTextField\n  | ReferenceField;\n\n/**\n * Similar to {@link Field} but with a required `id`.\n * TODO(stevenle): fix this.\n */\nexport type FieldWithId = Field;\n\nexport type ObjectLikeField =\n  | ImageField\n  | FileField\n  | ObjectField\n  | OneOfField\n  | ReferenceField;\n\nexport interface Schema {\n  name: string;\n  description?: string;\n  fields: FieldWithId[];\n}\n\nexport function defineSchema(schema: Schema): Schema {\n  return schema;\n}\n\n/** Defines the schema for a collection or reusable component. */\nexport const define = defineSchema;\n\nexport type Collection = Schema & {\n  /**\n   * Domain where the collection serves from. Used for multi-domain sites,\n   * defaults to the \"domain\" value `from root.config.ts`.\n   */\n  domain?: string;\n  /**\n   * URL path where the collection serves from. This is what's displayed in the\n   * preview pane in the CMS.\n   */\n  url?: string;\n  /**\n   * URL that can be used to render a preview page. Used by the side-by-side\n   * editor to render instant previews. If blank, defaults to the `url` config.\n   */\n  previewUrl?: string;\n  /** Page component to render the collection for instant previews */\n  Component?: FunctionalComponent;\n  /**\n   * Defines the fields to use for document preview. Defaults to \"title\" and\n   * \"image\". Use dot notation for nested fields, e.g. \"meta.title\".\n   */\n  preview?: {\n    title?: string;\n    image?: string;\n    defaultImage?: {\n      src: string;\n    };\n  };\n};\n\nexport function defineCollection(collection: Collection): Collection {\n  return collection;\n}\n\nexport const collection = defineCollection;\n"],
  "mappings": "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",
  "names": ["crypto", "Timestamp", "path", "Timestamp", "Timestamp", "path", "plugin", "collection", "Timestamp", "crypto", "string", "obj", "locale", "FieldValue", "collection", "FieldValue", "collection"]
}
