@codepress/blog 0.0.0-stage → 0.1.0

package/dist/chunks/chunk-3GCZFCUK.js

@@ -0,0 +1,51 @@
+import {
+  createHttpContentSource
+} from "./chunk-AEQDRBA3.js";
+
+// src/next/config.ts
+var DEFAULT_API_BASE = "https://api.codepress.dev/v1";
+var DEFAULT_BASE_PATH = "/blog";
+var DEFAULT_REVALIDATE_SECONDS = 60;
+function resolveBlog(config) {
+  const origin = new URL(config.baseUrl).origin;
+  const basePath = `/${(config.basePath ?? DEFAULT_BASE_PATH).replace(/^\/+|\/+$/g, "")}`;
+  const name = config.name ?? new URL(origin).host;
+  return {
+    site: {
+      baseUrl: `${origin}${basePath}`,
+      homeUrl: origin,
+      name,
+      title: config.title ?? `${name} Blog`,
+      description: config.description ?? `Posts from ${name}.`,
+      defaultImage: config.defaultImage ?? ""
+    },
+    basePath,
+    revalidate: config.revalidate ?? DEFAULT_REVALIDATE_SECONDS,
+    source: createHttpContentSource({
+      apiBase: config.apiBase ?? DEFAULT_API_BASE,
+      site: config.site,
+      timeoutMs: config.timeoutMs
+    })
+  };
+}
+function isBuildPhase() {
+  return process.env.NEXT_PHASE === "phase-production-build";
+}
+async function listPostsForRender(blog) {
+  try {
+    return await blog.source.listPosts();
+  } catch (error) {
+    if (!isBuildPhase()) throw error;
+    console.error("[blog] prerendering an empty blog, API unavailable:", error);
+    return [];
+  }
+}
+
+export {
+  DEFAULT_API_BASE,
+  DEFAULT_BASE_PATH,
+  DEFAULT_REVALIDATE_SECONDS,
+  resolveBlog,
+  isBuildPhase,
+  listPostsForRender
+};

package/dist/chunks/chunk-3WRTL63O.js

