@payloadcms/richtext-lexical 3.0.0-beta.13 → 3.0.0-beta.131

package/dist/features/horizontalRule/client/component/index.js

@@ -0,0 +1,100 @@
+'use client';
+
+import { c as _c } from "react/compiler-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection.js';
+import { addClassNamesToElement, mergeRegister, removeClassNamesFromElement } from '@lexical/utils';
+import { $getSelection, $isNodeSelection, CLICK_COMMAND, COMMAND_PRIORITY_LOW, KEY_BACKSPACE_COMMAND, KEY_DELETE_COMMAND } from 'lexical';
+import { useCallback, useEffect } from 'react';
+import { $isHorizontalRuleNode } from '../nodes/HorizontalRuleNode.js';
+const isSelectedClassName = 'selected';
+/**
+ * React component rendered in the lexical editor, WITHIN the hr element created by createDOM of the HorizontalRuleNode.
+ *
+ * @param nodeKey every node has a unique key (this key is not saved to the database and thus may differ between sessions). It's useful for working with the CURRENT lexical editor state
+ */
+export function HorizontalRuleComponent(t0) {
+  const $ = _c(16);
+  const {
+    nodeKey
+  } = t0;
+  const [editor] = useLexicalComposerContext();
+  const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey);
+  let t1;
+  if ($[0] !== isSelected || $[1] !== editor) {
+    t1 = event => {
+      const deleteSelection = $getSelection();
+      if (isSelected && $isNodeSelection(deleteSelection)) {
+        event.preventDefault();
+        editor.update(() => {
+          deleteSelection.getNodes().forEach(node => {
+            if ($isHorizontalRuleNode(node)) {
+              node.remove();
+            }
+          });
+        });
+      }
+      return false;
+    };
+    $[0] = isSelected;
+    $[1] = editor;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const $onDelete = t1;
+  let t2;
+  let t3;
+  if ($[3] !== editor || $[4] !== nodeKey || $[5] !== clearSelection || $[6] !== setSelected || $[7] !== isSelected || $[8] !== $onDelete) {
+    t2 = () => mergeRegister(editor.registerCommand(CLICK_COMMAND, event_0 => {
+      const hrElem = editor.getElementByKey(nodeKey);
+      if (event_0.target === hrElem) {
+        if (!event_0.shiftKey) {
+          clearSelection();
+        }
+        setSelected(!isSelected);
+        return true;
+      }
+      return false;
+    }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_DELETE_COMMAND, $onDelete, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_BACKSPACE_COMMAND, $onDelete, COMMAND_PRIORITY_LOW));
+    t3 = [clearSelection, editor, isSelected, nodeKey, $onDelete, setSelected];
+    $[3] = editor;
+    $[4] = nodeKey;
+    $[5] = clearSelection;
+    $[6] = setSelected;
+    $[7] = isSelected;
+    $[8] = $onDelete;
+    $[9] = t2;
+    $[10] = t3;
+  } else {
+    t2 = $[9];
+    t3 = $[10];
+  }
+  useEffect(t2, t3);
+  let t4;
+  let t5;
+  if ($[11] !== editor || $[12] !== nodeKey || $[13] !== isSelected) {
+    t4 = () => {
+      const hrElem_0 = editor.getElementByKey(nodeKey);
+      if (hrElem_0 !== null) {
+        if (isSelected) {
+          addClassNamesToElement(hrElem_0, isSelectedClassName);
+        } else {
+          removeClassNamesFromElement(hrElem_0, isSelectedClassName);
+        }
+      }
+    };
+    t5 = [editor, isSelected, nodeKey];
+    $[11] = editor;
+    $[12] = nodeKey;
+    $[13] = isSelected;
+    $[14] = t4;
+    $[15] = t5;
+  } else {
+    t4 = $[14];
+    t5 = $[15];
+  }
+  useEffect(t4, t5);
+  return null;
+}
+//# sourceMappingURL=index.js.map

