@tinacms/astro 0.0.0-00ff25a-20260605030238

package/dist/index.js

@@ -0,0 +1,94 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/data.ts
+import { addMetadata, hashFromQuery } from "@tinacms/bridge/metadata";
+import { readOverlay } from "@tinacms/bridge/preview";
+
+// src/internal/forms-store.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var STORE_KEY = Symbol.for("@tinacms/astro/forms-store");
+var slot = globalThis;
+var formsStore = slot[STORE_KEY] ??= new AsyncLocalStorage();
+function recordForm(form) {
+  const list = formsStore.getStore();
+  if (!list) return;
+  const existing = list.find((entry) => entry.id === form.id);
+  if (existing) {
+    if (form.priority === "primary") existing.priority = "primary";
+    return;
+  }
+  list.push(form);
+}
+
+// src/internal/request-context.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var STORE_KEY2 = Symbol.for("@tinacms/astro/request-context");
+var slot2 = globalThis;
+var requestStore = slot2[STORE_KEY2] ??= new AsyncLocalStorage2();
+
+// src/data.ts
+async function requestWithMetadata(source, options) {
+  let result = null;
+  try {
+    result = await source ?? null;
+  } catch (error) {
+    console.warn("[@tinacms/astro] client query failed", error);
+  }
+  const query = result?.query ?? "";
+  const variables = result?.variables ?? {};
+  const id = hashFromQuery(JSON.stringify({ query, variables }));
+  const data = result?.data ?? {};
+  const request = requestStore.getStore();
+  let resolvedData = data;
+  if (request) {
+    const overlay = await readOverlay(request, id);
+    if (overlay !== void 0) {
+      resolvedData = overlay;
+    }
+  }
+  const enriched = {
+    data: addMetadata(id, resolvedData),
+    query,
+    variables,
+    id
+  };
+  recordForm({
+    id,
+    query,
+    variables,
+    data: enriched.data,
+    priority: options?.priority
+  });
+  return enriched;
+}
+
+// src/tina-field.ts
+var tina_field_exports = {};
+__reExport(tina_field_exports, tina_field_star);
+import * as tina_field_star from "@tinacms/bridge/tina-field";
+
+// src/index.ts
+var TinaMarkdownPlaceholder = () => {
+  throw new Error(
+    "[@tinacms/astro] TinaMarkdown must be loaded through Astro's pipeline. Add `tina()` from `@tinacms/astro/integration` to your astro.config integrations, or import directly from `@tinacms/astro/TinaMarkdown.astro`."
+  );
+};
+var index_default = TinaMarkdownPlaceholder;
+var export_tinaField = tina_field_exports.tinaField;
+export {
+  index_default as default,
+  requestWithMetadata,
+  export_tinaField as tinaField
+};

package/dist/integration.d.ts

@@ -0,0 +1,12 @@
+import type { AstroIntegration } from 'astro';
+export interface TinaIntegrationOptions {
+    middlewareOrder?: 'pre' | 'post';
+    /**
+     * Force the Cloudflare Workers (workerd) `import.meta.url` workaround on or
+     * off. When omitted, it is applied automatically whenever the
+     * `@astrojs/cloudflare` adapter is detected. Set `false` to opt out, or
+     * `true` to force it for a custom Cloudflare setup.
+     */
+    cloudflareWorkers?: boolean;
+}
+export default function tina(options?: TinaIntegrationOptions): AstroIntegration;

package/dist/integration.js

