@avocadostudio-ai/richtext 0.2.0

package/dist/strapi.js

@@ -0,0 +1,236 @@
+/**
+ * Strapi 5 Blocks <-> the pivot document.
+ *
+ * Strapi's blocks field is Slate-shaped: a flat array of block objects, each
+ * with a `children` array, and formatting expressed as *boolean props on the
+ * text node* (`bold: true`) rather than as a list of marks. Links are inline
+ * nodes wrapping their text, the way Contentful does it, so the same
+ * gather-adjacent-text logic applies on the way out.
+ *
+ * Nesting is real here — a `list` may appear inside another list's children —
+ * which makes lists the one place Strapi is closer to the pivot than Portable
+ * Text is. Like Contentful and unlike Sanity, nothing carries a key, so a write
+ * replaces the field and there is nothing to merge against.
+ *
+ * The vocabulary has no thematic break. A `horizontalRule` in the pivot has
+ * nowhere to go and is dropped rather than faked as a paragraph of dashes.
+ */
+import { MARK, NODE } from "./doc.js";
+/** The boolean formatting props, and the pivot marks they are. */
+const FLAG_TO_MARK = {
+    bold: MARK.bold,
+    italic: MARK.italic,
+    underline: MARK.underline,
+    strikethrough: MARK.strike,
+    code: MARK.code
+};
+const MARK_TO_FLAG = Object.fromEntries(Object.entries(FLAG_TO_MARK).map(([flag, mark]) => [mark, flag]));
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// ---------------------------------------------------------------------------
+// Strapi -> document
+// ---------------------------------------------------------------------------
+function textToPivot(node, extraMarks = []) {
+    const text = typeof node.text === "string" ? node.text : "";
+    if (text.length === 0)
+        return null;
+    const marks = [];
+    for (const [flag, mark] of Object.entries(FLAG_TO_MARK)) {
+        if (node[flag] === true)
+            marks.push({ type: mark });
+    }
+    marks.push(...extraMarks);
+    return { type: NODE.text, text, ...(marks.length > 0 ? { marks } : {}) };
+}
+function inlineToPivot(nodes) {
+    const out = [];
+    for (const node of nodes ?? []) {
+        if (node.type === "text") {
+            const converted = textToPivot(node);
+            if (converted)
+                out.push(converted);
+            continue;
+        }
+        if (node.type === "link") {
+            const href = typeof node.url === "string" ? node.url : "";
+            for (const child of node.children ?? []) {
+                const converted = textToPivot(child, [{ type: MARK.link, attrs: { href } }]);
+                if (converted)
+                    out.push(converted);
+            }
+            continue;
+        }
+        out.push({ type: NODE.unknown, attrs: { data: node } });
+    }
+    return out;
+}
+function listToPivot(node) {
+    const type = node.format === "ordered" ? NODE.orderedList : NODE.bulletList;
+    const items = [];
+    for (const child of node.children ?? []) {
+        if (child.type === "list") {
+            // A nested list belongs to the item above it. With no item above it — a
+            // malformed value — it becomes an item of its own so the content stays.
+            const nested = listToPivot(child);
+            const parent = items[items.length - 1];
+            if (parent)
+                parent.content = [...(parent.content ?? []), nested];
+            else
+                items.push({ type: NODE.listItem, content: [nested] });
+            continue;
+        }
+        const content = inlineToPivot(child.children);
+        items.push({
+            type: NODE.listItem,
+            content: [content.length > 0 ? { type: NODE.paragraph, content } : { type: NODE.paragraph }]
+        });
+    }
+    return { type, content: items };
+}
+function blockToPivot(node) {
+    switch (node.type) {
+        case "paragraph": {
+            const content = inlineToPivot(node.children);
+            return [content.length > 0 ? { type: NODE.paragraph, content } : { type: NODE.paragraph }];
+        }
+        case "heading": {
+            const level = typeof node.level === "number" ? Math.min(6, Math.max(1, node.level)) : 2;
+            const content = inlineToPivot(node.children);
+            const base = { type: NODE.heading, attrs: { level } };
+            return [content.length > 0 ? { ...base, content } : base];
+        }
+        case "list":
+            return [listToPivot(node)];
+        case "quote": {
+            const content = inlineToPivot(node.children);
+            return [
+                {
+                    type: NODE.blockquote,
+                    content: [content.length > 0 ? { type: NODE.paragraph, content } : { type: NODE.paragraph }]
+                }
+            ];
+        }
+        case "code": {
+            const code = (node.children ?? []).map((c) => (typeof c.text === "string" ? c.text : "")).join("");
+            return [
+                {
+                    type: NODE.codeBlock,
+                    attrs: { language: typeof node.language === "string" ? node.language : null },
+                    ...(code.length > 0 ? { content: [{ type: NODE.text, text: code }] } : {})
+                }
+            ];
+        }
+        default:
+            return [{ type: NODE.unknown, attrs: { data: node } }];
+    }
+}
+/** Convert a Strapi Blocks value into the pivot document. */
+export function fromStrapiBlocks(blocks) {
+    if (!Array.isArray(blocks))
+        return { type: "doc", content: [] };
+    return { type: "doc", content: blocks.filter(isObject).flatMap(blockToPivot) };
+}
+// ---------------------------------------------------------------------------
+// document -> Strapi
+// ---------------------------------------------------------------------------
+function pivotTextToStrapi(node) {
+    const out = { type: "text", text: node.text ?? "" };
+    for (const mark of node.marks ?? []) {
+        const flag = MARK_TO_FLAG[mark.type];
+        if (flag)
+            out[flag] = true;
+    }
+    return out;
+}
+function inlineToStrapi(nodes) {
+    const out = [];
+    let openLink;
+    for (const node of nodes ?? []) {
+        if (node.type === NODE.unknown && isObject(node.attrs?.data)) {
+            openLink = undefined;
+            out.push(node.attrs.data);
+            continue;
+        }
+        if (node.type === NODE.hardBreak) {
+            const target = openLink ? openLink.node.children : out;
+            const last = target?.[target.length - 1];
+            if (last && typeof last.text === "string")
+                last.text += "\n";
+            continue;
+        }
+        if (typeof node.text !== "string" || node.text.length === 0)
+            continue;
+        const link = node.marks?.find((m) => m.type === MARK.link);
+        const href = typeof link?.attrs?.href === "string" ? link.attrs.href : undefined;
+        if (href === undefined) {
+            openLink = undefined;
+            out.push(pivotTextToStrapi(node));
+            continue;
+        }
+        if (!openLink || openLink.href !== href) {
+            openLink = { href, node: { type: "link", url: href, children: [] } };
+            out.push(openLink.node);
+        }
+        openLink.node.children.push(pivotTextToStrapi(node));
+    }
+    // Strapi rejects an empty children array; every block needs at least one
+    // (possibly empty) text node.
+    return out;
+}
+function withChildren(node, children) {
+    return { ...node, children: children.length > 0 ? children : [{ type: "text", text: "" }] };
+}
+function listToStrapi(node) {
+    const children = [];
+    for (const item of node.content ?? []) {
+        const parts = item.content ?? [];
+        const paragraphs = parts.filter((p) => p.type !== NODE.bulletList && p.type !== NODE.orderedList);
+        const nested = parts.filter((p) => p.type === NODE.bulletList || p.type === NODE.orderedList);
+        children.push(withChildren({ type: "list-item" }, paragraphs.flatMap((p) => inlineToStrapi(p.content))));
+        for (const child of nested)
+            children.push(listToStrapi(child));
+    }
+    return {
+        type: "list",
+        format: node.type === NODE.orderedList ? "ordered" : "unordered",
+        children
+    };
+}
+function nodeToStrapi(node) {
+    switch (node.type) {
+        case NODE.paragraph:
+            return [withChildren({ type: "paragraph" }, inlineToStrapi(node.content))];
+        case NODE.heading: {
+            const level = typeof node.attrs?.level === "number" ? Math.min(6, Math.max(1, node.attrs.level)) : 2;
+            return [withChildren({ type: "heading", level }, inlineToStrapi(node.content))];
+        }
+        case NODE.bulletList:
+        case NODE.orderedList:
+            return [listToStrapi(node)];
+        case NODE.blockquote:
+            // Strapi's `quote` holds inline children, not blocks, so a multi-paragraph
+            // quote becomes one quote per paragraph rather than losing the split.
+            return (node.content ?? []).map((child) => withChildren({ type: "quote" }, inlineToStrapi(child.content)));
+        case NODE.codeBlock: {
+            const code = (node.content ?? []).map((c) => c.text ?? "").join("");
+            return [
+                {
+                    type: "code",
+                    ...(typeof node.attrs?.language === "string" ? { language: node.attrs.language } : {}),
+                    children: [{ type: "text", text: code }]
+                }
+            ];
+        }
+        case NODE.horizontalRule:
+            return [];
+        case NODE.unknown:
+            return isObject(node.attrs?.data) ? [node.attrs.data] : [];
+        default:
+            return (node.content ?? []).flatMap(nodeToStrapi);
+    }
+}
+/** Convert the pivot document back to a Strapi Blocks value. */
+export function toStrapiBlocks(doc) {
+    return (doc.content ?? []).flatMap(nodeToStrapi);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@avocadostudio-ai/richtext",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/avocadostudio-ai/avocado.git",
+    "directory": "packages/richtext"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.3"
+  },
+  "description": "The Avocado Studio rich-text grammar and converters for Contentful, Sanity Portable Text and Strapi Blocks",
+  "keywords": [
+    "richtext",
+    "markdown",
+    "prosemirror",
+    "portable-text",
+    "contentful",
+    "strapi"
+  ],
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/avocadostudio-ai/avocado/tree/main/packages/richtext#readme",
+  "bugs": {
+    "url": "https://github.com/avocadostudio-ai/avocado/issues"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "NODE_ENV=test node ../../scripts/run-tests.mjs"
+  }
+}