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

@tinacms/astro 0.0.1 → 0.2.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 (64) hide show

package/README.md +37 -20
package/dist/bridge-route.d.ts +3 -0
package/dist/bridge-route.js +22 -0
package/dist/bridge.d.ts +7 -1
package/dist/bridge.js +1 -0
package/dist/data.d.ts +16 -0
package/dist/data.js +59 -0
package/dist/experimental.d.ts +10 -0
package/dist/experimental.js +57 -0
package/dist/index.d.ts +36 -1
package/dist/index.js +87 -2
package/dist/integration.d.ts +25 -0
package/dist/integration.js +22 -0
package/dist/internal/escape.d.ts +8 -0
package/dist/internal/forms-store.d.ts +23 -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 +43 -0
package/dist/island-route.js +57 -0
package/dist/middleware.d.ts +20 -0
package/dist/middleware.js +109 -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/package.json +89 -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 +42 -0
package/src/TinaMarkdown.astro +8 -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__/sanitize.test.ts +75 -0
package/src/bridge-route.ts +33 -0
package/src/bridge.ts +7 -0
package/src/data.ts +97 -0
package/src/experimental.ts +14 -0
package/src/index.ts +54 -0
package/src/integration.ts +49 -0
package/src/internal/escape.ts +15 -0
package/src/internal/forms-store.ts +41 -0
package/src/internal/request-context.ts +23 -0
package/src/is-edit-mode.ts +68 -0
package/src/island-route.ts +110 -0
package/src/middleware.ts +118 -0
package/src/sanitize.ts +64 -0
package/src/tina-field.ts +1 -0
package/src/types.ts +97 -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. Also needs an SSR adapter (`@astrojs/node`, `vercel`, `netlify`, or `cloudflare`) and `output: 'server'` in your Astro config.
 ## Usage