@@ -0,0 +1,93 @@
+// src/integration.ts
+import { copyFileSync, mkdirSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+var BRIDGE_ROUTE = "/admin/bridge.js";
+var CLOUDFLARE_ADAPTER_NAME = "@astrojs/cloudflare";
+var WORKERD_IMPORT_META_URL = JSON.stringify("file:///worker.mjs");
+var SERVER_ENVIRONMENTS = /* @__PURE__ */ new Set(["ssr", "astro"]);
+function tina(options = {}) {
+  const { middlewareOrder = "pre" } = options;
+  let clientDir;
+  let isCloudflareAdapter = false;
+  return {
+    name: "@tinacms/astro",
+    hooks: {
+      "astro:config:setup": ({ addMiddleware, updateConfig }) => {
+        addMiddleware({
+          entrypoint: "@tinacms/astro/middleware",
+          order: middlewareOrder
+        });
+        updateConfig({
+          vite: {
+            plugins: [
+              bridgeDevPlugin(),
+              cloudflareImportMetaUrlPlugin(() => isCloudflareAdapter)
+            ]
+          }
+        });
+      },
+      "astro:config:done": ({ config }) => {
+        clientDir = config.build.client;
+        isCloudflareAdapter = options.cloudflareWorkers ?? config.adapter?.name === CLOUDFLARE_ADAPTER_NAME;
+      },
+      "astro:build:done": ({ logger }) => {
+        if (!clientDir) return;
+        emitBridgeAsset(fileURLToPath(new URL("admin/", clientDir)), logger);
+      }
+    }
+  };
+}
+function resolveBridge() {
+  return createRequire(import.meta.url).resolve("@tinacms/bridge");
+}
+function bridgeDevPlugin() {
+  return {
+    name: "@tinacms/astro:bridge-dev",
+    apply: "serve",
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        const path = (req.url || "").split("?")[0];
+        if (path !== BRIDGE_ROUTE) {
+          next();
+          return;
+        }
+        try {
+          const body = readFileSync(resolveBridge());
+          res.setHeader("Content-Type", "text/javascript");
+          res.setHeader("Cache-Control", "no-cache");
+          res.end(body);
+        } catch (error) {
+          res.statusCode = 500;
+          res.end(`/* @tinacms/astro: bridge unavailable: ${error} */`);
+        }
+      });
+    }
+  };
+}
+function cloudflareImportMetaUrlPlugin(isCloudflare) {
+  const define = { "import.meta.url": WORKERD_IMPORT_META_URL };
+  return {
+    name: "@tinacms/astro:cloudflare-import-meta-url",
+    // No `apply`: the define is needed in both the build (ssr) and dev envs.
+    configEnvironment(name) {
+      if (!isCloudflare()) return;
+      if (!SERVER_ENVIRONMENTS.has(name)) return;
+      return { define };
+    }
+  };
+}
+function emitBridgeAsset(adminDir, logger) {
+  try {
+    mkdirSync(adminDir, { recursive: true });
+    copyFileSync(resolveBridge(), join(adminDir, "bridge.js"));
+  } catch (error) {
+    logger.warn(
+      `could not emit admin/bridge.js \u2014 visual editing will not load: ${error}`
+    );
+  }
+}
+export {
+  tina as default
+};

package/dist/internal/admin-origin.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve `PUBLIC_TINA_ADMIN_ORIGIN` (comma-separated allowed) from
+ * Astro's `import.meta.env`. Returns `null` when unset — the bridge then
+ * falls back to `window.location.origin`.
+ */
+export declare function adminOrigins(): string[] | null;

package/dist/internal/escape.d.ts

@@ -0,0 +1,8 @@
+/**
+ * HTML attribute escape for double-quoted attributes. `&` is escaped first
+ * so the subsequent replacements don't double-encode existing entities.
+ * Adequate for the shapes we emit server-side — `data-tina-form` payloads
+ * and `data-tina-island` marker paths — neither of which is parsed as
+ * HTML downstream.
+ */
+export declare function escapeAttr(s: string): string;

package/dist/internal/forms-store.d.ts

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export interface CollectedForm {
+    id: string;
+    query: string;
+    variables: object;
+    data: object;
+    priority?: 'primary';
+}
+export declare const formsStore: AsyncLocalStorage<CollectedForm[]>;
+export declare function recordForm(form: CollectedForm): void;
+export declare function sortByPriority(forms: CollectedForm[]): CollectedForm[];
+export declare function renderFormPayloadDiv(form: CollectedForm, primary: boolean): string;

package/dist/internal/request-context.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Request-scoped storage so `tina()` can read the current request without
+ * the caller threading `Astro.request` through every loader. The
+ * middleware injected by the `tina()` integration runs every request
+ * through `requestStore.run(...)`.
+ *
+ * Falls through to `undefined` outside a request scope (static builds,
+ * integration not installed) — `tina()` treats that as "no overlay,
+ * no edit mode," so static contexts still produce correct output.
+ *
+ * Stashed on `globalThis` via `Symbol.for(...)` so all bundle copies of
+ * this module share one ALS instance — esbuild inlines it into every
+ * entry that imports it, and per-entry copies wouldn't share state.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+export declare const requestStore: AsyncLocalStorage<Request>;