package/dist/features/horizontalRule/client/component/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["c","_c","useLexicalComposerContext","useLexicalNodeSelection","addClassNamesToElement","mergeRegister","removeClassNamesFromElement","$getSelection","$isNodeSelection","CLICK_COMMAND","COMMAND_PRIORITY_LOW","KEY_BACKSPACE_COMMAND","KEY_DELETE_COMMAND","useCallback","useEffect","$isHorizontalRuleNode","isSelectedClassName","HorizontalRuleComponent","t0","$","nodeKey","editor","isSelected","setSelected","clearSelection","t1","event","deleteSelection","preventDefault","update","getNodes","forEach","node","remove","$onDelete","t2","t3","registerCommand","event_0","hrElem","getElementByKey","target","shiftKey","t4","t5","hrElem_0"],"sources":["../../../../../src/features/horizontalRule/client/component/index.tsx"],"sourcesContent":["'use client'\n\nimport type { NodeKey } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection.js'\nimport { addClassNamesToElement, mergeRegister, removeClassNamesFromElement } from '@lexical/utils'\nimport {\n  $getSelection,\n  $isNodeSelection,\n  CLICK_COMMAND,\n  COMMAND_PRIORITY_LOW,\n  KEY_BACKSPACE_COMMAND,\n  KEY_DELETE_COMMAND,\n} from 'lexical'\nimport { useCallback, useEffect } from 'react'\n\nimport { $isHorizontalRuleNode } from '../nodes/HorizontalRuleNode.js'\n\nconst isSelectedClassName = 'selected'\n\n/**\n * React component rendered in the lexical editor, WITHIN the hr element created by createDOM of the HorizontalRuleNode.\n *\n * @param nodeKey every node has a unique key (this key is not saved to the database and thus may differ between sessions). It's useful for working with the CURRENT lexical editor state\n */\nexport function HorizontalRuleComponent({ nodeKey }: { nodeKey: NodeKey }) {\n  const [editor] = useLexicalComposerContext()\n  const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey)\n\n  const $onDelete = useCallback(\n    (event: KeyboardEvent) => {\n      const deleteSelection = $getSelection()\n      if (isSelected && $isNodeSelection(deleteSelection)) {\n        event.preventDefault()\n        editor.update(() => {\n          deleteSelection.getNodes().forEach((node) => {\n            if ($isHorizontalRuleNode(node)) {\n              node.remove()\n            }\n          })\n        })\n      }\n      return false\n    },\n    [editor, isSelected],\n  )\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerCommand(\n        CLICK_COMMAND,\n        (event: MouseEvent) => {\n          const hrElem = editor.getElementByKey(nodeKey)\n\n          if (event.target === hrElem) {\n            if (!event.shiftKey) {\n              clearSelection()\n            }\n            setSelected(!isSelected)\n            return true\n          }\n\n          return false\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n      editor.registerCommand(KEY_DELETE_COMMAND, $onDelete, COMMAND_PRIORITY_LOW),\n      editor.registerCommand(KEY_BACKSPACE_COMMAND, $onDelete, COMMAND_PRIORITY_LOW),\n    )\n  }, [clearSelection, editor, isSelected, nodeKey, $onDelete, setSelected])\n\n  useEffect(() => {\n    const hrElem = editor.getElementByKey(nodeKey)\n    if (hrElem !== null) {\n      if (isSelected) {\n        addClassNamesToElement(hrElem, isSelectedClassName)\n      } else {\n        removeClassNamesFromElement(hrElem, isSelectedClassName)\n      }\n    }\n  }, [editor, isSelected, nodeKey])\n\n  return null\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/horizontalRule/client/index.d.ts

@@ -0,0 +1,2 @@
+export declare const HorizontalRuleFeatureClient: import("../../typesClient.js").FeatureProviderProviderClient<undefined, undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/horizontalRule/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/horizontalRule/client/index.tsx"],"names":[],"mappings":"AAaA,eAAO,MAAM,2BAA2B,oFAmDtC,CAAA"}

package/dist/features/horizontalRule/client/index.js

@@ -0,0 +1,62 @@
+'use client';
+
+import { $isNodeSelection } from 'lexical';
+import { HorizontalRuleIcon } from '../../../lexical/ui/icons/HorizontalRule/index.js';
+import { createClientFeature } from '../../../utilities/createClientFeature.js';
+import { slashMenuBasicGroupWithItems } from '../../shared/slashMenu/basicGroup.js';
+import { toolbarAddDropdownGroupWithItems } from '../../shared/toolbar/addDropdownGroup.js';
+import { INSERT_HORIZONTAL_RULE_COMMAND } from '../server/nodes/HorizontalRuleNode.js';
+import { MarkdownTransformer } from './markdownTransformer.js';
+import { $isHorizontalRuleNode, HorizontalRuleNode } from './nodes/HorizontalRuleNode.js';
+import { HorizontalRulePlugin } from './plugin/index.js';
+export const HorizontalRuleFeatureClient = createClientFeature({
+  markdownTransformers: [MarkdownTransformer],
+  nodes: [HorizontalRuleNode],
+  plugins: [{
+    Component: HorizontalRulePlugin,
+    position: 'normal'
+  }],
+  slashMenu: {
+    groups: [slashMenuBasicGroupWithItems([{
+      Icon: HorizontalRuleIcon,
+      key: 'horizontalRule',
+      keywords: ['hr', 'horizontal rule', 'line', 'separator'],
+      label: ({
+        i18n
+      }) => {
+        return i18n.t('lexical:horizontalRule:label');
+      },
+      onSelect: ({
+        editor
+      }) => {
+        editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined);
+      }
+    }])]
+  },
+  toolbarFixed: {
+    groups: [toolbarAddDropdownGroupWithItems([{
+      ChildComponent: HorizontalRuleIcon,
+      isActive: ({
+        selection
+      }) => {
+        if (!$isNodeSelection(selection) || !selection.getNodes().length) {
+          return false;
+        }
+        const firstNode = selection.getNodes()[0];
+        return $isHorizontalRuleNode(firstNode);
+      },
+      key: 'horizontalRule',
+      label: ({
+        i18n
+      }) => {
+        return i18n.t('lexical:horizontalRule:label');
+      },
+      onSelect: ({
+        editor
+      }) => {
+        editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined);
+      }
+    }])]
+  }
+});
+//# sourceMappingURL=index.js.map

