@mezzanine-stack/content-document 0.1.0

package/README.md

@@ -0,0 +1,31 @@
+# @mezzanine-stack/content-document
+
+CMS プレビューや描画共通化向けの Document Model 変換ロジック。Markdown と frontmatter から正規化済みドキュメントを生成します。
+
+## 責務
+
+- Markdown 本文を `BodyNode` / `InlineNode` へ変換
+- frontmatter + body から `BlogDocument` を生成
+- frontmatter + body から `MarkdownPageDocument` を生成
+- CMS / Astro 共通で扱える `CmsDocument` 型を提供
+
+## 主要 API
+
+- `parseMarkdownToBodyNodes(markdown)`
+- `toBlogDocument({ frontmatter, body })`
+- `toMarkdownPageDocument({ frontmatter, body })`
+
+## 公開型
+
+- `InlineNode`
+- `BodyNode`
+- `EntrySource`
+- `BlogDocument`
+- `MarkdownPageDocument`
+- `CmsDocument`
+
+## 依存ライブラリ
+
+- `unified`
+- `remark-parse`
+

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@mezzanine-stack/content-document",
+  "version": "0.1.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.0"
+  },
+  "dependencies": {
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.5"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import {
+  parseMarkdownToBodyNodes,
+  toBlogDocument,
+  toMarkdownPageDocument,
+} from "./index.js";
+
+describe("content-document", () => {
+  it("parses markdown body nodes", () => {
+    const nodes = parseMarkdownToBodyNodes("# Title\n\nHello **world**");
+    expect(nodes.length).toBeGreaterThan(0);
+    expect(nodes[0]?.type).toBe("heading");
+  });
+
+  it("normalizes blog document from frontmatter + body", () => {
+    const doc = toBlogDocument({
+      frontmatter: {
+        title: "My Post",
+        draft: "1",
+        tags: ["news"],
+        pubDate: "2026-01-01",
+      },
+      body: "Hello",
+    });
+
+    expect(doc.type).toBe("blog");
+    expect(doc.title).toBe("My Post");
+    expect(doc.draft).toBe(true);
+    expect(doc.tags).toEqual(["news"]);
+    expect(doc.pubDate).toBe("2026-01-01");
+  });
+
+  it("normalizes markdown page document", () => {
+    const doc = toMarkdownPageDocument({
+      frontmatter: { name: "About", description: "desc" },
+      body: "body",
+    });
+
+    expect(doc.type).toBe("markdown-page");
+    expect(doc.title).toBe("About");
+    expect(doc.description).toBe("desc");
+  });
+});
+

package/src/index.ts

@@ -0,0 +1,4 @@
+export type { InlineNode, BodyNode, EntrySource, BlogDocument, MarkdownPageDocument, CmsDocument } from "./types.js";
+export { parseMarkdownToBodyNodes } from "./markdown/parseMarkdownToBodyNodes.js";
+export { toBlogDocument, toMarkdownPageDocument } from "./normalize.js";
+

package/src/markdown/parseMarkdownToBodyNodes.ts