package/dist/is-edit-mode.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Server-side check: is this request being rendered inside the TinaCMS
+ * admin iframe?
+ *
+ * Resolves true when any of the following hold:
+ *   1. `?tina-edit=1` — explicit signal added by the admin's router for
+ *      deep-link previews.
+ *   2. `Sec-Fetch-Dest: iframe` AND a same-origin Referer under
+ *      `/admin/` — covers the first request after the admin sets
+ *      `iframe.src` to a preview URL.
+ *   3. `Sec-Fetch-Dest: iframe` AND a `__tina_edit=1` cookie — covers
+ *      in-iframe link clicks, where the Referer is the previous preview
+ *      page rather than `/admin/`. The middleware sets the cookie on
+ *      every edit-mode response so the session sticks for the iframe's
+ *      lifetime.
+ *
+ * Direct browser visits set `Sec-Fetch-Dest: document` for top-level
+ * navigations, so a stale cookie left behind in someone's browser can
+ * never trip edit mode outside an iframe — production HTML is byte-
+ * identical to a Tina-free Astro app for end users.
+ */
+export declare const EDIT_COOKIE = "__tina_edit";
+/**
+ * Set-Cookie header value the middleware writes on every edit-mode
+ * response. Refreshing on each response keeps long editing sessions
+ * sticky and short Max-Age limits the blast radius if a cookie lingers.
+ * The `Sec-Fetch-Dest: iframe` gate in `isEditMode` blocks the cookie
+ * from triggering edit mode on top-level visits.
+ */
+export declare const EDIT_COOKIE_HEADER = "__tina_edit=1; Path=/; SameSite=Strict; Max-Age=3600";
+export declare function isEditMode(request: Request): boolean;
+export declare function readCookie(request: Request, name: string): string | null;

package/dist/is-edit-mode.js

@@ -0,0 +1,37 @@
+// src/is-edit-mode.ts
+var EDIT_COOKIE = "__tina_edit";
+var EDIT_COOKIE_HEADER = `${EDIT_COOKIE}=1; Path=/; SameSite=Strict; Max-Age=3600`;
+function isEditMode(request) {
+  const url = new URL(request.url);
+  if (url.searchParams.get("tina-edit") === "1") return true;
+  const dest = request.headers.get("Sec-Fetch-Dest");
+  if (dest !== "iframe") return false;
+  const referer = request.headers.get("Referer");
+  if (referer) {
+    try {
+      const refererUrl = new URL(referer);
+      if (refererUrl.origin === url.origin && refererUrl.pathname.startsWith("/admin/")) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return readCookie(request, EDIT_COOKIE) === "1";
+}
+function readCookie(request, name) {
+  const header = request.headers.get("Cookie");
+  if (!header) return null;
+  for (const pair of header.split(";")) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) continue;
+    const key = pair.slice(0, eq).trim();
+    if (key === name) return pair.slice(eq + 1).trim();
+  }
+  return null;
+}
+export {
+  EDIT_COOKIE,
+  EDIT_COOKIE_HEADER,
+  isEditMode,
+  readCookie
+};

package/dist/island-route.d.ts

@@ -0,0 +1,18 @@
+import type { APIRoute } from 'astro';
+import type { AstroComponentFactory } from 'astro/runtime/server/index.js';
+export interface IslandWrapper {
+    tag: string;
+    className?: string;
+}
+export interface IslandConfig {
+    /** Resolve the data the component needs. May ignore the search params. */
+    fetch: (request: Request, params: URLSearchParams) => Promise<unknown>;
+    /** Astro component to render with the fetched data. */
+    component: AstroComponentFactory;
+    /** Outer element the bridge swaps into — must match the page-side wrapper. */
+    wrapper: IslandWrapper;
+    /** Map fetched data + URL params to the component's props. */
+    propsFromData: (data: unknown, params: URLSearchParams) => Record<string, unknown>;
+}
+export type IslandRegistry = Record<string, IslandConfig>;
+export declare function experimental_createIslandRoute(islands: IslandRegistry): APIRoute;

package/dist/island-route.js