package/dist/features/horizontalRule/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["$isNodeSelection","HorizontalRuleIcon","createClientFeature","slashMenuBasicGroupWithItems","toolbarAddDropdownGroupWithItems","INSERT_HORIZONTAL_RULE_COMMAND","MarkdownTransformer","$isHorizontalRuleNode","HorizontalRuleNode","HorizontalRulePlugin","HorizontalRuleFeatureClient","markdownTransformers","nodes","plugins","Component","position","slashMenu","groups","Icon","key","keywords","label","i18n","t","onSelect","editor","dispatchCommand","undefined","toolbarFixed","ChildComponent","isActive","selection","getNodes","length","firstNode"],"sources":["../../../../src/features/horizontalRule/client/index.tsx"],"sourcesContent":["'use client'\n\nimport { $isNodeSelection } from 'lexical'\n\nimport { HorizontalRuleIcon } from '../../../lexical/ui/icons/HorizontalRule/index.js'\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { slashMenuBasicGroupWithItems } from '../../shared/slashMenu/basicGroup.js'\nimport { toolbarAddDropdownGroupWithItems } from '../../shared/toolbar/addDropdownGroup.js'\nimport { INSERT_HORIZONTAL_RULE_COMMAND } from '../server/nodes/HorizontalRuleNode.js'\nimport { MarkdownTransformer } from './markdownTransformer.js'\nimport { $isHorizontalRuleNode, HorizontalRuleNode } from './nodes/HorizontalRuleNode.js'\nimport { HorizontalRulePlugin } from './plugin/index.js'\n\nexport const HorizontalRuleFeatureClient = createClientFeature({\n  markdownTransformers: [MarkdownTransformer],\n  nodes: [HorizontalRuleNode],\n  plugins: [\n    {\n      Component: HorizontalRulePlugin,\n      position: 'normal',\n    },\n  ],\n  slashMenu: {\n    groups: [\n      slashMenuBasicGroupWithItems([\n        {\n          Icon: HorizontalRuleIcon,\n          key: 'horizontalRule',\n          keywords: ['hr', 'horizontal rule', 'line', 'separator'],\n          label: ({ i18n }) => {\n            return i18n.t('lexical:horizontalRule:label')\n          },\n\n          onSelect: ({ editor }) => {\n            editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined)\n          },\n        },\n      ]),\n    ],\n  },\n  toolbarFixed: {\n    groups: [\n      toolbarAddDropdownGroupWithItems([\n        {\n          ChildComponent: HorizontalRuleIcon,\n          isActive: ({ selection }) => {\n            if (!$isNodeSelection(selection) || !selection.getNodes().length) {\n              return false\n            }\n\n            const firstNode = selection.getNodes()[0]\n            return $isHorizontalRuleNode(firstNode)\n          },\n          key: 'horizontalRule',\n          label: ({ i18n }) => {\n            return i18n.t('lexical:horizontalRule:label')\n          },\n          onSelect: ({ editor }) => {\n            editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined)\n          },\n        },\n      ]),\n    ],\n  },\n})\n"],"mappings":"AAAA;;AAEA,SAASA,gBAAgB,QAAQ;AAEjC,SAASC,kBAAkB,QAAQ;AACnC,SAASC,mBAAmB,QAAQ;AACpC,SAASC,4BAA4B,QAAQ;AAC7C,SAASC,gCAAgC,QAAQ;AACjD,SAASC,8BAA8B,QAAQ;AAC/C,SAASC,mBAAmB,QAAQ;AACpC,SAASC,qBAAqB,EAAEC,kBAAkB,QAAQ;AAC1D,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,2BAAA,GAA8BR,mBAAA,CAAoB;EAC7DS,oBAAA,EAAsB,CAACL,mBAAA,CAAoB;EAC3CM,KAAA,EAAO,CAACJ,kBAAA,CAAmB;EAC3BK,OAAA,EAAS,CACP;IACEC,SAAA,EAAWL,oBAAA;IACXM,QAAA,EAAU;EACZ,EACD;EACDC,SAAA,EAAW;IACTC,MAAA,EAAQ,CACNd,4BAAA,CAA6B,CAC3B;MACEe,IAAA,EAAMjB,kBAAA;MACNkB,GAAA,EAAK;MACLC,QAAA,EAAU,CAAC,MAAM,mBAAmB,QAAQ,YAAY;MACxDC,KAAA,EAAOA,CAAC;QAAEC;MAAI,CAAE;QACd,OAAOA,IAAA,CAAKC,CAAC,CAAC;MAChB;MAEAC,QAAA,EAAUA,CAAC;QAAEC;MAAM,CAAE;QACnBA,MAAA,CAAOC,eAAe,CAACrB,8BAAA,EAAgCsB,SAAA;MACzD;IACF,EACD;EAEL;EACAC,YAAA,EAAc;IACZX,MAAA,EAAQ,CACNb,gCAAA,CAAiC,CAC/B;MACEyB,cAAA,EAAgB5B,kBAAA;MAChB6B,QAAA,EAAUA,CAAC;QAAEC;MAAS,CAAE;QACtB,IAAI,CAAC/B,gBAAA,CAAiB+B,SAAA,KAAc,CAACA,SAAA,CAAUC,QAAQ,GAAGC,MAAM,EAAE;UAChE,OAAO;QACT;QAEA,MAAMC,SAAA,GAAYH,SAAA,CAAUC,QAAQ,EAAE,CAAC,EAAE;QACzC,OAAOzB,qBAAA,CAAsB2B,SAAA;MAC/B;MACAf,GAAA,EAAK;MACLE,KAAA,EAAOA,CAAC;QAAEC;MAAI,CAAE;QACd,OAAOA,IAAA,CAAKC,CAAC,CAAC;MAChB;MACAC,QAAA,EAAUA,CAAC;QAAEC;MAAM,CAAE;QACnBA,MAAA,CAAOC,eAAe,CAACrB,8BAAA,EAAgCsB,SAAA;MACzD;IACF,EACD;EAEL;AACF","ignoreList":[]}

package/dist/features/horizontalRule/client/markdownTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../src/features/horizontalRule/client/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAQ3D,eAAO,MAAM,mBAAmB,EAAE,kBAiBjC,CAAA"}

package/dist/features/horizontalRule/client/markdownTransformer.js

@@ -0,0 +1,20 @@
+import { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode } from './nodes/HorizontalRuleNode.js';
+export const MarkdownTransformer = {
+  type: 'element',
+  dependencies: [HorizontalRuleNode],
+  export: (node, exportChildren) => {
+    if (!$isHorizontalRuleNode(node)) {
+      return null;
+    }
+    return '---';
+  },
+  // match ---
+  regExp: /^---\s*$/,
+  replace: parentNode => {
+    const node = $createHorizontalRuleNode();
+    if (node) {
+      parentNode.replace(node);
+    }
+  }
+};
+//# sourceMappingURL=markdownTransformer.js.map