@@ -0,0 +1,164 @@
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+
+import type { BodyNode, InlineNode } from "../types.js";
+
+type MdastNode = any;
+
+function isNonEmptyString(v: unknown): v is string {
+  return typeof v === "string" && v.trim().length > 0;
+}
+
+function clampHeadingLevel(depth: unknown): 1 | 2 | 3 | 4 {
+  const n = typeof depth === "number" ? depth : 2;
+  if (n <= 1) return 1;
+  if (n === 2) return 2;
+  if (n === 3) return 3;
+  return 4;
+}
+
+function plainTextFromInline(inlines: MdastNode[] | undefined): string {
+  if (!inlines) return "";
+  return inlines
+    .map((n) => {
+      if (!n) return "";
+      if (n.type === "text") return String(n.value ?? "");
+      if (n.type === "inlineCode") return String(n.value ?? "");
+      if (Array.isArray(n.children)) return plainTextFromInline(n.children);
+      return "";
+    })
+    .join("");
+}
+
+function toInlineNodes(nodes: MdastNode[] | undefined): InlineNode[] {
+  if (!nodes || nodes.length === 0) return [];
+
+  const out: InlineNode[] = [];
+  for (const n of nodes) {
+    if (!n) continue;
+    switch (n.type) {
+      case "text": {
+        out.push({ type: "text", text: String(n.value ?? "") });
+        break;
+      }
+      case "strong": {
+        out.push({ type: "strong", children: toInlineNodes(n.children) });
+        break;
+      }
+      case "emphasis": {
+        out.push({ type: "em", children: toInlineNodes(n.children) });
+        break;
+      }
+      case "link": {
+        out.push({
+          type: "link",
+          href: String(n.url ?? ""),
+          children: toInlineNodes(n.children),
+        });
+        break;
+      }
+      case "inlineCode": {
+        out.push({ type: "text", text: String(n.value ?? "") });
+        break;
+      }
+      case "break": {
+        out.push({ type: "text", text: "\n" });
+        break;
+      }
+      case "image": {
+        // inline image は BodyNode.image 側で扱う方針のため、ここでは alt を文字として扱う
+        const alt = isNonEmptyString(n.alt) ? String(n.alt) : "image";
+        out.push({ type: "text", text: alt });
+        break;
+      }
+      default: {
+        if (Array.isArray(n.children)) {
+          out.push(...toInlineNodes(n.children));
+        }
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+function toBodyNode(node: MdastNode): BodyNode | null {
+  if (!node) return null;
+
+  switch (node.type) {
+    case "heading": {
+      const level = clampHeadingLevel(node.depth);
+      const text = plainTextFromInline(node.children);
+      return { type: "heading", level, text };
+    }
+    case "paragraph": {
+      return { type: "paragraph", children: toInlineNodes(node.children) };
+    }
+    case "image": {
+      return {
+        type: "image",
+        src: String(node.url ?? ""),
+        alt: isNonEmptyString(node.alt) ? String(node.alt) : undefined,
+      };
+    }
+    case "blockquote": {
+      // blockquote は paragraph を inline にフラット化
+      const parts: InlineNode[] = [];
+      const children: MdastNode[] = Array.isArray(node.children) ? node.children : [];
+      let first = true;
+      for (const c of children) {
+        if (!c) continue;
+        if (c.type === "paragraph") {
+          if (!first) parts.push({ type: "text", text: "\n" });
+          parts.push(...toInlineNodes(c.children));
+          first = false;
+        }
+      }
+      if (parts.length === 0) {
+        return { type: "quote", children: [{ type: "text", text: "" }] };
+      }
+      return { type: "quote", children: parts };
+    }
+    case "code": {
+      return {
+        type: "code",
+        code: String(node.value ?? ""),
+        language: isNonEmptyString(node.lang) ? String(node.lang) : undefined,
+      };
+    }
+    case "list": {
+      const ordered = Boolean(node.ordered);
+      const items: InlineNode[][] = [];
+      const listItems: MdastNode[] = Array.isArray(node.children) ? node.children : [];
+      for (const li of listItems) {
+        if (!li || li.type !== "listItem") continue;
+        const inline: InlineNode[] = [];
+        const liChildren: MdastNode[] = Array.isArray(li.children) ? li.children : [];
+        for (const lc of liChildren) {
+          if (!lc) continue;
+          if (lc.type === "paragraph") {
+            inline.push(...toInlineNodes(lc.children));
+            break; // MVP: 先頭 paragraph のみ
+          }
+        }
+        items.push(inline);
+      }
+      return { type: "list", ordered, items };
+    }
+    default:
+      return null;
+  }
+}
+
+export function parseMarkdownToBodyNodes(md: string): BodyNode[] {
+  const tree = unified().use(remarkParse).parse(md ?? "") as MdastNode;
+  const children: MdastNode[] = Array.isArray(tree.children) ? tree.children : [];
+
+  const out: BodyNode[] = [];
+  for (const n of children) {
+    const node = toBodyNode(n);
+    if (node) out.push(node);
+  }
+  return out;
+}
+

package/src/normalize.ts

@@ -0,0 +1,63 @@
+import type { BlogDocument, EntrySource, MarkdownPageDocument } from "./types.js";
+import { parseMarkdownToBodyNodes } from "./markdown/parseMarkdownToBodyNodes.js";
+
+function isNonEmptyString(v: unknown): v is string {
+  return typeof v === "string" && v.trim().length > 0;
+}
+
+function asString(v: unknown): string | undefined {
+  return isNonEmptyString(v) ? v : undefined;
+}
+
+function asBoolean(v: unknown): boolean {
+  if (typeof v === "boolean") return v;
+  if (typeof v === "string") return v === "true" || v === "1";
+  return Boolean(v);
+}
+
+function asStringArray(v: unknown): string[] {
+  if (Array.isArray(v)) return v.map((x) => String(x)).filter((s) => s.trim().length > 0);
+  return [];
+}
+
+function asDateString(v: unknown): string | undefined {
+  if (v instanceof Date && !Number.isNaN(v.getTime())) return v.toISOString();
+  if (typeof v === "string" && v.trim().length > 0) return v;
+  return undefined;
+}
+
+export function toBlogDocument(entry: EntrySource): BlogDocument {
+  const fm = entry.frontmatter ?? {};
+
+  const title = asString(fm.title) ?? asString(fm.name) ?? "";
+  const description = asString(fm.description);
+  const heroSrc = asString(fm.heroImage);
+
+  return {
+    type: "blog",
+    template: "blog-standard",
+    title,
+    description,
+    heroImage: heroSrc ? { src: heroSrc, alt: undefined } : undefined,
+    pubDate: asDateString(fm.pubDate),
+    tags: asStringArray(fm.tags),
+    draft: asBoolean(fm.draft),
+    body: parseMarkdownToBodyNodes(entry.body ?? ""),
+  };
+}
+
+export function toMarkdownPageDocument(entry: EntrySource): MarkdownPageDocument {
+  const fm = entry.frontmatter ?? {};
+
+  const title = asString(fm.title) ?? asString(fm.name) ?? "";
+  const description = asString(fm.description);
+
+  return {
+    type: "markdown-page",
+    template: "markdown-page-standard",
+    title,
+    description,
+    body: parseMarkdownToBodyNodes(entry.body ?? ""),
+  };
+}
+

package/src/types.ts

@@ -0,0 +1,41 @@
+export type InlineNode =
+  | { type: "text"; text: string }
+  | { type: "strong"; children: InlineNode[] }
+  | { type: "em"; children: InlineNode[] }
+  | { type: "link"; href: string; children: InlineNode[] };
+
+export type BodyNode =
+  | { type: "heading"; level: 1 | 2 | 3 | 4; text: string }
+  | { type: "paragraph"; children: InlineNode[] }
+  | { type: "image"; src: string; alt?: string; caption?: string }
+  | { type: "quote"; children: InlineNode[]; cite?: string }
+  | { type: "code"; code: string; language?: string }
+  | { type: "list"; ordered: boolean; items: InlineNode[][] };
+
+export type EntrySource = {
+  frontmatter: Record<string, unknown>;
+  body: string;
+};
+
+export type BlogDocument = {
+  type: "blog";
+  template: "blog-standard";
+  title: string;
+  description?: string;
+  heroImage?: { src: string; alt?: string };
+  pubDate?: string;
+  tags: string[];
+  draft: boolean;
+  body: BodyNode[];
+};
+
+export type MarkdownPageDocument = {
+  type: "markdown-page";
+  template: "markdown-page-standard";
+  title: string;
+  description?: string;
+  body: BodyNode[];
+};
+
+export type CmsDocument = BlogDocument | MarkdownPageDocument;
+

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
+  "include": ["src"]
+}
+

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["src/**/*.test.ts"],
+  },
+});
+