@407dev/cms-astro 0.1.0

package/dist/index.js

@@ -0,0 +1,956 @@
+import { mintDevPreviewToken } from './chunk-7LMUFCWX.js';
+export { signPreviewToken, verifyPreviewToken } from './chunk-7LMUFCWX.js';
+import { collectionPaths, defineCollection, getEntry, getEntries, markBundleReady } from './chunk-7E3XJLKX.js';
+export { bundleReady, collectionPaths, defineCollection, getEntries, getEntry, isBundleReady, markBundleReady } from './chunk-7E3XJLKX.js';
+import { initCmsClient, buildBridgeScript, getClient } from './chunk-QYUVAKMC.js';
+export { createCmsClient, createPreviewMiddleware, getClient, initCmsClient, setClient } from './chunk-QYUVAKMC.js';
+import './chunk-B4YYLS7Y.js';
+import { getActiveBundle, recordMissingField, getMissingFieldWarnings, clearMissingFieldWarnings } from './chunk-DMLOBKYE.js';
+export { clearMissingFieldWarnings, getActiveBundle, getBuildBundle, getMissingFieldWarnings, isDraftMode, recordMissingField, runWithDraftBundle, setActiveDraftBundle, setBuildBundle, updateBundleFieldValue } from './chunk-DMLOBKYE.js';
+import './chunk-2TKIQIOE.js';
+export { DEFAULT_EDITOR_ORIGINS, resolveEditorOrigins } from './chunk-XJPVYMZM.js';
+import { listFieldTypes, getFieldType, isValidLinkHref } from '@407dev/field-types';
+import { createComponent, spreadAttributes, renderTemplate, markHTMLString } from 'astro/runtime/server/index.js';
+export { z } from '@407dev/blocks';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+function escapeHtml(str) {
+  if (typeof str !== "string") return "";
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var KNOWN_NODES = /* @__PURE__ */ new Set([
+  "doc",
+  "paragraph",
+  "heading",
+  "bulletList",
+  "orderedList",
+  "listItem",
+  "blockquote",
+  "codeBlock",
+  "hardBreak",
+  "horizontalRule",
+  "text",
+  "image"
+]);
+var KNOWN_MARKS = /* @__PURE__ */ new Set(["bold", "italic", "underline", "strike", "code", "link"]);
+function parseRichTextDoc(value) {
+  if (!value) return null;
+  let parsed = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const root = parsed;
+  if (root.type !== "doc" && !Array.isArray(root.content)) return null;
+  return root;
+}
+function renderMarksOnly(text, marks) {
+  let out = escapeHtml(text || "");
+  if (!Array.isArray(marks)) return out;
+  for (const mark of marks) {
+    if (!mark || typeof mark !== "object" || mark.type === "link" || !KNOWN_MARKS.has(mark.type)) {
+      continue;
+    }
+    if (mark.type === "bold") out = `<strong>${out}</strong>`;
+    else if (mark.type === "italic") out = `<em>${out}</em>`;
+    else if (mark.type === "underline") out = `<u>${out}</u>`;
+    else if (mark.type === "strike") out = `<s>${out}</s>`;
+    else if (mark.type === "code") out = `<code>${out}</code>`;
+  }
+  return out;
+}
+function getLinkMarkAttrs(marks) {
+  if (!Array.isArray(marks)) return null;
+  const linkMark = marks.find((m) => m && typeof m === "object" && m.type === "link");
+  if (!linkMark) return null;
+  const rawHref = linkMark.attrs?.href;
+  if (typeof rawHref !== "string" || !isValidLinkHref(rawHref)) return null;
+  const target = typeof linkMark.attrs?.target === "string" ? linkMark.attrs.target : void 0;
+  const rel = typeof linkMark.attrs?.rel === "string" ? linkMark.attrs.rel : target === "_blank" ? "noopener noreferrer" : void 0;
+  const title = typeof linkMark.attrs?.title === "string" ? linkMark.attrs.title : void 0;
+  return { href: rawHref, target, rel, title };
+}
+function renderRichTextHtml(doc, options = {}) {
+  if (!doc) return "";
+  let parsedDoc = doc;
+  if (typeof doc === "string") {
+    try {
+      parsedDoc = JSON.parse(doc);
+    } catch {
+      return `<p>${escapeHtml(doc)}</p>`;
+    }
+  }
+  if (typeof parsedDoc !== "object" || parsedDoc === null) {
+    return "";
+  }
+  const root = parsedDoc;
+  if (root.type !== "doc" && !Array.isArray(root.content)) {
+    return "";
+  }
+  const isDev = typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+  const maxDepth = options.maxDepth ?? 50;
+  function renderNode(node, depth = 0) {
+    if (depth > maxDepth) return "";
+    if (!node || typeof node !== "object") return "";
+    const n = node;
+    const nodeType = n.type || "";
+    if (!KNOWN_NODES.has(nodeType)) {
+      if (isDev) {
+        console.warn(`[RichText] Skipped unknown node type: "${nodeType}"`);
+      }
+      return "";
+    }
+    if (nodeType === "text") {
+      let text = escapeHtml(n.text || "");
+      if (Array.isArray(n.marks)) {
+        for (const mark of n.marks) {
+          if (!mark || typeof mark !== "object") continue;
+          const markType = mark.type;
+          if (!KNOWN_MARKS.has(markType)) {
+            if (isDev) {
+              console.warn(`[RichText] Skipped unknown mark type: "${markType}"`);
+            }
+            continue;
+          }
+          if (markType === "bold") {
+            text = `<strong>${text}</strong>`;
+          } else if (markType === "italic") {
+            text = `<em>${text}</em>`;
+          } else if (markType === "underline") {
+            text = `<u>${text}</u>`;
+          } else if (markType === "strike") {
+            text = `<s>${text}</s>`;
+          } else if (markType === "code") {
+            text = `<code>${text}</code>`;
+          } else if (markType === "link") {
+            const rawHref = mark.attrs?.href;
+            if (typeof rawHref === "string" && isValidLinkHref(rawHref)) {
+              const href = escapeHtml(rawHref);
+              const target = typeof mark.attrs?.target === "string" ? ` target="${escapeHtml(mark.attrs.target)}"` : "";
+              const rel = typeof mark.attrs?.rel === "string" ? ` rel="${escapeHtml(mark.attrs.rel)}"` : target.includes("_blank") ? ' rel="noopener noreferrer"' : "";
+              text = `<a href="${href}"${target}${rel}>${text}</a>`;
+            }
+          }
+        }
+      }
+      return text;
+    }
+    const children = Array.isArray(n.content) ? n.content.map((c) => renderNode(c, depth + 1)).join("") : "";
+    switch (nodeType) {
+      case "doc":
+        return children;
+      case "paragraph":
+        return `<p>${children}</p>`;
+      case "heading": {
+        const rawLevel = n.attrs?.level;
+        const level = typeof rawLevel === "number" && rawLevel >= 1 && rawLevel <= 6 ? rawLevel : 2;
+        return `<h${level}>${children}</h${level}>`;
+      }
+      case "bulletList":
+        return `<ul>${children}</ul>`;
+      case "orderedList": {
+        const start = n.attrs?.start || n.attrs?.order;
+        const startAttr = typeof start === "number" && start !== 1 ? ` start="${start}"` : "";
+        return `<ol${startAttr}>${children}</ol>`;
+      }
+      case "listItem":
+        return `<li>${children}</li>`;
+      case "blockquote":
+        return `<blockquote>${children}</blockquote>`;
+      case "codeBlock": {
+        const lang = typeof n.attrs?.language === "string" ? ` data-language="${escapeHtml(n.attrs.language)}"` : "";
+        return `<pre><code${lang}>${children}</code></pre>`;
+      }
+      case "hardBreak":
+        return "<br />";
+      case "horizontalRule":
+        return "<hr />";
+      case "image": {
+        if (options.components?.image) {
+          const src = typeof n.attrs?.src === "string" ? escapeHtml(n.attrs.src) : "";
+          const alt = typeof n.attrs?.alt === "string" ? escapeHtml(n.attrs.alt) : "";
+          return `<img src="${src}" alt="${alt}" />`;
+        }
+        return "";
+      }
+      default:
+        return children;
+    }
+  }
+  return renderNode(root);
+}
+
+// src/fields/attrs.ts
+function cmsFieldAttr(key) {
+  return { "data-cms-field": key };
+}
+function cmsGroupAttr(groupName, prefix) {
+  return { "data-cms-group": `${groupName}:${prefix}` };
+}
+function cmsEntryAttr(collectionKey, slug) {
+  if (slug) {
+    return {
+      "data-cms-collection": collectionKey,
+      "data-cms-entry": slug
+    };
+  }
+  return { "data-cms-collection": collectionKey };
+}
+function cmsEntryFieldAttr(path2) {
+  return { "data-cms-entry-field": path2 };
+}
+var DEFAULT_TAGS = {
+  text: "span",
+  number: "span",
+  toggle: "span",
+  select: "span",
+  image: "img",
+  img: "img",
+  video: "video",
+  vid: "video",
+  richtext: "div",
+  richText: "div"
+};
+function getPlaceholderForType(typeId, fullKey) {
+  const isDev = typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+  if (isDev) {
+    return `[${fullKey}]`;
+  }
+  const typeDef = getFieldType(typeId);
+  if (typeDef && typeDef.defaultValue !== void 0) {
+    return typeDef.defaultValue;
+  }
+  switch (typeId) {
+    case "number":
+      return 0;
+    case "toggle":
+      return false;
+    case "image":
+    case "video":
+      return null;
+    case "richtext":
+      return null;
+    default:
+      return "";
+  }
+}
+function createDualCallableHelper(typeId, publicName, prefix = "", defaultKey = "") {
+  const typeDef = getFieldType(typeId) || getFieldType(publicName);
+  const defaultTag = DEFAULT_TAGS[typeId] || DEFAULT_TAGS[publicName] || typeDef?.renderHint?.tag || "span";
+  const componentFactory = createComponent(async ($$result, $$props, _slots) => {
+    const rawKey = $$props?.k ?? $$props?.key ?? defaultKey;
+    const fullKey = prefix ? rawKey ? `${prefix}.${rawKey}` : prefix : rawKey;
+    const tag = $$props?.as || $$props?.tag || defaultTag;
+    const defaultValue = $$props?.defaultValue;
+    const bundle = getActiveBundle();
+    const rawVal = fullKey ? bundle?.fields?.[fullKey] : void 0;
+    let displayVal = rawVal;
+    if (displayVal === void 0 || displayVal === null) {
+      if (defaultValue !== void 0) {
+        displayVal = defaultValue;
+      } else {
+        if (fullKey) {
+          recordMissingField(fullKey);
+        }
+        displayVal = getPlaceholderForType(typeId, fullKey);
+      }
+    }
+    const {
+      k: _k,
+      key: _key,
+      defaultValue: _def,
+      as: _as,
+      tag: _tag,
+      components: _comp,
+      ...htmlProps
+    } = $$props || {};
+    const attrs = {
+      ...htmlProps
+    };
+    if (fullKey) {
+      attrs["data-cms-field"] = fullKey;
+    }
+    if (!attrs["data-cms-kind"]) {
+      attrs["data-cms-kind"] = typeId;
+    }
+    if (typeId === "image" || publicName === "img") {
+      if (displayVal && typeof displayVal === "object") {
+        const asset = displayVal;
+        if (asset.url && !attrs.src) attrs.src = asset.url;
+        if (asset.alt && !attrs.alt) attrs.alt = asset.alt;
+        if (asset.width && !attrs.width) attrs.width = asset.width;
+        if (asset.height && !attrs.height) attrs.height = asset.height;
+      } else if (typeof displayVal === "string" && displayVal) {
+        if (!attrs.src) attrs.src = displayVal;
+      }
+      return renderTemplate`<img${spreadAttributes(attrs)}>`;
+    }
+    if (typeId === "video" || publicName === "vid") {
+      if (displayVal && typeof displayVal === "object") {
+        const asset = displayVal;
+        if (asset.url && !attrs.src) attrs.src = asset.url;
+        if (asset.poster && !attrs.poster) attrs.poster = asset.poster;
+        if (asset.width && !attrs.width) attrs.width = asset.width;
+        if (asset.height && !attrs.height) attrs.height = asset.height;
+      } else if (typeof displayVal === "string" && displayVal) {
+        if (!attrs.src) attrs.src = displayVal;
+      }
+      if (attrs.controls === void 0) attrs.controls = true;
+      return renderTemplate`<video${spreadAttributes(attrs)}></video>`;
+    }
+    if (typeId === "richtext" || publicName === "richText") {
+      const html = renderRichTextHtml(displayVal, { components: $$props?.components });
+      return renderTemplate`<${tag}${spreadAttributes(attrs)}>${markHTMLString(html)}</${tag}>`;
+    }
+    return renderTemplate`<${tag}${spreadAttributes(attrs)}>${displayVal !== null && displayVal !== void 0 ? String(displayVal) : ""}</${tag}>`;
+  });
+  const fn = (arg0, ...rest) => {
+    const isComponentCall = arg0 && typeof arg0 === "object" && "styles" in arg0 && "scripts" in arg0;
+    if (!isComponentCall) {
+      let rawKey = defaultKey;
+      let options = {};
+      if (typeof arg0 === "string") {
+        rawKey = arg0;
+        options = rest[0] || {};
+      } else if (arg0 && typeof arg0 === "object") {
+        options = arg0;
+      }
+      const fullKey = prefix ? rawKey ? `${prefix}.${rawKey}` : prefix : rawKey;
+      const bundle = getActiveBundle();
+      const val = fullKey ? bundle?.fields?.[fullKey] : void 0;
+      if (val !== void 0 && val !== null) {
+        return val;
+      }
+      if (options.defaultValue !== void 0) {
+        return options.defaultValue;
+      }
+      if (fullKey) {
+        recordMissingField(fullKey);
+      }
+      return getPlaceholderForType(typeId, fullKey);
+    }
+    return componentFactory(arg0, rest[0], rest[1]);
+  };
+  Object.assign(fn, {
+    isAstroComponentFactory: true,
+    typeId,
+    publicName,
+    prefix,
+    defaultKey
+  });
+  return fn;
+}
+function generateAllFieldHelpers(prefix = "") {
+  const helpers = {};
+  const types = listFieldTypes();
+  for (const def of types) {
+    helpers[def.id] = createDualCallableHelper(def.id, def.id, prefix);
+    if (def.aliases) {
+      for (const alias of def.aliases) {
+        helpers[alias] = createDualCallableHelper(def.id, alias, prefix);
+      }
+    }
+  }
+  return helpers;
+}
+var createFieldHelpersMap = generateAllFieldHelpers;
+
+// src/fields/entryScope.ts
+var DEFAULT_TAGS2 = {
+  text: "span",
+  number: "span",
+  toggle: "span",
+  select: "span",
+  image: "img",
+  img: "img",
+  video: "video",
+  vid: "video",
+  richtext: "div",
+  richText: "div"
+};
+function getNestedValue(obj, path2) {
+  if (!obj || typeof obj !== "object" || !path2) return void 0;
+  if (path2 in obj) {
+    return obj[path2];
+  }
+  const parts = path2.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function createEntryDualCallableHelper(typeId, publicName, collectionKey, slug, defaultPath = "") {
+  const typeDef = getFieldType(typeId) || getFieldType(publicName);
+  const defaultTag = DEFAULT_TAGS2[typeId] || DEFAULT_TAGS2[publicName] || typeDef?.renderHint?.tag || "span";
+  const componentFactory = createComponent(async ($$result, $$props, _slots) => {
+    const rawPath = $$props?.k ?? $$props?.key ?? defaultPath;
+    const tag = $$props?.as || $$props?.tag || defaultTag;
+    const defaultValue = $$props?.defaultValue;
+    const bundle = getActiveBundle();
+    const entries = bundle?.entries?.[collectionKey] || [];
+    const entry = entries.find((e) => e.slug === slug);
+    const rawVal = entry?.content ? getNestedValue(entry.content, rawPath) : void 0;
+    let displayVal = rawVal;
+    if (displayVal === void 0 || displayVal === null) {
+      if (defaultValue !== void 0) {
+        displayVal = defaultValue;
+      } else {
+        displayVal = getPlaceholderForType(typeId, rawPath);
+      }
+    }
+    const {
+      k: _k,
+      key: _key,
+      defaultValue: _def,
+      as: _as,
+      tag: _tag,
+      components: _comp,
+      ...htmlProps
+    } = $$props || {};
+    const attrs = {
+      ...htmlProps
+    };
+    if (rawPath) {
+      attrs["data-cms-entry-field"] = rawPath;
+    }
+    if (!attrs["data-cms-kind"]) {
+      attrs["data-cms-kind"] = typeId;
+    }
+    if (typeId === "image" || publicName === "img") {
+      if (displayVal && typeof displayVal === "object") {
+        const asset = displayVal;
+        if (asset.url && !attrs.src) attrs.src = asset.url;
+        if (asset.alt && !attrs.alt) attrs.alt = asset.alt;
+        if (asset.width && !attrs.width) attrs.width = asset.width;
+        if (asset.height && !attrs.height) attrs.height = asset.height;
+      } else if (typeof displayVal === "string" && displayVal) {
+        if (!attrs.src) attrs.src = displayVal;
+      }
+      return renderTemplate`<img${spreadAttributes(attrs)}>`;
+    }
+    if (typeId === "video" || publicName === "vid") {
+      if (displayVal && typeof displayVal === "object") {
+        const asset = displayVal;
+        if (asset.url && !attrs.src) attrs.src = asset.url;
+        if (asset.poster && !attrs.poster) attrs.poster = asset.poster;
+        if (asset.width && !attrs.width) attrs.width = asset.width;
+        if (asset.height && !attrs.height) attrs.height = asset.height;
+      } else if (typeof displayVal === "string" && displayVal) {
+        if (!attrs.src) attrs.src = displayVal;
+      }
+      if (attrs.controls === void 0) attrs.controls = true;
+      return renderTemplate`<video${spreadAttributes(attrs)}></video>`;
+    }
+    if (typeId === "richtext" || publicName === "richText") {
+      const html = renderRichTextHtml(displayVal, { components: $$props?.components });
+      return renderTemplate`<${tag}${spreadAttributes(attrs)}>${markHTMLString(html)}</${tag}>`;
+    }
+    return renderTemplate`<${tag}${spreadAttributes(attrs)}>${displayVal !== null && displayVal !== void 0 ? String(displayVal) : ""}</${tag}>`;
+  });
+  const fn = (arg0, ...rest) => {
+    const isComponentCall = arg0 && typeof arg0 === "object" && "styles" in arg0 && "scripts" in arg0;
+    if (!isComponentCall) {
+      let rawPath = defaultPath;
+      let options = {};
+      if (typeof arg0 === "string") {
+        rawPath = arg0;
+        options = rest[0] || {};
+      } else if (arg0 && typeof arg0 === "object") {
+        options = arg0;
+      }
+      const bundle = getActiveBundle();
+      const entries = bundle?.entries?.[collectionKey] || [];
+      const entry = entries.find((e) => e.slug === slug);
+      const val = entry?.content ? getNestedValue(entry.content, rawPath) : void 0;
+      if (val !== void 0 && val !== null) {
+        return val;
+      }
+      if (options.defaultValue !== void 0) {
+        return options.defaultValue;
+      }
+      return getPlaceholderForType(typeId, rawPath);
+    }
+    return componentFactory(arg0, rest[0], rest[1]);
+  };
+  Object.assign(fn, {
+    isAstroComponentFactory: true,
+    typeId,
+    publicName,
+    collectionKey,
+    slug,
+    defaultPath
+  });
+  return fn;
+}
+function createEntryScope(handleOrKey, slug) {
+  const collectionKey = typeof handleOrKey === "string" ? handleOrKey : handleOrKey.key;
+  const boundHelpers = {};
+  const types = listFieldTypes();
+  for (const def of types) {
+    boundHelpers[def.id] = createEntryDualCallableHelper(def.id, def.id, collectionKey, slug);
+    if (def.aliases) {
+      for (const alias of def.aliases) {
+        boundHelpers[alias] = createEntryDualCallableHelper(def.id, alias, collectionKey, slug);
+      }
+    }
+  }
+  const accessor = {
+    ...boundHelpers,
+    attrs: () => cmsEntryAttr(collectionKey, slug),
+    collectionKey,
+    slug
+  };
+  return accessor;
+}
+var entryScope = createEntryScope;
+
+// src/fields/group.ts
+function defineGroup(nameOrShape, shapeOrUndefined) {
+  const groupName = typeof nameOrShape === "string" ? nameOrShape : "Group";
+  const shape = typeof nameOrShape === "string" ? shapeOrUndefined || {} : nameOrShape;
+  const groupDef = (scopeKey) => {
+    const accessorFn = (key) => {
+      return scopeKey ? `${scopeKey}.${key}` : key;
+    };
+    const boundHelpers = {};
+    for (const [key, helperDef] of Object.entries(shape)) {
+      const helperObj = helperDef;
+      const typeId = helperObj?.typeId || helperObj?.publicName;
+      if (!typeId) {
+        throw new Error(
+          `f.group('${groupName}', ...) field '${key}' must reference a field helper (e.g. f.text, f.img), got ${typeof helperDef}`
+        );
+      }
+      const publicName = helperObj?.publicName || typeId;
+      boundHelpers[key] = createDualCallableHelper(typeId, publicName, scopeKey, key);
+    }
+    Object.assign(accessorFn, boundHelpers, {
+      attrs: () => cmsGroupAttr(groupName, scopeKey),
+      key: (key) => scopeKey ? `${scopeKey}.${key}` : key,
+      groupName,
+      prefix: scopeKey
+    });
+    return accessorFn;
+  };
+  Object.assign(groupDef, {
+    groupName,
+    shape
+  });
+  return groupDef;
+}
+
+// src/fields/scope.ts
+function createScope(prefix = "") {
+  const helpers = generateAllFieldHelpers(prefix);
+  const scopeFn = (key) => {
+    return prefix ? `${prefix}.${key}` : key;
+  };
+  Object.assign(scopeFn, helpers, {
+    key: (key) => prefix ? `${prefix}.${key}` : key,
+    scope: (subPrefix) => {
+      const nextPrefix = prefix ? `${prefix}.${subPrefix}` : subPrefix;
+      return createScope(nextPrefix);
+    },
+    prefix
+  });
+  return scopeFn;
+}
+var baseHelpers = createFieldHelpersMap("");
+var f = {
+  ...baseHelpers,
+  scope: createScope,
+  entryScope: createEntryScope,
+  group: defineGroup,
+  entries: getEntries,
+  entry: getEntry,
+  defineCollection,
+  collectionPaths
+};
+
+// src/head.ts
+function buildHeadTags(route, siteConfig, options) {
+  const tags = [];
+  const defaultSeo = siteConfig?.default_seo || {};
+  const routeSeo = route?.seo || {};
+  const title = routeSeo.title || defaultSeo.title || route?.title || "";
+  if (title) {
+    tags.push({ tag: "title", content: title });
+  }
+  const description = routeSeo.description || defaultSeo.description;
+  if (description) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "description", content: description }
+    });
+  }
+  const siteUrl = options?.siteUrl ? options.siteUrl.replace(/\/+$/, "") : "";
+  let canonical = routeSeo.canonical || defaultSeo.canonical;
+  if (!canonical && siteUrl && route?.path) {
+    const normPath = route.path === "/" ? "" : route.path.startsWith("/") ? route.path : `/${route.path}`;
+    canonical = `${siteUrl}${normPath}`;
+  }
+  if (canonical) {
+    tags.push({
+      tag: "link",
+      attrs: { rel: "canonical", href: canonical }
+    });
+  }
+  if (routeSeo.noindex || defaultSeo.noindex) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "robots", content: "noindex, nofollow" }
+    });
+  }
+  const ogTitle = routeSeo.og_title || routeSeo.title || defaultSeo.og_title || defaultSeo.title || route?.title;
+  if (ogTitle) {
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:title", content: ogTitle }
+    });
+  }
+  const ogDescription = routeSeo.og_description || routeSeo.description || defaultSeo.og_description || defaultSeo.description;
+  if (ogDescription) {
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:description", content: ogDescription }
+    });
+  }
+  const rawOgImage = routeSeo.og_image || defaultSeo.og_image;
+  const ogImageUrl = typeof rawOgImage === "object" && rawOgImage !== null && "url" in rawOgImage ? rawOgImage.url : rawOgImage;
+  if (ogImageUrl) {
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:image", content: ogImageUrl }
+    });
+  }
+  if (canonical) {
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:url", content: canonical }
+    });
+  }
+  const twitterCard = routeSeo.twitter_card || defaultSeo.twitter_card || "summary_large_image";
+  tags.push({
+    tag: "meta",
+    attrs: { name: "twitter:card", content: twitterCard }
+  });
+  return tags;
+}
+
+// src/image.ts
+function isCdnTransformableUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  if (url.startsWith("data:") || url.startsWith("blob:")) return false;
+  if (url.includes("localhost") || url.includes("127.0.0.1") || url.includes(".r2.dev")) {
+    return false;
+  }
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+function buildCdnImageUrl(url, options = {}) {
+  if (!isCdnTransformableUrl(url)) {
+    return url;
+  }
+  const params = [];
+  if (options.width !== void 0 && options.width !== null) {
+    params.push(`width=${options.width}`);
+  }
+  if (options.height !== void 0 && options.height !== null) {
+    params.push(`height=${options.height}`);
+  }
+  params.push(`format=${options.format || "auto"}`);
+  if (options.fit) {
+    params.push(`fit=${options.fit}`);
+  }
+  if (options.quality !== void 0 && options.quality !== null) {
+    params.push(`quality=${options.quality}`);
+  }
+  const optionString = params.join(",");
+  return `/cdn-cgi/image/${optionString}/${url}`;
+}
+function buildSrcSet(url, widths = [400, 800, 1200, 1600], options = {}) {
+  if (!url) return "";
+  if (!isCdnTransformableUrl(url)) return "";
+  return widths.map((w) => `${buildCdnImageUrl(url, { ...options, width: w })} ${w}w`).join(", ");
+}
+
+// src/toolbar/icon.ts
+var CMS_TOOLBAR_ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"/>
+  <path d="M4 10h16"/>
+  <path d="M10 4v16"/>
+</svg>`;
+
+// src/integration.ts
+function deriveRouteFromComponent(componentPath) {
+  let route = componentPath.replace(/\\/g, "/").replace(/^.*src\/pages\/?/, "/").replace(/\.(astro|mdx|md|ts|js|jsx|tsx)$/, "").replace(/\/index$/, "");
+  if (!route.startsWith("/")) {
+    route = `/${route}`;
+  }
+  return route === "" ? "/" : route;
+}
+function cmsAstro(options = {}) {
+  return {
+    name: "@407dev/cms-astro",
+    hooks: {
+      "astro:config:setup": async ({
+        updateConfig,
+        command,
+        injectScript,
+        addMiddleware,
+        addDevToolbarApp,
+        logger
+      }) => {
+        addMiddleware({
+          entrypoint: "@407dev/cms-astro/middleware",
+          order: "pre"
+        });
+        if (options.client) {
+          initCmsClient({ client: options.client });
+        } else {
+          initCmsClient({
+            siteId: options.siteId,
+            contentUrl: options.contentUrl,
+            previewSecret: options.previewSecret
+          });
+        }
+        const effectiveSiteId = options.siteId || process.env.CMS_SITE_ID || "";
+        const effectiveContentUrl = options.contentUrl || process.env.CMS_CONTENT_URL || "";
+        const effectivePreviewSecret = options.previewSecret || process.env.CMS_PREVIEW_SECRET || "";
+        if (command !== "dev" && (options.previewSecret || process.env.CMS_PREVIEW_SECRET)) {
+          logger.warn(
+            "previewSecret and CMS_PREVIEW_SECRET are deprecated and ignored outside astro dev. Site hosts no longer verify preview tokens."
+          );
+        }
+        if (effectiveContentUrl || effectiveSiteId) {
+          updateConfig({
+            vite: {
+              define: {
+                "import.meta.env.CMS_CONTENT_URL": JSON.stringify(effectiveContentUrl),
+                "import.meta.env.CMS_SITE_ID": JSON.stringify(effectiveSiteId)
+              }
+            }
+          });
+        }
+        if (command === "dev") {
+          injectScript(
+            "page",
+            buildBridgeScript({
+              editorOrigins: options.editorOrigins
+            })
+          );
+          const devModulePath = "./dev/index.js";
+          const { resolveDevConfig, createVerifier, cmsDevApiPlugin } = await import(
+            /* @vite-ignore */
+            devModulePath
+          );
+          const devConfig = await resolveDevConfig({
+            siteId: options.siteId,
+            apiUrl: options.apiUrl,
+            siteDir: process.cwd()
+          });
+          if (devConfig.status === "refused") {
+            logger.error(`CMS dev routes disabled: ${devConfig.reason}`);
+          }
+          if (devConfig.status === "read-only") {
+            logger.warn(
+              `CMS dev toolbar is READ-ONLY: ${devConfig.mismatch?.source} (${devConfig.mismatch?.actual}) \u2260 site rendered (${devConfig.mismatch?.expected})`
+            );
+          }
+          const verifier = await createVerifier({
+            siteDir: process.cwd(),
+            siteId: devConfig.siteId
+          });
+          addDevToolbarApp({
+            id: "cms-content",
+            name: "CMS Content",
+            icon: CMS_TOOLBAR_ICON,
+            entrypoint: fileURLToPath(new URL("./toolbar/app.js", import.meta.url))
+          });
+          updateConfig({
+            vite: {
+              plugins: [
+                cmsDevApiPlugin({
+                  devConfig,
+                  client: getClient(),
+                  verifier,
+                  previewSecret: effectivePreviewSecret,
+                  editorOrigins: options.editorOrigins
+                })
+              ]
+            }
+          });
+        }
+        const activeClient = getClient();
+        if (activeClient) {
+          try {
+            const devPreviewToken = command === "dev" ? await mintDevPreviewToken(activeClient.siteId, effectivePreviewSecret) : null;
+            const bundle = await activeClient.getBundle(
+              devPreviewToken ? { previewToken: devPreviewToken } : void 0
+            );
+            markBundleReady(bundle);
+            const cmsDir = path.resolve(process.cwd(), ".cms");
+            if (!fs.existsSync(cmsDir)) {
+              fs.mkdirSync(cmsDir, { recursive: true });
+            }
+            fs.writeFileSync(
+              path.join(cmsDir, "bundle.json"),
+              JSON.stringify(bundle, null, 2),
+              "utf-8"
+            );
+          } catch {
+          }
+        }
+      },
+      "astro:routes:resolved": async ({ routes }) => {
+        try {
+          const cmsDir = path.resolve(process.cwd(), ".cms");
+          if (!fs.existsSync(cmsDir)) {
+            fs.mkdirSync(cmsDir, { recursive: true });
+          }
+          const serializedRoutes = routes.map(
+            (r) => {
+              const comp = r.component || r.entrypoint || "";
+              let routePattern = r.route || r.pathname || "";
+              if (!routePattern && comp) {
+                routePattern = deriveRouteFromComponent(comp);
+              }
+              return {
+                route: routePattern,
+                component: comp,
+                type: r.type || "page",
+                params: r.params || []
+              };
+            }
+          );
+          fs.writeFileSync(
+            path.join(cmsDir, "routes.json"),
+            JSON.stringify(serializedRoutes, null, 2),
+            "utf-8"
+          );
+        } catch {
+        }
+      },
+      "astro:build:done": async ({ logger }) => {
+        const missing = getMissingFieldWarnings();
+        if (missing.length > 0) {
+          logger.warn(
+            `CMS Build Warning: ${missing.length} field(s) were rendered with empty/missing values: ${missing.join(", ")}`
+          );
+          clearMissingFieldWarnings();
+        }
+      }
+    }
+  };
+}
+var cms = cmsAstro;
+
+// src/preview.ts
+async function getPreviewData(options) {
+  const { previewToken, client } = options;
+  if (!previewToken) {
+    return {
+      ok: false,
+      status: 404,
+      error: "Preview token is required"
+    };
+  }
+  try {
+    const bundle = await client.getBundle({ previewToken });
+    return {
+      ok: true,
+      status: 200,
+      bundle
+    };
+  } catch (_err) {
+    return {
+      ok: false,
+      status: 404,
+      error: "Preview token is not valid for this site"
+    };
+  }
+}
+
+// src/siteFiles.ts
+function renderRedirectsFile(redirects = []) {
+  const lines = redirects.filter((r) => r.enabled !== false && r.from_path && r.to_path).map((r) => `${r.from_path} ${r.to_path} ${r.status_code || 301}`);
+  return lines.length > 0 ? `${lines.join("\n")}
+` : "";
+}
+function renderRobotsTxt(config, options) {
+  if (config?.robots?.raw) {
+    return `${config.robots.raw.trim()}
+`;
+  }
+  const lines = [];
+  const rules = config?.robots?.rules || [{ user_agent: "*", allow: ["/"] }];
+  for (const rule of rules) {
+    lines.push(`User-agent: ${rule.user_agent || "*"}`);
+    if (rule.allow && rule.allow.length > 0) {
+      for (const path2 of rule.allow) {
+        lines.push(`Allow: ${path2}`);
+      }
+    }
+    if (rule.disallow && rule.disallow.length > 0) {
+      for (const path2 of rule.disallow) {
+        lines.push(`Disallow: ${path2}`);
+      }
+    }
+    lines.push("");
+  }
+  const siteUrl = options?.siteUrl ? options.siteUrl.replace(/\/+$/, "") : "";
+  if (siteUrl && config?.robots?.sitemap !== false) {
+    lines.push(`Sitemap: ${siteUrl}/sitemap.xml`);
+  }
+  return `${lines.join("\n").trim()}
+`;
+}
+function renderSitemapXml(routes, options) {
+  const siteUrl = options.siteUrl.replace(/\/+$/, "");
+  const config = options.siteConfig;
+  const excludes = new Set(config?.sitemap?.exclude || []);
+  if (config?.not_found_path) {
+    excludes.add(config.not_found_path);
+  }
+  const filtered = routes.filter((r) => {
+    if (r.path && excludes.has(r.path) || r.id && excludes.has(r.id)) {
+      return false;
+    }
+    if ("seo" in r && r.seo && typeof r.seo === "object") {
+      const seoObj = r.seo;
+      if (seoObj.noindex) {
+        return false;
+      }
+    }
+    return true;
+  });
+  const urlEntries = filtered.map((r) => {
+    const rawPath = r.path || "/";
+    const normPath = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
+    const loc = `${siteUrl}${normPath}`;
+    const dateStr = "published_at" in r && r.published_at || r.updated_at || (/* @__PURE__ */ new Date()).toISOString();
+    const lastmod = dateStr.split("T")[0];
+    return `  <url>
+    <loc>${loc}</loc>
+    <lastmod>${lastmod}</lastmod>
+  </url>`;
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urlEntries.join("\n")}
+</urlset>
+`;
+}
+
+export { KNOWN_NODES, buildCdnImageUrl, buildHeadTags, buildSrcSet, cms, cmsAstro, cmsEntryAttr, cmsEntryFieldAttr, cmsFieldAttr, cmsGroupAttr, createEntryDualCallableHelper, createEntryScope, createScope, defineGroup, entryScope, escapeHtml, f, getLinkMarkAttrs, getPreviewData, isCdnTransformableUrl, parseRichTextDoc, renderMarksOnly, renderRedirectsFile, renderRichTextHtml, renderRobotsTxt, renderSitemapXml };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map