npm - @tinacms/astro - Versions diffs - 0.0.1 → 0.3.0 - Mend

@tinacms/astro 0.0.1 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (75) hide show

package/README.md +50 -20
package/dist/bridge.d.ts +7 -1
package/dist/bridge.js +1 -0
package/dist/data.d.ts +19 -0
package/dist/data.js +64 -0
package/dist/data.test-d.d.ts +1 -0
package/dist/experimental.d.ts +10 -0
package/dist/experimental.js +87 -0
package/dist/index.d.ts +36 -1
package/dist/index.js +92 -2
package/dist/integration.d.ts +5 -0
package/dist/integration.js +69 -0
package/dist/internal/admin-origin.d.ts +6 -0
package/dist/internal/escape.d.ts +8 -0
package/dist/internal/forms-store.d.ts +12 -0
package/dist/internal/request-context.d.ts +16 -0
package/dist/is-edit-mode.d.ts +32 -0
package/dist/is-edit-mode.js +37 -0
package/dist/island-route.d.ts +18 -0
package/dist/island-route.js +87 -0
package/dist/middleware.d.ts +3 -0
package/dist/middleware.js +123 -0
package/dist/sanitize.d.ts +12 -1
package/dist/sanitize.js +6 -10
package/dist/tina-field.d.ts +1 -1
package/dist/tina-field.js +1 -0
package/dist/types.d.ts +92 -1
package/dist/types.js +0 -1
package/dist/vite.d.ts +21 -0
package/dist/vite.js +24 -0
package/package.json +88 -17
package/src/CodeBlockNode.astro +28 -0
package/src/Container.astro +56 -0
package/src/ImageNode.astro +17 -0
package/src/LinkNode.astro +22 -0
package/src/MdxNode.astro +24 -0
package/src/Node.astro +11 -4
package/src/TinaIsland.astro +44 -0
package/src/TinaMarkdown.astro +8 -0
package/src/__tests__/IslandStub.astro +8 -0
package/src/__tests__/TinaIsland.test.ts +60 -0
package/src/__tests__/TinaMarkdown.test.ts +112 -0
package/src/__tests__/__snapshots__/TinaMarkdown.test.ts.snap +7 -0
package/src/__tests__/fixtures/FancyHeading.astro +3 -0
package/src/__tests__/fixtures/MyFeature.astro +4 -0
package/src/__tests__/fixtures/basic-kitchen-sink.json +60 -0
package/src/__tests__/fixtures/code-block.json +34 -0
package/src/__tests__/fixtures/leaf-marks.json +199 -0
package/src/__tests__/fixtures/mdx-jsx-flow.json +40 -0
package/src/__tests__/fixtures/mdx-jsx-text.json +53 -0
package/src/__tests__/forms-store.test.ts +70 -0
package/src/__tests__/integration.test.ts +124 -0
package/src/__tests__/island-route.test.ts +119 -0
package/src/__tests__/middleware.test.ts +102 -0
package/src/__tests__/sanitize.test.ts +75 -0
package/src/__tests__/vite.test.ts +67 -0
package/src/bridge.ts +7 -0
package/src/data.test-d.ts +53 -0
package/src/data.ts +73 -0
package/src/experimental.ts +14 -0
package/src/index.ts +54 -0
package/src/integration.ts +94 -0
package/src/internal/admin-origin.ts +19 -0
package/src/internal/escape.ts +15 -0
package/src/internal/forms-store.ts +50 -0
package/src/internal/request-context.ts +23 -0
package/src/is-edit-mode.ts +68 -0
package/src/island-route.ts +109 -0
package/src/middleware.ts +89 -0
package/src/sanitize.ts +64 -0
package/src/tina-field.ts +1 -0
package/src/types.ts +97 -0
package/src/vite.ts +40 -0
package/dist/preview.d.ts +0 -1
package/dist/preview.js +0 -1

package/README.md CHANGED Viewed