package/dist/features/horizontalRule/client/markdownTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.js","names":["$createHorizontalRuleNode","$isHorizontalRuleNode","HorizontalRuleNode","MarkdownTransformer","type","dependencies","export","node","exportChildren","regExp","replace","parentNode"],"sources":["../../../../src/features/horizontalRule/client/markdownTransformer.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\n\nimport {\n  $createHorizontalRuleNode,\n  $isHorizontalRuleNode,\n  HorizontalRuleNode,\n} from './nodes/HorizontalRuleNode.js'\n\nexport const MarkdownTransformer: ElementTransformer = {\n  type: 'element',\n  dependencies: [HorizontalRuleNode],\n  export: (node, exportChildren) => {\n    if (!$isHorizontalRuleNode(node)) {\n      return null\n    }\n    return '---'\n  },\n  // match ---\n  regExp: /^---\\s*$/,\n  replace: (parentNode) => {\n    const node = $createHorizontalRuleNode()\n    if (node) {\n      parentNode.replace(node)\n    }\n  },\n}\n"],"mappings":"AAEA,SACEA,yBAAyB,EACzBC,qBAAqB,EACrBC,kBAAkB,QACb;AAEP,OAAO,MAAMC,mBAAA,GAA0C;EACrDC,IAAA,EAAM;EACNC,YAAA,EAAc,CAACH,kBAAA,CAAmB;EAClCI,MAAA,EAAQA,CAACC,IAAA,EAAMC,cAAA;IACb,IAAI,CAACP,qBAAA,CAAsBM,IAAA,GAAO;MAChC,OAAO;IACT;IACA,OAAO;EACT;EACA;EACAE,MAAA,EAAQ;EACRC,OAAA,EAAUC,UAAA;IACR,MAAMJ,IAAA,GAAOP,yBAAA;IACb,IAAIO,IAAA,EAAM;MACRI,UAAA,CAAWD,OAAO,CAACH,IAAA;IACrB;EACF;AACF","ignoreList":[]}

package/dist/features/horizontalRule/client/nodes/HorizontalRuleNode.d.ts

@@ -0,0 +1,20 @@
+import type { LexicalNode, SerializedLexicalNode } from 'lexical';
+import * as React from 'react';
+import type { SerializedHorizontalRuleNode } from '../../server/nodes/HorizontalRuleNode.js';
+import { HorizontalRuleServerNode } from '../../server/nodes/HorizontalRuleNode.js';
+export declare class HorizontalRuleNode extends HorizontalRuleServerNode {
+    static clone(node: HorizontalRuleServerNode): HorizontalRuleServerNode;
+    static getType(): string;
+    /**
+     * The data for this node is stored serialized as JSON. This is the "load function" of that node: it takes the saved data and converts it into a node.
+     */
+    static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode;
+    /**
+     * Allows you to render a React component within whatever createDOM returns.
+     */
+    decorate(): React.ReactElement;
+    exportJSON(): SerializedLexicalNode;
+}
+export declare function $createHorizontalRuleNode(): HorizontalRuleNode;
+export declare function $isHorizontalRuleNode(node: LexicalNode | null | undefined): node is HorizontalRuleNode;
+//# sourceMappingURL=HorizontalRuleNode.d.ts.map

package/dist/features/horizontalRule/client/nodes/HorizontalRuleNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HorizontalRuleNode.d.ts","sourceRoot":"","sources":["../../../../../src/features/horizontalRule/client/nodes/HorizontalRuleNode.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAuB,WAAW,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAGtF,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAA;AAE5F,OAAO,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAA;AAQnF,qBAAa,kBAAmB,SAAQ,wBAAwB;IAC9D,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,wBAAwB,GAAG,wBAAwB;IAItE,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,4BAA4B,GAAG,kBAAkB;IAInF;;OAEG;IACH,QAAQ,IAAI,KAAK,CAAC,YAAY;IAI9B,UAAU,IAAI,qBAAqB;CAGpC;AAMD,wBAAgB,yBAAyB,IAAI,kBAAkB,CAE9D;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,kBAAkB,CAE5B"}

package/dist/features/horizontalRule/client/nodes/HorizontalRuleNode.js

@@ -0,0 +1,46 @@
+'use client';
+
+import { jsx as _jsx } from "react/jsx-runtime";
+import { $applyNodeReplacement } from 'lexical';
+import * as React from 'react';
+import { HorizontalRuleServerNode } from '../../server/nodes/HorizontalRuleNode.js';
+const HorizontalRuleComponent = /*#__PURE__*/React.lazy(() => import('../../client/component/index.js').then(module => ({
+  default: module.HorizontalRuleComponent
+})));
+export class HorizontalRuleNode extends HorizontalRuleServerNode {
+  static clone(node) {
+    return super.clone(node);
+  }
+  static getType() {
+    return super.getType();
+  }
+  /**
+  * The data for this node is stored serialized as JSON. This is the "load function" of that node: it takes the saved data and converts it into a node.
+  */
+  static importJSON(serializedNode) {
+    return $createHorizontalRuleNode();
+  }
+  /**
+  * Allows you to render a React component within whatever createDOM returns.
+  */
+  decorate() {
+    return /*#__PURE__*/_jsx(HorizontalRuleComponent, {
+      nodeKey: this.__key
+    });
+  }
+  exportJSON() {
+    return super.exportJSON();
+  }
+}
+function $convertHorizontalRuleElement() {
+  return {
+    node: $createHorizontalRuleNode()
+  };
+}
+export function $createHorizontalRuleNode() {
+  return $applyNodeReplacement(new HorizontalRuleNode());
+}
+export function $isHorizontalRuleNode(node) {
+  return node instanceof HorizontalRuleNode;
+}
+//# sourceMappingURL=HorizontalRuleNode.js.map

package/dist/features/horizontalRule/client/nodes/HorizontalRuleNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HorizontalRuleNode.js","names":["$applyNodeReplacement","React","HorizontalRuleServerNode","HorizontalRuleComponent","lazy","then","module","default","HorizontalRuleNode","clone","node","getType","importJSON","serializedNode","$createHorizontalRuleNode","decorate","_jsx","nodeKey","__key","exportJSON","$convertHorizontalRuleElement","$isHorizontalRuleNode"],"sources":["../../../../../src/features/horizontalRule/client/nodes/HorizontalRuleNode.tsx"],"sourcesContent":["'use client'\nimport type { DOMConversionOutput, LexicalNode, SerializedLexicalNode } from 'lexical'\n\nimport { $applyNodeReplacement } from 'lexical'\nimport * as React from 'react'\n\nimport type { SerializedHorizontalRuleNode } from '../../server/nodes/HorizontalRuleNode.js'\n\nimport { HorizontalRuleServerNode } from '../../server/nodes/HorizontalRuleNode.js'\n\nconst HorizontalRuleComponent = React.lazy(() =>\n  import('../../client/component/index.js').then((module) => ({\n    default: module.HorizontalRuleComponent,\n  })),\n)\n\nexport class HorizontalRuleNode extends HorizontalRuleServerNode {\n  static clone(node: HorizontalRuleServerNode): HorizontalRuleServerNode {\n    return super.clone(node)\n  }\n\n  static getType(): string {\n    return super.getType()\n  }\n\n  /**\n   * The data for this node is stored serialized as JSON. This is the \"load function\" of that node: it takes the saved data and converts it into a node.\n   */\n  static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode {\n    return $createHorizontalRuleNode()\n  }\n\n  /**\n   * Allows you to render a React component within whatever createDOM returns.\n   */\n  decorate(): React.ReactElement {\n    return <HorizontalRuleComponent nodeKey={this.__key} />\n  }\n\n  exportJSON(): SerializedLexicalNode {\n    return super.exportJSON()\n  }\n}\n\nfunction $convertHorizontalRuleElement(): DOMConversionOutput {\n  return { node: $createHorizontalRuleNode() }\n}\n\nexport function $createHorizontalRuleNode(): HorizontalRuleNode {\n  return $applyNodeReplacement(new HorizontalRuleNode())\n}\n\nexport function $isHorizontalRuleNode(\n  node: LexicalNode | null | undefined,\n): node is HorizontalRuleNode {\n  return node instanceof HorizontalRuleNode\n}\n"],"mappings":"AAAA;;;AAGA,SAASA,qBAAqB,QAAQ;AACtC,YAAYC,KAAA,MAAW;AAIvB,SAASC,wBAAwB,QAAQ;AAEzC,MAAMC,uBAAA,gBAA0BF,KAAA,CAAMG,IAAI,CAAC,MACzC,MAAM,CAAC,mCAAmCC,IAAI,CAAEC,MAAA,KAAY;EAC1DC,OAAA,EAASD,MAAA,CAAOH;AAClB;AAGF,OAAO,MAAMK,kBAAA,SAA2BN,wBAAA;EACtC,OAAOO,MAAMC,IAA8B,EAA4B;IACrE,OAAO,KAAK,CAACD,KAAA,CAAMC,IAAA;EACrB;EAEA,OAAOC,QAAA,EAAkB;IACvB,OAAO,KAAK,CAACA,OAAA;EACf;EAEA;;;EAGA,OAAOC,WAAWC,cAA4C,EAAsB;IAClF,OAAOC,yBAAA;EACT;EAEA;;;EAGAC,SAAA,EAA+B;IAC7B,oBAAOC,IAAA,CAACb,uBAAA;MAAwBc,OAAA,EAAS,IAAI,CAACC;;EAChD;EAEAC,WAAA,EAAoC;IAClC,OAAO,KAAK,CAACA,UAAA;EACf;AACF;AAEA,SAASC,8BAAA;EACP,OAAO;IAAEV,IAAA,EAAMI,yBAAA;EAA4B;AAC7C;AAEA,OAAO,SAASA,0BAAA;EACd,OAAOd,qBAAA,CAAsB,IAAIQ,kBAAA;AACnC;AAEA,OAAO,SAASa,sBACdX,IAAoC;EAEpC,OAAOA,IAAA,YAAgBF,kBAAA;AACzB","ignoreList":[]}

package/dist/features/horizontalRule/client/plugin/index.d.ts

@@ -0,0 +1,7 @@
+import type { PluginComponent } from '../../../typesClient.js';
+import './index.scss';
+/**
+ * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.
+ */
+export declare const HorizontalRulePlugin: PluginComponent<undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/horizontalRule/client/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/horizontalRule/client/plugin/index.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAI9D,OAAO,cAAc,CAAA;AAErB;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,eAAe,CAAC,SAAS,CA2B3D,CAAA"}

package/dist/features/horizontalRule/client/plugin/index.js

@@ -0,0 +1,42 @@
+'use client';
+
+import { c as _c } from "react/compiler-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { $insertNodeToNearestRoot } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from 'lexical';
+import { useEffect } from 'react';
+import { INSERT_HORIZONTAL_RULE_COMMAND } from '../../server/nodes/HorizontalRuleNode.js';
+import { $createHorizontalRuleNode } from '../nodes/HorizontalRuleNode.js';
+/**
+ * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.
+ */
+export const HorizontalRulePlugin = () => {
+  const $ = _c(3);
+  const [editor] = useLexicalComposerContext();
+  let t0;
+  let t1;
+  if ($[0] !== editor) {
+    t0 = () => editor.registerCommand(INSERT_HORIZONTAL_RULE_COMMAND, type => {
+      const selection = $getSelection();
+      if (!$isRangeSelection(selection)) {
+        return false;
+      }
+      const focusNode = selection.focus.getNode();
+      if (focusNode !== null) {
+        const horizontalRuleNode = $createHorizontalRuleNode();
+        $insertNodeToNearestRoot(horizontalRuleNode);
+      }
+      return true;
+    }, COMMAND_PRIORITY_EDITOR);
+    t1 = [editor];
+    $[0] = editor;
+    $[1] = t0;
+    $[2] = t1;
+  } else {
+    t0 = $[1];
+    t1 = $[2];
+  }
+  useEffect(t0, t1);
+  return null;
+};
+//# sourceMappingURL=index.js.map

package/dist/features/horizontalRule/client/plugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["c","_c","useLexicalComposerContext","$insertNodeToNearestRoot","$getSelection","$isRangeSelection","COMMAND_PRIORITY_EDITOR","useEffect","INSERT_HORIZONTAL_RULE_COMMAND","$createHorizontalRuleNode","HorizontalRulePlugin","$","editor","t0","t1","registerCommand","type","selection","focusNode","focus","getNode","horizontalRuleNode"],"sources":["../../../../../src/features/horizontalRule/client/plugin/index.tsx"],"sourcesContent":["'use client'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { $insertNodeToNearestRoot } from '@lexical/utils'\nimport { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from 'lexical'\nimport { useEffect } from 'react'\n\nimport type { PluginComponent } from '../../../typesClient.js'\n\nimport { INSERT_HORIZONTAL_RULE_COMMAND } from '../../server/nodes/HorizontalRuleNode.js'\nimport { $createHorizontalRuleNode } from '../nodes/HorizontalRuleNode.js'\nimport './index.scss'\n\n/**\n * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.\n */\nexport const HorizontalRulePlugin: PluginComponent<undefined> = () => {\n  const [editor] = useLexicalComposerContext()\n\n  useEffect(() => {\n    return editor.registerCommand(\n      INSERT_HORIZONTAL_RULE_COMMAND,\n      (type) => {\n        const selection = $getSelection()\n\n        if (!$isRangeSelection(selection)) {\n          return false\n        }\n\n        const focusNode = selection.focus.getNode()\n\n        if (focusNode !== null) {\n          const horizontalRuleNode = $createHorizontalRuleNode()\n          $insertNodeToNearestRoot(horizontalRuleNode)\n        }\n\n        return true\n      },\n      COMMAND_PRIORITY_EDITOR,\n    )\n  }, [editor])\n\n  return null\n}\n"],"mappings":"AAAA;;AAAA,SAAAA,CAAA,IAAAC,EAAA;AAEA,SAASC,yBAAyB,QAAQ;AAC1C,SAASC,wBAAwB,QAAQ;AACzC,SAASC,aAAa,EAAEC,iBAAiB,EAAEC,uBAAuB,QAAQ;AAC1E,SAASC,SAAS,QAAQ;AAI1B,SAASC,8BAA8B,QAAQ;AAC/C,SAASC,yBAAyB,QAAQ;AAG1C;;;AAGA,OAAO,MAAMC,oBAAA,GAAmDA,CAAA;EAAA,MAAAC,CAAA,GAAAV,EAAA;EAC9D,OAAAW,MAAA,IAAiBV,yBAAA;EAAA,IAAAW,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAH,CAAA,QAAAC,MAAA;IAEPC,EAAA,GAAAA,CAAA,KACDD,MAAA,CAAAG,eAAA,CAAAP,8BAAA,EAAAQ,IAAA;MAGH,MAAAC,SAAA,GAAkBb,aAAA;MAAA,KAEbC,iBAAA,CAAkBY,SAAA;QAAA;MAAA;MAIvB,MAAAC,SAAA,GAAkBD,SAAA,CAAAE,KAAA,CAAAC,OAAA,CAAuB;MAAA,IAErCF,SAAA,SAAc;QAChB,MAAAG,kBAAA,GAA2BZ,yBAAA;QAC3BN,wBAAA,CAAyBkB,kBAAA;MAAA;MAAA;IAAA,GAAAf,uBAK7B;IAEDQ,EAAA,IAACF,MAAA;IAAOD,CAAA,MAAAC,MAAA;IAAAD,CAAA,MAAAE,EAAA;IAAAF,CAAA,MAAAG,EAAA;EAAA;IAAAD,EAAA,GAAAF,CAAA;IAAAG,EAAA,GAAAH,CAAA;EAAA;EArBXJ,SAAA,CAAUM,EAqBV,EAAGC,EAAQ;EAAA;AAAA,CAGb","ignoreList":[]}

