@webiny/lexical-editor 0.0.0-unstable.1145e7667f

package/plugins/FloatingLinkEditorPlugin/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _FloatingLinkEditorPlugin = require("./FloatingLinkEditorPlugin");
+Object.keys(_FloatingLinkEditorPlugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _FloatingLinkEditorPlugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _FloatingLinkEditorPlugin[key];
+    }
+  });
+});

package/plugins/FloatingLinkEditorPlugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./FloatingLinkEditorPlugin\";\n"],"mappings":";;;;;AAAA;AAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA"}

package/plugins/FontColorPlugin/FontColorPlugin.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const FontColorPlugin: React.FC;

package/plugins/FontColorPlugin/FontColorPlugin.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FontColorPlugin = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+var _FontColorNode = require("../../nodes/FontColorNode");
+var _lexical = require("lexical");
+var _utils = require("@lexical/utils");
+var FontColorPlugin = function FontColorPlugin() {
+  var _useLexicalComposerCo = (0, _LexicalComposerContext.useLexicalComposerContext)(),
+    _useLexicalComposerCo2 = (0, _slicedToArray2.default)(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  (0, _react.useEffect)(function () {
+    return editor.registerCommand(_FontColorNode.ADD_FONT_COLOR_COMMAND, function (payload) {
+      editor.update(function () {
+        var color = payload.color,
+          themeColorName = payload.themeColorName;
+        var selection = (0, _lexical.$getSelection)();
+        if ((0, _lexical.$isRangeSelection)(selection)) {
+          var fontColorNode = (0, _FontColorNode.$createFontColorNode)(selection.getTextContent(), color, themeColorName);
+          (0, _FontColorNode.$applyStylesToNode)(fontColorNode, selection);
+          (0, _lexical.$insertNodes)([fontColorNode]);
+          if ((0, _lexical.$isRootOrShadowRoot)(fontColorNode.getParentOrThrow())) {
+            (0, _utils.$wrapNodeInElement)(fontColorNode, _lexical.$createParagraphNode).selectEnd();
+          }
+        }
+      });
+      return true;
+    }, _lexical.COMMAND_PRIORITY_EDITOR);
+  }, [editor]);
+  return null;
+};
+exports.FontColorPlugin = FontColorPlugin;

package/plugins/FontColorPlugin/FontColorPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FontColorPlugin","useLexicalComposerContext","editor","useEffect","registerCommand","ADD_FONT_COLOR_COMMAND","payload","update","color","themeColorName","selection","$getSelection","$isRangeSelection","fontColorNode","$createFontColorNode","getTextContent","$applyStylesToNode","$insertNodes","$isRootOrShadowRoot","getParentOrThrow","$wrapNodeInElement","$createParagraphNode","selectEnd","COMMAND_PRIORITY_EDITOR"],"sources":["FontColorPlugin.tsx"],"sourcesContent":["import React, { useEffect } from \"react\";\nimport { useLexicalComposerContext } from \"@lexical/react/LexicalComposerContext\";\nimport {\n    $applyStylesToNode,\n    $createFontColorNode,\n    ADD_FONT_COLOR_COMMAND,\n    FontColorPayload\n} from \"~/nodes/FontColorNode\";\nimport {\n    $createParagraphNode,\n    $getSelection,\n    $insertNodes,\n    $isRangeSelection,\n    $isRootOrShadowRoot,\n    COMMAND_PRIORITY_EDITOR\n} from \"lexical\";\nimport { $wrapNodeInElement } from \"@lexical/utils\";\n\nexport const FontColorPlugin: React.FC = () => {\n    const [editor] = useLexicalComposerContext();\n\n    useEffect(() => {\n        return editor.registerCommand<FontColorPayload>(\n            ADD_FONT_COLOR_COMMAND,\n            payload => {\n                editor.update(() => {\n                    const { color, themeColorName } = payload;\n                    const selection = $getSelection();\n\n                    if ($isRangeSelection(selection)) {\n                        const fontColorNode = $createFontColorNode(\n                            selection.getTextContent(),\n                            color,\n                            themeColorName\n                        );\n                        $applyStylesToNode(fontColorNode, selection);\n                        $insertNodes([fontColorNode]);\n                        if ($isRootOrShadowRoot(fontColorNode.getParentOrThrow())) {\n                            $wrapNodeInElement(fontColorNode, $createParagraphNode).selectEnd();\n                        }\n                    }\n                });\n                return true;\n            },\n            COMMAND_PRIORITY_EDITOR\n        );\n    }, [editor]);\n\n    return null;\n};\n"],"mappings":";;;;;;;;AAAA;AACA;AACA;AAMA;AAQA;AAEO,IAAMA,eAAyB,GAAG,SAA5BA,eAAyB,GAAS;EAC3C,4BAAiB,IAAAC,iDAAyB,GAAE;IAAA;IAArCC,MAAM;EAEb,IAAAC,gBAAS,EAAC,YAAM;IACZ,OAAOD,MAAM,CAACE,eAAe,CACzBC,qCAAsB,EACtB,UAAAC,OAAO,EAAI;MACPJ,MAAM,CAACK,MAAM,CAAC,YAAM;QAChB,IAAQC,KAAK,GAAqBF,OAAO,CAAjCE,KAAK;UAAEC,cAAc,GAAKH,OAAO,CAA1BG,cAAc;QAC7B,IAAMC,SAAS,GAAG,IAAAC,sBAAa,GAAE;QAEjC,IAAI,IAAAC,0BAAiB,EAACF,SAAS,CAAC,EAAE;UAC9B,IAAMG,aAAa,GAAG,IAAAC,mCAAoB,EACtCJ,SAAS,CAACK,cAAc,EAAE,EAC1BP,KAAK,EACLC,cAAc,CACjB;UACD,IAAAO,iCAAkB,EAACH,aAAa,EAAEH,SAAS,CAAC;UAC5C,IAAAO,qBAAY,EAAC,CAACJ,aAAa,CAAC,CAAC;UAC7B,IAAI,IAAAK,4BAAmB,EAACL,aAAa,CAACM,gBAAgB,EAAE,CAAC,EAAE;YACvD,IAAAC,yBAAkB,EAACP,aAAa,EAAEQ,6BAAoB,CAAC,CAACC,SAAS,EAAE;UACvE;QACJ;MACJ,CAAC,CAAC;MACF,OAAO,IAAI;IACf,CAAC,EACDC,gCAAuB,CAC1B;EACL,CAAC,EAAE,CAACrB,MAAM,CAAC,CAAC;EAEZ,OAAO,IAAI;AACf,CAAC;AAAC"}