@@ -5,22 +5,42 @@ The one-stop [TinaCMS](https://tina.io) integration for Astro. Ships:
 - A vanilla-Astro **rich-text renderer** that mirrors the React `TinaMarkdown` API — same `content` prop, same `components` map shape, but emits pure HTML with no React in the page tree.
 - The framework-agnostic **`@tinacms/bridge`** re-exported under `@tinacms/astro/bridge` so you only install one package.
+> **Adopting in a new project?** Follow the step-by-step [GETTING_STARTED.md](./GETTING_STARTED.md) — covers install (incl. `@tinacms/cli`), integration wiring, data loaders, island registry, and troubleshooting. The rest of this README is the API reference.
 ## Install
 ```bash
-pnpm add @tinacms/astro
+pnpm add @tinacms/astro tinacms
+pnpm add -D @tinacms/cli
 ```
-Requires Astro 5.
+Requires Astro 5 and an SSR adapter (`@astrojs/node`, `vercel`, `netlify`, or `cloudflare`) — the island-refresh endpoint (`/tina-island/[name]`) is on-demand. `output: 'server'` is the simplest choice; `output: 'static'` also works as long as editable regions are wrapped in [`<TinaIsland>`](#static-site-editing) and the adapter can serve that one on-demand route.
 ## Usage
+Add the integration to `astro.config.mjs` once. It wires the request-scoped middleware and stages the bundled bridge as a static asset at `/admin/bridge.js` — everything else is auto-injected only on edit-mode requests:
+```ts
+// astro.config.mjs
+import { defineConfig } from 'astro/config';
+import tina from '@tinacms/astro/integration';
+export default defineConfig({
+  integrations: [tina()],
+});
+```
+Then load data the same way you would in any TinaCMS project — call the generated client, wrap the result with `requestWithMetadata()`:
 ```astro
 ---
-import TinaMarkdown from '@tinacms/astro';
-import { tinaField } from '@tinacms/astro/tina-field';
+import TinaMarkdown from '@tinacms/astro/TinaMarkdown.astro';
+import { requestWithMetadata, tinaField } from '@tinacms/astro';
+import client from '../tina/__generated__/client';
-const post = await client.queries.post({ relativePath: 'hello.md' });
+const post = await requestWithMetadata(
+  client.queries.post({ relativePath: 'hello.md' }),
+);
 ---
 <article>
   <h1 data-tina-field={tinaField(post.data.post, 'title')}>
@@ -32,28 +52,38 @@ const post = await client.queries.post({ relativePath: 'hello.md' });
 </article>
 ```
-Wire the bridge in your base layout to enable click-to-focus and live preview:
+That's the whole user surface. No wiring component in your layout, no `forms` prop to maintain, no `Astro.request` to thread. The integration's middleware buffers each HTML response, and on edit-mode requests splices the form payloads and a `<script type="module" src="/admin/bridge.js">` before `</head>`. Production visitors get **byte-identical HTML to a Tina-free Astro app** — no `data-tina-form` divs, no script tag, no bundle preload. (Exception: pages that use [`<TinaIsland>`](#static-site-editing) carry a one-line inline bootstrap so editing also works when the page is statically built.)
-```astro
-<head>
-  <script type="application/tina+json" set:html={JSON.stringify(form)} />
-  <script>
-    import { init } from '@tinacms/astro/bridge';
-    init();
-  </script>
-</head>
-```
+For cross-origin admin deployments (Codespaces, separate-domain self-hosted), set `PUBLIC_TINA_ADMIN_ORIGIN` in your env (comma-separate to allow multiple). The middleware embeds it inline so the bridge validates inbound `postMessage` events.
+## Static-site editing
+`output: 'static'` is supported. The middleware described above only runs on on-demand-rendered routes, so on a prerendered page it never injects anything — instead, **`<TinaIsland>` emits a tiny in-iframe bootstrap script** that loads `/admin/bridge.js` *only* when the page is inside the admin iframe (a no-op for everyone else). On boot the bridge "primes" the page by fetching each island's `/tina-island/[name]` endpoint — which is `prerender = false`, so the adapter still renders it on demand — to pick up the page's form payloads, after which editing works exactly as it does in an SSR project.
+Requirements for static editing:
+- Wrap every editable region in `<TinaIsland>` with a registered island (see [GETTING_STARTED.md](./GETTING_STARTED.md) steps 5–7) — that's both how the bridge re-renders regions and how the bootstrap gets onto the page.
+- Pass `primary` on your page's main `<TinaIsland>` (`<TinaIsland name="post" params={{ slug }} primary>`). On a static page the bridge can't tell which island is "the page", so without this the editor may land on the multi-document "Referenced Files" list when the page also has e.g. a global-config form. (On SSR pages the first `requestWithMetadata()` call is treated as primary automatically; pass `{ priority: 'primary' }` as the second argument if you need to override that.) Mark at most one per page.
+- Keep the `tina-island/[name].ts` route (`export const prerender = false`).
+Trade-off: a page that uses `<TinaIsland>` carries that one-line inline bootstrap in its production HTML, so it's no longer byte-identical to a Tina-free Astro app. Pages without `<TinaIsland>` are unaffected. (On `output: 'server'` the middleware path is unchanged; the bootstrap and the middleware's own injection coexist harmlessly — `bridge.init()` is idempotent.)
 ## Subpath exports
 | Subpath | What it gives you |
 |---------|-------------------|
-| `@tinacms/astro` | `TinaMarkdown` (default) |
+| `@tinacms/astro` | `requestWithMetadata`, `tinaField`, `QueryResult`, and types |
+| `@tinacms/astro/TinaMarkdown.astro` | `<TinaMarkdown content components />` — rich-text renderer. Import from this subpath so Astro's check sees a real `.astro` component (the bare-package default resolves through the types condition to a placeholder). |
+| `@tinacms/astro/integration` | `tina()` integration — auto-wires the middleware and stages the static `/admin/bridge.js` asset so `requestWithMetadata()` works without you threading `Astro.request` or writing wiring components |
+| `@tinacms/astro/TinaIsland.astro` | `<TinaIsland name wrapper params [primary] />` — marker wrapper for an editable region; pass `primary` on the page's main region so the editor opens that form instead of the "Referenced Files" list |
 | `@tinacms/astro/types` | `TinaRichTextContent`, `CustomComponentsMap`, `TinaRichTextNode`, `MdxElement`, `TextElement` |
 | `@tinacms/astro/sanitize` | `sanitizeHref` / `sanitizeImageSrc` for CMS-supplied URLs |
-| `@tinacms/astro/bridge` | `init` and the rest of `@tinacms/bridge` |
+| `@tinacms/astro/bridge` | `init`, `refreshForms`, and the rest of `@tinacms/bridge` |
 | `@tinacms/astro/tina-field` | `tinaField()` helper |
-| `@tinacms/astro/preview` | `readOverlay()` server helper for island refresh endpoints |
+| `@tinacms/astro/is-edit-mode` | `isEditMode(request)` — server-side admin-iframe detection |
+| `@tinacms/astro/middleware` | The middleware the integration auto-wires — exported here in case you need to compose it manually |
+| `@tinacms/astro/vite` | `tinaAdminDevRedirect()` — dev-only Vite plugin that redirects `/admin` and `/admin/` to `/admin/index.html` so the admin SPA is reachable from a bare URL during `astro dev` |
+| `@tinacms/astro/experimental` | `experimental_createIslandRoute()` — opt-in helper built on Astro's unstable `experimental_AstroContainer` |
 ## Custom MDX components
@@ -61,7 +91,7 @@ Register Astro components against the names Tina uses for them in the editor:
 ```astro
 ---
-import TinaMarkdown from '@tinacms/astro';
+import TinaMarkdown from '@tinacms/astro/TinaMarkdown.astro';
 import type { CustomComponentsMap } from '@tinacms/astro/types';
 import BlockQuote from '../components/BlockQuote.astro';
 import NewsletterSignup from '../components/NewsletterSignup.astro';
@@ -99,8 +129,8 @@ The renderer doesn't emit `data-tina-field` attributes — wrap the call site to
 ```astro
 ---
+import TinaMarkdown from '@tinacms/astro/TinaMarkdown.astro';
 import { tinaField } from '@tinacms/astro/tina-field';
-import TinaMarkdown from '@tinacms/astro';
 ---
 <div data-tina-field={tinaField(post.data.post, '_body')}>
   <TinaMarkdown content={post.data.post._body} components={components} />

package/dist/bridge.d.ts CHANGED Viewed

@@ -1 +1,7 @@
-export * from "../src/bridge"
+/**
+ * Re-exports of `@tinacms/bridge` so Astro projects can pull the bridge from
+ * `@tinacms/astro/bridge` instead of installing it separately. The bridge
+ * package stays publishable on its own for non-Astro frontends (Hugo, plain
+ * HTML, Eleventy).
+ */
+export * from '@tinacms/bridge';

package/dist/bridge.js CHANGED Viewed

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

package/dist/data.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+export interface QueryResult<TData> {
+    data: TData;
+    query: string;
+    variables: Record<string, unknown>;
+    id: string;
+}
+type ClientResult<TData> = {
+    data: TData;
+    query: string;
+    variables: Record<string, unknown>;
+} | null | undefined;
+export interface RequestOptions {
+    /** Mark the page's own document so the admin opens it on load instead
+     *  of a layout-level global. Mirrors `useTina`'s
+     *  `experimental___selectFormByFormId`. */
+    priority?: 'primary';
+}
+export declare function requestWithMetadata<TData>(source: ClientResult<TData> | Promise<ClientResult<TData>>, options?: RequestOptions): Promise<QueryResult<TData>>;
+export {};

package/dist/data.js ADDED Viewed

@@ -0,0 +1,64 @@
+// 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;
+}
+export {
+  requestWithMetadata
+};

package/dist/data.test-d.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/experimental.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * Experimental surface area. Anything here may change in a minor or
+ * patch release — opt in only when the underlying tradeoff is worth
+ * it for your project.
+ *
+ * `experimental_createIslandRoute` builds on Astro's
+ * `experimental_AstroContainer`, which Astro itself flags as unstable;
+ * this re-export inherits the same caveat.
+ */
+export { experimental_createIslandRoute, type IslandConfig, type IslandRegistry, } from './island-route';

package/dist/experimental.js ADDED Viewed

@@ -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/index.d.ts CHANGED Viewed

@@ -1 +1,36 @@
-export * from "../src/index"
+/**
+ * Runtime entry for the package's `.` subpath. Astro consumers resolve
+ * through the `astro` export condition straight to `src/TinaMarkdown.astro`
+ * — they get the real component as the default export plus the named
+ * helpers re-exported from the .astro frontmatter.
+ *
+ * This file is the fallback for any tool that *doesn't* understand the
+ * `astro` condition (TypeScript types, plain Node ESM resolution). It
+ * exposes the named runtime helpers and a placeholder default that
+ * throws with a clear redirect if someone reaches it.
+ */
+import type { AstroComponentFactory } from 'astro/runtime/server/index.js';
+import type { CustomComponentsMap, TinaRichTextContent } from './types';
+export { requestWithMetadata, type QueryResult } from './data';
+export { tinaField } from './tina-field';
+export type { AstroComponent, CustomComponentsMap, MdxElement, TextElement, TinaRichTextContent, TinaRichTextNode, TinaRichTextRoot, } from './types';
+/**
+ * Typed shape of `<TinaMarkdown content={...} components={...} />` for tools
+ * that resolve through the `types` / `default` export condition rather than
+ * the `astro` condition. The actual component is `src/TinaMarkdown.astro`;
+ * this placeholder throws if invoked because the only legitimate caller is
+ * Astro's component pipeline, which reaches the .astro file directly.
+ *
+ * The intersection of `AstroComponentFactory` (Astro's component-validity
+ * check) and a typed prop signature (TinaMarkdown's actual API) gives the
+ * Astro language server enough shape to both recognise this as a renderable
+ * component AND offer prop completions / type errors at the call site.
+ */
+type TinaMarkdownComponent = AstroComponentFactory & {
+    (props: {
+        content: TinaRichTextContent;
+        components?: CustomComponentsMap;
+    }): unknown;
+};
+declare const TinaMarkdownPlaceholder: TinaMarkdownComponent;
+export default TinaMarkdownPlaceholder;

package/dist/index.js CHANGED Viewed

@@ -1,4 +1,94 @@
-const TinaMarkdown$1 = TinaMarkdown;
+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 {
-  TinaMarkdown$1 as default
+  index_default as default,
+  requestWithMetadata,
+  export_tinaField as tinaField
 };

package/dist/integration.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import type { AstroIntegration } from 'astro';
+export interface TinaIntegrationOptions {
+    middlewareOrder?: 'pre' | 'post';
+}
+export default function tina(options?: TinaIntegrationOptions): AstroIntegration;

package/dist/integration.js ADDED Viewed

@@ -0,0 +1,69 @@
+// 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";
+function tina(options = {}) {
+  const { middlewareOrder = "pre" } = options;
+  let clientDir;
+  return {
+    name: "@tinacms/astro",
+    hooks: {
+      "astro:config:setup": ({ addMiddleware, updateConfig }) => {
+        addMiddleware({
+          entrypoint: "@tinacms/astro/middleware",
+          order: middlewareOrder
+        });
+        updateConfig({ vite: { plugins: [bridgeDevPlugin()] } });
+      },
+      "astro:config:done": ({ config }) => {
+        clientDir = config.build.client;
+      },
+      "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 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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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
+};