+Add the integration to `astro.config.mjs` once. It wires the request-scoped middleware and the dynamic route that serves the bridge — 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,25 @@ 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="/_tina/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.
-```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.
 ## 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 middleware + bridge route so `requestWithMetadata()` works without you threading `Astro.request` or writing wiring components |
+| `@tinacms/astro/TinaIsland.astro` | `<TinaIsland name wrapper params />` — marker wrapper for an editable region |
 | `@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/experimental` | `experimental_createIslandRoute()` — opt-in helper built on Astro's unstable `experimental_AstroContainer` |
 ## Custom MDX components
@@ -61,7 +78,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 +116,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-route.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { APIRoute } from 'astro';
+export declare const prerender = false;
+export declare const GET: APIRoute;

package/dist/bridge-route.js ADDED Viewed

@@ -0,0 +1,22 @@
+// src/bridge-route.ts
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var cached;
+function loadBridge() {
+  if (cached !== void 0) return cached;
+  const bridgePath = require2.resolve("@tinacms/bridge");
+  cached = readFileSync(bridgePath, "utf-8");
+  return cached;
+}
+var prerender = false;
+var GET = () => new Response(loadBridge(), {
+  headers: {
+    "Content-Type": "application/javascript; charset=utf-8",
+    "Cache-Control": "public, max-age=31536000, immutable"
+  }
+});
+export {
+  GET,
+  prerender
+};

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,16 @@
+export interface QueryResult<TData> {
+    data: TData;
+    query: string;
+    variables: Record<string, unknown>;
+    id: string;
+}
+/** Shape every `client.queries.<name>` returns. Inferring from this lets
+ *  `requestWithMetadata()` stay framework-agnostic — it doesn't need to
+ *  know about `PostQuery`, `PageQuery`, etc. */
+type ClientResult<TData> = {
+    data: TData;
+    query: string;
+    variables: Record<string, unknown>;
+} | null | undefined;
+export declare function requestWithMetadata<TData>(source: ClientResult<TData> | Promise<ClientResult<TData>>): Promise<QueryResult<TData>>;
+export {};

package/dist/data.js ADDED Viewed

@@ -0,0 +1,59 @@
+// 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;
+  if (list.some((existing) => existing.id === form.id)) 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) {
+  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
+  });
+  return enriched;
+}
+export {
+  requestWithMetadata
+};

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,57 @@
+// src/island-route.ts
+import { experimental_AstroContainer as AstroContainer } from "astro/container";
+import { PREVIEW_CONTENT_TYPE } from "@tinacms/bridge/preview";
+// 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/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 });
+    }
+    try {
+      const data = await island.fetch(request, url.searchParams);
+      const container = await AstroContainer.create();
+      const html = await container.renderToString(island.component, {
+        props: island.propsFromData(data, url.searchParams)
+      });
+      return new Response(wrapIsland(html, island.wrapper, url), {
+        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 });
+  }
+  const fetchSite = request.headers.get("sec-fetch-site");
+  if (fetchSite === "cross-site" || fetchSite === "cross-origin") {
+    return new Response("Forbidden", { status: 403 });
+  }
+  return null;
+}
+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,89 @@
-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;
+  if (list.some((existing) => existing.id === form.id)) 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) {
+  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
+  });
+  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,25 @@
+/**
+ * Tina Astro integration. Wires the middleware that exposes
+ * `Astro.locals.tinaEdit` so pages and components can branch on edit
+ * context without writing `src/middleware.ts` themselves.
+ *
+ * Usage:
+ *
+ * ```ts
+ * // astro.config.mjs
+ * import { defineConfig } from 'astro/config';
+ * import tina from '@tinacms/astro/integration';
+ *
+ * export default defineConfig({
+ *   integrations: [tina()],
+ * });
+ * ```
+ */
+import type { AstroIntegration } from 'astro';
+export interface TinaIntegrationOptions {
+    /** Override the middleware ordering relative to other integrations.
+     *  Defaults to `'pre'` so `Astro.locals.tinaEdit` is populated before
+     *  user middleware sees the request. */
+    middlewareOrder?: 'pre' | 'post';
+}
+export default function tina(options?: TinaIntegrationOptions): AstroIntegration;

package/dist/integration.js ADDED Viewed

@@ -0,0 +1,22 @@
+// src/integration.ts
+function tina(options = {}) {
+  const { middlewareOrder = "pre" } = options;
+  return {
+    name: "@tinacms/astro",
+    hooks: {
+      "astro:config:setup": ({ addMiddleware, injectRoute }) => {
+        addMiddleware({
+          entrypoint: "@tinacms/astro/middleware",
+          order: middlewareOrder
+        });
+        injectRoute({
+          pattern: "/_tina/bridge.js",
+          entrypoint: "@tinacms/astro/bridge-route"
+        });
+      }
+    }
+  };
+}
+export {
+  tina as default
+};

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,23 @@
+/**
+ * Per-request collector for `tina()` results. Each call pushes its
+ * `{id, query, variables, data}` payload here so the integration's
+ * middleware can read the full list at response time and splice the
+ * bridge wiring into edit-mode pages — the user never writes a `forms`
+ * prop or imports a wiring component.
+ *
+ * Initialised by the middleware the `tina()` integration injects.
+ *
+ * The store is keyed by a `Symbol.for(...)` slot on `globalThis` so all
+ * bundle copies of this module (esbuild inlines it into each entry that
+ * imports it) share the same instance — without that, the middleware
+ * would `.run()` one ALS while `tina()` reads from a different one.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+export interface CollectedForm {
+    id: string;
+    query: string;
+    variables: object;
+    data: object;
+}
+export declare const formsStore: AsyncLocalStorage<CollectedForm[]>;
+export declare function recordForm(form: CollectedForm): void;

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

package/dist/island-route.d.ts ADDED Viewed

@@ -0,0 +1,43 @@
+/**
+ * Factory for the dynamic `/tina-island/[name]` endpoint the bridge calls
+ * to refetch a region with the editor's overlay applied. Each entry in
+ * `islands` describes one editable region: how to load its data, which
+ * Astro component to render, and the wrapper element the page-side
+ * `<div data-tina-island>` is expected to swap.
+ *
+ * @experimental
+ *
+ * Built on Astro's `experimental_AstroContainer`, which is itself
+ * experimental — Astro may break the underlying API in any minor or patch
+ * release. The shape of `createIslandRoute` is similarly experimental and
+ * will graduate once the container API stabilises.
+ *
+ * Usage:
+ *
+ * ```ts
+ * // src/pages/tina-island/[name].ts
+ * import { experimental_createIslandRoute } from '@tinacms/astro/experimental';
+ * import { islands } from '../../lib/islands';
+ *
+ * export const prerender = false;
+ * export const ALL = experimental_createIslandRoute(islands);
+ * ```
+ */
+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;