@platecms/delta-cast-util-to-hast 1.0.0 → 1.3.0

package/README.md

@@ -89,7 +89,7 @@ const cast: Root = {
                     },
                 ]
             },
-            prn: "prn:plate-dev:a7734468-b894-4191-83b1-7d218f8c9922:cxc:content-value:b2119c94-24e6-4358-b557-c705dcd19d1d"
+            prn: "prn:plate-dev:a7734468-b894-4191-83b1-7d218f8c9922:cms:content-value:b2119c94-24e6-4358-b557-c705dcd19d1d"
         },
       ],
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platecms/delta-cast-util-to-hast",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "description": "Utility to convert CAST to HAST syntax tree.",
   "license": "UNLICENSED",
   "publishConfig": {
@@ -17,14 +17,12 @@
     "src/**/*"
   ],
   "dependencies": {
-    "@platecms/delta-cast": "1.0.0",
-    "@platecms/delta-plate-resource-notation": "1.0.0",
+    "@platecms/delta-cast": "1.3.0",
+    "@platecms/delta-plate-resource-notation": "1.3.0",
     "class-transformer": "0.5.1",
     "hast": "1.0.0",
     "reflect-metadata": "0.2.2",
     "tslib": "2.8.1",
-    "zwitch": "2.0.4",
-    "lodash": "4.17.21"
-  },
-  "type": "commonjs"
+    "zwitch": "2.0.4"
+  }
 }

package/src/{index.d.ts → index.ts}

@@ -1,3 +1,4 @@
 export { toHast } from "./lib";
+
 export * from "./lib/utils";
 export * from "./lib/transformers";

package/src/lib/elements/blockquote.ts

@@ -0,0 +1,13 @@
+import { Blockquote } from "@platecms/delta-cast";
+import { Element as HastElement } from "hast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+
+export function blockquote(node: Blockquote, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: "blockquote",
+    properties: {},
+    children: all(node.children, state, transform),
+  };
+}

package/src/lib/elements/bold.ts

@@ -0,0 +1,13 @@
+import { Bold } from "@platecms/delta-cast";
+import { Element as HastElement } from "hast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+
+export function bold(node: Bold, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: "strong",
+    properties: {},
+    children: all(node.children, state, transform),
+  };
+}

package/src/lib/elements/code.ts

@@ -0,0 +1,13 @@
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+import { Code } from "@platecms/delta-cast";
+import { Element as HastElement, Text } from "hast";
+
+export function code(node: Code, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: "code",
+    properties: { lang: node.lang },
+    children: all((node as Code & { children: Text[] }).children, state, transform),
+  };
+}

package/src/lib/elements/contentValue.ts

@@ -0,0 +1,15 @@
+import { InterpolatedContentValue } from "@platecms/delta-cast";
+import { Element as HastElement } from "hast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+
+export function contentValue(node: InterpolatedContentValue, state: object, transform: NodeTransformers): HastElement {
+  const transformedNode = transform.contentValue ? transform.contentValue(node) : node;
+
+  return {
+    type: "element",
+    tagName: "span",
+    properties: {},
+    children: transformedNode.value ? all(transformedNode.value.children, state, transform) : [],
+  };
+}

package/src/lib/elements/heading.ts

@@ -0,0 +1,13 @@
+import { Heading } from "@platecms/delta-cast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+import { Element as HastElement } from "hast";
+
+export function heading(node: Heading, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: `h${node.level}`,
+    properties: {},
+    children: all(node.children, state, transform),
+  };
+}

package/src/lib/elements/{index.d.ts → index.ts}

@@ -10,4 +10,19 @@ import { strikehrough } from "./strikehrough";
 import { text } from "./text";
 import { blockquote } from "./blockquote";
 import { link } from "./link";
-export { heading, link, list, listItem, code, contentValue, paragraph, bold, italic, underline, strikehrough, text, blockquote, };
+
+export {
+  heading,
+  link,
+  list,
+  listItem,
+  code,
+  contentValue,
+  paragraph,
+  bold,
+  italic,
+  underline,
+  strikehrough,
+  text,
+  blockquote,
+};

package/src/lib/elements/italic.ts

@@ -0,0 +1,13 @@
+import { Italic } from "@platecms/delta-cast";
+import { Element as HastElement } from "hast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+
+export function italic(node: Italic, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: "em",
+    properties: {},
+    children: all(node.children, state, transform),
+  };
+}

package/src/lib/elements/link.ts

@@ -0,0 +1,20 @@
+import { ExternalLink, InternalLink } from "@platecms/delta-cast";
+import { Element as HastElement } from "hast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+
+export function link(node: ExternalLink | InternalLink, state: object, transform: NodeTransformers): HastElement {
+  if (node.url === undefined) {
+    throw new Error("Cannot construct a link with an undefined URL.");
+  }
+
+  return {
+    type: "element",
+    tagName: "a",
+    properties: {
+      href: node.url,
+      target: node.target,
+    },
+    children: all(node.children, state, transform),
+  };
+}