package/plugins/LexicalUpdateStatePlugin/LexicalUpdateStatePlugin.d.ts

@@ -0,0 +1,8 @@
+import { FC } from "react";
+import { LexicalValue } from "../../types";
+interface LexicalUpdateStatePlugin {
+    value: LexicalValue | null;
+    readOnly?: boolean;
+}
+export declare const LexicalUpdateStatePlugin: FC<LexicalUpdateStatePlugin>;
+export {};

package/plugins/LexicalUpdateStatePlugin/LexicalUpdateStatePlugin.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LexicalUpdateStatePlugin = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+var _react = _interopRequireWildcard(require("react"));
+var _isValidLexicalData = require("../../utils/isValidLexicalData");
+var _generateInitialLexicalValue = require("../../utils/generateInitialLexicalValue");
+/*
+ * Updates the lexical state if new value is provided to the lexical editor trough props
+ */
+var LexicalUpdateStatePlugin = function LexicalUpdateStatePlugin(_ref) {
+  var value = _ref.value;
+  var _useLexicalComposerCo = (0, _LexicalComposerContext.useLexicalComposerContext)(),
+    _useLexicalComposerCo2 = (0, _slicedToArray2.default)(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  (0, _react.useEffect)(function () {
+    if (value && editor) {
+      var editorState = editor.getEditorState();
+      if (JSON.stringify(editorState.toJSON()) === value) {
+        return;
+      }
+      var initialEditorState = editor.parseEditorState((0, _isValidLexicalData.isValidLexicalData)(value) ? value : (0, _generateInitialLexicalValue.generateInitialLexicalValue)());
+      editor.setEditorState(initialEditorState);
+    }
+  }, [value, editor]);
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null);
+};
+exports.LexicalUpdateStatePlugin = LexicalUpdateStatePlugin;