@@ -0,0 +1,106 @@
+// src/editor/client.ts
+async function failure(response) {
+  try {
+    const body = await response.json();
+    if (typeof body.detail === "string") return body.detail;
+  } catch {
+  }
+  return `Request failed (${response.status})`;
+}
+var networkMessage = "Could not reach the server.";
+function createDraftClient({
+  apiBase,
+  auth
+}) {
+  const root = apiBase.replace(/\/+$/, "");
+  const request = async (method, path, body) => {
+    const headers = { Accept: "application/json" };
+    if (body !== void 0) headers["Content-Type"] = "application/json";
+    const token = await auth.getToken();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const response = await fetch(`${root}${path}`, {
+      method,
+      headers,
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    auth.onResponse?.(response);
+    return response;
+  };
+  const draftPath = (site, slug) => `/content-sites/${site}/drafts/${slug}`;
+  async function action(send) {
+    try {
+      const response = await send();
+      if (response.ok) return { kind: "ok" };
+      if (response.status === 422) {
+        const body = await response.json().catch(() => ({}));
+        if (body.violations) {
+          return {
+            kind: "rejected",
+            detail: body.detail ?? "The content was rejected.",
+            violations: body.violations
+          };
+        }
+      }
+      return {
+        kind: "error",
+        message: await failure(response),
+        status: response.status
+      };
+    } catch {
+      return { kind: "error", message: networkMessage };
+    }
+  }
+  return {
+    async getCapabilities(site) {
+      try {
+        const response = await request("GET", `/content-sites/${site}/me`);
+        return response.ok ? await response.json() : null;
+      } catch {
+        return null;
+      }
+    },
+    async getDraft(site, slug) {
+      try {
+        const response = await request("GET", draftPath(site, slug));
+        if (!response.ok) return { error: await failure(response) };
+        return { draft: await response.json() };
+      } catch {
+        return { error: networkMessage };
+      }
+    },
+    async saveDraft(site, slug, html, baseSha) {
+      try {
+        const response = await request("PUT", draftPath(site, slug), {
+          html,
+          base_sha: baseSha
+        });
+        if (response.ok) {
+          return { kind: "saved", draft: await response.json() };
+        }
+        const body = await response.json().catch(() => ({}));
+        if (response.status === 409 && body.current) {
+          return { kind: "conflict", current: body.current };
+        }
+        if (response.status === 422 && body.violations) {
+          return {
+            kind: "rejected",
+            detail: body.detail ?? "The content was rejected.",
+            violations: body.violations
+          };
+        }
+        return {
+          kind: "error",
+          message: body.detail ?? `Request failed (${response.status})`
+        };
+      } catch {
+        return { kind: "error", message: networkMessage };
+      }
+    },
+    publishDraft: (site, slug) => action(() => request("POST", `${draftPath(site, slug)}/publish`)),
+    discardDraft: (site, slug) => action(() => request("DELETE", draftPath(site, slug)))
+  };
+}
+
+export {
+  createDraftClient
+};

package/dist/chunks/chunk-AEQDRBA3.js

@@ -0,0 +1,128 @@
+import {
+  SLUG_PATTERN,
+  postMetaSchema
+} from "./chunk-XLJBCIXI.js";
+
+// src/seo.ts
+function blogUrl(site) {
+  return site.baseUrl.replace(/\/+$/, "");
+}
+function postUrl(site, slug) {
+  return `${blogUrl(site)}/${slug}`;
+}
+function feedUrl(site) {
+  return `${blogUrl(site)}/feed.xml`;
+}
+function siteOrigin(site) {
+  return new URL(site.baseUrl).origin;
+}
+function homeUrl(site) {
+  return site.homeUrl ?? siteOrigin(site);
+}
+function jsonLd(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function absoluteImage(site, ogImage) {
+  if (!ogImage) return site.defaultImage;
+  return ogImage.startsWith("/") ? `${siteOrigin(site)}${ogImage}` : ogImage;
+}
+function blogPostingJsonLd(site, slug, meta) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "BlogPosting",
+    headline: meta.title,
+    description: meta.description,
+    url: postUrl(site, slug),
+    mainEntityOfPage: postUrl(site, slug),
+    datePublished: meta.date,
+    dateModified: meta.updated ?? meta.date,
+    image: absoluteImage(site, meta.ogImage),
+    author: (meta.authors?.length ? meta.authors : [site.name]).map((name) => ({
+      "@type": "Person",
+      name
+    })),
+    publisher: {
+      "@type": "Organization",
+      name: site.name,
+      url: homeUrl(site)
+    },
+    ...meta.tags?.length ? { keywords: meta.tags.join(", ") } : {}
+  };
+}
+function breadcrumbJsonLd(site, slug, title) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: [
+      {
+        "@type": "ListItem",
+        position: 1,
+        name: site.name,
+        item: homeUrl(site)
+      },
+      { "@type": "ListItem", position: 2, name: "Blog", item: blogUrl(site) },
+      {
+        "@type": "ListItem",
+        position: 3,
+        name: title,
+        item: postUrl(site, slug)
+      }
+    ]
+  };
+}
+
+// src/content-source.ts
+import { z } from "zod";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var postSchema = z.object({
+  slug: z.string(),
+  meta: postMetaSchema,
+  html: z.string()
+});
+var listSchema = z.object({
+  posts: z.array(z.object({ slug: z.string(), meta: postMetaSchema }))
+});
+function createHttpContentSource({
+  apiBase,
+  site,
+  timeoutMs = DEFAULT_TIMEOUT_MS
+}) {
+  const siteUrl = `${apiBase.replace(/\/+$/, "")}/content-sites/${encodeURIComponent(site)}`;
+  async function fetchJson(path) {
+    const response = await fetch(`${siteUrl}${path}`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (response.status === 404) return null;
+    if (!response.ok) {
+      throw new Error(`[blog] backend ${path} answered ${response.status}`);
+    }
+    return response.json();
+  }
+  return {
+    async listPosts() {
+      const body = await fetchJson("/posts");
+      if (body === null) return [];
+      return listSchema.parse(body).posts;
+    },
+    async getPost(slug) {
+      if (!SLUG_PATTERN.test(slug)) return null;
+      const body = await fetchJson(`/posts/${slug}`);
+      if (body === null) return null;
+      const { meta, html } = postSchema.parse(body);
+      return { slug, meta, html };
+    }
+  };
+}
+
+export {
+  blogUrl,
+  postUrl,
+  feedUrl,
+  homeUrl,
+  jsonLd,
+  absoluteImage,
+  blogPostingJsonLd,
+  breadcrumbJsonLd,
+  createHttpContentSource
+};

package/dist/chunks/chunk-AJVVTSKZ.js

@@ -0,0 +1,90 @@
+import {
+  sanitizeNodes
+} from "./chunk-EICE5ONB.js";
+import {
+  COMPONENTS,
+  PROPS_ATTRIBUTE,
+  isComponentTag
+} from "./chunk-XLJBCIXI.js";
+
+// src/react/components.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var CALLOUT_LABELS = {
+  info: "Note",
+  warn: "Warning",
+  tip: "Tip"
+};
+function CpCallout({ type, children, ...rest }) {
+  return /* @__PURE__ */ jsxs(
+    "aside",
+    {
+      ...rest,
+      role: "note",
+      className: `not-prose cp-callout cp-callout--${type}`,
+      children: [
+        /* @__PURE__ */ jsx("p", { className: "cp-callout__label", children: CALLOUT_LABELS[type] }),
+        children
+      ]
+    }
+  );
+}
+function CpFigure({
+  src,
+  alt,
+  caption,
+  width,
+  height,
+  ...rest
+}) {
+  return /* @__PURE__ */ jsxs("figure", { ...rest, className: "cp-figure", children: [
+    /* @__PURE__ */ jsx(
+      "img",
+      {
+        src,
+        alt,
+        width,
+        height,
+        loading: "lazy",
+        className: "cp-figure__img"
+      }
+    ),
+    caption ? /* @__PURE__ */ jsx("figcaption", { className: "cp-figure__caption", children: caption }) : null
+  ] });
+}
+var COMPONENT_VIEWS = {
+  "cp-callout": CpCallout,
+  "cp-figure": CpFigure
+};
+
+// src/react/render.tsx
+import {
+  domToReact
+} from "html-react-parser";
+import { createElement } from "react";
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+var options = {
+  replace(node) {
+    if (node.type !== "tag" || !isComponentTag(node.name)) return void 0;
+    const definition = COMPONENTS[node.name];
+    const parsed = definition.props.safeParse(
+      JSON.parse(node.attribs[PROPS_ATTRIBUTE] ?? "{}")
+    );
+    if (!parsed.success) return /* @__PURE__ */ jsx2(Fragment, {});
+    const blockId = node.attribs["data-cp-id"];
+    return createElement(
+      COMPONENT_VIEWS[node.name],
+      { ...parsed.data, ...blockId ? { "data-cp-id": blockId } : {} },
+      definition.content === "none" ? void 0 : domToReact(node.children, options)
+    );
+  }
+};
+function renderPostBody(html) {
+  return domToReact(sanitizeNodes(html).nodes, options);
+}
+
+export {
+  CpCallout,
+  CpFigure,
+  COMPONENT_VIEWS,
+  renderPostBody
+};