package/src/lib/elements/lists.ts

@@ -0,0 +1,22 @@
+import { List, ListItem } from "@platecms/delta-cast";
+import { Element as HastElement } from "hast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+
+export function list(node: List, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: node.ordered ? "ol" : "ul",
+    properties: {},
+    children: all(node.children, state, transform),
+  };
+}
+
+export function listItem(node: ListItem, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: "li",
+    properties: {},
+    children: all(node.children, state, transform),
+  };
+}

package/src/lib/elements/paragraph.ts

@@ -0,0 +1,13 @@
+import { Paragraph } from "@platecms/delta-cast";
+import { Element as HastElement } from "hast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+
+export function paragraph(node: Paragraph, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: "p",
+    properties: {},
+    children: all(node.children, state, transform),
+  };
+}

package/src/lib/elements/strikehrough.ts

@@ -0,0 +1,13 @@
+import { Strikethrough } from "@platecms/delta-cast";
+import { Element as HastElement } from "hast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+
+export function strikehrough(node: Strikethrough, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: "s",
+    properties: {},
+    children: all(node.children, state, transform),
+  };
+}

package/src/lib/elements/text.ts

@@ -0,0 +1,9 @@
+import { Text } from "@platecms/delta-cast";
+import { Text as HastText } from "hast";
+
+export function text(node: Text): HastText {
+  return {
+    type: "text",
+    value: node.value,
+  };
+}

package/src/lib/elements/underline.ts

@@ -0,0 +1,13 @@
+import { Underline } from "@platecms/delta-cast";
+import { Element as HastElement } from "hast";
+import { all } from "..";
+import { NodeTransformers } from "../transformers";
+
+export function underline(node: Underline, state: object = {}, transform: NodeTransformers = {}): HastElement {
+  return {
+    type: "element",
+    tagName: "u",
+    properties: {},
+    children: all(node.children, state, transform),
+  };
+}

package/src/lib/index.spec.ts

