@webiny/lexical-converter 5.38.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# @webiny/lexical-converter
+
+[![](https://img.shields.io/npm/dw/@webiny/lexical-converter.svg)](https://www.npmjs.com/package/@webiny/llexical-lexical-converter)
+[![](https://img.shields.io/npm/v/@webiny/lexical-converter.svg)](https://www.npmjs.com/package/@webiny/lexical-converter)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+## About
+
+This package provides features that will enable you to parse your HTML pages into Lexical editor state object.
+
+Further, this lexical state object can be imported into Webiny's apps like the Page builder and Headless CMS, trough the [Webiny's graphql API](https://www.webiny.com/docs/headless-cms/basics/graphql-api).
+
+> Webiny use the Lexical editor as primary rich text editor across the platform.
+
+Note: This module is built to be used in the `node.js` environment.
+
+## Usage
+
+To parse the HTML to lexical editor state object, you need to import `createHtmlToLexicalParser` factory function,
+to create the parser function (with default or custom configuration) and provide the HTML content as parameter.
+Parser will return Lexical editor state object.
+
+> The parser uses the default configuration with the Webiny's Lexical nodes. DOM elements like headings and
+> paragraph, for example, will be converted to our custom Webiny Lexical nodes.
+
+```tsx
+import { createHtmlToLexicalParser } from "@webiny/lexical-converter";
+
+const htmlString = "<p>My paragraph</p>";
+
+// Create a parser function.
+const myParser = createHtmlToLexicalParser();
+
+// Parse the HTML string to Lexical editor state object.
+const lexicalEditorState = myParser(htmlString);
+```
+
+Here is the result in JSON format. This object structure is a valid Lexical editor state.
+
+```json
+{
+  "root": {
+    "children": [
+      {
+        "children": [
+          {
+            "detail": 0,
+            "format": 0,
+            "mode": "normal",
+            "style": "",
+            "text": "Space",
+            "type": "text",
+            "version": 1
+          }
+        ],
+        "direction": null,
+        "format": "",
+        "indent": 0,
+        "styles": [],
+        "type": "paragraph-element",
+        "version": 1
+      }
+    ],
+    "direction": null,
+    "format": "",
+    "indent": 0,
+    "type": "root",
+    "version": 1
+  }
+}
+```
+
+## Configuration
+
+To configure the parser, you can pass an optional configuration object to the parser factory.
+
+```ts
+import { createHtmlToLexicalParser } from "@webiny/lexical-converter";
+import { myCustomTheme } from "./theme/myCustomTheme";
+import { MyCustomLexicalNode } from "./lexical/nodes/MyCustomLexicalNode";
+
+const addCustomThemeStyleToHeadings = (node: LexicalNode): LexicalNode => {
+  if (node.getType() === "heading-element") {
+    return (node as HeadingNode).setThemeStyles([{ styleId: "my-default-id", type: "typography" }]);
+  }
+  return node;
+};
+
+// Create your parser with custom configuration
+const myParser = createHtmlToLexicalParser({
+  // Lexical editor configuration
+  editorConfig: {
+    // Add custom nodes for parsing
+    nodes: [MyCustomLexicalNode],
+    // Add you custom theme
+    theme: myCustomTheme
+  },
+  nodeMapper: addCustomThemeStyleToHeadings,
+  normalizeTextNodes: false // Default: true
+});
+
+const lexicalEditorState = myParser(htmlString);
+```
+
+To learn more about how to create custom Lexical nodes, please visit [Lexical's documentation web page](https://lexical.dev/docs/intro).

package/createHtmlToLexicalParser.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+/// <reference types="web" />
+/// <reference types="aos" />
+import { ParserConfigurationOptions } from "./types";
+/**
+ * Parse html string to lexical JSON object.
+ */
+export declare const createHtmlToLexicalParser: (config?: ParserConfigurationOptions) => (domDocument: Document) => Record<string, any> | null;

package/createHtmlToLexicalParser.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHtmlToLexicalParser = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _headless = require("@lexical/headless");
+var _html = require("@lexical/html");
+var _lexical = require("lexical");
+var _lexicalNodes = require("@webiny/lexical-nodes");
+/**
+ * By itself, "text" node without a parent node (like "paragraph"), is not a valid node. Lexical will simply ignore these elements.
+ * To fix this issue, we wrap the text node with a paragraph node.
+ *
+ * EXAMPLE:
+ * When we parse DOM, sometimes, 'span' html tag doesn't have parent elements that match the
+ * lexical node elements (there's no Node class that can handle that HTML element), like paragraph or headings.
+ * In this case, Lexical will parse the 'span' tag as a text node, but without a parent element.
+ */
+const textNodeParentNormalizer = node => {
+  if (node.getType() === "text" && node.getParent() === null) {
+    return (0, _lexicalNodes.$createParagraphNode)().append(node);
+  }
+  return node;
+};
+const passthroughMapper = node => node;
+
+/**
+ * Parse html string to lexical JSON object.
+ */
+const createHtmlToLexicalParser = (config = {}) => {
+  return domDocument => {
+    var _config$editorConfig;
+    const normalizeTextNodes = config.normalizeTextNodes ?? true;
+    const textNodeNormalizer = normalizeTextNodes ? textNodeParentNormalizer : passthroughMapper;
+    const customNodeMapper = config.nodeMapper ?? passthroughMapper;
+    const editor = (0, _headless.createHeadlessEditor)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, config.editorConfig), {}, {
+      nodes: [..._lexicalNodes.allNodes, ...(((_config$editorConfig = config.editorConfig) === null || _config$editorConfig === void 0 ? void 0 : _config$editorConfig.nodes) || [])]
+    }));
+    let parsingError;
+    editor.update(() => {
+      // Convert to lexical node objects that can be stored in db.
+      const lexicalNodes = (0, _html.$generateNodesFromDOM)(editor, domDocument).map(textNodeNormalizer).map(customNodeMapper);
+
+      // Select the root
+      (0, _lexical.$getRoot)().select();
+
+      // Insert the nodes at a selection.
+      const selection = (0, _lexical.$getSelection)();
+      if (selection) {
+        try {
+          selection.insertNodes(lexicalNodes);
+        } catch (err) {
+          parsingError = err;
+        }
+      }
+    },
+    /**
+     * Prevents this update from being batched, forcing it to run synchronously.
+     */
+    {
+      discrete: true
+    });
+    if (parsingError) {
+      throw parsingError;
+    }
+    return editor.getEditorState().toJSON();
+  };
+};
+exports.createHtmlToLexicalParser = createHtmlToLexicalParser;
+
+//# sourceMappingURL=createHtmlToLexicalParser.js.map

package/createHtmlToLexicalParser.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_headless","require","_html","_lexical","_lexicalNodes","textNodeParentNormalizer","node","getType","getParent","$createParagraphNode","append","passthroughMapper","createHtmlToLexicalParser","config","domDocument","_config$editorConfig","normalizeTextNodes","textNodeNormalizer","customNodeMapper","nodeMapper","editor","createHeadlessEditor","_objectSpread2","default","editorConfig","nodes","allNodes","parsingError","update","lexicalNodes","$generateNodesFromDOM","map","$getRoot","select","selection","$getSelection","insertNodes","err","discrete","getEditorState","toJSON","exports"],"sources":["createHtmlToLexicalParser.ts"],"sourcesContent":["import { createHeadlessEditor } from \"@lexical/headless\";\nimport { $generateNodesFromDOM } from \"@lexical/html\";\nimport { $getRoot, $getSelection } from \"lexical\";\nimport { allNodes, $createParagraphNode } from \"@webiny/lexical-nodes\";\nimport { NodeMapper, ParserConfigurationOptions } from \"~/types\";\n\n/**\n * By itself, \"text\" node without a parent node (like \"paragraph\"), is not a valid node. Lexical will simply ignore these elements.\n * To fix this issue, we wrap the text node with a paragraph node.\n *\n * EXAMPLE:\n * When we parse DOM, sometimes, 'span' html tag doesn't have parent elements that match the\n * lexical node elements (there's no Node class that can handle that HTML element), like paragraph or headings.\n * In this case, Lexical will parse the 'span' tag as a text node, but without a parent element.\n */\nconst textNodeParentNormalizer: NodeMapper = node => {\n    if (node.getType() === \"text\" && node.getParent() === null) {\n        return $createParagraphNode().append(node);\n    }\n    return node;\n};\n\nconst passthroughMapper: NodeMapper = node => node;\n\n/**\n * Parse html string to lexical JSON object.\n */\nexport const createHtmlToLexicalParser = (config: ParserConfigurationOptions = {}) => {\n    return (domDocument: Document): Record<string, any> | null => {\n        const normalizeTextNodes = config.normalizeTextNodes ?? true;\n        const textNodeNormalizer = normalizeTextNodes\n            ? textNodeParentNormalizer\n            : passthroughMapper;\n\n        const customNodeMapper: NodeMapper = config.nodeMapper ?? passthroughMapper;\n\n        const editor = createHeadlessEditor({\n            ...config.editorConfig,\n            nodes: [...allNodes, ...(config.editorConfig?.nodes || [])]\n        });\n\n        let parsingError;\n\n        editor.update(\n            () => {\n                // Convert to lexical node objects that can be stored in db.\n                const lexicalNodes = $generateNodesFromDOM(editor, domDocument)\n                    .map(textNodeNormalizer)\n                    .map(customNodeMapper);\n\n                // Select the root\n                $getRoot().select();\n\n                // Insert the nodes at a selection.\n                const selection = $getSelection();\n                if (selection) {\n                    try {\n                        selection.insertNodes(lexicalNodes);\n                    } catch (err) {\n                        parsingError = err;\n                    }\n                }\n            },\n            /**\n             * Prevents this update from being batched, forcing it to run synchronously.\n             */\n            { discrete: true }\n        );\n\n        if (parsingError) {\n            throw parsingError;\n        }\n\n        return editor.getEditorState().toJSON();\n    };\n};\n"],"mappings":";;;;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AACA,IAAAC,KAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AACA,IAAAG,aAAA,GAAAH,OAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMI,wBAAoC,GAAGC,IAAI,IAAI;EACjD,IAAIA,IAAI,CAACC,OAAO,CAAC,CAAC,KAAK,MAAM,IAAID,IAAI,CAACE,SAAS,CAAC,CAAC,KAAK,IAAI,EAAE;IACxD,OAAO,IAAAC,kCAAoB,EAAC,CAAC,CAACC,MAAM,CAACJ,IAAI,CAAC;EAC9C;EACA,OAAOA,IAAI;AACf,CAAC;AAED,MAAMK,iBAA6B,GAAGL,IAAI,IAAIA,IAAI;;AAElD;AACA;AACA;AACO,MAAMM,yBAAyB,GAAGA,CAACC,MAAkC,GAAG,CAAC,CAAC,KAAK;EAClF,OAAQC,WAAqB,IAAiC;IAAA,IAAAC,oBAAA;IAC1D,MAAMC,kBAAkB,GAAGH,MAAM,CAACG,kBAAkB,IAAI,IAAI;IAC5D,MAAMC,kBAAkB,GAAGD,kBAAkB,GACvCX,wBAAwB,GACxBM,iBAAiB;IAEvB,MAAMO,gBAA4B,GAAGL,MAAM,CAACM,UAAU,IAAIR,iBAAiB;IAE3E,MAAMS,MAAM,GAAG,IAAAC,8BAAoB,MAAAC,cAAA,CAAAC,OAAA,MAAAD,cAAA,CAAAC,OAAA,MAC5BV,MAAM,CAACW,YAAY;MACtBC,KAAK,EAAE,CAAC,GAAGC,sBAAQ,EAAE,IAAI,EAAAX,oBAAA,GAAAF,MAAM,CAACW,YAAY,cAAAT,oBAAA,uBAAnBA,oBAAA,CAAqBU,KAAK,KAAI,EAAE,CAAC;IAAC,EAC9D,CAAC;IAEF,IAAIE,YAAY;IAEhBP,MAAM,CAACQ,MAAM,CACT,MAAM;MACF;MACA,MAAMC,YAAY,GAAG,IAAAC,2BAAqB,EAACV,MAAM,EAAEN,WAAW,CAAC,CAC1DiB,GAAG,CAACd,kBAAkB,CAAC,CACvBc,GAAG,CAACb,gBAAgB,CAAC;;MAE1B;MACA,IAAAc,iBAAQ,EAAC,CAAC,CAACC,MAAM,CAAC,CAAC;;MAEnB;MACA,MAAMC,SAAS,GAAG,IAAAC,sBAAa,EAAC,CAAC;MACjC,IAAID,SAAS,EAAE;QACX,IAAI;UACAA,SAAS,CAACE,WAAW,CAACP,YAAY,CAAC;QACvC,CAAC,CAAC,OAAOQ,GAAG,EAAE;UACVV,YAAY,GAAGU,GAAG;QACtB;MACJ;IACJ,CAAC;IACD;AACZ;AACA;IACY;MAAEC,QAAQ,EAAE;IAAK,CACrB,CAAC;IAED,IAAIX,YAAY,EAAE;MACd,MAAMA,YAAY;IACtB;IAEA,OAAOP,MAAM,CAACmB,cAAc,CAAC,CAAC,CAACC,MAAM,CAAC,CAAC;EAC3C,CAAC;AACL,CAAC;AAACC,OAAA,CAAA7B,yBAAA,GAAAA,yBAAA"}