package/dist/features/horizontalRule/server/i18n.d.ts

@@ -0,0 +1,3 @@
+import type { GenericLanguages } from '@payloadcms/translations';
+export declare const i18n: Partial<GenericLanguages>;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/features/horizontalRule/server/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../../../src/features/horizontalRule/server/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE,eAAO,MAAM,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAiG1C,CAAA"}

package/dist/features/horizontalRule/server/i18n.js

@@ -0,0 +1,99 @@
+export const i18n = {
+  ar: {
+    label: 'القاعدة الأفقية'
+  },
+  az: {
+    label: 'Üfüqi Xətt'
+  },
+  bg: {
+    label: 'Хоризонтална линия'
+  },
+  cs: {
+    label: 'Vodorovný pravítko'
+  },
+  de: {
+    label: 'Trennlinie'
+  },
+  en: {
+    label: 'Horizontal Rule'
+  },
+  es: {
+    label: 'Regla Horizontal'
+  },
+  fa: {
+    label: 'قاعده افقی'
+  },
+  fr: {
+    label: 'Règle horizontale'
+  },
+  he: {
+    label: 'קו אופקי'
+  },
+  hr: {
+    label: 'Vodoravna linija'
+  },
+  hu: {
+    label: 'Vízszintes vonal'
+  },
+  it: {
+    label: 'Regola Orizzontale'
+  },
+  ja: {
+    label: '水平線'
+  },
+  ko: {
+    label: '수평 규칙'
+  },
+  my: {
+    label: 'Peraturan Mendatar'
+  },
+  nb: {
+    label: 'Horisontal Regel'
+  },
+  nl: {
+    label: 'Horizontale Regel'
+  },
+  pl: {
+    label: 'Pozioma Linia'
+  },
+  pt: {
+    label: 'Regra Horizontal'
+  },
+  ro: {
+    label: 'Linie orizontală'
+  },
+  rs: {
+    label: 'Horizontalna linija'
+  },
+  'rs-latin': {
+    label: 'Horizontalna linija'
+  },
+  ru: {
+    label: 'Горизонтальная линия'
+  },
+  sk: {
+    label: 'Vodorovná čiara'
+  },
+  sv: {
+    label: 'Horisontell linje'
+  },
+  th: {
+    label: 'กฎขีดตรง'
+  },
+  tr: {
+    label: 'Yatay Çizgi'
+  },
+  uk: {
+    label: 'Горизонтальна лінія'
+  },
+  vi: {
+    label: 'Quy tắc ngang'
+  },
+  zh: {
+    label: '水平线'
+  },
+  'zh-TW': {
+    label: '水平線'
+  }
+};
+//# sourceMappingURL=i18n.js.map

