@platecms/delta-cast-util-to-hast 1.17.0 → 1.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platecms/delta-cast-util-to-hast",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "description": "Utility to convert CAST to HAST syntax tree.",
   "license": "UNLICENSED",
   "publishConfig": {
@@ -17,8 +17,8 @@
     "src/**/*"
   ],
   "dependencies": {
-    "@platecms/delta-cast": "1.17.0",
-    "@platecms/delta-plate-resource-notation": "1.17.0",
+    "@platecms/delta-cast": "1.19.0",
+    "@platecms/delta-plate-resource-notation": "1.19.0",
     "class-transformer": "0.5.1",
     "hast": "1.0.0",
     "reflect-metadata": "0.2.2",

package/src/lib/elements/text.ts

@@ -1,9 +1,23 @@
 import { Text } from "@platecms/delta-cast";
-import { Text as HastText } from "hast";
+import { Element as HastElement, Text as HastText } from "hast";
 
-export function text(node: Text): HastText {
-  return {
-    type: "text",
-    value: node.value,
-  };
+/**
+ * A text node's value may contain soft returns ("\n", inserted with shift+enter in the
+ * editor). HTML collapses raw newlines in running text, so each one is rendered as an
+ * explicit <br> to keep the line break visible on the published page.
+ */
+export function text(node: Text): (HastElement | HastText)[] {
+  const lines = node.value.split("\n");
+  const lineBreak: HastElement = { type: "element", tagName: "br", properties: {}, children: [] };
+
+  return lines.flatMap((line, index): (HastElement | HastText)[] => {
+    const isLastLine = index === lines.length - 1;
+
+    if (line.length === 0) {
+      return isLastLine ? [{ type: "text", value: "" }] : [lineBreak];
+    }
+
+    const textNode: HastText = { type: "text", value: line };
+    return isLastLine ? [textNode] : [textNode, lineBreak];
+  });
 }

package/src/lib/index.spec.ts

@@ -29,6 +29,84 @@ describe("single nodes", () => {
     });
   });
 
+  it("should convert a soft return within a paragraph into a <br> element", () => {
+    // Arrange
+    const cast: Root = c("root", [c("paragraph", "Line one\nLine two")]);
+
+    // Act
+    const expected = toHast(cast);
+
+    // Assert
+    expect(expected).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "element",
+          tagName: "p",
+          properties: {},
+          children: [
+            {
+              type: "text",
+              value: "Line one",
+            },
+            {
+              type: "element",
+              tagName: "br",
+              properties: {},
+              children: [],
+            },
+            {
+              type: "text",
+              value: "Line two",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("should convert multiple consecutive soft returns into consecutive <br> elements", () => {
+    // Arrange
+    const cast: Root = c("root", [c("paragraph", "Line one\n\nLine two")]);
+
+    // Act
+    const expected = toHast(cast);
+
+    // Assert
+    expect(expected).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "element",
+          tagName: "p",
+          properties: {},
+          children: [
+            {
+              type: "text",
+              value: "Line one",
+            },
+            {
+              type: "element",
+              tagName: "br",
+              properties: {},
+              children: [],
+            },
+            {
+              type: "element",
+              tagName: "br",
+              properties: {},
+              children: [],
+            },
+            {
+              type: "text",
+              value: "Line two",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
   it("should convert a heading from cast to hast", () => {
     // Arrange
     const cast: Root = c("root", [c("heading", "Hello, world!", { level: 1 })]);

package/src/lib/index.ts

@@ -55,11 +55,15 @@ const one = zwitch("type", {
 
 export function all(nodes: Content[], state: object = {}, transform: NodeTransformers = {}): HastElement[] {
   let index = -1;
-  const results = [];
+  const results: HastElement[] = [];
 
   while (++index < nodes.length) {
     const result = one(nodes[index], state, transform);
-    results.push(result);
+    if (Array.isArray(result)) {
+      results.push(...result);
+    } else {
+      results.push(result);
+    }
   }
 
   return results;