@@ -0,0 +1,87 @@
+// src/island-route.ts
+import { PREVIEW_CONTENT_TYPE, PRIME_HEADER } from "@tinacms/bridge/preview";
+import { experimental_AstroContainer as AstroContainer } from "astro/container";
+
+// src/internal/escape.ts
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/internal/forms-store.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var STORE_KEY = Symbol.for("@tinacms/astro/forms-store");
+var slot = globalThis;
+var formsStore = slot[STORE_KEY] ??= new AsyncLocalStorage();
+function sortByPriority(forms) {
+  return [...forms].sort(
+    (a, b) => (a.priority === "primary" ? 0 : 1) - (b.priority === "primary" ? 0 : 1)
+  );
+}
+function renderFormPayloadDiv(form, primary) {
+  return `<div data-tina-form="${escapeAttr(JSON.stringify(form))}"${primary ? " data-tina-primary" : ""} hidden></div>`;
+}
+
+// src/internal/request-context.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var STORE_KEY2 = Symbol.for("@tinacms/astro/request-context");
+var slot2 = globalThis;
+var requestStore = slot2[STORE_KEY2] ??= new AsyncLocalStorage2();
+
+// src/island-route.ts
+function experimental_createIslandRoute(islands) {
+  return async ({ params, request, url }) => {
+    const rejection = rejectIfUnsafe(request);
+    if (rejection) return rejection;
+    const island = islands[params.name ?? ""];
+    if (!island) {
+      return new Response(`Unknown island "${params.name}"`, { status: 404 });
+    }
+    const priming = request.headers.get(PRIME_HEADER) !== null;
+    try {
+      const forms = [];
+      const html = await requestStore.run(
+        request,
+        () => formsStore.run(forms, async () => {
+          const data = await island.fetch(request, url.searchParams);
+          const container = await AstroContainer.create();
+          return container.renderToString(island.component, {
+            props: island.propsFromData(data, url.searchParams)
+          });
+        })
+      );
+      const body = (priming ? renderFormPayloads(forms) : "") + wrapIsland(html, island.wrapper, url);
+      return new Response(body, {
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          "Cache-Control": "no-store"
+        }
+      });
+    } catch {
+      return new Response("Island render failed", { status: 500 });
+    }
+  };
+}
+function rejectIfUnsafe(request) {
+  if (request.method !== "POST") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+  const contentType = request.headers.get("content-type") ?? "";
+  if (!contentType.includes(PREVIEW_CONTENT_TYPE)) {
+    return new Response("Not Found", { status: 404 });
+  }
+  if (request.headers.get("sec-fetch-site") === "cross-site") {
+    return new Response("Forbidden", { status: 403 });
+  }
+  return null;
+}
+function renderFormPayloads(forms) {
+  return sortByPriority(forms).map((form) => renderFormPayloadDiv(form, form.priority === "primary")).join("");
+}
+function wrapIsland(html, wrapper, url) {
+  const cls = wrapper.className ? ` class="${escapeAttr(wrapper.className)}"` : "";
+  const marker = escapeAttr(`${url.pathname}${url.search}`);
+  return `<${wrapper.tag}${cls} data-tina-island="${marker}">${html}</${wrapper.tag}>`;
+}
+export {
+  experimental_createIslandRoute
+};

package/dist/middleware.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareHandler } from 'astro';
+export declare const onRequest: MiddlewareHandler;
+export default onRequest;

package/dist/middleware.js