package/dist/features/horizontalRule/server/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.js","names":["i18n","ar","label","az","bg","cs","de","en","es","fa","fr","he","hr","hu","it","ja","ko","my","nb","nl","pl","pt","ro","rs","ru","sk","sv","th","tr","uk","vi","zh"],"sources":["../../../../src/features/horizontalRule/server/i18n.ts"],"sourcesContent":["import type { GenericLanguages } from '@payloadcms/translations'\n\nexport const i18n: Partial<GenericLanguages> = {\n  ar: {\n    label: 'القاعدة الأفقية',\n  },\n  az: {\n    label: 'Üfüqi Xətt',\n  },\n  bg: {\n    label: 'Хоризонтална линия',\n  },\n  cs: {\n    label: 'Vodorovný pravítko',\n  },\n  de: {\n    label: 'Trennlinie',\n  },\n  en: {\n    label: 'Horizontal Rule',\n  },\n  es: {\n    label: 'Regla Horizontal',\n  },\n  fa: {\n    label: 'قاعده افقی',\n  },\n  fr: {\n    label: 'Règle horizontale',\n  },\n  he: {\n    label: 'קו אופקי',\n  },\n  hr: {\n    label: 'Vodoravna linija',\n  },\n  hu: {\n    label: 'Vízszintes vonal',\n  },\n  it: {\n    label: 'Regola Orizzontale',\n  },\n  ja: {\n    label: '水平線',\n  },\n  ko: {\n    label: '수평 규칙',\n  },\n  my: {\n    label: 'Peraturan Mendatar',\n  },\n  nb: {\n    label: 'Horisontal Regel',\n  },\n  nl: {\n    label: 'Horizontale Regel',\n  },\n  pl: {\n    label: 'Pozioma Linia',\n  },\n  pt: {\n    label: 'Regra Horizontal',\n  },\n  ro: {\n    label: 'Linie orizontală',\n  },\n  rs: {\n    label: 'Horizontalna linija',\n  },\n  'rs-latin': {\n    label: 'Horizontalna linija',\n  },\n  ru: {\n    label: 'Горизонтальная линия',\n  },\n  sk: {\n    label: 'Vodorovná čiara',\n  },\n  sv: {\n    label: 'Horisontell linje',\n  },\n  th: {\n    label: 'กฎขีดตรง',\n  },\n  tr: {\n    label: 'Yatay Çizgi',\n  },\n  uk: {\n    label: 'Горизонтальна лінія',\n  },\n  vi: {\n    label: 'Quy tắc ngang',\n  },\n  zh: {\n    label: '水平线',\n  },\n  'zh-TW': {\n    label: '水平線',\n  },\n}\n"],"mappings":"AAEA,OAAO,MAAMA,IAAA,GAAkC;EAC7CC,EAAA,EAAI;IACFC,KAAA,EAAO;EACT;EACAC,EAAA,EAAI;IACFD,KAAA,EAAO;EACT;EACAE,EAAA,EAAI;IACFF,KAAA,EAAO;EACT;EACAG,EAAA,EAAI;IACFH,KAAA,EAAO;EACT;EACAI,EAAA,EAAI;IACFJ,KAAA,EAAO;EACT;EACAK,EAAA,EAAI;IACFL,KAAA,EAAO;EACT;EACAM,EAAA,EAAI;IACFN,KAAA,EAAO;EACT;EACAO,EAAA,EAAI;IACFP,KAAA,EAAO;EACT;EACAQ,EAAA,EAAI;IACFR,KAAA,EAAO;EACT;EACAS,EAAA,EAAI;IACFT,KAAA,EAAO;EACT;EACAU,EAAA,EAAI;IACFV,KAAA,EAAO;EACT;EACAW,EAAA,EAAI;IACFX,KAAA,EAAO;EACT;EACAY,EAAA,EAAI;IACFZ,KAAA,EAAO;EACT;EACAa,EAAA,EAAI;IACFb,KAAA,EAAO;EACT;EACAc,EAAA,EAAI;IACFd,KAAA,EAAO;EACT;EACAe,EAAA,EAAI;IACFf,KAAA,EAAO;EACT;EACAgB,EAAA,EAAI;IACFhB,KAAA,EAAO;EACT;EACAiB,EAAA,EAAI;IACFjB,KAAA,EAAO;EACT;EACAkB,EAAA,EAAI;IACFlB,KAAA,EAAO;EACT;EACAmB,EAAA,EAAI;IACFnB,KAAA,EAAO;EACT;EACAoB,EAAA,EAAI;IACFpB,KAAA,EAAO;EACT;EACAqB,EAAA,EAAI;IACFrB,KAAA,EAAO;EACT;EACA,YAAY;IACVA,KAAA,EAAO;EACT;EACAsB,EAAA,EAAI;IACFtB,KAAA,EAAO;EACT;EACAuB,EAAA,EAAI;IACFvB,KAAA,EAAO;EACT;EACAwB,EAAA,EAAI;IACFxB,KAAA,EAAO;EACT;EACAyB,EAAA,EAAI;IACFzB,KAAA,EAAO;EACT;EACA0B,EAAA,EAAI;IACF1B,KAAA,EAAO;EACT;EACA2B,EAAA,EAAI;IACF3B,KAAA,EAAO;EACT;EACA4B,EAAA,EAAI;IACF5B,KAAA,EAAO;EACT;EACA6B,EAAA,EAAI;IACF7B,KAAA,EAAO;EACT;EACA,SAAS;IACPA,KAAA,EAAO;EACT;AACF","ignoreList":[]}