package/plugins/LexicalUpdateStatePlugin/LexicalUpdateStatePlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LexicalUpdateStatePlugin","value","useLexicalComposerContext","editor","useEffect","editorState","getEditorState","JSON","stringify","toJSON","initialEditorState","parseEditorState","isValidLexicalData","generateInitialLexicalValue","setEditorState"],"sources":["LexicalUpdateStatePlugin.tsx"],"sourcesContent":["import { useLexicalComposerContext } from \"@lexical/react/LexicalComposerContext\";\nimport React, { FC, useEffect } from \"react\";\nimport { isValidLexicalData } from \"~/utils/isValidLexicalData\";\nimport { generateInitialLexicalValue } from \"~/utils/generateInitialLexicalValue\";\nimport { LexicalValue } from \"~/types\";\n\ninterface LexicalUpdateStatePlugin {\n    value: LexicalValue | null;\n    readOnly?: boolean;\n}\n\n/*\n * Updates the lexical state if new value is provided to the lexical editor trough props\n */\nexport const LexicalUpdateStatePlugin: FC<LexicalUpdateStatePlugin> = ({\n    value\n}): React.ReactElement => {\n    const [editor] = useLexicalComposerContext();\n    useEffect(() => {\n        if (value && editor) {\n            const editorState = editor.getEditorState();\n            if (JSON.stringify(editorState.toJSON()) === value) {\n                return;\n            }\n\n            const initialEditorState = editor.parseEditorState(\n                isValidLexicalData(value)\n                    ? (value as string)\n                    : (generateInitialLexicalValue() as string)\n            );\n            editor.setEditorState(initialEditorState);\n        }\n    }, [value, editor]);\n\n    return <></>;\n};\n"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AAQA;AACA;AACA;AACO,IAAMA,wBAAsD,GAAG,SAAzDA,wBAAsD,OAEzC;EAAA,IADtBC,KAAK,QAALA,KAAK;EAEL,4BAAiB,IAAAC,iDAAyB,GAAE;IAAA;IAArCC,MAAM;EACb,IAAAC,gBAAS,EAAC,YAAM;IACZ,IAAIH,KAAK,IAAIE,MAAM,EAAE;MACjB,IAAME,WAAW,GAAGF,MAAM,CAACG,cAAc,EAAE;MAC3C,IAAIC,IAAI,CAACC,SAAS,CAACH,WAAW,CAACI,MAAM,EAAE,CAAC,KAAKR,KAAK,EAAE;QAChD;MACJ;MAEA,IAAMS,kBAAkB,GAAGP,MAAM,CAACQ,gBAAgB,CAC9C,IAAAC,sCAAkB,EAACX,KAAK,CAAC,GAClBA,KAAK,GACL,IAAAY,wDAA2B,GAAa,CAClD;MACDV,MAAM,CAACW,cAAc,CAACJ,kBAAkB,CAAC;IAC7C;EACJ,CAAC,EAAE,CAACT,KAAK,EAAEE,MAAM,CAAC,CAAC;EAEnB,oBAAO,2DAAK;AAChB,CAAC;AAAC"}

package/plugins/LexicalUpdateStatePlugin/index.d.ts

@@ -0,0 +1 @@
+export * from "./LexicalUpdateStatePlugin";

package/plugins/LexicalUpdateStatePlugin/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _LexicalUpdateStatePlugin = require("./LexicalUpdateStatePlugin");
+Object.keys(_LexicalUpdateStatePlugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _LexicalUpdateStatePlugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _LexicalUpdateStatePlugin[key];
+    }
+  });
+});

package/plugins/LexicalUpdateStatePlugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./LexicalUpdateStatePlugin\";\n"],"mappings":";;;;;AAAA;AAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA"}

package/plugins/TypographyPlugin/TypographyPlugin.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const TypographyPlugin: React.FC;