package/createLexicalStateTransformer.d.ts

@@ -0,0 +1,17 @@
+import { CreateEditorArgs, SerializedEditorState, LexicalNode } from "lexical";
+interface LexicalStateTransformerConfig {
+    editorConfig?: Pick<CreateEditorArgs, "nodes" | "theme">;
+}
+export declare type FlatStateWithHTML = Array<{
+    node: LexicalNode;
+    html: string;
+}>;
+declare class LexicalStateTransformer {
+    private readonly editor;
+    constructor(config?: LexicalStateTransformerConfig);
+    flatten(state: string | SerializedEditorState): FlatStateWithHTML;
+    toHtml(state: string | SerializedEditorState): string;
+    private getNodeDescendants;
+}
+export declare const createLexicalStateTransformer: (config?: LexicalStateTransformerConfig) => LexicalStateTransformer;
+export {};

package/createLexicalStateTransformer.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLexicalStateTransformer = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _lexical = require("lexical");
+var _html = require("@lexical/html");
+var _headless = require("@lexical/headless");
+var _lexicalNodes = require("@webiny/lexical-nodes");
+class LexicalStateTransformer {
+  constructor(config = {}) {
+    var _config$editorConfig;
+    (0, _defineProperty2.default)(this, "editor", void 0);
+    this.editor = (0, _headless.createHeadlessEditor)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, config.editorConfig), {}, {
+      nodes: [..._lexicalNodes.allNodes, ...(((_config$editorConfig = config.editorConfig) === null || _config$editorConfig === void 0 ? void 0 : _config$editorConfig.nodes) || [])]
+    }));
+  }
+  flatten(state) {
+    const editorState = this.editor.parseEditorState(state);
+    this.editor.setEditorState(editorState);
+    let flattenedNodes = [];
+    this.editor.update(() => {
+      const children = (0, _lexical.$getRoot)().getChildren();
+      flattenedNodes = children.map(childNode => {
+        const selection = (0, _lexical.$createNodeSelection)();
+        selection.add(childNode.getKey());
+        this.getNodeDescendants(childNode).forEach(node => {
+          selection.add(node.getKey());
+        });
+        const html = (0, _html.$generateHtmlFromNodes)(this.editor, selection);
+        return {
+          node: childNode,
+          html
+        };
+      });
+    });
+    return flattenedNodes;
+  }
+  toHtml(state) {
+    const editorState = this.editor.parseEditorState(state);
+    this.editor.setEditorState(editorState);
+    let html = "";
+    this.editor.update(() => {
+      html = (0, _html.$generateHtmlFromNodes)(this.editor);
+    });
+    return html;
+  }
+  getNodeDescendants(node) {
+    if (!(0, _lexical.$isElementNode)(node)) {
+      return [];
+    }
+    const children = node.getChildren();
+    return [...children, ...children.map(child => this.getNodeDescendants(child)).flat()];
+  }
+}
+const createLexicalStateTransformer = config => {
+  return new LexicalStateTransformer(config);
+};
+exports.createLexicalStateTransformer = createLexicalStateTransformer;
+
+//# sourceMappingURL=createLexicalStateTransformer.js.map