@@ -0,0 +1,123 @@
+// src/internal/admin-origin.ts
+function adminOrigins() {
+  const env = import.meta.env;
+  const raw = env?.PUBLIC_TINA_ADMIN_ORIGIN;
+  if (!raw) return null;
+  const origins = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return origins.length > 0 ? origins : null;
+}
+
+// src/internal/forms-store.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// src/internal/escape.ts
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/internal/forms-store.ts
+var STORE_KEY = Symbol.for("@tinacms/astro/forms-store");
+var slot = globalThis;
+var formsStore = slot[STORE_KEY] ??= new AsyncLocalStorage();
+function sortByPriority(forms) {
+  return [...forms].sort(
+    (a, b) => (a.priority === "primary" ? 0 : 1) - (b.priority === "primary" ? 0 : 1)
+  );
+}
+function renderFormPayloadDiv(form, primary) {
+  return `<div data-tina-form="${escapeAttr(JSON.stringify(form))}"${primary ? " data-tina-primary" : ""} hidden></div>`;
+}
+
+// src/internal/request-context.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var STORE_KEY2 = Symbol.for("@tinacms/astro/request-context");
+var slot2 = globalThis;
+var requestStore = slot2[STORE_KEY2] ??= new AsyncLocalStorage2();
+
+// src/is-edit-mode.ts
+var EDIT_COOKIE = "__tina_edit";
+var EDIT_COOKIE_HEADER = `${EDIT_COOKIE}=1; Path=/; SameSite=Strict; Max-Age=3600`;
+function isEditMode(request) {
+  const url = new URL(request.url);
+  if (url.searchParams.get("tina-edit") === "1") return true;
+  const dest = request.headers.get("Sec-Fetch-Dest");
+  if (dest !== "iframe") return false;
+  const referer = request.headers.get("Referer");
+  if (referer) {
+    try {
+      const refererUrl = new URL(referer);
+      if (refererUrl.origin === url.origin && refererUrl.pathname.startsWith("/admin/")) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return readCookie(request, EDIT_COOKIE) === "1";
+}
+function readCookie(request, name) {
+  const header = request.headers.get("Cookie");
+  if (!header) return null;
+  for (const pair of header.split(";")) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) continue;
+    const key = pair.slice(0, eq).trim();
+    if (key === name) return pair.slice(eq + 1).trim();
+  }
+  return null;
+}
+
+// src/middleware.ts
+var HEAD_CLOSE = "</head>";
+var onRequest = (context, next) => {
+  if (context.isPrerendered) {
+    context.locals.tinaEdit = false;
+    return next();
+  }
+  const editing = isEditMode(context.request);
+  context.locals.tinaEdit = editing;
+  const forms = [];
+  return requestStore.run(
+    context.request,
+    () => formsStore.run(forms, async () => {
+      const response = await next();
+      return editing ? injectEditMode(response, forms) : response;
+    })
+  );
+};
+var middleware_default = onRequest;
+async function injectEditMode(response, forms) {
+  const init = editModeInit(response);
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("text/html")) {
+    return new Response(response.body, init);
+  }
+  const html = await response.text();
+  const headEnd = html.indexOf(HEAD_CLOSE);
+  if (headEnd === -1) {
+    return new Response(html, init);
+  }
+  const injection = renderInjection(forms);
+  return new Response(
+    html.slice(0, headEnd) + injection + html.slice(headEnd),
+    init
+  );
+}
+function editModeInit(response) {
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  headers.append("Set-Cookie", EDIT_COOKIE_HEADER);
+  return { status: response.status, statusText: response.statusText, headers };
+}
+function renderInjection(forms) {
+  const formDivs = sortByPriority(forms).map((form, i) => renderFormPayloadDiv(form, i === 0)).join("");
+  return formDivs + bridgeScript();
+}
+function bridgeScript() {
+  const origins = adminOrigins();
+  const initArg = origins ? `{adminOrigin:${JSON.stringify(origins)}}` : "";
+  return `<script type="module">import{init,refreshForms}from"/admin/bridge.js";init(${initArg});document.addEventListener("astro:page-load",refreshForms);</script>`;
+}
+export {
+  middleware_default as default,
+  onRequest
+};

package/dist/sanitize.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Sanitizes a CMS-supplied href, returning a safe URL or the fallback.
+ * Blocks dangerous schemes (javascript:, data:, vbscript:) and
+ * protocol-relative URLs (//evil.com). Allows relative paths, http(s),
+ * and mailto:.
+ */
+export declare function sanitizeHref(value: unknown, fallback?: string): string;
+/**
+ * Validates a CMS-supplied image src, returning the src string if safe or ''
+ * if it is empty, not a string, or uses a non-http(s)/relative scheme.
+ */
+export declare function sanitizeImageSrc(src: unknown): string;

package/dist/sanitize.js

@@ -0,0 +1,41 @@
+// src/sanitize.ts
+function sanitizeHref(value, fallback = "#") {
+  if (typeof value !== "string") return fallback;
+  const trimmed = value.trim();
+  if (!trimmed) return fallback;
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:")) {
+    return fallback;
+  }
+  if (trimmed.startsWith("/") && !trimmed.startsWith("//") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("#")) {
+    return trimmed;
+  }
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol === "http:" || url.protocol === "https:" || url.protocol === "mailto:") {
+      return trimmed;
+    }
+  } catch {
+    return fallback;
+  }
+  return fallback;
+}
+function sanitizeImageSrc(src) {
+  if (typeof src !== "string") return "";
+  const trimmed = src.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("/") && !trimmed.startsWith("//")) {
+    return trimmed;
+  }
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol === "http:" || url.protocol === "https:") return trimmed;
+  } catch {
+    return "";
+  }
+  return "";
+}
+export {
+  sanitizeHref,
+  sanitizeImageSrc
+};

package/dist/tina-field.d.ts

@@ -0,0 +1 @@
+export * from '@tinacms/bridge/tina-field';

package/dist/tina-field.js

@@ -0,0 +1,2 @@
+// src/tina-field.ts
+export * from "@tinacms/bridge/tina-field";