@@ -0,0 +1,404 @@
+import { toHast } from "../index";
+import { c } from "@platecms/delta-castscript";
+import { Root } from "@platecms/delta-cast";
+
+describe("single nodes", () => {
+  it("should convert a paragraph from cast to hast", () => {
+    // Arrange
+    const cast: Root = c("root", [c("paragraph", "Hello, world!")]);
+
+    // Act
+    const expected = toHast(cast);
+
+    // Assert
+    expect(expected).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "element",
+          tagName: "p",
+          properties: {},
+          children: [
+            {
+              type: "text",
+              value: "Hello, world!",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("should convert a heading from cast to hast", () => {
+    // Arrange
+    const cast: Root = c("root", [c("heading", "Hello, world!", { level: 1 })]);
+
+    // Act
+    const expected = toHast(cast);
+
+    // Assert
+    expect(expected).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "element",
+          tagName: "h1",
+          properties: {},
+          children: [
+            {
+              type: "text",
+              value: "Hello, world!",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("should convert a list from cast to hast", () => {
+    // Arrange
+    const cast: Root = c("root", [
+      c("list", { ordered: true }, [c("listItem", "Hello, world!"), c("listItem", "Hello, world!")]),
+    ]);
+
+    // Act
+    const expected = toHast(cast);
+
+    // Assert
+    expect(expected).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "element",
+          tagName: "ol",
+          properties: {},
+          children: [
+            {
+              type: "element",
+              tagName: "li",
+              properties: {},
+              children: [
+                {
+                  type: "text",
+                  value: "Hello, world!",
+                },
+              ],
+            },
+            {
+              type: "element",
+              tagName: "li",
+              properties: {},
+              children: [
+                {
+                  type: "text",
+                  value: "Hello, world!",
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("should convert a blockquote from from cast to hast", () => {
+    // Arrange
+    const cast: Root = c("root", [c("blockquote", "Hello, world!")]);
+
+    // Act
+    const expected = toHast(cast);
+
+    // Assert
+    expect(expected).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "element",
+          tagName: "blockquote",
+          properties: {},
+          children: [
+            {
+              type: "text",
+              value: "Hello, world!",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("should convert code from cast to hast", () => {
+    // Arrange
+    const cast: Root = c("root", [c("code", [c("text", "Hello, world!")])]);
+
+    // Act
+    const expected = toHast(cast);
+
+    // Assert
+    expect(expected).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "element",
+          tagName: "code",
+          properties: {},
+          children: [
+            {
+              type: "text",
+              value: "Hello, world!",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("should convert a content value from cast to hast", () => {
+    // Arrange
+    const cast: Root = c("root", [
+      c("contentValue", {
+        prn: "prn:content-value",
+        value: c("root", [c("paragraph", "Hello, world!")]),
+      }),
+    ]);
+
+    // Act
+    const expected = toHast(cast);
+
+    // Assert
+    expect(expected).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "element",
+          properties: {},
+          tagName: "span",
+          children: [
+            {
+              type: "text",
+              value: "Hello, world!",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  describe("links", () => {
+    it("should convert an external link from cast to hast", () => {
+      // Arrange
+      const cast: Root = c("root", [
+        c("externalLink", { url: "https://www.google.com" }, [c("text", "Hello, world!")]),
+      ]);
+
+      // Act
+      const result = toHast(cast);
+
+      // Assert
+      expect(result).toEqual({
+        type: "root",
+        children: [
+          {
+            type: "element",
+            tagName: "a",
+            properties: {
+              href: "https://www.google.com",
+            },
+            children: [{ type: "text", value: "Hello, world!" }],
+          },
+        ],
+      });
+    });
+
+    it("should convert an external link with target from cast to hast", () => {
+      // Arrange
+      const cast: Root = c("root", [
+        c("externalLink", { url: "https://www.google.com", target: "blank" }, [c("text", "Hello, world!")]),
+      ]);
+
+      // Act
+      const result = toHast(cast);
+
+      // Assert
+      expect(result).toEqual({
+        type: "root",
+        children: [
+          {
+            type: "element",
+            tagName: "a",
+            properties: {
+              href: "https://www.google.com",
+              target: "blank",
+            },
+            children: [{ type: "text", value: "Hello, world!" }],
+          },
+        ],
+      });
+    });
+
+    it("should convert an internal link from cast to hast", () => {
+      // Arrange
+      const cast: Root = c("root", [
+        c("internalLink", { url: "https://www.google.com", prn: "prn:path-part:path-part" }, [
+          c("text", "Hello, world!"),
+        ]),
+      ]);
+
+      // Act
+      const result = toHast(cast);
+
+      // Assert
+      expect(result).toEqual({
+        type: "root",
+        children: [
+          {
+            type: "element",
+            tagName: "a",
+            properties: { href: "https://www.google.com" },
+            children: [{ type: "text", value: "Hello, world!" }],
+          },
+        ],
+      });
+    });
+
+    it("should convert an internal anchor link from cast to hast", () => {
+      // Arrange
+      const cast: Root = c("root", [
+        c("internalLink", { url: "https://www.google.com#anchor-name", prn: "prn:grid-placement:grid-placement" }, [
+          c("text", "Hello, world!"),
+        ]),
+      ]);
+
+      // Act
+      const result = toHast(cast);
+
+      // Assert
+      expect(result).toEqual({
+        type: "root",
+        children: [
+          {
+            type: "element",
+            tagName: "a",
+            properties: { href: "https://www.google.com#anchor-name" },
+            children: [{ type: "text", value: "Hello, world!" }],
+          },
+        ],
+      });
+    });
+  });
+});
+
+describe("nested nodes", () => {
+  it("should convert a nested tree from cast to hast", () => {
+    // Arrange
+    const tree: Root = c("root", [
+      c("list", { ordered: false }, [c("listItem", [c("bold", "Hello, world!")])]),
+      c("paragraph", [
+        c("text", "Hello, world!"),
+        c("contentValue", "", {
+          prn: "prn:content-value:content-value",
+          value: c("root", [c("paragraph", "Hello, world!")]),
+        }),
+      ]),
+    ]);
+
+    // Act
+    const expected = toHast(tree);
+
+    // Assert
+    expect(expected).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "element",
+          tagName: "ul",
+          properties: {},
+          children: [
+            {
+              type: "element",
+              tagName: "li",
+              properties: {},
+              children: [
+                {
+                  type: "element",
+                  tagName: "strong",
+                  properties: {},
+                  children: [
+                    {
+                      type: "text",
+                      value: "Hello, world!",
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+        {
+          type: "element",
+          tagName: "p",
+          properties: {},
+          children: [
+            {
+              type: "text",
+              value: "Hello, world!",
+            },
+            {
+              type: "element",
+              properties: {},
+              tagName: "span",
+              children: [
+                {
+                  type: "text",
+                  value: "Hello, world!",
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+  });
+});
+
+describe("wihtout transformations", () => {
+  describe("contentValue", () => {
+    it("should convert a content value from cast to hast", () => {
+      // Arrange
+      const cast: Root = c("root", [
+        c("contentValue", {
+          prn: "prn:content-value",
+          value: c("root", [c("paragraph", "Hello, world!")]),
+        }),
+      ]);
+
+      // Act
+      const expected = toHast(cast, {});
+
+      // Assert
+      expect(expected).toEqual({
+        type: "root",
+        children: [
+          {
+            type: "element",
+            properties: {},
+            tagName: "span",
+            children: [
+              {
+                type: "element",
+                properties: {},
+                tagName: "p",
+                children: [
+                  {
+                    type: "text",
+                    value: "Hello, world!",
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      });
+    });
+  });
+});