package/createLexicalStateTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_lexical","require","_html","_headless","_lexicalNodes","LexicalStateTransformer","constructor","config","_config$editorConfig","_defineProperty2","default","editor","createHeadlessEditor","_objectSpread2","editorConfig","nodes","allNodes","flatten","state","editorState","parseEditorState","setEditorState","flattenedNodes","update","children","$getRoot","getChildren","map","childNode","selection","$createNodeSelection","add","getKey","getNodeDescendants","forEach","node","html","$generateHtmlFromNodes","toHtml","$isElementNode","child","flat","createLexicalStateTransformer","exports"],"sources":["createLexicalStateTransformer.ts"],"sourcesContent":["import {\n    CreateEditorArgs,\n    LexicalEditor,\n    SerializedEditorState,\n    $getRoot,\n    $createNodeSelection,\n    $isElementNode,\n    LexicalNode\n} from \"lexical\";\nimport { $generateHtmlFromNodes } from \"@lexical/html\";\nimport { createHeadlessEditor } from \"@lexical/headless\";\nimport { allNodes } from \"@webiny/lexical-nodes\";\n\ninterface LexicalStateTransformerConfig {\n    editorConfig?: Pick<CreateEditorArgs, \"nodes\" | \"theme\">;\n}\n\nexport type FlatStateWithHTML = Array<{ node: LexicalNode; html: string }>;\n\nclass LexicalStateTransformer {\n    private readonly editor: LexicalEditor;\n\n    constructor(config: LexicalStateTransformerConfig = {}) {\n        this.editor = createHeadlessEditor({\n            ...config.editorConfig,\n            nodes: [...allNodes, ...(config.editorConfig?.nodes || [])]\n        });\n    }\n\n    public flatten(state: string | SerializedEditorState) {\n        const editorState = this.editor.parseEditorState(state);\n        this.editor.setEditorState(editorState);\n\n        let flattenedNodes: FlatStateWithHTML = [];\n\n        this.editor.update(() => {\n            const children = $getRoot().getChildren();\n\n            flattenedNodes = children.map(childNode => {\n                const selection = $createNodeSelection();\n                selection.add(childNode.getKey());\n\n                this.getNodeDescendants(childNode).forEach(node => {\n                    selection.add(node.getKey());\n                });\n\n                const html = $generateHtmlFromNodes(this.editor, selection);\n\n                return {\n                    node: childNode,\n                    html\n                };\n            });\n        });\n\n        return flattenedNodes;\n    }\n\n    public toHtml(state: string | SerializedEditorState) {\n        const editorState = this.editor.parseEditorState(state);\n        this.editor.setEditorState(editorState);\n\n        let html = \"\";\n\n        this.editor.update(() => {\n            html = $generateHtmlFromNodes(this.editor);\n        });\n\n        return html;\n    }\n\n    private getNodeDescendants(node: LexicalNode): LexicalNode[] {\n        if (!$isElementNode(node)) {\n            return [];\n        }\n        const children = node.getChildren();\n        return [...children, ...children.map(child => this.getNodeDescendants(child)).flat()];\n    }\n}\n\nexport const createLexicalStateTransformer = (config?: LexicalStateTransformerConfig) => {\n    return new LexicalStateTransformer(config);\n};\n"],"mappings":";;;;;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AASA,IAAAC,KAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AACA,IAAAG,aAAA,GAAAH,OAAA;AAQA,MAAMI,uBAAuB,CAAC;EAG1BC,WAAWA,CAACC,MAAqC,GAAG,CAAC,CAAC,EAAE;IAAA,IAAAC,oBAAA;IAAA,IAAAC,gBAAA,CAAAC,OAAA;IACpD,IAAI,CAACC,MAAM,GAAG,IAAAC,8BAAoB,MAAAC,cAAA,CAAAH,OAAA,MAAAG,cAAA,CAAAH,OAAA,MAC3BH,MAAM,CAACO,YAAY;MACtBC,KAAK,EAAE,CAAC,GAAGC,sBAAQ,EAAE,IAAI,EAAAR,oBAAA,GAAAD,MAAM,CAACO,YAAY,cAAAN,oBAAA,uBAAnBA,oBAAA,CAAqBO,KAAK,KAAI,EAAE,CAAC;IAAC,EAC9D,CAAC;EACN;EAEOE,OAAOA,CAACC,KAAqC,EAAE;IAClD,MAAMC,WAAW,GAAG,IAAI,CAACR,MAAM,CAACS,gBAAgB,CAACF,KAAK,CAAC;IACvD,IAAI,CAACP,MAAM,CAACU,cAAc,CAACF,WAAW,CAAC;IAEvC,IAAIG,cAAiC,GAAG,EAAE;IAE1C,IAAI,CAACX,MAAM,CAACY,MAAM,CAAC,MAAM;MACrB,MAAMC,QAAQ,GAAG,IAAAC,iBAAQ,EAAC,CAAC,CAACC,WAAW,CAAC,CAAC;MAEzCJ,cAAc,GAAGE,QAAQ,CAACG,GAAG,CAACC,SAAS,IAAI;QACvC,MAAMC,SAAS,GAAG,IAAAC,6BAAoB,EAAC,CAAC;QACxCD,SAAS,CAACE,GAAG,CAACH,SAAS,CAACI,MAAM,CAAC,CAAC,CAAC;QAEjC,IAAI,CAACC,kBAAkB,CAACL,SAAS,CAAC,CAACM,OAAO,CAACC,IAAI,IAAI;UAC/CN,SAAS,CAACE,GAAG,CAACI,IAAI,CAACH,MAAM,CAAC,CAAC,CAAC;QAChC,CAAC,CAAC;QAEF,MAAMI,IAAI,GAAG,IAAAC,4BAAsB,EAAC,IAAI,CAAC1B,MAAM,EAAEkB,SAAS,CAAC;QAE3D,OAAO;UACHM,IAAI,EAAEP,SAAS;UACfQ;QACJ,CAAC;MACL,CAAC,CAAC;IACN,CAAC,CAAC;IAEF,OAAOd,cAAc;EACzB;EAEOgB,MAAMA,CAACpB,KAAqC,EAAE;IACjD,MAAMC,WAAW,GAAG,IAAI,CAACR,MAAM,CAACS,gBAAgB,CAACF,KAAK,CAAC;IACvD,IAAI,CAACP,MAAM,CAACU,cAAc,CAACF,WAAW,CAAC;IAEvC,IAAIiB,IAAI,GAAG,EAAE;IAEb,IAAI,CAACzB,MAAM,CAACY,MAAM,CAAC,MAAM;MACrBa,IAAI,GAAG,IAAAC,4BAAsB,EAAC,IAAI,CAAC1B,MAAM,CAAC;IAC9C,CAAC,CAAC;IAEF,OAAOyB,IAAI;EACf;EAEQH,kBAAkBA,CAACE,IAAiB,EAAiB;IACzD,IAAI,CAAC,IAAAI,uBAAc,EAACJ,IAAI,CAAC,EAAE;MACvB,OAAO,EAAE;IACb;IACA,MAAMX,QAAQ,GAAGW,IAAI,CAACT,WAAW,CAAC,CAAC;IACnC,OAAO,CAAC,GAAGF,QAAQ,EAAE,GAAGA,QAAQ,CAACG,GAAG,CAACa,KAAK,IAAI,IAAI,CAACP,kBAAkB,CAACO,KAAK,CAAC,CAAC,CAACC,IAAI,CAAC,CAAC,CAAC;EACzF;AACJ;AAEO,MAAMC,6BAA6B,GAAInC,MAAsC,IAAK;EACrF,OAAO,IAAIF,uBAAuB,CAACE,MAAM,CAAC;AAC9C,CAAC;AAACoC,OAAA,CAAAD,6BAAA,GAAAA,6BAAA"}

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./createHtmlToLexicalParser";
+export * from "./createLexicalStateTransformer";

