tinacms 0.0.0-d94de9b-20250707010010 → 0.0.0-d9ccf29-20251222052725

package/dist/admin/api.d.ts

@@ -2,7 +2,10 @@ import type { TinaCMS } from '@tinacms/toolkit';
 import type { Collection, TinaSchema } from '@tinacms/schema-tools';
 import type { Client } from '../internalClient';
 import type { CollectionResponse, DocumentForm } from './types';
-import { SearchClient } from '@tinacms/search/dist/index-client';
+import { SearchClient } from '@tinacms/search/index-client';
+export declare const CREATE_DOCUMENT_GQL = "#graphql\nmutation($collection: String!, $relativePath: String!, $params: DocumentMutation!) {\n  createDocument(\n    collection: $collection,\n    relativePath: $relativePath,\n    params: $params\n  ){__typename}\n}";
+export declare const UPDATE_DOCUMENT_GQL = "#graphql\nmutation($collection: String!, $relativePath: String!, $params: DocumentUpdateMutation!) {\n  updateDocument(\n    collection: $collection,\n    relativePath: $relativePath,\n    params: $params\n  ){__typename}\n}";
+export declare const DELETE_DOCUMENT_GQL = "#graphql\nmutation DeleteDocument($collection: String!, $relativePath: String!){\n  deleteDocument(collection: $collection, relativePath: $relativePath){\n    __typename\n  }\n}";
 export interface FilterArgs {
     filterField: string;
     collection?: string;

package/dist/auth/AuthModal.d.ts

@@ -1,10 +1,7 @@
-/**
-
-*/
 import React from 'react';
 interface ModalBuilderProps {
     title: string;
-    message?: string;
+    message?: React.ReactNode;
     error?: string;
     actions: ButtonProps[];
     close(): void;

package/dist/auth/TinaCloudProvider.d.ts

@@ -18,7 +18,6 @@ export interface TinaCloudAuthWallProps {
     }[];
     mediaStore?: TinaCloudMediaStoreClass | (() => Promise<TinaCloudMediaStoreClass>);
 }
-export declare const AuthWallInner: ({ children, cms, getModalActions, }: TinaCloudAuthWallProps) => React.JSX.Element;
 /**
  * Provides the ability to setup your CMS and media while also providing an authentication wall so Tina is not enabled without a valid user session.
  *

package/dist/cache/node-cache.d.ts

@@ -1,3 +1,7 @@
 import type { Cache } from './index';
-export declare const makeCacheDir: (dir: string, fs: any, path: any, os: any) => Promise<string>;
-export declare const NodeCache: (dir: string) => Promise<Cache>;
+type FsModule = typeof import('node:fs');
+type PathModule = typeof import('node:path');
+type OsModule = typeof import('node:os');
+export declare const makeCacheDir: (dir: string, fsArg: FsModule, pathArg: PathModule, osArg: OsModule) => string | null;
+export declare const NodeCache: (dir: string) => Promise<Cache | null>;
+export {};

package/dist/client.js

@@ -1,199 +1,258 @@
-(function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("async-lock")) : typeof define === "function" && define.amd ? define(["exports", "async-lock"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.tinacms = {}, global.NOOP));
-})(this, function(exports2, AsyncLock) {
-  "use strict";
-  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;
-    }
-  }
-  class TinaClient {
-    constructor({
-      token,
-      url,
-      queries,
-      errorPolicy,
-      cacheDir
-    }) {
-      this.initialized = false;
-      this.apiUrl = url;
-      this.readonlyToken = token == null ? void 0 : token.trim();
-      this.queries = queries(this);
-      this.errorPolicy = errorPolicy || "throw";
-      this.cacheDir = cacheDir || "";
-    }
-    async init() {
-      if (this.initialized) {
-        return;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 {
-        if (this.cacheDir && typeof window === "undefined" && typeof require !== "undefined") {
-          const { NodeCache: NodeCache2 } = await Promise.resolve().then(() => nodeCache);
-          this.cache = await NodeCache2(this.cacheDir);
-          this.cacheLock = new AsyncLock();
+        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.error(e);
+        console.warn(
+          "Warning: Failed to initialize cache. Caching will be disabled.",
+          e.message
+        );
+        return null;
       }
-      this.initialized = true;
+    };
+  }
+});
+
+// src/unifiedClient/index.ts
+import AsyncLock from "async-lock";
+var 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;
+  }
+}
+var TinaClient = class {
+  apiUrl;
+  readonlyToken;
+  queries;
+  errorPolicy;
+  initialized = false;
+  cacheLock;
+  cacheDir;
+  cache;
+  constructor({
+    token,
+    url,
+    queries,
+    errorPolicy,
+    cacheDir
+  }) {
+    this.apiUrl = url;
+    this.readonlyToken = token?.trim();
+    this.queries = queries(this);
+    this.errorPolicy = errorPolicy || "throw";
+    this.cacheDir = cacheDir || "";
+  }
+  async init() {
+    if (this.initialized) {
+      return;
     }
-    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);
-          });
+    try {
+      if (this.cacheDir && typeof window === "undefined") {
+        const { NodeCache: NodeCache2 } = await Promise.resolve().then(() => (init_node_cache(), node_cache_exports));
+        this.cache = await NodeCache2(this.cacheDir);
+        if (this.cache) {
+          this.cacheLock = new AsyncLock();
         }
       }
-      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;
+    } catch (e) {
+      console.error(e);
     }
+    this.initialized = true;
   }
-  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.";
+  async request({ errorPolicy, ...args }, options) {
+    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?.fetchOptions) {
+      if (options?.fetchOptions?.headers) {
+        Object.entries(options.fetchOptions.headers).forEach(([key2, value]) => {
+          headers.append(key2, value);
+        });
       }
-      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/errors/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/errors/faq/
-      Errors: 
-	${json.errors.map((error) => error.message).join("\n")}`
+    const { headers: _, ...providedFetchOptions } = options?.fetchOptions || {};
+    const bodyString = JSON.stringify({
+      query: args.query,
+      variables: args?.variables || {}
+    });
+    const optionsObject = {
+      method: "POST",
+      headers,
+      body: bodyString,
+      redirect: "follow",
+      ...providedFetchOptions
+    };
+    const draftBranch = headers.get("x-branch");
+    const url = replaceGithubPathSplit(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
       );
     }
-    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;
-  }
-  const makeCacheDir = async (dir, fs, path, os) => {
-    const pathParts = dir.split(path.sep).filter(Boolean);
-    const cacheHash = pathParts[pathParts.length - 1];
-    const rootUser = pathParts[0];
-    let cacheDir = dir;
-    if (!fs.existsSync(path.join(path.sep, rootUser))) {
-      cacheDir = path.join(os.tmpdir(), cacheHash);
-    }
-    try {
-      fs.mkdirSync(cacheDir, { recursive: true });
-    } catch (error) {
-      throw new Error(`Failed to create cache directory: ${error.message}`);
+};
+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.";
     }
-    return cacheDir;
-  };
-  const NodeCache = async (dir) => {
-    const fs = require("node:fs");
-    const path = require("node:path");
-    const os = require("node:os");
-    const { createHash } = require("node:crypto");
-    const cacheDir = await makeCacheDir(dir, fs, path, os);
-    return {
-      makeKey: (key) => {
-        const input = key && key instanceof Object ? JSON.stringify(key) : key || "";
-        return createHash("sha256").update(input).digest("hex");
-      },
-      get: async (key) => {
-        let readValue;
-        const cacheFilename = `${cacheDir}/${key}`;
-        try {
-          const data = await fs.promises.readFile(cacheFilename, "utf-8");
-          readValue = JSON.parse(data);
-        } catch (e) {
-          if (e.code !== "ENOENT") {
-            console.error(
-              `Failed to read cache file to ${cacheFilename}: ${e.message}`
-            );
-          }
-        }
-        return readValue;
-      },
-      set: async (key, value) => {
-        const cacheFilename = `${cacheDir}/${key}`;
-        try {
-          await fs.promises.writeFile(cacheFilename, JSON.stringify(value), {
-            encoding: "utf-8",
-            flag: "wx"
-            // Don't overwrite existing caches
-          });
-        } catch (e) {
-          if (e.code !== "EEXIST") {
-            console.error(
-              `Failed to write cache file to ${cacheFilename}: ${e.message}`
-            );
-          }
-        }
-      }
-    };
+    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?.data,
+    errors: json?.errors || null,
+    query
   };
-  const nodeCache = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-    __proto__: null,
-    NodeCache,
-    makeCacheDir
-  }, Symbol.toStringTag, { value: "Module" }));
-  exports2.TINA_HOST = TINA_HOST;
-  exports2.TinaClient = TinaClient;
-  exports2.createClient = createClient;
-  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
-});
+  return result;
+}
+function createClient(args) {
+  const client = new TinaClient(args);
+  return client;
+}
+export {
+  TINA_HOST,
+  TinaClient,
+  createClient
+};