package/dist/features/horizontalRule/server/index.d.ts

@@ -0,0 +1,2 @@
+export declare const HorizontalRuleFeature: import("../../typesServer.js").FeatureProviderProviderServer<undefined, undefined, undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/horizontalRule/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/horizontalRule/server/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,qBAAqB,+FAoBhC,CAAA"}

package/dist/features/horizontalRule/server/index.js

@@ -0,0 +1,25 @@
+import { createServerFeature } from '../../../utilities/createServerFeature.js';
+import { createNode } from '../../typeUtilities.js';
+import { i18n } from './i18n.js';
+import { MarkdownTransformer } from './markdownTransformer.js';
+import { HorizontalRuleServerNode } from './nodes/HorizontalRuleNode.js';
+export const HorizontalRuleFeature = createServerFeature({
+  feature: {
+    ClientFeature: '@payloadcms/richtext-lexical/client#HorizontalRuleFeatureClient',
+    i18n,
+    markdownTransformers: [MarkdownTransformer],
+    nodes: [createNode({
+      converters: {
+        html: {
+          converter: () => {
+            return `<hr/>`;
+          },
+          nodeTypes: [HorizontalRuleServerNode.getType()]
+        }
+      },
+      node: HorizontalRuleServerNode
+    })]
+  },
+  key: 'horizontalRule'
+});
+//# sourceMappingURL=index.js.map