package/dist/chunks/chunk-EICE5ONB.js

@@ -0,0 +1,197 @@
+import {
+  BLOCK_ID_ATTRIBUTE,
+  COMPONENTS,
+  ELEMENTS,
+  PROPS_ATTRIBUTE,
+  URL_SCHEMES,
+  isComponentTag,
+  isElementTag
+} from "./chunk-XLJBCIXI.js";
+
+// src/sanitize.ts
+import { Element, Text } from "domhandler";
+import render from "dom-serializer";
+import { parseDocument } from "htmlparser2";
+var DROP_WITH_CONTENT = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "iframe",
+  "frame",
+  "frameset",
+  "object",
+  "embed",
+  "applet",
+  "noscript",
+  "template",
+  "svg",
+  "math",
+  "textarea",
+  "select",
+  "title",
+  "head",
+  "audio",
+  "video"
+]);
+var VOID_ELEMENTS = /* @__PURE__ */ new Set(["br", "hr", "img"]);
+var MAX_DEPTH = 64;
+var HAS_CONTROL_CHARACTERS = /[\u0000- \u007f-\u009f]/;
+var SCHEME = /^([a-zA-Z][a-zA-Z0-9+.-]*):/;
+function sanitizeUrl(value) {
+  const url = value.trim();
+  if (!url || HAS_CONTROL_CHARACTERS.test(url)) return null;
+  const scheme = SCHEME.exec(url)?.[1]?.toLowerCase();
+  if (scheme) {
+    return URL_SCHEMES.includes(scheme) ? url : null;
+  }
+  if (url.startsWith("#")) return url;
+  if (url.startsWith("/") && !/^\/[/\\]/.test(url)) return url;
+  return null;
+}
+var ATTRIBUTE_VALUE_PATTERNS = {
+  [BLOCK_ID_ATTRIBUTE]: /^[A-Za-z0-9_-]{1,64}$/,
+  id: /^[A-Za-z][\w-]{0,99}$/,
+  target: /^(_blank|_self)$/,
+  loading: /^(lazy|eager)$/,
+  width: /^\d{1,5}$/,
+  height: /^\d{1,5}$/,
+  rel: /^[a-z]+(\s+[a-z]+)*$/i
+};
+function cleanAttributes(tag, attribs, issues) {
+  const definition = ELEMENTS[tag];
+  const allowed = new Set(definition?.attributes ?? []);
+  const urlAttributes = new Set(definition?.urlAttributes ?? []);
+  const cleaned = {};
+  for (const [name, value] of Object.entries(attribs)) {
+    if (!allowed.has(name)) {
+      issues.push({
+        kind: "attribute",
+        tag,
+        name,
+        message: `<${tag}> does not allow the attribute "${name}"`
+      });
+      continue;
+    }
+    if (urlAttributes.has(name)) {
+      const url = sanitizeUrl(value);
+      if (url === null) {
+        issues.push({
+          kind: "url",
+          tag,
+          name,
+          message: `<${tag} ${name}> has a URL that is not allowed`
+        });
+        continue;
+      }
+      cleaned[name] = url;
+      continue;
+    }
+    const pattern = ATTRIBUTE_VALUE_PATTERNS[name];
+    if (pattern && !pattern.test(value)) {
+      issues.push({
+        kind: "attribute",
+        tag,
+        name,
+        message: `<${tag} ${name}> has an invalid value`
+      });
+      continue;
+    }
+    cleaned[name] = value;
+  }
+  if (tag === "a" && cleaned.target === "_blank") {
+    cleaned.rel = "noopener noreferrer";
+  }
+  return cleaned;
+}
+function sanitizeChildren(children, issues, depth) {
+  return children.flatMap((child) => sanitizeNode(child, issues, depth));
+}
+function sanitizeComponent(element, issues, depth) {
+  const tag = element.name;
+  const definition = COMPONENTS[tag];
+  const attribs = {};
+  for (const [name, value] of Object.entries(element.attribs)) {
+    if (!definition.attributes.includes(name)) {
+      issues.push({
+        kind: "attribute",
+        tag,
+        name,
+        message: `<${tag}> does not allow the attribute "${name}"`
+      });
+    } else if (name !== PROPS_ATTRIBUTE) {
+      const valid = ATTRIBUTE_VALUE_PATTERNS[name]?.test(value) ?? true;
+      if (valid) attribs[name] = value;
+    }
+  }
+  let raw;
+  try {
+    raw = JSON.parse(element.attribs[PROPS_ATTRIBUTE] ?? "");
+  } catch {
+    raw = void 0;
+  }
+  const parsed = definition.props.safeParse(raw);
+  if (!parsed.success) {
+    issues.push({
+      kind: "props",
+      tag,
+      name: PROPS_ATTRIBUTE,
+      message: `<${tag}> has invalid ${PROPS_ATTRIBUTE}: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"} ${issue.message}`).join("; ")}`
+    });
+    return [];
+  }
+  attribs[PROPS_ATTRIBUTE] = JSON.stringify(parsed.data);
+  const children = definition.content === "none" ? [] : sanitizeChildren(element.children, issues, depth + 1);
+  return [new Element(tag, attribs, children)];
+}
+function sanitizeNode(node, issues, depth) {
+  if (node.type === "text") return [new Text(node.data)];
+  if (!(node instanceof Element)) return [];
+  const tag = node.name;
+  if (depth > MAX_DEPTH) {
+    issues.push({ kind: "element", tag, message: "nested too deeply" });
+    return [];
+  }
+  if (DROP_WITH_CONTENT.has(tag)) {
+    issues.push({
+      kind: "element",
+      tag,
+      message: `<${tag}> is not allowed and was removed with its content`
+    });
+    return [];
+  }
+  if (isComponentTag(tag)) return sanitizeComponent(node, issues, depth);
+  if (tag.startsWith("cp-")) {
+    issues.push({
+      kind: "element",
+      tag,
+      message: `<${tag}> is not a registered component`
+    });
+    return [];
+  }
+  if (!isElementTag(tag)) {
+    issues.push({
+      kind: "element",
+      tag,
+      message: `<${tag}> is not allowed; its children were kept`
+    });
+    return sanitizeChildren(node.children, issues, depth + 1);
+  }
+  const attribs = cleanAttributes(tag, node.attribs, issues);
+  if (tag === "img" && !attribs.src) return [];
+  const children = VOID_ELEMENTS.has(tag) ? [] : sanitizeChildren(node.children, issues, depth + 1);
+  return [new Element(tag, attribs, children)];
+}
+function sanitizeNodes(html) {
+  const issues = [];
+  const nodes = sanitizeChildren(parseDocument(html).children, issues, 0);
+  return { nodes, issues };
+}
+function sanitizeHtml(html) {
+  return render(sanitizeNodes(html).nodes);
+}
+
+export {
+  DROP_WITH_CONTENT,
+  sanitizeUrl,
+  sanitizeNodes,
+  sanitizeHtml
+};

package/dist/chunks/chunk-HWR3R5MU.js

@@ -0,0 +1,48 @@
+import {
+  COMPONENTS,
+  ELEMENTS,
+  URL_SCHEMES,
+  postMetaSchema
+} from "./chunk-XLJBCIXI.js";
+
+// src/schema.ts
+import { z } from "zod";
+var schemaVersion = 1;
+function toJsonSchema(schema) {
+  const { $schema: _draft, ...jsonSchema } = z.toJSONSchema(schema, {
+    target: "draft-7"
+  });
+  return jsonSchema;
+}
+function buildContentSchema() {
+  return {
+    version: schemaVersion,
+    elements: Object.fromEntries(
+      Object.entries(ELEMENTS).map(([tag, definition]) => [
+        tag,
+        {
+          attributes: [...definition.attributes],
+          ...definition.urlAttributes ? { urlAttributes: [...definition.urlAttributes] } : {}
+        }
+      ])
+    ),
+    components: Object.fromEntries(
+      Object.entries(COMPONENTS).map(([tag, definition]) => [
+        tag,
+        {
+          attributes: [...definition.attributes],
+          content: definition.content,
+          props: toJsonSchema(definition.props)
+        }
+      ])
+    ),
+    urlSchemes: [...URL_SCHEMES],
+    relativeUrls: true,
+    meta: toJsonSchema(postMetaSchema)
+  };
+}
+
+export {
+  schemaVersion,
+  buildContentSchema
+};

package/dist/chunks/chunk-TYX2HJZC.js

@@ -0,0 +1,68 @@
+import {
+  blogUrl,
+  feedUrl,
+  postUrl
+} from "./chunk-AEQDRBA3.js";
+
+// src/xml.ts
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/feed.ts
+function feedXml(site, posts) {
+  const items = posts.map(({ slug, meta }) => {
+    const categories = (meta.tags ?? []).map((tag) => `      <category>${escapeXml(tag)}</category>`).join("\n");
+    return `    <item>
+      <title>${escapeXml(meta.title)}</title>
+      <link>${escapeXml(postUrl(site, slug))}</link>
+      <guid isPermaLink="true">${escapeXml(postUrl(site, slug))}</guid>
+      <pubDate>${(/* @__PURE__ */ new Date(`${meta.date}T00:00:00Z`)).toUTCString()}</pubDate>
+      <description>${escapeXml(meta.description)}</description>${categories ? `
+${categories}` : ""}
+    </item>`;
+  }).join("\n");
+  const newest = posts[0]?.meta;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${escapeXml(site.title)}</title>
+    <link>${escapeXml(blogUrl(site))}</link>
+    <description>${escapeXml(site.description)}</description>
+    <language>${escapeXml(site.language ?? "en")}</language>
+    <atom:link href="${escapeXml(feedUrl(site))}" rel="self" type="application/rss+xml" />${newest ? `
+    <lastBuildDate>${(/* @__PURE__ */ new Date(`${newest.updated ?? newest.date}T00:00:00Z`)).toUTCString()}</lastBuildDate>` : ""}
+${items}
+  </channel>
+</rss>
+`;
+}
+
+// src/sitemap.ts
+function sitemapXml(site, posts) {
+  const newest = posts[0]?.meta;
+  const entries = [
+    {
+      loc: blogUrl(site),
+      lastmod: newest ? newest.updated ?? newest.date : void 0
+    },
+    ...posts.map(({ slug, meta }) => ({
+      loc: postUrl(site, slug),
+      lastmod: meta.updated ?? meta.date
+    }))
+  ];
+  const urls = entries.map(
+    ({ loc, lastmod }) => `  <url><loc>${escapeXml(loc)}</loc>${lastmod ? `<lastmod>${lastmod}</lastmod>` : ""}</url>`
+  ).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>
+`;
+}
+
+export {
+  escapeXml,
+  feedXml,
+  sitemapXml
+};