@elytracms/next 0.0.53 → 0.0.55

package/dist/index.js

@@ -4,7 +4,7 @@ import { basePrimitives, getImplementation, renderComposition, ImageManifest, se
 import { isValidElement } from 'react';
 import { jsx, Fragment } from 'react/jsx-runtime';
 import { cacheTags, isSectionSourceId, parseCmsSourceQueryConfig, listQueryOfCmsConfig, isDocumentHistory, resolvedAsset, createContentClient, createContentContext } from '@elytracms/core/content';
-import { documentKey, splitPath, hierarchyMount, composePath } from '@elytracms/core/cms-core';
+import { documentKey, splitPath, hierarchyMount, composePath, documentSchema, redirectRecordSchema } from '@elytracms/core/cms-core';
 export { documentSchema, localeConfigSchema, redirectRecordSchema, routeRecordSchema } from '@elytracms/core/cms-core';
 import { revalidateTag, unstable_cache } from 'next/cache';
 import { draftMode } from 'next/headers';
@@ -252,7 +252,7 @@ function createStaticContentSource(data) {
     byCollection.set(doc.collection, list);
   }
   const assets = /* @__PURE__ */ new Map();
-  for (const record of data.assets ?? []) assets.set(record.id, record);
+  for (const record2 of data.assets ?? []) assets.set(record2.id, record2);
   const lookupFor = (_perspective) => ({
     collection: (id) => collections.get(id),
     document: (ref) => documents.get(documentKey(ref)),
@@ -279,7 +279,7 @@ function createStaticContentSource(data) {
     // `asset`-typed Image prop (an asset id) to a usable url + intrinsic
     // dimensions. Baked into the (serializable) render outcome by the route
     // helper, so a cached page keeps its images during a backend outage.
-    assets: () => [...assets.values()].map((record) => resolvedAsset(record, record.url ?? assetUrl(record))),
+    assets: () => [...assets.values()].map((record2) => resolvedAsset(record2, record2.url ?? assetUrl(record2))),
     ...data.sources ? { sources: data.sources } : {}
   };
 }
@@ -289,26 +289,26 @@ async function createContentSnapshot(adapter, projectId, options = {}) {
   const versionRecords = await adapter.cms.listAllDocumentVersions(projectId);
   const assetRecords = await adapter.assets.listAssets(projectId);
   const redirectRecords = await adapter.redirects.listRedirects(projectId);
-  const redirects = redirectRecords.filter((record) => record.enabled).map((record) => ({
-    id: record.id,
-    from: record.from,
-    to: record.to,
-    permanent: record.permanent
+  const redirects = redirectRecords.filter((record2) => record2.enabled).map((record2) => ({
+    id: record2.id,
+    from: record2.from,
+    to: record2.to,
+    permanent: record2.permanent
   }));
   const versionsByKey = /* @__PURE__ */ new Map();
-  for (const record of versionRecords) {
-    const key = `${record.collection}:${record.docId}`;
+  for (const record2 of versionRecords) {
+    const key = `${record2.collection}:${record2.docId}`;
     let byVersion = versionsByKey.get(key);
     if (!byVersion) {
       byVersion = /* @__PURE__ */ new Map();
       versionsByKey.set(key, byVersion);
     }
-    byVersion.set(record.version, record.snapshot);
+    byVersion.set(record2.version, record2.snapshot);
   }
-  const documents = documentRecords.map((record) => {
-    if (record.publishedVersion === void 0) return record.document;
-    const published = versionsByKey.get(`${record.document.collection}:${record.document.id}`)?.get(record.publishedVersion);
-    return { draft: record.document, published, versions: [] };
+  const documents = documentRecords.map((record2) => {
+    if (record2.publishedVersion === void 0) return record2.document;
+    const published = versionsByKey.get(`${record2.document.collection}:${record2.document.id}`)?.get(record2.publishedVersion);
+    return { draft: record2.document, published, versions: [] };
   });
   return createStaticContentSource({
     projectId,
@@ -898,6 +898,258 @@ function nextImagePrimitive(options = {}) {
     implementation: createNextImagePrimitive(options)
   };
 }
+function elytraHostImage(options = {}) {
+  return ({ asset, alt, className, priority, sizes }) => /* @__PURE__ */ jsx(
+    ElytraImage,
+    {
+      asset: { ...asset, alt },
+      ...className !== void 0 ? { className } : {},
+      ...priority ? { priority: true } : {},
+      ...sizes !== void 0 ? { sizes } : {},
+      ...options.loader !== void 0 ? { loader: options.loader } : {},
+      ...options.quality !== void 0 ? { quality: options.quality } : {}
+    }
+  );
+}
+
+// src/full-bleed.ts
+function firstBlockFullBleed(document, registry) {
+  const first = compositionNodesOf(document)[0];
+  if (!first) return false;
+  return registry.getManifest(first.componentId)?.presentation?.fullBleed === true;
+}
+
+// src/host-env.ts
+var ELYTRA_HOST_ENV_KEYS = {
+  convexUrl: "ELYTRA_CONVEX_URL",
+  projectId: "ELYTRA_PROJECT_ID",
+  draftToken: "DRAFT_PREVIEW_TOKEN",
+  revalidateSecret: "REVALIDATE_SECRET",
+  studioOrigin: "STUDIO_ORIGIN"
+};
+function cleaned(value) {
+  const trimmed = value?.trim();
+  return trimmed !== void 0 && trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveHostEnv(env) {
+  const resolved = {};
+  for (const [key, name] of Object.entries(ELYTRA_HOST_ENV_KEYS)) {
+    const value = cleaned(env[name]);
+    if (value !== void 0) resolved[key] = value;
+  }
+  return resolved;
+}
+async function runConvexQuery(fetchImpl, convexUrl, path, args) {
+  const response = await fetchImpl(`${convexUrl.replace(/\/$/, "")}/api/query`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ path, args, format: "json" }),
+    cache: "no-store"
+  });
+  const body = await response.json().catch(() => void 0);
+  if (!response.ok || body?.status !== "success") {
+    throw new Error(
+      `Convex query "${path}" failed (${response.status}): ${body?.errorMessage ?? body?.message ?? "no error message"}`
+    );
+  }
+  return body.value;
+}
+function parseDocuments(rows) {
+  const documents = [];
+  for (const row of rows) {
+    const parsed = documentSchema.safeParse(row);
+    if (parsed.success) documents.push(parsed.data);
+  }
+  return documents;
+}
+function parseRedirects(rows) {
+  const redirects = [];
+  for (const row of rows) {
+    const parsed = redirectRecordSchema.safeParse(row);
+    if (parsed.success) redirects.push(parsed.data);
+  }
+  return redirects;
+}
+var canvasDataSourceSchema = z.object({
+  kind: z.string().min(1),
+  id: z.string().min(1),
+  label: z.string().optional(),
+  config: z.unknown().optional()
+});
+function parseSources(rows) {
+  if (!Array.isArray(rows)) return [];
+  const sources = [];
+  for (const row of rows) {
+    const parsed = canvasDataSourceSchema.safeParse(row);
+    if (parsed.success) sources.push(parsed.data);
+  }
+  return sources;
+}
+function fallbackHomeRoutes(documents, locales) {
+  const homePage = [...documents].filter((doc) => doc.collection === "page").sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)[0];
+  if (!homePage) return [];
+  return locales.locales.map((locale) => ({
+    id: `r-live-home-${locale}`,
+    pattern: "/",
+    locale,
+    document: { collection: "page", id: homePage.id }
+  }));
+}
+function assembleLiveSource(payload, options, perspective) {
+  const locales = options.locales;
+  const documents = parseDocuments(payload.documents);
+  const routes = mergeRouteRecords([...options.routes], fallbackHomeRoutes(documents, locales));
+  const documentSources = perspective === "published" ? documents.map((doc) => ({ draft: doc, published: doc, versions: [] })) : documents;
+  return createStaticContentSource({
+    projectId: payload.projectId,
+    locales,
+    routes,
+    // Redirects are editorial DATA (EC-303): the ENABLED ones ship in the
+    // snapshot, so they change dynamically (no redeploy). Native next.config
+    // redirects run before this.
+    redirects: parseRedirects(payload.redirects ?? []),
+    collections: [...options.collections],
+    documents: documentSources,
+    assets: payload.assets,
+    // EC-166 LIVE mode: the builder's persisted section/template sources, so
+    // the route helper materializes their payloads.
+    sources: parseSources(payload.sources)
+  });
+}
+async function loadLiveContent(options, perspective) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const args = { projectId: options.projectId };
+  let payload;
+  if (perspective === "draft") {
+    if (!options.draftToken) {
+      throw new Error(
+        "Draft preview requested but DRAFT_PREVIEW_TOKEN is not configured on the host."
+      );
+    }
+    payload = await runConvexQuery(fetchImpl, options.convexUrl, "delivery:draftSnapshot", {
+      ...args,
+      token: options.draftToken
+    });
+  } else {
+    payload = await runConvexQuery(
+      fetchImpl,
+      options.convexUrl,
+      "delivery:snapshot",
+      args
+    );
+  }
+  return assembleLiveSource(payload, options, perspective);
+}
+
+// src/host-globals.ts
+var DEFAULT_ITEMS_FIELDS = ["items", "links"];
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function str2(value) {
+  return typeof value === "string" ? value : "";
+}
+function items(value) {
+  return Array.isArray(value) ? value.map(record) : [];
+}
+function resolveGlobals(source, options = {}) {
+  const perspective = options.perspective ?? "published";
+  const conventions = options.conventions ?? {};
+  const settingsCollection = conventions.settingsCollection ?? "settings";
+  const navigationCollection = conventions.navigationCollection ?? "navigation";
+  const itemsFields = conventions.navigationItemsFields ?? DEFAULT_ITEMS_FIELDS;
+  const client = source.client({ perspective, ...options.locale ? { locale: options.locale } : {} });
+  const assets = source.assets?.() ?? [];
+  const assetById = new Map(assets.map((asset) => [asset.id, asset]));
+  const listDocs = (collection) => {
+    const result = client.listDocuments(collection);
+    return result.ok ? result.documents : [];
+  };
+  const settings = listDocs(settingsCollection)[0] ?? null;
+  const navDocs = listDocs(navigationCollection);
+  const navigation = (slot) => navDocs.find((doc) => doc.alias === slot) ?? null;
+  const assetUrl = (value) => {
+    if (typeof value === "string") {
+      const found = assetById.get(value);
+      if (found) return found.url;
+      return value.startsWith("http") || value.startsWith("/") ? value : void 0;
+    }
+    const url = record(value).url;
+    return typeof url === "string" && url.length > 0 ? url : void 0;
+  };
+  const refOf = (value) => {
+    const ref = record(value);
+    return typeof ref.collection === "string" && typeof ref.id === "string" ? { collection: ref.collection, id: ref.id } : null;
+  };
+  const resolveLink = (value) => {
+    const link = record(value);
+    const openInNewTab = link.openInNewTab === true;
+    const href = str2(link.href) || str2(link.url);
+    const linkType = str2(link.linkType) || (href ? "href" : "");
+    if (linkType === "href" || linkType === "external") {
+      return href ? { href, openInNewTab } : null;
+    }
+    if (linkType === "file") {
+      const url = assetUrl(link.file);
+      return url ? { href: url, openInNewTab } : null;
+    }
+    if (linkType === "page") {
+      const page = link.page;
+      const ref = refOf(page);
+      if (ref) {
+        const path = client.resolveLink(ref);
+        if (path !== null) return { href: path, openInNewTab };
+      }
+      const shaped = record(page);
+      if (typeof shaped.path === "string" && shaped.path.startsWith("/")) {
+        return { href: shaped.path, openInNewTab };
+      }
+      const slug = str2(shaped.slug);
+      if (slug) return { href: `/${slug}`, openInNewTab };
+      return null;
+    }
+    return null;
+  };
+  const toNavLink = (entry) => {
+    const label = str2(entry.label);
+    const resolved = resolveLink("link" in entry ? entry.link : entry);
+    if (!label || !resolved) return null;
+    const description = str2(entry.description);
+    return { label, ...resolved, ...description ? { description } : {} };
+  };
+  const toNavEntry = (entry) => {
+    const label = str2(entry.label);
+    if (!label) return null;
+    const resolved = resolveLink("link" in entry ? entry.link : entry);
+    const description = str2(entry.description);
+    const children = items(entry.children).map(toNavLink).filter((child) => child !== null);
+    if (!resolved && children.length === 0) return null;
+    return {
+      label,
+      ...resolved ? { href: resolved.href } : {},
+      openInNewTab: resolved?.openInNewTab ?? false,
+      ...description ? { description } : {},
+      children
+    };
+  };
+  const navigationEntries = (slot) => {
+    const doc = navigation(slot);
+    if (!doc) return [];
+    const values = doc;
+    const field = itemsFields.find((name) => Array.isArray(values[name]));
+    if (!field) return [];
+    return items(values[field]).map(toNavEntry).filter((entry) => entry !== null);
+  };
+  return {
+    settings,
+    navigation,
+    navigationEntries,
+    resolveLink,
+    assetUrl,
+    client,
+    source
+  };
+}
 
 // src/preview-core.ts
 function safeRedirectTarget(value, fallback = "/") {
@@ -925,6 +1177,8 @@ function evaluatePreviewRequest(requestUrl, expectedToken) {
   }
   return { ok: true, redirectTo };
 }
+
+// src/preview.ts
 function createPreviewRoute(options) {
   return {
     async GET(request) {
@@ -953,8 +1207,105 @@ function createPreviewDisableRoute() {
     }
   };
 }
+
+// src/host-kit.ts
+function materializeRoutes(routes, collections) {
+  return typeof routes === "function" ? routes([...collections]) : [...routes];
+}
+function createElytraHost(options) {
+  const env = resolveHostEnv(options.env ?? process.env);
+  const routes = materializeRoutes(options.routes, options.collections);
+  const live = env.convexUrl !== void 0 && env.projectId !== void 0;
+  const contentScope = live ? env.projectId : options.slug;
+  const components = defineHostComponents([
+    // Batteries included (EC-368 image defaults): graph `base.Image` nodes render
+    // through next/image — resized variants via the host's own optimizer. The
+    // canonical manifest stays (first registration wins in defineHostComponents).
+    ...options.image === false ? [] : [nextImagePrimitive(options.image ?? {})],
+    ...options.components ?? []
+  ]);
+  const emptySource = createStaticContentSource({
+    projectId: contentScope,
+    locales: options.locales,
+    routes,
+    // Redirects are editorial DATA (EC-303) — the no-backend build has none.
+    redirects: [],
+    collections: [...options.collections],
+    documents: [],
+    assets: [],
+    sources: []
+  });
+  const loadContent = (request) => {
+    if (live) {
+      return loadLiveContent(
+        {
+          convexUrl: env.convexUrl,
+          projectId: env.projectId,
+          locales: options.locales,
+          collections: options.collections,
+          routes,
+          ...env.draftToken ? { draftToken: env.draftToken } : {},
+          ...options.fetch ? { fetch: options.fetch } : {}
+        },
+        request.perspective
+      );
+    }
+    if (options.fallbackContent) return options.fallbackContent(request);
+    return Promise.resolve(emptySource);
+  };
+  const loadGlobals = async (globalsOptions = {}) => {
+    const perspective = globalsOptions.perspective ?? "published";
+    const source = await loadContent({ perspective });
+    return resolveGlobals(source, {
+      perspective,
+      ...options.globals ? { conventions: options.globals } : {}
+    });
+  };
+  const canvasRoute = (routeOptions = {}) => {
+    const { cache, ...rest } = routeOptions;
+    return createCanvasRoute({
+      loadContent,
+      components,
+      // Tag scope = the project id the studio publishes under, so its webhook
+      // tags match this site's cached entries.
+      ...cache === false ? {} : { cache: cache ?? { scope: contentScope } },
+      ...rest
+    });
+  };
+  const revalidateRoute = (overrides = {}) => createRevalidateRoute({
+    // An unset secret keeps the endpoint CLOSED (401) — the kit never ships a
+    // default secret (an auth-shaped no-op is worse than an explicit gap).
+    secret: "secret" in overrides ? overrides.secret : env.revalidateSecret,
+    ...overrides.allowOrigin !== void 0 ? { allowOrigin: overrides.allowOrigin } : env.studioOrigin !== void 0 ? { allowOrigin: env.studioOrigin } : {}
+  });
+  const previewRoute = () => createPreviewRoute({ token: env.draftToken });
+  const previewDisableRoute = () => createPreviewDisableRoute();
+  const pageOpensFullBleed = async (slug) => {
+    const { isEnabled } = await draftMode();
+    const perspective = isEnabled ? "draft" : "published";
+    const source = await loadContent({ perspective });
+    const { locale, path } = splitLocalePath(pathFromSlug(slug), source.locales);
+    const client = source.client({ perspective, locale });
+    const resolved = client.resolvePage(path);
+    return firstBlockFullBleed(resolved.document, components.registry);
+  };
+  return {
+    contentScope,
+    env,
+    routes,
+    components,
+    ...options.frontendUrl !== void 0 ? { frontendUrl: options.frontendUrl } : {},
+    loadContent,
+    loadGlobals,
+    canvasRoute,
+    revalidateRoute,
+    previewRoute,
+    previewDisableRoute,
+    pageOpensFullBleed
+  };
+}
 var PACKAGE = "@elytracms/next";
 
-export { CanvasRenderer, ElytraImage, PACKAGE, REVALIDATE_SIGNATURE_HEADER, canvasPageMetadata, canvasSitemapEntries, collectBindingSourceIds, collectionCacheTag, createAssetImageLoader, createBindingResolver, createCanvasRoute, createCanvasSitemap, createContentSnapshot, createPreviewDisableRoute, createPreviewRoute, createRevalidateRoute, createStaticContentSource, defaultBindingPayloads, defineHostComponents, docCacheTag, evaluatePreviewRequest, evaluateRevalidateRequest, isSourcePayloadError, loadCachedEntry, materializeSourcePayloads, mergeCacheTags, mergeRouteRecords, nextCacheTags, nextImagePrimitive, pathFromSlug, projectSweepTag, resolveCanvasPage, resolvePayloadToken, revalidatePayloadSchema, routeCacheTag, safeRedirectTarget, scopeCacheTag, signRevalidateBody, sourcePayloadError, splitLocalePath };
+export { CanvasRenderer, ELYTRA_HOST_ENV_KEYS, ElytraImage, PACKAGE, REVALIDATE_SIGNATURE_HEADER, assembleLiveSource, canvasPageMetadata, canvasSitemapEntries, collectBindingSourceIds, collectionCacheTag, createAssetImageLoader, createBindingResolver, createCanvasRoute, createCanvasSitemap, createContentSnapshot, createElytraHost, createPreviewDisableRoute, createPreviewRoute, createRevalidateRoute, createStaticContentSource, defaultBindingPayloads, defineHostComponents, docCacheTag, elytraHostImage, evaluatePreviewRequest, evaluateRevalidateRequest, fallbackHomeRoutes, firstBlockFullBleed, isSourcePayloadError, loadCachedEntry, loadLiveContent, materializeSourcePayloads, mergeCacheTags, mergeRouteRecords, nextCacheTags, nextImagePrimitive, pathFromSlug, projectSweepTag, resolveCanvasPage, resolveGlobals, resolveHostEnv, resolvePayloadToken, revalidatePayloadSchema, routeCacheTag, safeRedirectTarget, scopeCacheTag, signRevalidateBody, sourcePayloadError, splitLocalePath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map