package/dist/features/horizontalRule/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createServerFeature","createNode","i18n","MarkdownTransformer","HorizontalRuleServerNode","HorizontalRuleFeature","feature","ClientFeature","markdownTransformers","nodes","converters","html","converter","nodeTypes","getType","node","key"],"sources":["../../../../src/features/horizontalRule/server/index.ts"],"sourcesContent":["import { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { createNode } from '../../typeUtilities.js'\nimport { i18n } from './i18n.js'\nimport { MarkdownTransformer } from './markdownTransformer.js'\nimport { HorizontalRuleServerNode } from './nodes/HorizontalRuleNode.js'\n\nexport const HorizontalRuleFeature = createServerFeature({\n  feature: {\n    ClientFeature: '@payloadcms/richtext-lexical/client#HorizontalRuleFeatureClient',\n    i18n,\n    markdownTransformers: [MarkdownTransformer],\n    nodes: [\n      createNode({\n        converters: {\n          html: {\n            converter: () => {\n              return `<hr/>`\n            },\n            nodeTypes: [HorizontalRuleServerNode.getType()],\n          },\n        },\n        node: HorizontalRuleServerNode,\n      }),\n    ],\n  },\n  key: 'horizontalRule',\n})\n"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,UAAU,QAAQ;AAC3B,SAASC,IAAI,QAAQ;AACrB,SAASC,mBAAmB,QAAQ;AACpC,SAASC,wBAAwB,QAAQ;AAEzC,OAAO,MAAMC,qBAAA,GAAwBL,mBAAA,CAAoB;EACvDM,OAAA,EAAS;IACPC,aAAA,EAAe;IACfL,IAAA;IACAM,oBAAA,EAAsB,CAACL,mBAAA,CAAoB;IAC3CM,KAAA,EAAO,CACLR,UAAA,CAAW;MACTS,UAAA,EAAY;QACVC,IAAA,EAAM;UACJC,SAAA,EAAWA,CAAA;YACT,OAAO,OAAO;UAChB;UACAC,SAAA,EAAW,CAACT,wBAAA,CAAyBU,OAAO;QAC9C;MACF;MACAC,IAAA,EAAMX;IACR;EAEJ;EACAY,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/horizontalRule/server/markdownTransformer.d.ts

@@ -0,0 +1,3 @@
+import type { ElementTransformer } from '@lexical/markdown';
+export declare const MarkdownTransformer: ElementTransformer;
+//# sourceMappingURL=markdownTransformer.d.ts.map

package/dist/features/horizontalRule/server/markdownTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../src/features/horizontalRule/server/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAQ3D,eAAO,MAAM,mBAAmB,EAAE,kBAiBjC,CAAA"}

package/dist/features/horizontalRule/server/markdownTransformer.js

@@ -0,0 +1,20 @@
+import { $createHorizontalRuleServerNode, $isHorizontalRuleServerNode, HorizontalRuleServerNode } from './nodes/HorizontalRuleNode.js';
+export const MarkdownTransformer = {
+  type: 'element',
+  dependencies: [HorizontalRuleServerNode],
+  export: (node, exportChildren) => {
+    if (!$isHorizontalRuleServerNode(node)) {
+      return null;
+    }
+    return '---';
+  },
+  // match ---
+  regExp: /^---\s*$/,
+  replace: parentNode => {
+    const node = $createHorizontalRuleServerNode();
+    if (node) {
+      parentNode.replace(node);
+    }
+  }
+};
+//# sourceMappingURL=markdownTransformer.js.map

package/dist/features/horizontalRule/server/markdownTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.js","names":["$createHorizontalRuleServerNode","$isHorizontalRuleServerNode","HorizontalRuleServerNode","MarkdownTransformer","type","dependencies","export","node","exportChildren","regExp","replace","parentNode"],"sources":["../../../../src/features/horizontalRule/server/markdownTransformer.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\n\nimport {\n  $createHorizontalRuleServerNode,\n  $isHorizontalRuleServerNode,\n  HorizontalRuleServerNode,\n} from './nodes/HorizontalRuleNode.js'\n\nexport const MarkdownTransformer: ElementTransformer = {\n  type: 'element',\n  dependencies: [HorizontalRuleServerNode],\n  export: (node, exportChildren) => {\n    if (!$isHorizontalRuleServerNode(node)) {\n      return null\n    }\n    return '---'\n  },\n  // match ---\n  regExp: /^---\\s*$/,\n  replace: (parentNode) => {\n    const node = $createHorizontalRuleServerNode()\n    if (node) {\n      parentNode.replace(node)\n    }\n  },\n}\n"],"mappings":"AAEA,SACEA,+BAA+B,EAC/BC,2BAA2B,EAC3BC,wBAAwB,QACnB;AAEP,OAAO,MAAMC,mBAAA,GAA0C;EACrDC,IAAA,EAAM;EACNC,YAAA,EAAc,CAACH,wBAAA,CAAyB;EACxCI,MAAA,EAAQA,CAACC,IAAA,EAAMC,cAAA;IACb,IAAI,CAACP,2BAAA,CAA4BM,IAAA,GAAO;MACtC,OAAO;IACT;IACA,OAAO;EACT;EACA;EACAE,MAAA,EAAQ;EACRC,OAAA,EAAUC,UAAA;IACR,MAAMJ,IAAA,GAAOP,+BAAA;IACb,IAAIO,IAAA,EAAM;MACRI,UAAA,CAAWD,OAAO,CAACH,IAAA;IACrB;EACF;AACF","ignoreList":[]}

package/dist/features/horizontalRule/server/nodes/HorizontalRuleNode.d.ts

@@ -0,0 +1,53 @@
+import type { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalCommand, LexicalNode, SerializedLexicalNode, Spread } from 'lexical';
+import type * as React from 'react';
+import { DecoratorNode } from 'lexical';
+/**
+ * Serialized representation of a horizontal rule node. Serialized = converted to JSON. This is what is stored in the database / in the lexical editor state.
+ */
+export type SerializedHorizontalRuleNode = Spread<{
+    children?: never;
+    type: 'horizontalrule';
+}, SerializedLexicalNode>;
+export declare const INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;
+/**
+ * This node is a DecoratorNode. DecoratorNodes allow you to render React components in the editor.
+ *
+ * They need both createDom and decorate functions. createDom => outside of the html. decorate => React Component inside of the html.
+ *
+ * If we used DecoratorBlockNode instead, we would only need a decorate method
+ */
+export declare class HorizontalRuleServerNode extends DecoratorNode<null | React.ReactElement> {
+    static clone(node: HorizontalRuleServerNode): HorizontalRuleServerNode;
+    static getType(): string;
+    /**
+     * Defines what happens if you copy an hr element from another page and paste it into the lexical editor
+     *
+     * This also determines the behavior of lexical's internal HTML -> Lexical converter
+     */
+    static importDOM(): DOMConversionMap | null;
+    /**
+     * The data for this node is stored serialized as JSON. This is the "load function" of that node: it takes the saved data and converts it into a node.
+     */
+    static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleServerNode;
+    /**
+     * Determines how the hr element is rendered in the lexical editor. This is only the "initial" / "outer" HTML element.
+     */
+    createDOM(config: EditorConfig): HTMLElement;
+    decorate(): null | React.ReactElement;
+    /**
+     * Opposite of importDOM, this function defines what happens when you copy an hr element from the lexical editor and paste it into another page.
+     *
+     * This also determines the behavior of lexical's internal Lexical -> HTML converter
+     */
+    exportDOM(): DOMExportOutput;
+    /**
+     * Opposite of importJSON. This determines what data is saved in the database / in the lexical editor state.
+     */
+    exportJSON(): SerializedLexicalNode;
+    getTextContent(): string;
+    isInline(): false;
+    updateDOM(): boolean;
+}
+export declare function $createHorizontalRuleServerNode(): HorizontalRuleServerNode;
+export declare function $isHorizontalRuleServerNode(node: LexicalNode | null | undefined): node is HorizontalRuleServerNode;
+//# sourceMappingURL=HorizontalRuleNode.d.ts.map

package/dist/features/horizontalRule/server/nodes/HorizontalRuleNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HorizontalRuleNode.d.ts","sourceRoot":"","sources":["../../../../../src/features/horizontalRule/server/nodes/HorizontalRuleNode.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEhB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,WAAW,EACX,qBAAqB,EACrB,MAAM,EACP,MAAM,SAAS,CAAA;AAChB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAGnC,OAAO,EAAwC,aAAa,EAAE,MAAM,SAAS,CAAA;AAE7E;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,MAAM,CAC/C;IACE,QAAQ,CAAC,EAAE,KAAK,CAAA;IAChB,IAAI,EAAE,gBAAgB,CAAA;CACvB,EACD,qBAAqB,CACtB,CAAA;AAED,eAAO,MAAM,8BAA8B,EAAE,cAAc,CAAC,IAAI,CAE/D,CAAA;AAED;;;;;;GAMG;AACH,qBAAa,wBAAyB,SAAQ,aAAa,CAAC,IAAI,GAAG,KAAK,CAAC,YAAY,CAAC;IACpF,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,wBAAwB,GAAG,wBAAwB;IAItE,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB;;;;OAIG;IACH,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAS3C;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,4BAA4B,GAAG,wBAAwB;IAIzF;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,QAAQ,IAAI,IAAI,GAAG,KAAK,CAAC,YAAY;IAIrC;;;;OAIG;IACH,SAAS,IAAI,eAAe;IAG5B;;OAEG;IACH,UAAU,IAAI,qBAAqB;IAOnC,cAAc,IAAI,MAAM;IAIxB,QAAQ,IAAI,KAAK;IAIjB,SAAS,IAAI,OAAO;CAGrB;AAMD,wBAAgB,+BAA+B,IAAI,wBAAwB,CAE1E;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,wBAAwB,CAElC"}