package/plugins/TypographyPlugin/TypographyPlugin.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypographyPlugin = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+var _lexical = require("lexical");
+var _TypographyElementNode = require("../../nodes/TypographyElementNode");
+var _selection = require("@lexical/selection");
+var TypographyPlugin = function TypographyPlugin() {
+  var _useLexicalComposerCo = (0, _LexicalComposerContext.useLexicalComposerContext)(),
+    _useLexicalComposerCo2 = (0, _slicedToArray2.default)(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  (0, _react.useEffect)(function () {
+    return editor.registerCommand(_TypographyElementNode.ADD_TYPOGRAPHY_ELEMENT_COMMAND, function (payload) {
+      var selection = (0, _lexical.$getSelection)();
+      if ((0, _lexical.$isRangeSelection)(selection)) {
+        (0, _selection.$wrapNodes)(selection, function () {
+          return (0, _TypographyElementNode.$createTypographyNode)(payload.value);
+        });
+      }
+      return true;
+    }, _lexical.COMMAND_PRIORITY_EDITOR);
+  }, [editor]);
+  return null;
+};
+exports.TypographyPlugin = TypographyPlugin;

package/plugins/TypographyPlugin/TypographyPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TypographyPlugin","useLexicalComposerContext","editor","useEffect","registerCommand","ADD_TYPOGRAPHY_ELEMENT_COMMAND","payload","selection","$getSelection","$isRangeSelection","$wrapNodes","$createTypographyNode","value","COMMAND_PRIORITY_EDITOR"],"sources":["TypographyPlugin.tsx"],"sourcesContent":["import React, { useEffect } from \"react\";\nimport { useLexicalComposerContext } from \"@lexical/react/LexicalComposerContext\";\nimport { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from \"lexical\";\nimport {\n    $createTypographyNode,\n    ADD_TYPOGRAPHY_ELEMENT_COMMAND,\n    TypographyPayload\n} from \"~/nodes/TypographyElementNode\";\nimport { $wrapNodes } from \"@lexical/selection\";\n\nexport const TypographyPlugin: React.FC = () => {\n    const [editor] = useLexicalComposerContext();\n\n    useEffect(() => {\n        return editor.registerCommand<TypographyPayload>(\n            ADD_TYPOGRAPHY_ELEMENT_COMMAND,\n            payload => {\n                const selection = $getSelection();\n                if ($isRangeSelection(selection)) {\n                    $wrapNodes(selection, () => $createTypographyNode(payload.value));\n                }\n                return true;\n            },\n            COMMAND_PRIORITY_EDITOR\n        );\n    }, [editor]);\n\n    return null;\n};\n"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AAKA;AAEO,IAAMA,gBAA0B,GAAG,SAA7BA,gBAA0B,GAAS;EAC5C,4BAAiB,IAAAC,iDAAyB,GAAE;IAAA;IAArCC,MAAM;EAEb,IAAAC,gBAAS,EAAC,YAAM;IACZ,OAAOD,MAAM,CAACE,eAAe,CACzBC,qDAA8B,EAC9B,UAAAC,OAAO,EAAI;MACP,IAAMC,SAAS,GAAG,IAAAC,sBAAa,GAAE;MACjC,IAAI,IAAAC,0BAAiB,EAACF,SAAS,CAAC,EAAE;QAC9B,IAAAG,qBAAU,EAACH,SAAS,EAAE;UAAA,OAAM,IAAAI,4CAAqB,EAACL,OAAO,CAACM,KAAK,CAAC;QAAA,EAAC;MACrE;MACA,OAAO,IAAI;IACf,CAAC,EACDC,gCAAuB,CAC1B;EACL,CAAC,EAAE,CAACX,MAAM,CAAC,CAAC;EAEZ,OAAO,IAAI;AACf,CAAC;AAAC"}

package/plugins/WebinyListPLugin/WebinyListPlugin.d.ts

@@ -0,0 +1 @@
+export declare function WebinyListPlugin(): null;

package/plugins/WebinyListPLugin/WebinyListPlugin.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WebinyListPlugin = WebinyListPlugin;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+var _react = require("react");
+var _WebinyListNode = require("../../nodes/list-node/WebinyListNode");
+var _WebinyListItemNode = require("../../nodes/list-node/WebinyListItemNode");
+var _useWebinyList = require("../../hooks/useWebinyList");
+function WebinyListPlugin() {
+  var _useLexicalComposerCo = (0, _LexicalComposerContext.useLexicalComposerContext)(),
+    _useLexicalComposerCo2 = (0, _slicedToArray2.default)(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  (0, _react.useEffect)(function () {
+    if (!editor.hasNodes([_WebinyListNode.WebinyListNode, _WebinyListItemNode.WebinyListItemNode])) {
+      throw new Error("WebinyListPlugin: WebinyListNode and/or WebinyListItemNode not registered on editor");
+    }
+  }, [editor]);
+  (0, _useWebinyList.useWebinyList)(editor);
+  return null;
+}

package/plugins/WebinyListPLugin/WebinyListPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyListPlugin","useLexicalComposerContext","editor","useEffect","hasNodes","WebinyListNode","WebinyListItemNode","Error","useWebinyList"],"sources":["WebinyListPlugin.ts"],"sourcesContent":["import { useLexicalComposerContext } from \"@lexical/react/LexicalComposerContext\";\nimport { useEffect } from \"react\";\nimport { WebinyListNode } from \"~/nodes/list-node/WebinyListNode\";\nimport { WebinyListItemNode } from \"~/nodes/list-node/WebinyListItemNode\";\nimport { useWebinyList } from \"~/hooks/useWebinyList\";\n\nexport function WebinyListPlugin(): null {\n    const [editor] = useLexicalComposerContext();\n\n    useEffect(() => {\n        if (!editor.hasNodes([WebinyListNode, WebinyListItemNode])) {\n            throw new Error(\n                \"WebinyListPlugin: WebinyListNode and/or WebinyListItemNode not registered on editor\"\n            );\n        }\n    }, [editor]);\n\n    useWebinyList(editor);\n\n    return null;\n}\n"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA;AAEO,SAASA,gBAAgB,GAAS;EACrC,4BAAiB,IAAAC,iDAAyB,GAAE;IAAA;IAArCC,MAAM;EAEb,IAAAC,gBAAS,EAAC,YAAM;IACZ,IAAI,CAACD,MAAM,CAACE,QAAQ,CAAC,CAACC,8BAAc,EAAEC,sCAAkB,CAAC,CAAC,EAAE;MACxD,MAAM,IAAIC,KAAK,CACX,qFAAqF,CACxF;IACL;EACJ,CAAC,EAAE,CAACL,MAAM,CAAC,CAAC;EAEZ,IAAAM,4BAAa,EAACN,MAAM,CAAC;EAErB,OAAO,IAAI;AACf"}

package/plugins/WebinyQuoteNodePlugin/WebinyQuoteNodePlugin.d.ts

@@ -0,0 +1 @@
+export declare function WebinyQuotePlugin(): null;

package/plugins/WebinyQuoteNodePlugin/WebinyQuoteNodePlugin.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WebinyQuotePlugin = WebinyQuotePlugin;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+var _react = require("react");
+var _WebinyQuoteNode = require("../../nodes/WebinyQuoteNode");
+var _useWebinyQuote = require("../../hooks/useWebinyQuote");
+function WebinyQuotePlugin() {
+  var _useLexicalComposerCo = (0, _LexicalComposerContext.useLexicalComposerContext)(),
+    _useLexicalComposerCo2 = (0, _slicedToArray2.default)(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  (0, _react.useEffect)(function () {
+    if (!editor.hasNodes([_WebinyQuoteNode.WebinyQuoteNode])) {
+      throw new Error("WebinyQuoteNodePlugin: WebinyQuoteNode is e not registered on editor");
+    }
+  }, [editor]);
+  (0, _useWebinyQuote.useWebinyQuote)(editor);
+  return null;
+}

package/plugins/WebinyQuoteNodePlugin/WebinyQuoteNodePlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyQuotePlugin","useLexicalComposerContext","editor","useEffect","hasNodes","WebinyQuoteNode","Error","useWebinyQuote"],"sources":["WebinyQuoteNodePlugin.ts"],"sourcesContent":["import { useLexicalComposerContext } from \"@lexical/react/LexicalComposerContext\";\nimport { useEffect } from \"react\";\nimport { WebinyQuoteNode } from \"~/nodes/WebinyQuoteNode\";\nimport { useWebinyQuote } from \"~/hooks/useWebinyQuote\";\n\nexport function WebinyQuotePlugin(): null {\n    const [editor] = useLexicalComposerContext();\n\n    useEffect(() => {\n        if (!editor.hasNodes([WebinyQuoteNode])) {\n            throw new Error(\"WebinyQuoteNodePlugin: WebinyQuoteNode is e not registered on editor\");\n        }\n    }, [editor]);\n\n    useWebinyQuote(editor);\n\n    return null;\n}\n"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AAEO,SAASA,iBAAiB,GAAS;EACtC,4BAAiB,IAAAC,iDAAyB,GAAE;IAAA;IAArCC,MAAM;EAEb,IAAAC,gBAAS,EAAC,YAAM;IACZ,IAAI,CAACD,MAAM,CAACE,QAAQ,CAAC,CAACC,gCAAe,CAAC,CAAC,EAAE;MACrC,MAAM,IAAIC,KAAK,CAAC,sEAAsE,CAAC;IAC3F;EACJ,CAAC,EAAE,CAACJ,MAAM,CAAC,CAAC;EAEZ,IAAAK,8BAAc,EAACL,MAAM,CAAC;EAEtB,OAAO,IAAI;AACf"}

package/themes/webinyLexicalTheme.css

@@ -0,0 +1,420 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ .ContentEditable__root{
+   font-size: inherit;
+   line-height: 1.25;
+
+ }
+.WebinyLexical__ltr {
+  text-align: inherit;
+}
+.WebinyLexical__rtl {
+  text-align: inherit;
+}
+.WebinyLexical__paragraph {
+  margin: 0;
+  position: relative;
+  text-align: inherit;
+  font-size: inherit;
+}
+.WebinyLexical__quote {
+  margin: 0;
+  margin-left: 20px;
+  margin-bottom: 10px;
+  font-size: 15px;
+  color: rgb(101, 103, 107);
+  border-left-color: rgb(206, 208, 212);
+  border-left-width: 4px;
+  border-left-style: solid;
+  padding-left: 16px;
+}
+.WebinyLexical__h1 {
+  font-size: 24px;
+  color: rgb(5, 5, 5);
+  font-weight: 400;
+  margin: 0;
+}
+.WebinyLexical__h2 {
+  font-size: 15px;
+  color: rgb(101, 103, 107);
+  font-weight: 700;
+  margin: 0;
+  text-transform: uppercase;
+}
+.WebinyLexical__h3 {
+  font-size: 12px;
+  margin: 0;
+  text-transform: uppercase;
+}
+.WebinyLexical__textBold {
+  font-weight: bold;
+}
+.WebinyLexical__textItalic {
+  font-style: italic;
+}
+.WebinyLexical__textUnderline {
+  text-decoration: underline;
+}
+.WebinyLexical__textStrikethrough {
+  text-decoration: line-through;
+}
+.WebinyLexical__textUnderlineStrikethrough {
+  text-decoration: underline line-through;
+}
+.WebinyLexical__textSubscript {
+  font-size: 0.8em;
+  vertical-align: sub !important;
+}
+.WebinyLexical__textSuperscript {
+  font-size: 0.8em;
+  vertical-align: super;
+}
+.WebinyLexical__textCode {
+  background-color: rgb(240, 242, 245);
+  padding: 1px 0.25rem;
+  font-family: Menlo, Consolas, Monaco, monospace;
+  font-size: 94%;
+}
+.WebinyLexical__hashtag {
+  background-color: rgba(88, 144, 255, 0.15);
+  border-bottom: 1px solid rgba(88, 144, 255, 0.3);
+}
+.WebinyLexical__link {
+  color: rgb(33, 111, 219);
+  text-decoration: none;
+}
+.WebinyLexical__link:hover {
+  text-decoration: underline;
+}
+.WebinyLexical__code {
+  background-color: rgb(240, 242, 245);
+  font-family: Menlo, Consolas, Monaco, monospace;
+  display: block;
+  padding: 8px 8px 8px 52px;
+  line-height: 1.53;
+  font-size: 13px;
+  margin: 0;
+  margin-top: 8px;
+  margin-bottom: 8px;
+  tab-size: 2;
+  /* white-space: pre; */
+  overflow-x: auto;
+  position: relative;
+}
+.WebinyLexical__code:before {
+  content: attr(data-gutter);
+  position: absolute;
+  background-color: #eee;
+  left: 0;
+  top: 0;
+  border-right: 1px solid #ccc;
+  padding: 8px;
+  color: #777;
+  white-space: pre-wrap;
+  text-align: right;
+  min-width: 25px;
+}
+.WebinyLexical__table {
+  border-collapse: collapse;
+  border-spacing: 0;
+  max-width: 100%;
+  overflow-y: scroll;
+  table-layout: fixed;
+  width: calc(100% - 25px);
+  margin: 30px 0;
+}
+.WebinyLexical__tableSelected {
+  outline: 2px solid rgb(60, 132, 244);
+}
+.WebinyLexical__tableCell {
+  border: 1px solid #bbb;
+  min-width: 75px;
+  vertical-align: top;
+  text-align: start;
+  padding: 6px 8px;
+  position: relative;
+  cursor: default;
+  outline: none;
+}
+.WebinyLexical__tableCellSortedIndicator {
+  display: block;
+  opacity: 0.5;
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  width: 100%;
+  height: 4px;
+  background-color: #999;
+}
+.WebinyLexical__tableCellResizer {
+  position: absolute;
+  right: -4px;
+  height: 100%;
+  width: 8px;
+  cursor: ew-resize;
+  z-index: 10;
+  top: 0;
+}
+.WebinyLexical__tableCellHeader {
+  background-color: #f2f3f5;
+  text-align: start;
+}
+.WebinyLexical__tableCellSelected {
+  background-color: #c9dbf0;
+}
+.WebinyLexical__tableCellPrimarySelected {
+  border: 2px solid rgb(60, 132, 244);
+  display: block;
+  height: calc(100% - 2px);
+  position: absolute;
+  width: calc(100% - 2px);
+  left: -1px;
+  top: -1px;
+  z-index: 2;
+}
+.WebinyLexical__tableCellEditing {
+  box-shadow: 0 0 5px rgba(0, 0, 0, 0.4);
+  border-radius: 3px;
+}
+.WebinyLexical__tableAddColumns {
+  position: absolute;
+  top: 0;
+  width: 20px;
+  background-color: #eee;
+  height: 100%;
+  right: 0;
+  animation: table-controls 0.2s ease;
+  border: 0;
+  cursor: pointer;
+}
+
+.WebinyLexical__tableAddColumns:hover {
+  background-color: #c9dbf0;
+}
+.WebinyLexical__tableAddRows {
+  position: absolute;
+  bottom: -25px;
+  width: calc(100% - 25px);
+  background-color: #eee;
+  height: 20px;
+  left: 0;
+  animation: table-controls 0.2s ease;
+  border: 0;
+  cursor: pointer;
+}
+.WebinyLexical__tableAddRows:hover {
+  background-color: #c9dbf0;
+}
+@keyframes table-controls {
+  0% {
+    opacity: 0;
+  }
+  100% {
+    opacity: 1;
+  }
+}
+.WebinyLexical__tableCellResizeRuler {
+  display: block;
+  position: absolute;
+  width: 1px;
+  background-color: rgb(60, 132, 244);
+  height: 100%;
+  top: 0;
+}
+.WebinyLexical__tableCellActionButtonContainer {
+  display: block;
+  right: 5px;
+  top: 6px;
+  position: absolute;
+  z-index: 4;
+  width: 20px;
+  height: 20px;
+}
+.WebinyLexical__tableCellActionButton {
+  background-color: #eee;
+  display: block;
+  border: 0;
+  border-radius: 20px;
+  width: 20px;
+  height: 20px;
+  color: #222;
+  cursor: pointer;
+}
+.WebinyLexical__tableCellActionButton:hover {
+  background-color: #ddd;
+}
+.WebinyLexical__characterLimit {
+  display: inline;
+  background-color: #ffbbbb !important;
+}
+.WebinyLexical__ol1 {
+  list-style: auto;
+  padding: 0;
+  margin: 0;
+  margin-left: 16px;
+  list-style-position: inside;
+}
+.WebinyLexical__ol2 {
+  list-style: initial;
+  padding: 0;
+  margin: 0;
+  margin-left: 16px;
+  list-style-type: upper-alpha;
+  list-style-position: inside;
+}
+.WebinyLexical__ol3 {
+  list-style: initial;
+  list-style: auto;
+  padding: 0;
+  margin: 0;
+  margin-left: 16px;
+  list-style-type: lower-alpha;
+  list-style-position: inside;
+}
+.WebinyLexical__ol4 {
+  list-style: initial;
+  padding: 0;
+  margin: 0;
+  margin-left: 16px;
+  list-style-type: upper-roman;
+  list-style-position: inside;
+}
+.WebinyLexical__ol5 {
+  list-style: initial;
+  padding: 0;
+  margin: 0;
+  margin-left: 16px;
+  list-style-type: lower-roman;
+  list-style-position: inside;
+}
+.WebinyLexical__ul {
+  list-style: initial;
+  padding: 0;
+  margin: 0;
+  margin-left: 16px;
+  list-style-position: inside;
+}
+.WebinyLexical__listItem {
+  margin: 0 32px;
+}
+.WebinyLexical__listItemChecked,
+.WebinyLexical__listItemUnchecked {
+  position: relative;
+  margin-left: 8px;
+  margin-right: 8px;
+  padding-left: 24px;
+  padding-right: 24px;
+  list-style-type: none;
+  outline: none;
+}
+.WebinyLexical__listItemChecked {
+  text-decoration: line-through;
+}
+.WebinyLexical__listItemUnchecked:before,
+.WebinyLexical__listItemChecked:before {
+  content: '';
+  width: 16px;
+  height: 16px;
+  top: 2px;
+  left: 0;
+  cursor: pointer;
+  display: block;
+  background-size: cover;
+  position: absolute;
+}
+.WebinyLexical__listItemUnchecked[dir='rtl']:before,
+.WebinyLexical__listItemChecked[dir='rtl']:before {
+  left: auto;
+  right: 0;
+}
+.WebinyLexical__listItemUnchecked:focus:before,
+.WebinyLexical__listItemChecked:focus:before {
+  box-shadow: 0 0 0 2px #a6cdfe;
+  border-radius: 2px;
+}
+.WebinyLexical__listItemUnchecked:before {
+  border: 1px solid #999;
+  border-radius: 2px;
+}
+.WebinyLexical__listItemChecked:before {
+  border: 1px solid rgb(61, 135, 245);
+  border-radius: 2px;
+  background-color: #3d87f5;
+  background-repeat: no-repeat;
+}
+.WebinyLexical__listItemChecked:after {
+  content: '';
+  cursor: pointer;
+  border-color: #fff;
+  border-style: solid;
+  position: absolute;
+  display: block;
+  top: 6px;
+  width: 3px;
+  left: 7px;
+  height: 6px;
+  transform: rotate(45deg);
+  border-width: 0 2px 2px 0;
+}
+.WebinyLexical__nestedListItem {
+  list-style-type: none;
+}
+.WebinyLexical__nestedListItem:before,
+.WebinyLexical__nestedListItem:after {
+  display: none;
+}
+.WebinyLexical__tokenComment {
+  color: slategray;
+}
+.WebinyLexical__tokenPunctuation {
+  color: #999;
+}
+.WebinyLexical__tokenProperty {
+  color: #905;
+}
+.WebinyLexical__tokenSelector {
+  color: #690;
+}
+.WebinyLexical__tokenOperator {
+  color: #9a6e3a;
+}
+.WebinyLexical__tokenAttr {
+  color: #07a;
+}
+.WebinyLexical__tokenVariable {
+  color: #e90;
+}
+.WebinyLexical__tokenFunction {
+  color: #dd4a68;
+}
+.WebinyLexical__mark {
+  background: rgba(255, 212, 0, 0.14);
+  border-bottom: 2px solid rgba(255, 212, 0, 0.3);
+  padding-bottom: 2px;
+}
+.WebinyLexical__markOverlap {
+  background: rgba(255, 212, 0, 0.3);
+  border-bottom: 2px solid rgba(255, 212, 0, 0.7);
+}
+.WebinyLexical__mark.selected {
+  background: rgba(255, 212, 0, 0.5);
+  border-bottom: 2px solid rgba(255, 212, 0, 1);
+}
+.WebinyLexical__markOverlap.selected {
+  background: rgba(255, 212, 0, 0.7);
+  border-bottom: 2px solid rgba(255, 212, 0, 0.7);
+}
+.WebinyLexical__embedBlock {
+  user-select: none;
+}
+.WebinyLexical__embedBlockFocus {
+  outline: 2px solid rgb(60, 132, 244);
+}
+
+.WebinyLexical__placeholder {
+  text-align: left;
+}