package/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _createHtmlToLexicalParser = require("./createHtmlToLexicalParser");
+Object.keys(_createHtmlToLexicalParser).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createHtmlToLexicalParser[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createHtmlToLexicalParser[key];
+    }
+  });
+});
+var _createLexicalStateTransformer = require("./createLexicalStateTransformer");
+Object.keys(_createLexicalStateTransformer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createLexicalStateTransformer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createLexicalStateTransformer[key];
+    }
+  });
+});
+
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_createHtmlToLexicalParser","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_createLexicalStateTransformer"],"sources":["index.ts"],"sourcesContent":["export * from \"./createHtmlToLexicalParser\";\nexport * from \"./createLexicalStateTransformer\";\n"],"mappings":";;;;;AAAA,IAAAA,0BAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,0BAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,0BAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,0BAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,8BAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,8BAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,8BAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,8BAAA,CAAAL,GAAA;IAAA;EAAA;AAAA"}

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@webiny/lexical-converter",
+	"version": "5.38.0-beta.0",
+	"dependencies": {
+		"@lexical/headless": "0.12.2",
+		"@lexical/html": "0.12.2",
+		"@webiny/lexical-nodes": "5.38.0-beta.0",
+		"lexical": "0.12.2"
+	},
+	"devDependencies": {
+		"@types/jsdom": "21.1.3",
+		"@webiny/cli": "5.38.0-beta.0",
+		"@webiny/project-utils": "5.38.0-beta.0",
+		"jsdom": "21.1.2"
+	},
+	"publishConfig": {
+		"access": "public",
+		"directory": "dist"
+	},
+	"scripts": {
+		"build": "yarn webiny run build",
+		"watch": "yarn webiny run watch"
+	},
+	"test": "jest --verbose --runInBand --detectOpenHandles --forceExit",
+	"gitHead": "5746389d4988626b50e2523ccfa0a9a5e398e0ed"
+}

package/types.d.ts

@@ -0,0 +1,7 @@
+import { CreateEditorArgs, LexicalNode } from "lexical";
+export declare type NodeMapper = (node: LexicalNode) => LexicalNode;
+export interface ParserConfigurationOptions {
+    editorConfig?: Pick<CreateEditorArgs, "nodes" | "theme">;
+    nodeMapper?: NodeMapper;
+    normalizeTextNodes?: boolean;
+}

package/types.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=types.js.map

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import { CreateEditorArgs, LexicalNode } from \"lexical\";\n\nexport type NodeMapper = (node: LexicalNode) => LexicalNode;\n\nexport interface ParserConfigurationOptions {\n    editorConfig?: Pick<CreateEditorArgs, \"nodes\" | \"theme\">;\n    nodeMapper?: NodeMapper;\n    normalizeTextNodes?: boolean;\n}\n"],"mappings":""}