tinacms 0.0.0-e48ff80-20251203000400 → 0.0.0-e52f289-20251216060413

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,11 +1,123 @@
 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);
-  return value;
+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 {
+        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/index.ts
 import AsyncLock from "async-lock";
-const TINA_HOST = "content.tinajs.io";
+var TINA_HOST = "content.tinajs.io";
 function replaceGithubPathSplit(url, replacement) {
   const parts = url.split("github/");
   if (parts.length > 1 && replacement) {
@@ -14,7 +126,15 @@ function replaceGithubPathSplit(url, replacement) {
     return url;
   }
 }
-class TinaClient {
+var TinaClient = class {
+  apiUrl;
+  readonlyToken;
+  queries;
+  errorPolicy;
+  initialized = false;
+  cacheLock;
+  cacheDir;
+  cache;
   constructor({
     token,
     url,
@@ -22,16 +142,8 @@ class TinaClient {
     errorPolicy,
     cacheDir
   }) {
-    __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");
     this.apiUrl = url;
-    this.readonlyToken = token == null ? void 0 : token.trim();
+    this.readonlyToken = token?.trim();
     this.queries = queries(this);
     this.errorPolicy = errorPolicy || "throw";
     this.cacheDir = cacheDir || "";
@@ -41,10 +153,12 @@ class TinaClient {
       return;
     }
     try {
-      if (this.cacheDir && typeof window === "undefined" && typeof require !== "undefined") {
-        const { NodeCache } = await import("./node-cache-c9558e1e.js");
-        this.cache = await NodeCache(this.cacheDir);
-        this.cacheLock = new AsyncLock();
+      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();
+        }
       }
     } catch (e) {
       console.error(e);
@@ -52,7 +166,6 @@ class TinaClient {
     this.initialized = true;
   }
   async request({ errorPolicy, ...args }, options) {
-    var _a;
     await this.init();
     const errorPolicyDefined = errorPolicy || this.errorPolicy;
     const headers = new Headers();
@@ -60,17 +173,17 @@ class TinaClient {
       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) {
+    if (options?.fetchOptions) {
+      if (options?.fetchOptions?.headers) {
         Object.entries(options.fetchOptions.headers).forEach(([key2, value]) => {
           headers.append(key2, value);
         });
       }
     }
-    const { headers: _, ...providedFetchOptions } = (options == null ? void 0 : options.fetchOptions) || {};
+    const { headers: _, ...providedFetchOptions } = options?.fetchOptions || {};
     const bodyString = JSON.stringify({
       query: args.query,
-      variables: (args == null ? void 0 : args.variables) || {}
+      variables: args?.variables || {}
     });
     const optionsObject = {
       method: "POST",
@@ -80,7 +193,7 @@ class TinaClient {
       ...providedFetchOptions
     };
     const draftBranch = headers.get("x-branch");
-    const url = replaceGithubPathSplit((args == null ? void 0 : args.url) || this.apiUrl, draftBranch);
+    const url = replaceGithubPathSplit(args?.url || this.apiUrl, draftBranch);
     let key = "";
     let result;
     if (this.cache) {
@@ -107,7 +220,7 @@ class TinaClient {
     }
     return result;
   }
-}
+};
 async function requestFromServer(url, query, optionsObject, errorPolicyDefined) {
   const res = await fetch(url, optionsObject);
   if (!res.ok) {
@@ -128,8 +241,8 @@ async function requestFromServer(url, query, optionsObject, errorPolicyDefined)
     );
   }
   const result = {
-    data: json == null ? void 0 : json.data,
-    errors: (json == null ? void 0 : json.errors) || null,
+    data: json?.data,
+    errors: json?.errors || null,
     query
   };
   return result;