tinacms 3.13.0 → 3.14.1

package/README.md

@@ -2,9 +2,9 @@
 [![npm version](https://img.shields.io/npm/v/tinacms.svg?style=flat)](https://www.npmjs.com/package/tinacms)
 [![Build, Test, Lint for Main](https://github.com/tinacms/tinacms/actions/workflows/main.yml/badge.svg?branch=main&event=push)](https://github.com/tinacms/tinacms/actions/workflows/main.yml)
 
-# [![TINA CMS](./.github/assets/tinacms-logo-small-default.svg)](https://tina.io)
+# [![TINA CMS](https://raw.githubusercontent.com/tinacms/tinacms/main/.github/assets/tinacms-logo-small-default.svg)](https://tina.io)
 
-[![Tina Demo](./.github/assets/homepage-demo-2.gif)](https://tina.io/)
+[![Tina Demo](https://raw.githubusercontent.com/tinacms/tinacms/main/.github/assets/homepage-demo-2.gif)](https://tina.io/)
 
 Tina is a headless content management system with support for **Markdown**, MDX, JSON, YAML, and more.
 

package/dist/admin/preview-url.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resolve a router splat into a same-origin preview path.
+ *
+ * Do not filter the splat instead: the URL parser treats `\` as `/` and drops
+ * leading tabs, so a character filter does not hold. Resolve the value first,
+ * then reject any result that left this origin.
+ *
+ * `offOrigin` is true only when a splat was supplied and resolved elsewhere, so
+ * callers can tell a rejected link from an empty one.
+ */
+export declare function resolvePreviewPath(splat: string | undefined, baseOrigin?: string): {
+    path: string;
+    offOrigin: boolean;
+};

package/dist/client.browser.d.ts

@@ -0,0 +1 @@
+export * from './unifiedClient';

package/dist/client.browser.js

@@ -0,0 +1,175 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class AsyncLock {
+  constructor() {
+    __publicField(this, "queues", /* @__PURE__ */ new Map());
+  }
+  acquire(key, fn) {
+    const prev = this.queues.get(key) ?? Promise.resolve();
+    const next = prev.then(fn);
+    this.queues.set(
+      key,
+      next.then(
+        () => void 0,
+        () => void 0
+      )
+    );
+    return next;
+  }
+}
+const TINA_HOST = "content.tinajs.io";
+function replaceGithubPathSplit(url, replacement) {
+  const parts = url.split("github/");
+  if (parts.length > 1 && replacement) {
+    return parts[0] + "github/" + replacement;
+  } else {
+    return url;
+  }
+}
+function isEdgeRuntimeWithoutFs() {
+  if (typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers") {
+    return true;
+  }
+  if (typeof globalThis.EdgeRuntime !== "undefined") {
+    return true;
+  }
+  return false;
+}
+class TinaClient {
+  constructor({
+    token,
+    url,
+    queries,
+    errorPolicy,
+    cacheDir,
+    cache
+  }) {
+    __publicField(this, "apiUrl");
+    __publicField(this, "readonlyToken");
+    __publicField(this, "queries");
+    __publicField(this, "errorPolicy");
+    __publicField(this, "initialized", false);
+    __publicField(this, "cacheLock");
+    __publicField(this, "cacheDir");
+    __publicField(this, "cache");
+    __publicField(this, "cacheEnabled");
+    this.apiUrl = url;
+    this.readonlyToken = token == null ? void 0 : token.trim();
+    this.queries = queries(this);
+    this.errorPolicy = errorPolicy || "throw";
+    this.cacheDir = cacheDir || "";
+    this.cacheEnabled = cache !== false;
+  }
+  async init() {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      if (this.cacheEnabled && this.cacheDir && typeof window === "undefined" && !isEdgeRuntimeWithoutFs()) {
+        this.cache = await this.createCache(this.cacheDir);
+        if (this.cache) {
+          this.cacheLock = new AsyncLock();
+        }
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    this.initialized = true;
+  }
+  async createCache(_dir) {
+    return null;
+  }
+  async request({ errorPolicy, ...args }, options) {
+    var _a;
+    await this.init();
+    const errorPolicyDefined = errorPolicy || this.errorPolicy;
+    const headers = new Headers();
+    if (this.readonlyToken) {
+      headers.append("X-API-KEY", this.readonlyToken);
+    }
+    headers.append("Content-Type", "application/json");
+    if (options == null ? void 0 : options.fetchOptions) {
+      if ((_a = options == null ? void 0 : options.fetchOptions) == null ? void 0 : _a.headers) {
+        Object.entries(options.fetchOptions.headers).forEach(([key2, value]) => {
+          headers.append(key2, value);
+        });
+      }
+    }
+    const { headers: _, ...providedFetchOptions } = (options == null ? void 0 : options.fetchOptions) || {};
+    const bodyString = JSON.stringify({
+      query: args.query,
+      variables: (args == null ? void 0 : args.variables) || {}
+    });
+    const optionsObject = {
+      method: "POST",
+      headers,
+      body: bodyString,
+      redirect: "follow",
+      ...providedFetchOptions
+    };
+    const draftBranch = headers.get("x-branch");
+    const url = replaceGithubPathSplit((args == null ? void 0 : args.url) || this.apiUrl, draftBranch);
+    let key = "";
+    let result;
+    if (this.cache) {
+      key = this.cache.makeKey(bodyString);
+      await this.cacheLock.acquire(key, async () => {
+        result = await this.cache.get(key);
+        if (!result) {
+          result = await requestFromServer(
+            url,
+            args.query,
+            optionsObject,
+            errorPolicyDefined
+          );
+          await this.cache.set(key, result);
+        }
+      });
+    } else {
+      result = await requestFromServer(
+        url,
+        args.query,
+        optionsObject,
+        errorPolicyDefined
+      );
+    }
+    return result;
+  }
+}
+async function requestFromServer(url, query, optionsObject, errorPolicyDefined) {
+  const res = await fetch(url, optionsObject);
+  if (!res.ok) {
+    let additionalInfo = "";
+    if (res.status === 401) {
+      additionalInfo = "Please check that your client ID, URL and read only token are configured properly.";
+    }
+    throw new Error(
+      `Server responded with status code ${res.status}, ${res.statusText}. ${additionalInfo ? additionalInfo : ""} Please see our FAQ for more information: https://tina.io/docs/r/FAQ/`
+    );
+  }
+  const json = await res.json();
+  if (json.errors && errorPolicyDefined === "throw") {
+    throw new Error(
+      `Unable to fetch, please see our FAQ for more information: https://tina.io/docs/r/FAQ/
+      Errors: 
+	${json.errors.map((error) => error.message).join("\n")}`
+    );
+  }
+  const result = {
+    data: json == null ? void 0 : json.data,
+    errors: (json == null ? void 0 : json.errors) || null,
+    query
+  };
+  return result;
+}
+function createClient(args) {
+  const client = new TinaClient(args);
+  return client;
+}
+export {
+  AsyncLock,
+  TINA_HOST,
+  TinaClient,
+  createClient
+};

package/dist/client.d.ts

@@ -1,4 +1,7 @@
-/**
-
-*/
 export * from './unifiedClient';
+import { TinaClient as BaseTinaClient } from './unifiedClient';
+import type { TinaClientArgs } from './unifiedClient';
+export declare class TinaClient<GenQueries> extends BaseTinaClient<GenQueries> {
+    protected createCache(dir: string): Promise<import("./cache").Cache>;
+}
+export declare function createClient<GenQueries>(args: TinaClientArgs<GenQueries>): TinaClient<GenQueries>;

package/dist/client.js

@@ -1,125 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res, err) => function __init() {
-  if (err) throw err[0];
-  try {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-  } catch (e) {
-    throw err = [e], e;
-  }
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/cache/node-cache.ts
-var node_cache_exports = {};
-__export(node_cache_exports, {
-  NodeCache: () => NodeCache,
-  makeCacheDir: () => makeCacheDir
-});
-var resolveModule, getRootPath, makeCacheDir, NodeCache;
-var init_node_cache = __esm({
-  "src/cache/node-cache.ts"() {
-    resolveModule = (mod) => {
-      if (mod && typeof mod === "object" && "default" in mod && mod.default) {
-        return mod.default;
-      }
-      return mod;
-    };
-    getRootPath = (pathParts, pathArg) => {
-      if (pathParts.length === 0) return null;
-      const isWindows = pathArg.sep === "\\";
-      const root = pathParts[0];
-      return isWindows ? `${root}${pathArg.sep}` : `${pathArg.sep}${root}`;
-    };
-    makeCacheDir = (dir, fsArg, pathArg, osArg) => {
-      const normalizedDir = pathArg.normalize(dir);
-      const pathParts = normalizedDir.split(pathArg.sep).filter(Boolean);
-      const cacheHash = pathParts[pathParts.length - 1];
-      const rootPath = getRootPath(pathParts, pathArg);
-      const rootExists = rootPath && fsArg.existsSync(rootPath);
-      const cacheDir = rootExists ? normalizedDir : pathArg.join(osArg.tmpdir(), cacheHash);
-      try {
-        fsArg.mkdirSync(cacheDir, { recursive: true });
-      } catch (error) {
-        console.warn(
-          `Warning: Failed to create cache directory: ${error.message}. Caching will be disabled.`
-        );
-        return null;
-      }
-      return cacheDir;
-    };
-    NodeCache = async (dir) => {
-      try {
-        const [fsModule, pathModule, osModule, cryptoModule] = await Promise.all([
-          import("node:fs"),
-          import("node:path"),
-          import("node:os"),
-          import("node:crypto")
-        ]);
-        const fs = resolveModule(fsModule);
-        const path = resolveModule(pathModule);
-        const os = resolveModule(osModule);
-        const crypto = resolveModule(cryptoModule);
-        if (typeof path?.join !== "function") {
-          console.warn(
-            "Warning: Node.js path module not available. Caching will be disabled."
-          );
-          return null;
-        }
-        const cacheDir = makeCacheDir(dir, fs, path, os);
-        if (cacheDir === null) {
-          return null;
-        }
-        return {
-          makeKey: (key) => {
-            const input = key && key instanceof Object ? JSON.stringify(key) : key || "";
-            return crypto.createHash("sha256").update(input).digest("hex");
-          },
-          get: async (key) => {
-            let readValue;
-            const cacheFilename = path.join(cacheDir, key);
-            try {
-              const data = await fs.promises.readFile(cacheFilename, "utf-8");
-              readValue = JSON.parse(data);
-            } catch (e) {
-              if (e.code !== "ENOENT") {
-                console.warn(
-                  `Warning: Failed to read cache file ${cacheFilename}: ${e.message}`
-                );
-              }
-            }
-            return readValue;
-          },
-          set: async (key, value) => {
-            const cacheFilename = path.join(cacheDir, key);
-            try {
-              await fs.promises.writeFile(cacheFilename, JSON.stringify(value), {
-                encoding: "utf-8",
-                flag: "wx"
-              });
-            } catch (e) {
-              if (e.code !== "EEXIST") {
-                console.warn(
-                  `Warning: Failed to write cache file ${cacheFilename}: ${e.message}`
-                );
-              }
-            }
-          }
-        };
-      } catch (e) {
-        console.warn(
-          "Warning: Failed to initialize cache. Caching will be disabled.",
-          e.message
-        );
-        return null;
-      }
-    };
-  }
-});
-
 // src/unifiedClient/asyncLock.ts
 var AsyncLock = class {
   queues = /* @__PURE__ */ new Map();
@@ -187,8 +65,7 @@ var TinaClient = class {
     }
     try {
       if (this.cacheEnabled && this.cacheDir && typeof window === "undefined" && !isEdgeRuntimeWithoutFs()) {
-        const { NodeCache: NodeCache2 } = await Promise.resolve().then(() => (init_node_cache(), node_cache_exports));
-        this.cache = await NodeCache2(this.cacheDir);
+        this.cache = await this.createCache(this.cacheDir);
         if (this.cache) {
           this.cacheLock = new AsyncLock();
         }
@@ -198,6 +75,9 @@ var TinaClient = class {
     }
     this.initialized = true;
   }
+  async createCache(_dir) {
+    return null;
+  }
   async request({ errorPolicy, ...args }, options) {
     await this.init();
     const errorPolicyDefined = errorPolicy || this.errorPolicy;
@@ -280,13 +160,116 @@ async function requestFromServer(url, query, optionsObject, errorPolicyDefined)
   };
   return result;
 }
+
+// src/cache/node-cache.ts
+var resolveModule = (mod) => {
+  if (mod && typeof mod === "object" && "default" in mod && mod.default) {
+    return mod.default;
+  }
+  return mod;
+};
+var getRootPath = (pathParts, pathArg) => {
+  if (pathParts.length === 0) return null;
+  const isWindows = pathArg.sep === "\\";
+  const root = pathParts[0];
+  return isWindows ? `${root}${pathArg.sep}` : `${pathArg.sep}${root}`;
+};
+var makeCacheDir = (dir, fsArg, pathArg, osArg) => {
+  const normalizedDir = pathArg.normalize(dir);
+  const pathParts = normalizedDir.split(pathArg.sep).filter(Boolean);
+  const cacheHash = pathParts[pathParts.length - 1];
+  const rootPath = getRootPath(pathParts, pathArg);
+  const rootExists = rootPath && fsArg.existsSync(rootPath);
+  const cacheDir = rootExists ? normalizedDir : pathArg.join(osArg.tmpdir(), cacheHash);
+  try {
+    fsArg.mkdirSync(cacheDir, { recursive: true });
+  } catch (error) {
+    console.warn(
+      `Warning: Failed to create cache directory: ${error.message}. Caching will be disabled.`
+    );
+    return null;
+  }
+  return cacheDir;
+};
+var NodeCache = async (dir) => {
+  try {
+    const [fsModule, pathModule, osModule, cryptoModule] = await Promise.all([
+      import("node:fs"),
+      import("node:path"),
+      import("node:os"),
+      import("node:crypto")
+    ]);
+    const fs = resolveModule(fsModule);
+    const path = resolveModule(pathModule);
+    const os = resolveModule(osModule);
+    const crypto = resolveModule(cryptoModule);
+    if (typeof path?.join !== "function") {
+      console.warn(
+        "Warning: Node.js path module not available. Caching will be disabled."
+      );
+      return null;
+    }
+    const cacheDir = makeCacheDir(dir, fs, path, os);
+    if (cacheDir === null) {
+      return null;
+    }
+    return {
+      makeKey: (key) => {
+        const input = key && key instanceof Object ? JSON.stringify(key) : key || "";
+        return crypto.createHash("sha256").update(input).digest("hex");
+      },
+      get: async (key) => {
+        let readValue;
+        const cacheFilename = path.join(cacheDir, key);
+        try {
+          const data = await fs.promises.readFile(cacheFilename, "utf-8");
+          readValue = JSON.parse(data);
+        } catch (e) {
+          if (e.code !== "ENOENT") {
+            console.warn(
+              `Warning: Failed to read cache file ${cacheFilename}: ${e.message}`
+            );
+          }
+        }
+        return readValue;
+      },
+      set: async (key, value) => {
+        const cacheFilename = path.join(cacheDir, key);
+        try {
+          await fs.promises.writeFile(cacheFilename, JSON.stringify(value), {
+            encoding: "utf-8",
+            flag: "wx"
+          });
+        } catch (e) {
+          if (e.code !== "EEXIST") {
+            console.warn(
+              `Warning: Failed to write cache file ${cacheFilename}: ${e.message}`
+            );
+          }
+        }
+      }
+    };
+  } catch (e) {
+    console.warn(
+      "Warning: Failed to initialize cache. Caching will be disabled.",
+      e.message
+    );
+    return null;
+  }
+};
+
+// src/client.ts
+var TinaClient2 = class extends TinaClient {
+  createCache(dir) {
+    return NodeCache(dir);
+  }
+};
 function createClient(args) {
-  const client = new TinaClient(args);
-  return client;
+  return new TinaClient2(args);
 }
 export {
   AsyncLock,
   TINA_HOST,
-  TinaClient,
+  TinaClient2 as TinaClient,
   createClient
 };