@plasmicpkgs/plasmic-cms 0.0.284 → 0.0.285

package/dist/index.esm.js

@@ -0,0 +1,1531 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.tsx
+import registerComponent from "@plasmicapp/host/registerComponent";
+import registerGlobalContext from "@plasmicapp/host/registerGlobalContext";
+
+// src/components.tsx
+import { repeatedElement, usePlasmicCanvasContext } from "@plasmicapp/host";
+import { usePlasmicQueryData } from "@plasmicapp/query";
+import dayjs from "dayjs";
+import React2 from "react";
+
+// src/api.ts
+function queryParamsToApi(params) {
+  return {
+    where: params.where,
+    limit: params.limit,
+    offset: params.offset,
+    order: params.orderBy ? [
+      {
+        field: params.orderBy,
+        dir: params.desc ? "desc" : "asc"
+      }
+    ] : void 0,
+    fields: params.fields
+  };
+}
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+var API = class {
+  constructor(config) {
+    this.config = config;
+  }
+  get(_0) {
+    return __async(this, arguments, function* (endpoint, params = {}) {
+      var _a;
+      const url = new URL(
+        `${this.config.host}/api/v1/cms/databases/${this.config.databaseId}${endpoint}`
+      );
+      const fixedParams = Object.keys(params).reduce((newObj, key) => {
+        const value = params[key];
+        if (value != null) {
+          newObj[key] = value;
+        }
+        return newObj;
+      }, {});
+      url.search = new URLSearchParams(fixedParams).toString();
+      const response = yield fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          accept: "*/*",
+          "x-plasmic-api-cms-tokens": `${this.config.databaseId}:${this.config.databaseToken}`
+        },
+        mode: "cors"
+      });
+      if (response.status !== 200) {
+        let message = yield response.text();
+        try {
+          const json = JSON.parse(message);
+          if ((_a = json.error) == null ? void 0 : _a.message) {
+            message = json.error.message;
+          }
+        } catch (e) {
+        }
+        throw new HttpError(response.status, message);
+      }
+      return yield response.json();
+    });
+  }
+  fetchTables() {
+    return __async(this, null, function* () {
+      try {
+        const response = yield this.get(``);
+        return response.tables;
+      } catch (e) {
+        console.error(e);
+        throw e;
+      }
+    });
+  }
+  useDraftForTable(table) {
+    var _a;
+    if (Array.isArray(this.config.useDraft)) {
+      return this.config.useDraft.includes(table);
+    } else {
+      return (_a = this.config.useDraft) != null ? _a : false;
+    }
+  }
+  query(_0) {
+    return __async(this, arguments, function* (table, params = {}) {
+      try {
+        const response = yield this.get(`/tables/${table}/query`, {
+          q: JSON.stringify(queryParamsToApi(params)),
+          draft: Number(this.useDraftForTable(table) || params.useDraft),
+          locale: this.config.locale
+        });
+        return response.rows;
+      } catch (e) {
+        console.error(e);
+        throw e;
+      }
+    });
+  }
+  count(_0) {
+    return __async(this, arguments, function* (table, params = {}) {
+      try {
+        const response = yield this.get(`/tables/${table}/count`, {
+          q: JSON.stringify(queryParamsToApi(params)),
+          draft: Number(this.useDraftForTable(table) || params.useDraft)
+        });
+        return response.count;
+      } catch (e) {
+        console.error(e);
+        throw e;
+      }
+    });
+  }
+};
+function mkApi(config) {
+  if (!config) {
+    throw new Error("Component must be wrapped in 'CMS Data Provider'.");
+  }
+  return new API(config);
+}
+
+// src/constants.ts
+var DEFAULT_HOST = "https://data.plasmic.app";
+
+// src/context.tsx
+import {
+  DataProvider,
+  useDataEnv,
+  useSelector
+} from "@plasmicapp/host";
+import React from "react";
+var contextPrefix = "plasmicCms";
+var databaseContextKey = `${contextPrefix}Database`;
+var tablesContextKey = `${contextPrefix}Tables`;
+var tableSchemaContextKey = `${contextPrefix}TableSchema`;
+var collectionResultSuffix = `Collection`;
+var mkQueryContextKey = (table) => `${contextPrefix}${capitalizeFirst(table)}${collectionResultSuffix}`;
+var itemContextSuffix = `Item`;
+var countContextSuffix = `Count`;
+var modeContextSuffix = `Mode`;
+var mkRowContextKey = (table) => `${contextPrefix}${capitalizeFirst(table)}${itemContextSuffix}`;
+var mkCountContextKey = (table) => `${contextPrefix}${capitalizeFirst(table)}${countContextSuffix}`;
+var mkModeContextKey = (table) => `${contextPrefix}${capitalizeFirst(table)}${modeContextSuffix}`;
+function capitalizeFirst(str) {
+  var _a;
+  return ((_a = str[0]) == null ? void 0 : _a.toUpperCase()) + str.slice(1);
+}
+function useDatabase() {
+  return useSelector(databaseContextKey);
+}
+function makeDatabaseCacheKey(config) {
+  if (!config) {
+    return null;
+  }
+  const _a = config, { databaseToken } = _a, rest = __objRest(_a, ["databaseToken"]);
+  return JSON.stringify(rest);
+}
+function DatabaseProvider({
+  config,
+  children
+}) {
+  return /* @__PURE__ */ React.createElement(DataProvider, { name: databaseContextKey, data: config, hidden: true }, children);
+}
+function useTables() {
+  return useSelector(tablesContextKey);
+}
+function TablesProvider({
+  children,
+  tables
+}) {
+  return /* @__PURE__ */ React.createElement(DataProvider, { name: tablesContextKey, data: tables, hidden: true }, children);
+}
+function TableSchemaProvider({
+  children,
+  table
+}) {
+  var _a, _b;
+  const tables = useTables();
+  let schema;
+  if (tables && (tables == null ? void 0 : tables.length) > 0) {
+    if (!table) {
+      schema = (_a = tables[0]) == null ? void 0 : _a.schema;
+    } else {
+      schema = (_b = tables == null ? void 0 : tables.find((t) => (t == null ? void 0 : t.identifier) === table)) == null ? void 0 : _b.schema;
+    }
+  }
+  return /* @__PURE__ */ React.createElement(DataProvider, { name: tableSchemaContextKey, data: schema }, children);
+}
+function getClosestMatchingKeysBy(env, pred) {
+  return [...Object.keys(env).reverse()].filter((key) => pred(key));
+}
+function QueryResultProvider({
+  children,
+  table,
+  rows,
+  hidden
+}) {
+  return /* @__PURE__ */ React.createElement(
+    DataProvider,
+    {
+      name: table ? mkModeContextKey(table) : void 0,
+      data: "rows",
+      hidden: true
+    },
+    /* @__PURE__ */ React.createElement(
+      DataProvider,
+      {
+        name: table ? mkQueryContextKey(table) : void 0,
+        data: rows,
+        hidden
+      },
+      children
+    )
+  );
+}
+function useTablesWithDataLoaded(mode) {
+  const env = useDataEnv();
+  const tables = useTables();
+  if (!env) {
+    return void 0;
+  }
+  if (!tables) {
+    return void 0;
+  }
+  const matchingKeys = getClosestMatchingKeysBy(env, (key) => {
+    if (mode === "rows") {
+      return key.endsWith(itemContextSuffix);
+    } else if (mode === "count") {
+      return key.endsWith(countContextSuffix);
+    } else {
+      return key.endsWith(itemContextSuffix) || key.endsWith(countContextSuffix);
+    }
+  });
+  return tables.filter(
+    (table) => matchingKeys.some((key) => {
+      if (mode === "rows") {
+        return mkRowContextKey(table.identifier) === key;
+      } else if (mode === "count") {
+        return mkCountContextKey(table.identifier) === key;
+      } else {
+        return mkRowContextKey(table.identifier) === key || mkCountContextKey(table.identifier) === key;
+      }
+    })
+  );
+}
+function deriveTableId(tables, table) {
+  if (!table && tables && tables.length > 0) {
+    table = tables[0].identifier;
+  }
+  return table;
+}
+function useRow(tables, table) {
+  const env = useDataEnv();
+  if (!env) {
+    return void 0;
+  }
+  table = deriveTableId(tables, table);
+  if (table) {
+    return {
+      table,
+      row: env[mkRowContextKey(table)]
+    };
+  }
+  return void 0;
+}
+function useCount(tables, table) {
+  const env = useDataEnv();
+  if (!env) {
+    return void 0;
+  }
+  table = deriveTableId(tables, table);
+  if (table) {
+    return {
+      table,
+      count: env[mkCountContextKey(table)]
+    };
+  }
+  return void 0;
+}
+function RowProvider({
+  children,
+  table,
+  row
+}) {
+  return /* @__PURE__ */ React.createElement(DataProvider, { name: mkRowContextKey(table), data: row }, children);
+}
+function CountProvider({
+  children,
+  table,
+  count
+}) {
+  return /* @__PURE__ */ React.createElement(
+    DataProvider,
+    {
+      name: table ? mkModeContextKey(table) : void 0,
+      data: "count",
+      hidden: true
+    },
+    /* @__PURE__ */ React.createElement(
+      DataProvider,
+      {
+        name: table ? mkCountContextKey(table) : void 0,
+        data: count
+      },
+      children
+    )
+  );
+}
+
+// src/util.ts
+function mkTableOptions(tables) {
+  if (!tables) {
+    return [];
+  }
+  return tables.map((table) => ({
+    value: table.identifier,
+    label: table.name
+  }));
+}
+function mkFieldOptions(tables, tableIdentifier, types) {
+  if (!tables) {
+    return [];
+  }
+  const table = tables.find((t) => t.identifier === tableIdentifier);
+  if (!table) {
+    return [];
+  }
+  let fields = table.schema.fields;
+  if (types) {
+    fields = fields.filter((f) => types.includes(f.type));
+  }
+  const options = fields.map((f) => ({
+    value: f.identifier,
+    label: f.name || f.identifier
+  }));
+  if (!options.some((option) => option.value === "_id")) {
+    options.push({
+      label: "System-assigned ID",
+      value: "_id"
+    });
+  }
+  return options;
+}
+
+// src/components.tsx
+var modulePath = "@plasmicpkgs/plasmic-cms";
+var componentPrefix = "hostless-plasmic-cms";
+function renderMaybeData(maybeData, renderFn, loaderProps, inEditor, loadingMessage, forceLoadingState) {
+  if ("error" in maybeData) {
+    const error = maybeData.error;
+    if (!inEditor) {
+      return /* @__PURE__ */ React2.createElement(React2.Fragment, null, loadingMessage != null ? loadingMessage : /* @__PURE__ */ React2.createElement("div", null, "Loading..."));
+    }
+    if (error && error instanceof HttpError && error.status === 404) {
+      if (loaderProps.hideIfNotFound) {
+        return null;
+      } else {
+        return /* @__PURE__ */ React2.createElement("div", null, "Error: Data not found");
+      }
+    } else {
+      return /* @__PURE__ */ React2.createElement("div", null, "Error: ", error == null ? void 0 : error.message);
+    }
+  }
+  if (!("data" in maybeData) || forceLoadingState) {
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, loadingMessage != null ? loadingMessage : /* @__PURE__ */ React2.createElement("div", null, "Loading..."));
+  }
+  return renderFn(maybeData.data);
+}
+var cmsCredentialsProviderMeta = {
+  name: `${componentPrefix}-credentials-provider`,
+  displayName: "CMS Credentials Provider",
+  description: `
+Find (or create) your CMS in the [dashboard](https://studio.plasmic.app), and go to its Settings view for the ID and token.
+
+[See tutorial video](https://docs.plasmic.app/learn/plasmic-cms/).`,
+  importName: "CmsCredentialsProvider",
+  importPath: modulePath,
+  providesData: true,
+  props: {
+    host: {
+      type: "string",
+      displayName: "Studio URL",
+      description: `The default host for use in production is ${DEFAULT_HOST}.`,
+      defaultValue: DEFAULT_HOST,
+      defaultValueHint: DEFAULT_HOST,
+      advanced: true
+    },
+    databaseId: {
+      type: "string",
+      displayName: "CMS ID",
+      description: "The ID of the CMS (database) to use. (Can get on the CMS settings page)"
+    },
+    databaseToken: {
+      type: "string",
+      displayName: "CMS Public Token",
+      description: "The Public Token of the CMS (database) you are using. (Can get on the CMS settings page)"
+    },
+    locale: {
+      type: "string",
+      displayName: "Locale",
+      description: "The locale to use for localized values, leave empty for the default locale."
+    }
+  }
+};
+function CmsCredentialsProvider({
+  children,
+  databaseId,
+  databaseToken,
+  host,
+  locale,
+  useDraft
+}) {
+  const config = {
+    databaseId,
+    databaseToken,
+    locale,
+    host: host || DEFAULT_HOST,
+    useDraft: useDraft != null ? useDraft : false
+  };
+  return /* @__PURE__ */ React2.createElement(DatabaseProvider, { config }, /* @__PURE__ */ React2.createElement(TablesFetcher, null, children));
+}
+function TablesFetcher({ children }) {
+  const databaseConfig = useDatabase();
+  const cacheKey = JSON.stringify({
+    component: "TablesFetcher",
+    databaseConfig: makeDatabaseCacheKey(databaseConfig)
+  });
+  const maybeData = usePlasmicQueryData(cacheKey, () => __async(this, null, function* () {
+    if (!isDatabaseConfigured(databaseConfig)) {
+      return [];
+    }
+    return yield mkApi(databaseConfig).fetchTables();
+  }));
+  const inEditor = !!usePlasmicCanvasContext();
+  return /* @__PURE__ */ React2.createElement(TablesProvider, { tables: maybeData.data }, inEditor && maybeData.error ? /* @__PURE__ */ React2.createElement("div", null, "CMS Error: ", maybeData.error.message) : children);
+}
+function isDatabaseConfigured(config) {
+  return (config == null ? void 0 : config.databaseId) && (config == null ? void 0 : config.databaseToken);
+}
+var cmsQueryRepeaterMeta = {
+  name: `${componentPrefix}-query-repeater`,
+  displayName: "CMS Data Fetcher",
+  description: "Fetches CMS data. Repeats `children` slot content for each row fetched. [See tutorial video](https://docs.plasmic.app/learn/plasmic-cms/).",
+  importName: "CmsQueryRepeater",
+  importPath: modulePath,
+  providesData: true,
+  defaultStyles: {
+    display: "flex",
+    width: "stretch",
+    maxWidth: "100%",
+    flexDirection: "column"
+  },
+  props: {
+    children: {
+      type: "slot",
+      isRepeated: true,
+      defaultValue: {
+        type: "vbox",
+        children: [
+          {
+            type: "component",
+            name: `${componentPrefix}-row-field`
+          }
+        ]
+      }
+    },
+    table: {
+      type: "choice",
+      displayName: "Model",
+      description: "CMS model (table) to query.",
+      options: (_, ctx) => mkTableOptions(ctx == null ? void 0 : ctx.tables),
+      defaultValueHint: (_, ctx) => ctx == null ? void 0 : ctx.table
+    },
+    useDraft: {
+      type: "boolean",
+      displayName: "Use drafts?",
+      description: "If set, also query unpublished content.",
+      defaultValue: false,
+      hidden: () => true
+    },
+    mode: {
+      type: "choice",
+      options: [
+        { label: "Rows", value: "rows" },
+        { label: "Count", value: "count" }
+      ],
+      defaultValueHint: "rows"
+    },
+    where: {
+      type: "object",
+      displayName: "Filter",
+      description: "Filter clause, as a JSON in Mongo query format. Should not be used together with Filter field and Filter value",
+      advanced: true
+    },
+    filterField: {
+      type: "choice",
+      displayName: "Filter field",
+      description: "Field (from model schema) to filter by",
+      options: ({ table }, ctx) => {
+        var _a;
+        return mkFieldOptions(ctx == null ? void 0 : ctx.tables, (_a = ctx == null ? void 0 : ctx.table) != null ? _a : table, [
+          "number" /* NUMBER */,
+          "boolean" /* BOOLEAN */,
+          "text" /* TEXT */,
+          "long-text" /* LONG_TEXT */,
+          "ref" /* REF */
+        ]);
+      }
+    },
+    filterValue: {
+      type: "string",
+      displayName: "Filter value",
+      description: "Value to filter by, should be of filter field type"
+    },
+    orderBy: {
+      type: "choice",
+      displayName: "Order by",
+      description: "Field to order by.",
+      options: (_, ctx) => mkFieldOptions(ctx == null ? void 0 : ctx.tables, ctx == null ? void 0 : ctx.table, [
+        "number" /* NUMBER */,
+        "boolean" /* BOOLEAN */,
+        "date-time" /* DATE_TIME */,
+        "long-text" /* LONG_TEXT */,
+        "text" /* TEXT */
+      ]),
+      hidden: (ps) => ps.mode === "count"
+    },
+    desc: {
+      type: "boolean",
+      displayName: "Sort descending?",
+      description: 'Sort descending by "Order by" field.',
+      defaultValue: false,
+      hidden: (ps) => ps.mode === "count"
+    },
+    limit: {
+      type: "number",
+      displayName: "Limit",
+      description: "Maximum number of entries to fetch (0 for unlimited).",
+      defaultValue: 0,
+      min: 0,
+      hidden: (ps) => ps.mode === "count"
+    },
+    offset: {
+      type: "number",
+      displayName: "Offset",
+      description: "Skips this number of rows in the result set; used in combination with limit to build pagination",
+      min: 0,
+      hidden: (ps) => ps.mode === "count"
+    },
+    fields: {
+      type: "choice",
+      multiSelect: true,
+      displayName: "Fields",
+      description: "Fields from the CMS model to include with each row; by default, all fields are included",
+      options: ({ table }, ctx) => {
+        var _a;
+        return mkFieldOptions(ctx == null ? void 0 : ctx.tables, (_a = ctx == null ? void 0 : ctx.table) != null ? _a : table);
+      },
+      hidden: (ps) => ps.mode === "count"
+    },
+    emptyMessage: {
+      type: "slot",
+      defaultValue: {
+        type: "text",
+        value: "No matching published entries found."
+      }
+    },
+    forceEmptyState: {
+      type: "boolean",
+      displayName: "Force empty state",
+      description: "If set, will render as if no matching entries were found.",
+      defaultValue: false
+    },
+    loadingMessage: {
+      type: "slot",
+      defaultValue: {
+        type: "text",
+        value: "Loading..."
+      }
+    },
+    forceLoadingState: {
+      type: "boolean",
+      displayName: "Force loading state",
+      description: "If set, will render as if it is waiting for the query to run.",
+      defaultValue: false
+    },
+    noLayout: {
+      type: "boolean",
+      displayName: "No layout",
+      description: "When set, CMS Data Loader will not layout its children; instead, the layout set on its parent element will be used. Useful if you want to set flex gap or control container tag type.",
+      defaultValue: false
+    },
+    noAutoRepeat: {
+      type: "boolean",
+      displayName: "No auto-repeat",
+      description: "Do not automatically repeat children for every entry.",
+      defaultValue: false,
+      hidden: (ps) => ps.mode === "count"
+    }
+  }
+};
+function CmsQueryRepeater({
+  table,
+  children,
+  setControlContextData,
+  mode,
+  where,
+  useDraft,
+  orderBy,
+  desc,
+  limit,
+  offset,
+  emptyMessage,
+  forceEmptyState,
+  loadingMessage,
+  forceLoadingState,
+  noLayout,
+  noAutoRepeat,
+  className,
+  filterField,
+  filterValue,
+  fields
+}) {
+  const databaseConfig = useDatabase();
+  const tables = useTables();
+  if (filterField && filterValue) {
+    where = {
+      [filterField]: filterValue
+    };
+  }
+  const params = { where, useDraft, orderBy, desc, limit, offset, fields };
+  if (!table && tables && tables.length > 0) {
+    table = tables[0].identifier;
+  }
+  const cacheKey = JSON.stringify({
+    component: "CmsQueryLoader",
+    mode,
+    table,
+    databaseConfig: makeDatabaseCacheKey(databaseConfig),
+    params
+  });
+  if (tables) {
+    setControlContextData == null ? void 0 : setControlContextData({ tables, table });
+  }
+  const maybeData = usePlasmicQueryData(cacheKey, () => __async(this, null, function* () {
+    if (!isDatabaseConfigured(databaseConfig)) {
+      throw new Error(`You must specify a CMS ID and API key`);
+    }
+    if (!table) {
+      throw new Error(`You must select a model to query`);
+    } else if (tables && !tables.find((t) => t.identifier === table)) {
+      throw new Error(`There is no model called "${table}"`);
+    } else if (mode === "count") {
+      return mkApi(databaseConfig).count(table, params);
+    } else {
+      return mkApi(databaseConfig).query(table, params);
+    }
+  }));
+  const inEditor = !!usePlasmicCanvasContext();
+  if (mode === "count") {
+    const node = renderMaybeData(
+      maybeData,
+      () => children,
+      { hideIfNotFound: false },
+      inEditor,
+      loadingMessage,
+      forceLoadingState
+    );
+    return /* @__PURE__ */ React2.createElement(TableSchemaProvider, { table }, /* @__PURE__ */ React2.createElement(
+      CountProvider,
+      {
+        table,
+        count: typeof (maybeData == null ? void 0 : maybeData.data) === "number" ? maybeData.data : void 0
+      },
+      node
+    ));
+  } else {
+    const node = renderMaybeData(
+      maybeData,
+      (rows) => {
+        if (rows.length === 0 || forceEmptyState) {
+          return emptyMessage;
+        }
+        return noAutoRepeat ? children : rows.map((row, index) => /* @__PURE__ */ React2.createElement(RowProvider, { key: index, table, row }, repeatedElement(index, children)));
+      },
+      { hideIfNotFound: false },
+      inEditor,
+      loadingMessage,
+      forceLoadingState
+    );
+    return /* @__PURE__ */ React2.createElement(TableSchemaProvider, { table }, /* @__PURE__ */ React2.createElement(
+      QueryResultProvider,
+      {
+        rows: Array.isArray(maybeData == null ? void 0 : maybeData.data) ? maybeData.data : void 0,
+        table
+      },
+      noLayout ? /* @__PURE__ */ React2.createElement(React2.Fragment, null, " ", node, " ") : /* @__PURE__ */ React2.createElement("div", { className }, " ", node, " ")
+    ));
+  }
+}
+var cmsRowFieldMeta = {
+  name: `${componentPrefix}-row-field`,
+  displayName: "CMS Entry Field",
+  importName: "CmsRowField",
+  importPath: modulePath,
+  props: {
+    table: {
+      type: "choice",
+      displayName: "Model",
+      hidden: (props, ctx) => {
+        var _a, _b;
+        return ((_b = (_a = ctx == null ? void 0 : ctx.tables) == null ? void 0 : _a.length) != null ? _b : 0) <= 1 && !props.table;
+      },
+      helpText: "Pick model from a CMS Data Fetcher",
+      description: "Usually not used! Only with multiple CMS Data Loaders, use this to choose which to show. Otherwise, go select the CMS Data Loader if you want to load different data.",
+      options: (_, ctx) => mkTableOptions(ctx == null ? void 0 : ctx.tables),
+      defaultValueHint: (_, ctx) => ctx == null ? void 0 : ctx.table
+    },
+    field: {
+      type: "choice",
+      displayName: "Field",
+      description: "Field (from model schema) to use.",
+      options: ({ table }, ctx) => {
+        var _a;
+        return mkFieldOptions(ctx == null ? void 0 : ctx.tables, (_a = ctx == null ? void 0 : ctx.table) != null ? _a : table, [
+          "number" /* NUMBER */,
+          "boolean" /* BOOLEAN */,
+          "text" /* TEXT */,
+          "long-text" /* LONG_TEXT */,
+          "date-time" /* DATE_TIME */,
+          "rich-text" /* RICH_TEXT */,
+          "image" /* IMAGE */,
+          "file" /* FILE */,
+          "enum" /* ENUM */
+        ]);
+      },
+      defaultValueHint: (_, ctx) => {
+        var _a, _b;
+        return ((_a = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _a.name) || ((_b = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _b.identifier);
+      }
+    },
+    dateFormat: {
+      type: "choice",
+      displayName: "Date Format",
+      hidden: ({ field }, ctx) => {
+        if (!ctx) {
+          return true;
+        }
+        const { table: tableIdentifier, tables } = ctx;
+        const table = tables == null ? void 0 : tables.find((t) => t.identifier === tableIdentifier);
+        if (!table) {
+          return true;
+        }
+        const fieldMeta = table.schema.fields.find(
+          (f) => f.identifier === field
+        );
+        if (!fieldMeta) {
+          return true;
+        }
+        return fieldMeta.type !== "date-time" /* DATE_TIME */;
+      },
+      options: [
+        {
+          label: "July 26, 2014",
+          value: "MMMM D, YYYY"
+        },
+        {
+          label: "July 26, 2014 10:02 PM",
+          value: "MMMM D, YYYY h:mm A"
+        },
+        {
+          label: "Jul 26, 2014",
+          value: "MMM D, YYYY"
+        },
+        {
+          label: "Jul 26, 2014 10:02 PM",
+          value: "MMM D, YYYY h:mm A"
+        },
+        {
+          label: "Saturday, July 26, 2014",
+          value: "dddd, MMMM D, YYYY"
+        },
+        {
+          label: "7/26/2014",
+          value: "M/D/YYYY"
+        },
+        {
+          label: "7/26/2014 10:02 PM",
+          value: "M/D/YYYY h:mm A"
+        },
+        {
+          label: "26/7/2014",
+          value: "D/M/YYYY"
+        },
+        {
+          label: "26/7/2014 10:02 PM",
+          value: "D/M/YYYY h:mm A"
+        },
+        {
+          label: "7/26/14",
+          value: "M/D/YY"
+        },
+        {
+          label: "7/26/14 10:02 PM",
+          value: "M/D/YY h:mm A"
+        },
+        {
+          label: "26/7/14",
+          value: "D/M/YY"
+        },
+        {
+          label: "26/7/14 10:02 PM",
+          value: "D/M/YY h:mm A"
+        }
+      ]
+    },
+    usePlasmicTheme: {
+      type: "boolean",
+      displayName: "Use Plasmic tag styles?",
+      description: "For HTML content, use tag styles defined in Plasmic",
+      advanced: true
+    },
+    themeResetClassName: {
+      type: "themeResetClass",
+      targetAllTags: true
+    }
+  },
+  defaultStyles: {
+    objectFit: "cover"
+  }
+};
+function CmsRowField(_a) {
+  var _b = _a, {
+    className,
+    table,
+    field,
+    dateFormat,
+    setControlContextData,
+    usePlasmicTheme,
+    themeResetClassName
+  } = _b, rest = __objRest(_b, [
+    "className",
+    "table",
+    "field",
+    "dateFormat",
+    "setControlContextData",
+    "usePlasmicTheme",
+    "themeResetClassName"
+  ]);
+  var _a2;
+  const tables = useTablesWithDataLoaded("rows");
+  const res = useRow(tables, table);
+  const unknown = /* @__PURE__ */ React2.createElement("div", __spreadValues({ className }, rest), "Field ", table != null ? table : "Unknown Model", ".", field != null ? field : "Unknown Field");
+  const fieldMeta = res ? deriveInferredTableField({
+    table: res.table,
+    tables,
+    field,
+    typeFilters: [
+      "text" /* TEXT */,
+      "long-text" /* LONG_TEXT */,
+      "rich-text" /* RICH_TEXT */
+    ]
+  }) : void 0;
+  if (tables) {
+    setControlContextData == null ? void 0 : setControlContextData(__spreadValues({
+      tables
+    }, res && res.row ? { table: res.table, row: res.row, fieldMeta } : {}));
+  }
+  if (!res) {
+    return unknown;
+  }
+  if (!res.row) {
+    return /* @__PURE__ */ React2.createElement("div", { className }, "Error: No CMS Entry found");
+  }
+  if (!fieldMeta) {
+    return unknown;
+  }
+  let data = (_a2 = res.row.data) == null ? void 0 : _a2[fieldMeta.identifier];
+  if (!data) {
+    return null;
+  }
+  if (fieldMeta.type === "date-time" /* DATE_TIME */ && dateFormat) {
+    data = dayjs(data).format(dateFormat);
+  }
+  return data ? renderValue(data, fieldMeta.type, __spreadValues({
+    className: `${usePlasmicTheme ? themeResetClassName : ""} ${className}`
+  }, rest)) : null;
+}
+var cmsCountFieldMeta = {
+  name: `${componentPrefix}-count`,
+  displayName: "CMS Entries Count",
+  importName: "CmsCount",
+  importPath: modulePath,
+  props: {
+    table: {
+      type: "choice",
+      displayName: "Model",
+      hidden: (props, ctx) => {
+        var _a, _b;
+        return ((_b = (_a = ctx == null ? void 0 : ctx.tables) == null ? void 0 : _a.length) != null ? _b : 0) <= 1 && !props.table;
+      },
+      helpText: "Pick model from a CMS Data Fetcher",
+      description: "Usually not used! Only with multiple CMS Data Loaders, use this to choose which to show. Otherwise, go select the CMS Data Loader if you want to load different data.",
+      options: (_, ctx) => mkTableOptions(ctx == null ? void 0 : ctx.tables),
+      defaultValueHint: (_, ctx) => ctx == null ? void 0 : ctx.table
+    }
+  }
+};
+function CmsCount(_a) {
+  var _b = _a, {
+    className,
+    table,
+    setControlContextData: _
+  } = _b, rest = __objRest(_b, [
+    "className",
+    "table",
+    "setControlContextData"
+  ]);
+  const tables = useTablesWithDataLoaded("count");
+  const res = useCount(tables, table);
+  const unknown = /* @__PURE__ */ React2.createElement("div", __spreadValues({ className }, rest), "Count: ", table != null ? table : "Unknown Model");
+  if (!res) {
+    return unknown;
+  }
+  if (res.count == null) {
+    return null;
+  } else {
+    return /* @__PURE__ */ React2.createElement("div", __spreadValues({ className }, rest), new Intl.NumberFormat().format(res.count));
+  }
+}
+var DEFAULT_TYPE_FILTERS = ["text" /* TEXT */];
+function deriveInferredTableField(opts) {
+  var _a;
+  const { table, tables, field, typeFilters } = opts;
+  if (!table)
+    return void 0;
+  const schema = (_a = tables == null ? void 0 : tables.find((t) => t.identifier === table)) == null ? void 0 : _a.schema;
+  const fieldMeta = field ? schema == null ? void 0 : schema.fields.find((f) => f.identifier === field) : schema == null ? void 0 : schema.fields.find(
+    (f) => (typeFilters != null ? typeFilters : DEFAULT_TYPE_FILTERS).includes(f.type)
+  );
+  return fieldMeta;
+}
+function assertNever(_) {
+  throw new Error("unexpected branch taken");
+}
+function renderValue(value, type, props) {
+  switch (type) {
+    case "number" /* NUMBER */:
+    case "boolean" /* BOOLEAN */:
+    case "text" /* TEXT */:
+    case "long-text" /* LONG_TEXT */:
+    case "date-time" /* DATE_TIME */:
+    case "enum" /* ENUM */:
+    case "ref" /* REF */:
+      return /* @__PURE__ */ React2.createElement("div", __spreadValues({}, props), value);
+    case "rich-text" /* RICH_TEXT */:
+      return /* @__PURE__ */ React2.createElement(
+        "div",
+        __spreadValues({
+          dangerouslySetInnerHTML: { __html: value },
+          style: { whiteSpace: "normal" }
+        }, props)
+      );
+    case "image" /* IMAGE */:
+      if (value && typeof value === "object" && value.url && value.imageMeta) {
+        return /* @__PURE__ */ React2.createElement(
+          "img",
+          __spreadValues({
+            src: value.url,
+            width: value.imageMeta.width,
+            height: value.imageMeta.height
+          }, props)
+        );
+      }
+      return null;
+    case "file" /* FILE */:
+      if (value && typeof value === "object" && value.url && value.name) {
+        return /* @__PURE__ */ React2.createElement("a", __spreadValues({ href: value.url, target: "_blank" }, props), value.name);
+      }
+      return null;
+    default:
+      assertNever(type);
+  }
+}
+var cmsRowLinkMeta = {
+  name: `${componentPrefix}-row-link`,
+  displayName: "CMS Entry Link",
+  importName: "CmsRowLink",
+  importPath: modulePath,
+  props: {
+    children: {
+      type: "slot",
+      defaultValue: {
+        type: "text",
+        tag: "a",
+        value: "Link"
+      }
+    },
+    table: {
+      type: "choice",
+      displayName: "Model",
+      hidden: (props, ctx) => {
+        var _a, _b;
+        return ((_b = (_a = ctx == null ? void 0 : ctx.tables) == null ? void 0 : _a.length) != null ? _b : 0) <= 1 && !props.table;
+      },
+      helpText: "Pick model from a CMS Data Fetcher",
+      description: "Usually not used! Only with multiple CMS Data Loaders, use this to choose which to show. Otherwise, go select the CMS Data Loader if you want to load different data.",
+      options: (_, ctx) => mkTableOptions(ctx == null ? void 0 : ctx.tables),
+      defaultValueHint: (_, ctx) => ctx == null ? void 0 : ctx.table
+    },
+    field: {
+      type: "choice",
+      displayName: "Field",
+      description: "Field (from model schema) to use.",
+      options: ({ table }, ctx) => {
+        var _a;
+        return mkFieldOptions(ctx == null ? void 0 : ctx.tables, (_a = ctx == null ? void 0 : ctx.table) != null ? _a : table);
+      },
+      defaultValueHint: (_, ctx) => {
+        var _a, _b;
+        return ((_a = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _a.name) || ((_b = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _b.identifier);
+      }
+    },
+    hrefProp: {
+      type: "string",
+      displayName: '"href" prop',
+      description: "Prop to inject into children",
+      defaultValue: "href"
+    },
+    prefix: {
+      type: "string",
+      displayName: "Optional prefix",
+      description: "Prefix to prepend to prop value.",
+      hidden: (_, ctx) => {
+        var _a;
+        return ((_a = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _a.type) === "file";
+      }
+    },
+    suffix: {
+      type: "string",
+      displayName: "Optional suffix",
+      description: "Suffix to append to prop value.",
+      hidden: (_, ctx) => {
+        var _a;
+        return ((_a = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _a.type) === "file";
+      }
+    }
+  }
+};
+function CmsRowLink({
+  table,
+  field,
+  hrefProp,
+  children,
+  setControlContextData,
+  prefix,
+  suffix
+}) {
+  var _a;
+  const tables = useTablesWithDataLoaded("rows");
+  const res = useRow(tables, table);
+  if (!res || !res.row) {
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
+  }
+  const fieldMeta = deriveInferredTableField({
+    table: res.table,
+    tables,
+    field,
+    typeFilters: ["file" /* FILE */, "text" /* TEXT */]
+  });
+  if (tables) {
+    setControlContextData == null ? void 0 : setControlContextData({
+      tables,
+      table: res.table,
+      row: res.row,
+      fieldMeta
+    });
+  }
+  if (!fieldMeta) {
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
+  }
+  if (!children) {
+    return null;
+  }
+  const value = ((_a = res.row.data) == null ? void 0 : _a[fieldMeta.identifier]) || "";
+  const childrenWithProps = React2.Children.map(children, (child) => {
+    if (React2.isValidElement(child)) {
+      return React2.cloneElement(child, {
+        [hrefProp]: fieldMeta.type === "file" /* FILE */ ? value.url : prefix || suffix ? `${prefix || ""}${value}${suffix || ""}` : value
+      });
+    }
+    return child;
+  });
+  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, childrenWithProps != null ? childrenWithProps : null);
+}
+var cmsRowImageMeta = {
+  name: `${componentPrefix}-row-image`,
+  displayName: "CMS Entry Image",
+  importName: "CmsRowImage",
+  importPath: modulePath,
+  props: {
+    children: {
+      type: "slot",
+      defaultValue: {
+        type: "img",
+        src: "https://studio.plasmic.app/static/img/placeholder-full.png"
+      }
+    },
+    table: {
+      type: "choice",
+      displayName: "Model",
+      hidden: (props, ctx) => {
+        var _a, _b;
+        return ((_b = (_a = ctx == null ? void 0 : ctx.tables) == null ? void 0 : _a.length) != null ? _b : 0) <= 1 && !props.table;
+      },
+      helpText: "Pick model from a CMS Data Fetcher",
+      description: "Usually not used! Only with multiple CMS Data Loaders, use this to choose which to show. Otherwise, go select the CMS Data Loader if you want to load different data.",
+      options: (_, ctx) => mkTableOptions(ctx == null ? void 0 : ctx.tables),
+      defaultValueHint: (_, ctx) => ctx == null ? void 0 : ctx.table
+    },
+    field: {
+      type: "choice",
+      displayName: "Field",
+      description: "Field (from model schema) to use.",
+      options: ({ table }, ctx) => {
+        var _a;
+        return mkFieldOptions(ctx == null ? void 0 : ctx.tables, (_a = ctx == null ? void 0 : ctx.table) != null ? _a : table, ["image" /* IMAGE */]);
+      },
+      defaultValueHint: (_, ctx) => {
+        var _a, _b;
+        return ((_a = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _a.name) || ((_b = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _b.identifier);
+      }
+    },
+    srcProp: {
+      type: "string",
+      displayName: 'Image "src" prop',
+      description: "Prop to inject into children",
+      defaultValue: "src"
+    }
+  }
+};
+function CmsRowImage({
+  table,
+  field,
+  srcProp,
+  children,
+  setControlContextData
+}) {
+  var _a;
+  const tables = useTablesWithDataLoaded("rows");
+  const res = useRow(tables, table);
+  if (!res || !res.row) {
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
+  }
+  const fieldMeta = deriveInferredTableField({
+    table: res.table,
+    tables,
+    field,
+    typeFilters: ["image" /* IMAGE */]
+  });
+  if (tables) {
+    setControlContextData == null ? void 0 : setControlContextData({
+      tables,
+      table: res.table,
+      row: res.row,
+      fieldMeta
+    });
+  }
+  if (!fieldMeta) {
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
+  }
+  const value = ((_a = res.row.data) == null ? void 0 : _a[fieldMeta.identifier]) || "";
+  const childrenWithProps = React2.Children.map(children, (child) => {
+    if (React2.isValidElement(child) && value) {
+      if (typeof value === "object" && value.url && value.imageMeta) {
+        return React2.cloneElement(child, {
+          [srcProp]: {
+            src: value.url,
+            fullHeight: value.imageMeta.height,
+            fullWidth: value.imageMeta.width
+          }
+        });
+      }
+      return React2.cloneElement(child, { [srcProp]: value });
+    }
+    return child;
+  });
+  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, childrenWithProps);
+}
+var cmsRowFieldValueMeta = {
+  name: `${componentPrefix}-row-value`,
+  displayName: "CMS Entry Value",
+  importName: "CmsRowFieldValue",
+  importPath: modulePath,
+  props: {
+    children: {
+      type: "slot"
+    },
+    table: {
+      type: "choice",
+      displayName: "Model",
+      hidden: (props, ctx) => {
+        var _a, _b;
+        return ((_b = (_a = ctx == null ? void 0 : ctx.tables) == null ? void 0 : _a.length) != null ? _b : 0) <= 1 && !props.table;
+      },
+      helpText: "Pick model from a CMS Data Fetcher",
+      description: "Usually not used! Only with multiple CMS Data Loaders, use this to choose which to show. Otherwise, go select the CMS Data Loader if you want to load different data.",
+      options: (_, ctx) => mkTableOptions(ctx == null ? void 0 : ctx.tables),
+      defaultValueHint: (_, ctx) => ctx == null ? void 0 : ctx.table
+    },
+    field: {
+      type: "choice",
+      displayName: "Field",
+      description: "Field (from model schema) to use.",
+      options: ({ table }, ctx) => {
+        var _a;
+        return mkFieldOptions(ctx == null ? void 0 : ctx.tables, (_a = ctx == null ? void 0 : ctx.table) != null ? _a : table);
+      },
+      defaultValueHint: (_, ctx) => {
+        var _a, _b;
+        return ((_a = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _a.name) || ((_b = ctx == null ? void 0 : ctx.fieldMeta) == null ? void 0 : _b.identifier);
+      }
+    },
+    valueProp: {
+      type: "string",
+      displayName: "Value prop",
+      description: "Prop to inject into children as",
+      defaultValue: "children"
+    }
+  }
+};
+function CmsRowFieldValue(_a) {
+  var _b = _a, {
+    table,
+    field,
+    valueProp,
+    children,
+    setControlContextData
+  } = _b, rest = __objRest(_b, [
+    "table",
+    "field",
+    "valueProp",
+    "children",
+    "setControlContextData"
+  ]);
+  var _a2;
+  const tables = useTablesWithDataLoaded("rows");
+  const res = useRow(tables, table);
+  if (!res || !res.row) {
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
+  }
+  const fieldMeta = deriveInferredTableField({
+    table: res.table,
+    tables,
+    field,
+    typeFilters: ["text" /* TEXT */]
+  });
+  if (tables) {
+    setControlContextData == null ? void 0 : setControlContextData({
+      tables,
+      table: res.table,
+      row: res.row,
+      fieldMeta
+    });
+  }
+  if (!fieldMeta) {
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
+  }
+  const value = ((_a2 = res.row.data) == null ? void 0 : _a2[fieldMeta.identifier]) || "";
+  const childrenWithProps = React2.Children.map(children, (child) => {
+    if (React2.isValidElement(child)) {
+      return React2.cloneElement(child, __spreadProps(__spreadValues({}, rest), { [valueProp]: value }));
+    }
+    return child;
+  });
+  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, childrenWithProps);
+}
+
+// src/custom-functions.ts
+import registerFunction from "@plasmicapp/host/registerFunction";
+function getCmsHost() {
+  var _a;
+  return (_a = globalThis["__PLASMIC_CMS_HOST__"]) != null ? _a : DEFAULT_HOST;
+}
+function createTableOptions(_args, ctx) {
+  if (!(ctx == null ? void 0 : ctx.tables)) {
+    return [];
+  }
+  return ctx.tables.map((table) => ({
+    value: table.identifier,
+    label: table.name
+  }));
+}
+var sharedTableFnContext = (cmsId, cmsPublicToken, ..._args) => {
+  if (!cmsId || !cmsPublicToken) {
+    return {
+      dataKey: "",
+      fetcher: () => __async(void 0, null, function* () {
+        return { tables: [] };
+      })
+    };
+  }
+  return {
+    dataKey: `cms_tables/${JSON.stringify({
+      cmsId,
+      cmsPublicToken
+    })}`,
+    fetcher: () => __async(void 0, null, function* () {
+      const api = mkApi({
+        databaseId: cmsId,
+        databaseToken: cmsPublicToken,
+        host: getCmsHost()
+      });
+      const tables = yield api.fetchTables();
+      return { tables };
+    })
+  };
+};
+var cmsIdParam = {
+  name: "cmsId",
+  type: "string",
+  description: "The cms ID"
+};
+var cmsPublicTokenParam = {
+  name: "cmsPublicToken",
+  type: "string",
+  description: "The cms public token"
+};
+var tableIdParam = {
+  name: "tableId",
+  type: "choice",
+  options: createTableOptions
+};
+var paramsParam = {
+  name: "params",
+  type: "object",
+  description: "The parameters to filter the content (e.g., for sorting, limit, offset, advanced queries)"
+};
+var useDraftParam = {
+  name: "useDraft",
+  type: "boolean",
+  description: "Whether to use draft data. Defaults to false."
+};
+var localeParam = {
+  name: "locale",
+  type: "string",
+  description: "The locale to use. Defaults to empty string."
+};
+function fetchTables(cmsId, cmsPublicToken) {
+  return __async(this, null, function* () {
+    const api = mkApi({
+      databaseId: cmsId,
+      databaseToken: cmsPublicToken,
+      host: getCmsHost()
+    });
+    return api.fetchTables();
+  });
+}
+function fetchContent(cmsId, cmsPublicToken, tableId, params, useDraft, locale) {
+  return __async(this, null, function* () {
+    const api = mkApi({
+      databaseId: cmsId,
+      databaseToken: cmsPublicToken,
+      host: getCmsHost(),
+      useDraft,
+      locale
+    });
+    return api.query(tableId, params);
+  });
+}
+function fetchCount(cmsId, cmsPublicToken, tableId, params, useDraft) {
+  return __async(this, null, function* () {
+    const api = mkApi({
+      databaseId: cmsId,
+      databaseToken: cmsPublicToken,
+      host: getCmsHost(),
+      useDraft
+    });
+    return api.count(tableId, params);
+  });
+}
+function registerAllCustomFunctions(loader) {
+  function _registerFunction(fn, meta) {
+    if (loader) {
+      loader.registerFunction(fn, meta);
+    } else {
+      registerFunction(fn, meta);
+    }
+  }
+  _registerFunction(fetchTables, {
+    name: "fetchTables",
+    description: "Fetches the tables from the cms",
+    importPath: "@plasmicpkgs/plasmic-cms",
+    params: [cmsIdParam, cmsPublicTokenParam]
+  });
+  _registerFunction(fetchContent, {
+    name: "fetchContent",
+    description: "Fetch content from a cms table",
+    importPath: "@plasmicpkgs/plasmic-cms",
+    params: [
+      cmsIdParam,
+      cmsPublicTokenParam,
+      tableIdParam,
+      paramsParam,
+      useDraftParam,
+      localeParam
+    ],
+    fnContext: sharedTableFnContext
+  });
+  _registerFunction(fetchCount, {
+    name: "fetchCount",
+    description: "Fetch the count of entries from a cms table",
+    importPath: "@plasmicpkgs/plasmic-cms",
+    params: [
+      cmsIdParam,
+      cmsPublicTokenParam,
+      tableIdParam,
+      paramsParam,
+      useDraftParam
+    ],
+    fnContext: sharedTableFnContext
+  });
+}
+
+// src/index.tsx
+function registerAll(loader) {
+  const _registerComponent = (Component, defaultMeta) => {
+    if (loader) {
+      loader.registerComponent(Component, defaultMeta);
+    } else {
+      registerComponent(Component, defaultMeta);
+    }
+  };
+  const _registerGlobalContext = (Component, defaultMeta) => {
+    if (loader) {
+      loader.registerGlobalContext(Component, defaultMeta);
+    } else {
+      registerGlobalContext(Component, defaultMeta);
+    }
+  };
+  _registerGlobalContext(CmsCredentialsProvider, cmsCredentialsProviderMeta);
+  _registerComponent(CmsQueryRepeater, cmsQueryRepeaterMeta);
+  _registerComponent(CmsRowField, cmsRowFieldMeta);
+  _registerComponent(CmsRowLink, cmsRowLinkMeta);
+  _registerComponent(CmsRowImage, cmsRowImageMeta);
+  _registerComponent(CmsRowFieldValue, cmsRowFieldValueMeta);
+  _registerComponent(CmsCount, cmsCountFieldMeta);
+}
+export {
+  API,
+  CmsCount,
+  CmsCredentialsProvider,
+  CmsQueryRepeater,
+  CmsRowField,
+  CmsRowFieldValue,
+  CmsRowImage,
+  CmsRowLink,
+  HttpError,
+  cmsCountFieldMeta,
+  cmsCredentialsProviderMeta,
+  cmsQueryRepeaterMeta,
+  cmsRowFieldMeta,
+  cmsRowFieldValueMeta,
+  cmsRowImageMeta,
+  cmsRowLinkMeta,
+  fetchContent,
+  fetchCount,
+  fetchTables,
+  mkApi,
+  registerAll,
+  registerAllCustomFunctions
+};
+//# sourceMappingURL=index.esm.js.map