@payloadcms/richtext-lexical 3.0.0-beta.6 → 3.0.0-beta.9

package/dist/field/features/horizontalrule/component/index.d.ts

@@ -0,0 +1,10 @@
+import type { NodeKey } from 'lexical';
+/**
+ * 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 declare function HorizontalRuleComponent({ nodeKey }: {
+    nodeKey: NodeKey;
+}): any;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/horizontalrule/component/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/horizontalrule/component/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAqBtC;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,OAmDxE"}

package/dist/field/features/horizontalrule/component/index.js

@@ -0,0 +1,64 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection.js';
+import lexicalUtilsImport from '@lexical/utils';
+const { mergeRegister } = lexicalUtilsImport;
+import lexicalImport from 'lexical';
+const { $getNodeByKey, $getSelection, $isNodeSelection, CLICK_COMMAND, COMMAND_PRIORITY_LOW, KEY_BACKSPACE_COMMAND, KEY_DELETE_COMMAND } = lexicalImport;
+import { useCallback, useEffect } from 'react';
+import { $isHorizontalRuleNode } from '../nodes/HorizontalRuleNode.js';
+/**
+ * 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({ nodeKey }) {
+    const [editor] = useLexicalComposerContext();
+    const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey);
+    const onDelete = useCallback((event)=>{
+        if (isSelected && $isNodeSelection($getSelection())) {
+            event.preventDefault();
+            const node = $getNodeByKey(nodeKey);
+            if ($isHorizontalRuleNode(node)) {
+                node.remove();
+                return true;
+            }
+        }
+        return false;
+    }, [
+        isSelected,
+        nodeKey
+    ]);
+    useEffect(()=>{
+        return mergeRegister(editor.registerCommand(CLICK_COMMAND, (event)=>{
+            const hrElem = editor.getElementByKey(nodeKey);
+            if (event.target === hrElem) {
+                if (!event.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));
+    }, [
+        clearSelection,
+        editor,
+        isSelected,
+        nodeKey,
+        onDelete,
+        setSelected
+    ]);
+    useEffect(()=>{
+        const hrElem = editor.getElementByKey(nodeKey);
+        if (hrElem !== null) {
+            hrElem.className = isSelected ? 'selected' : '';
+        }
+    }, [
+        editor,
+        isSelected,
+        nodeKey
+    ]);
+    return null;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/field/features/horizontalrule/component/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/horizontalrule/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 lexicalUtilsImport from '@lexical/utils'\nconst { mergeRegister } = lexicalUtilsImport\n\nimport lexicalImport from 'lexical'\nconst {\n  $getNodeByKey,\n  $getSelection,\n  $isNodeSelection,\n  CLICK_COMMAND,\n  COMMAND_PRIORITY_LOW,\n  KEY_BACKSPACE_COMMAND,\n  KEY_DELETE_COMMAND,\n} = lexicalImport\nimport { useCallback, useEffect } from 'react'\n\nimport { $isHorizontalRuleNode } from '../nodes/HorizontalRuleNode.js'\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      if (isSelected && $isNodeSelection($getSelection())) {\n        event.preventDefault()\n        const node = $getNodeByKey(nodeKey)\n        if ($isHorizontalRuleNode(node)) {\n          node.remove()\n          return true\n        }\n      }\n      return false\n    },\n    [isSelected, nodeKey],\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      hrElem.className = isSelected ? 'selected' : ''\n    }\n  }, [editor, isSelected, nodeKey])\n\n  return null\n}\n"],"names":["useLexicalComposerContext","useLexicalNodeSelection","lexicalUtilsImport","mergeRegister","lexicalImport","$getNodeByKey","$getSelection","$isNodeSelection","CLICK_COMMAND","COMMAND_PRIORITY_LOW","KEY_BACKSPACE_COMMAND","KEY_DELETE_COMMAND","useCallback","useEffect","$isHorizontalRuleNode","HorizontalRuleComponent","nodeKey","editor","isSelected","setSelected","clearSelection","onDelete","event","preventDefault","node","remove","registerCommand","hrElem","getElementByKey","target","shiftKey","className"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,uBAAuB,QAAQ,4CAA2C;AACnF,OAAOC,wBAAwB,iBAAgB;AAC/C,MAAM,EAAEC,aAAa,EAAE,GAAGD;AAE1B,OAAOE,mBAAmB,UAAS;AACnC,MAAM,EACJC,aAAa,EACbC,aAAa,EACbC,gBAAgB,EAChBC,aAAa,EACbC,oBAAoB,EACpBC,qBAAqB,EACrBC,kBAAkB,EACnB,GAAGP;AACJ,SAASQ,WAAW,EAAEC,SAAS,QAAQ,QAAO;AAE9C,SAASC,qBAAqB,QAAQ,iCAAgC;AAEtE;;;;CAIC,GACD,OAAO,SAASC,wBAAwB,EAAEC,OAAO,EAAwB;IACvE,MAAM,CAACC,OAAO,GAAGjB;IACjB,MAAM,CAACkB,YAAYC,aAAaC,eAAe,GAAGnB,wBAAwBe;IAE1E,MAAMK,WAAWT,YACf,CAACU;QACC,IAAIJ,cAAcX,iBAAiBD,kBAAkB;YACnDgB,MAAMC,cAAc;YACpB,MAAMC,OAAOnB,cAAcW;YAC3B,IAAIF,sBAAsBU,OAAO;gBAC/BA,KAAKC,MAAM;gBACX,OAAO;YACT;QACF;QACA,OAAO;IACT,GACA;QAACP;QAAYF;KAAQ;IAGvBH,UAAU;QACR,OAAOV,cACLc,OAAOS,eAAe,CACpBlB,eACA,CAACc;YACC,MAAMK,SAASV,OAAOW,eAAe,CAACZ;YAEtC,IAAIM,MAAMO,MAAM,KAAKF,QAAQ;gBAC3B,IAAI,CAACL,MAAMQ,QAAQ,EAAE;oBACnBV;gBACF;gBACAD,YAAY,CAACD;gBACb,OAAO;YACT;YAEA,OAAO;QACT,GACAT,uBAEFQ,OAAOS,eAAe,CAACf,oBAAoBU,UAAUZ,uBACrDQ,OAAOS,eAAe,CAAChB,uBAAuBW,UAAUZ;IAE5D,GAAG;QAACW;QAAgBH;QAAQC;QAAYF;QAASK;QAAUF;KAAY;IAEvEN,UAAU;QACR,MAAMc,SAASV,OAAOW,eAAe,CAACZ;QACtC,IAAIW,WAAW,MAAM;YACnBA,OAAOI,SAAS,GAAGb,aAAa,aAAa;QAC/C;IACF,GAAG;QAACD;QAAQC;QAAYF;KAAQ;IAEhC,OAAO;AACT"}

package/dist/field/features/horizontalrule/feature.client.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" resolution-mode="require"/>
+export declare const HorizontalRuleFeatureClientComponent: import("react").FC<undefined>;
+//# sourceMappingURL=feature.client.d.ts.map

package/dist/field/features/horizontalrule/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/field/features/horizontalrule/feature.client.tsx"],"names":[],"mappings":";AA8CA,eAAO,MAAM,oCAAoC,+BAEhD,CAAA"}

package/dist/field/features/horizontalrule/feature.client.js

@@ -0,0 +1,53 @@
+'use client';
+import { SlashMenuOption } from '../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js';
+import { HorizontalRuleIcon } from '../../lexical/ui/icons/HorizontalRule/index.js';
+import { createClientComponent } from '../createClientComponent.js';
+import { MarkdownTransformer } from './markdownTransformer.js';
+import { HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from './nodes/HorizontalRuleNode.js';
+import { HorizontalRulePlugin } from './plugin/index.js';
+const HorizontalRuleFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                markdownTransformers: [
+                    MarkdownTransformer
+                ],
+                nodes: [
+                    HorizontalRuleNode
+                ],
+                plugins: [
+                    {
+                        Component: HorizontalRulePlugin,
+                        position: 'normal'
+                    }
+                ],
+                slashMenu: {
+                    options: [
+                        {
+                            displayName: 'Basic',
+                            key: 'basic',
+                            options: [
+                                new SlashMenuOption(`horizontalrule`, {
+                                    Icon: HorizontalRuleIcon,
+                                    displayName: `Horizontal Rule`,
+                                    keywords: [
+                                        'hr',
+                                        'horizontal rule',
+                                        'line',
+                                        'separator'
+                                    ],
+                                    onSelect: ({ editor })=>{
+                                        editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined);
+                                    }
+                                })
+                            ]
+                        }
+                    ]
+                }
+            })
+    };
+};
+export const HorizontalRuleFeatureClientComponent = createClientComponent(HorizontalRuleFeatureClient);
+
+//# sourceMappingURL=feature.client.js.map

package/dist/field/features/horizontalrule/feature.client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/field/features/horizontalrule/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../types.js'\n\nimport { SlashMenuOption } from '../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nimport { HorizontalRuleIcon } from '../../lexical/ui/icons/HorizontalRule/index.js'\nimport { createClientComponent } from '../createClientComponent.js'\nimport { MarkdownTransformer } from './markdownTransformer.js'\nimport { HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from './nodes/HorizontalRuleNode.js'\nimport { HorizontalRulePlugin } from './plugin/index.js'\n\nconst HorizontalRuleFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => ({\n      clientFeatureProps: props,\n      markdownTransformers: [MarkdownTransformer],\n      nodes: [HorizontalRuleNode],\n      plugins: [\n        {\n          Component: HorizontalRulePlugin,\n          position: 'normal',\n        },\n      ],\n      slashMenu: {\n        options: [\n          {\n            displayName: 'Basic',\n            key: 'basic',\n            options: [\n              new SlashMenuOption(`horizontalrule`, {\n                Icon: HorizontalRuleIcon,\n                displayName: `Horizontal Rule`,\n                keywords: ['hr', 'horizontal rule', 'line', 'separator'],\n                onSelect: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined)\n                },\n              }),\n            ],\n          },\n        ],\n      },\n    }),\n  }\n}\n\nexport const HorizontalRuleFeatureClientComponent = createClientComponent(\n  HorizontalRuleFeatureClient,\n)\n"],"names":["SlashMenuOption","HorizontalRuleIcon","createClientComponent","MarkdownTransformer","HorizontalRuleNode","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRulePlugin","HorizontalRuleFeatureClient","props","clientFeatureProps","feature","markdownTransformers","nodes","plugins","Component","position","slashMenu","options","displayName","key","Icon","keywords","onSelect","editor","dispatchCommand","undefined","HorizontalRuleFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,SAASA,eAAe,QAAQ,sEAAqE;AACrG,SAASC,kBAAkB,QAAQ,iDAAgD;AACnF,SAASC,qBAAqB,QAAQ,8BAA6B;AACnE,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,kBAAkB,EAAEC,8BAA8B,QAAQ,gCAA+B;AAClG,SAASC,oBAAoB,QAAQ,oBAAmB;AAExD,MAAMC,8BAAwE,CAACC;IAC7E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,IAAO,CAAA;gBACdD,oBAAoBD;gBACpBG,sBAAsB;oBAACR;iBAAoB;gBAC3CS,OAAO;oBAACR;iBAAmB;gBAC3BS,SAAS;oBACP;wBACEC,WAAWR;wBACXS,UAAU;oBACZ;iBACD;gBACDC,WAAW;oBACTC,SAAS;wBACP;4BACEC,aAAa;4BACbC,KAAK;4BACLF,SAAS;gCACP,IAAIjB,gBAAgB,CAAC,cAAc,CAAC,EAAE;oCACpCoB,MAAMnB;oCACNiB,aAAa,CAAC,eAAe,CAAC;oCAC9BG,UAAU;wCAAC;wCAAM;wCAAmB;wCAAQ;qCAAY;oCACxDC,UAAU,CAAC,EAAEC,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAACnB,gCAAgCoB;oCACzD;gCACF;6BACD;wBACH;qBACD;gBACH;YACF,CAAA;IACF;AACF;AAEA,OAAO,MAAMC,uCAAuCxB,sBAClDK,6BACD"}

package/dist/field/features/horizontalrule/feature.server.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureProviderProviderServer } from '../types.js';
+export declare const HorizontalRuleFeature: FeatureProviderProviderServer<undefined, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

package/dist/field/features/horizontalrule/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/horizontalrule/feature.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAOhE,eAAO,MAAM,qBAAqB,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CA4BrF,CAAA"}

package/dist/field/features/horizontalrule/feature.server.js

@@ -0,0 +1,36 @@
+import { HorizontalRuleFeatureClientComponent } from './feature.client.js';
+import { MarkdownTransformer } from './markdownTransformer.js';
+import { HorizontalRuleNode } from './nodes/HorizontalRuleNode.js';
+export const HorizontalRuleFeature = (props)=>{
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: HorizontalRuleFeatureClientComponent,
+                clientFeatureProps: null,
+                markdownTransformers: [
+                    MarkdownTransformer
+                ],
+                nodes: [
+                    {
+                        converters: {
+                            html: {
+                                converter: ()=>{
+                                    return `<hr/>`;
+                                },
+                                nodeTypes: [
+                                    HorizontalRuleNode.getType()
+                                ]
+                            }
+                        },
+                        node: HorizontalRuleNode
+                    }
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'horizontalrule',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=feature.server.js.map

package/dist/field/features/horizontalrule/feature.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/field/features/horizontalrule/feature.server.ts"],"sourcesContent":["import type { HTMLConverter } from '../converters/html/converter/types.js'\nimport type { FeatureProviderProviderServer } from '../types.js'\nimport type { SerializedHorizontalRuleNode } from './nodes/HorizontalRuleNode.js'\n\nimport { HorizontalRuleFeatureClientComponent } from './feature.client.js'\nimport { MarkdownTransformer } from './markdownTransformer.js'\nimport { HorizontalRuleNode } from './nodes/HorizontalRuleNode.js'\n\nexport const HorizontalRuleFeature: FeatureProviderProviderServer<undefined, undefined> = (\n  props,\n) => {\n  return {\n    feature: () => {\n      return {\n        ClientComponent: HorizontalRuleFeatureClientComponent,\n        clientFeatureProps: null,\n        markdownTransformers: [MarkdownTransformer],\n        nodes: [\n          {\n            converters: {\n              html: {\n                converter: () => {\n                  return `<hr/>`\n                },\n                nodeTypes: [HorizontalRuleNode.getType()],\n              } as HTMLConverter<SerializedHorizontalRuleNode>,\n            },\n            node: HorizontalRuleNode,\n          },\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'horizontalrule',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["HorizontalRuleFeatureClientComponent","MarkdownTransformer","HorizontalRuleNode","HorizontalRuleFeature","props","feature","ClientComponent","clientFeatureProps","markdownTransformers","nodes","converters","html","converter","nodeTypes","getType","node","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,oCAAoC,QAAQ,sBAAqB;AAC1E,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,kBAAkB,QAAQ,gCAA+B;AAElE,OAAO,MAAMC,wBAA6E,CACxFC;IAEA,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBN;gBACjBO,oBAAoB;gBACpBC,sBAAsB;oBAACP;iBAAoB;gBAC3CQ,OAAO;oBACL;wBACEC,YAAY;4BACVC,MAAM;gCACJC,WAAW;oCACT,OAAO,CAAC,KAAK,CAAC;gCAChB;gCACAC,WAAW;oCAACX,mBAAmBY,OAAO;iCAAG;4BAC3C;wBACF;wBACAC,MAAMb;oBACR;iBACD;gBACDc,oBAAoBZ;YACtB;QACF;QACAa,KAAK;QACLD,oBAAoBZ;IACtB;AACF,EAAC"}

package/dist/field/features/horizontalrule/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/field/features/horizontalrule/markdownTransformer.d.ts.map

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

package/dist/field/features/horizontalrule/markdownTransformer.js

@@ -0,0 +1,23 @@
+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/field/features/horizontalrule/markdownTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/field/features/horizontalrule/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"],"names":["$createHorizontalRuleNode","$isHorizontalRuleNode","HorizontalRuleNode","MarkdownTransformer","type","dependencies","export","node","exportChildren","regExp","replace","parentNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SACEA,yBAAyB,EACzBC,qBAAqB,EACrBC,kBAAkB,QACb,gCAA+B;AAEtC,OAAO,MAAMC,sBAA0C;IACrDC,MAAM;IACNC,cAAc;QAACH;KAAmB;IAClCI,QAAQ,CAACC,MAAMC;QACb,IAAI,CAACP,sBAAsBM,OAAO;YAChC,OAAO;QACT;QACA,OAAO;IACT;IACA,YAAY;IACZE,QAAQ;IACRC,SAAS,CAACC;QACR,MAAMJ,OAAOP;QACb,IAAIO,MAAM;YACRI,WAAWD,OAAO,CAACH;QACrB;IACF;AACF,EAAC"}

package/dist/field/features/horizontalrule/nodes/HorizontalRuleNode.d.ts

@@ -0,0 +1,55 @@
+import type { DOMConversionMap, DOMExportOutput, LexicalCommand, LexicalNode, SerializedLexicalNode } from 'lexical';
+import lexicalImport from 'lexical';
+declare const DecoratorNode: typeof lexicalImport.DecoratorNode;
+import * as React from 'react';
+/**
+ * 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 = 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 HorizontalRuleNode extends DecoratorNode<React.ReactElement> {
+    static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+    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): HorizontalRuleNode;
+    /**
+     * Determines how the hr element is rendered in the lexical editor. This is only the "initial" / "outer" HTML element.
+     */
+    createDOM(): HTMLElement;
+    /**
+     * Allows you to render a React component within whatever createDOM returns.
+     */
+    decorate(): 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 $createHorizontalRuleNode(): HorizontalRuleNode;
+export declare function $isHorizontalRuleNode(node: LexicalNode | null | undefined): node is HorizontalRuleNode;
+export {};
+//# sourceMappingURL=HorizontalRuleNode.d.ts.map

package/dist/field/features/horizontalrule/nodes/HorizontalRuleNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HorizontalRuleNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/horizontalrule/nodes/HorizontalRuleNode.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEhB,eAAe,EACf,cAAc,EACd,WAAW,EACX,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAEhB,OAAO,aAAa,MAAM,SAAS,CAAA;AACnC,QAAA,MAA+B,aAAa,oCAAiC,CAAA;AAC7E,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,qBAAqB,CAAA;AAEhE,eAAO,MAAM,8BAA8B,EAAE,cAAc,CAAC,IAAI,CAE/D,CAAA;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC;IACvE,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,kBAAkB,GAAG,kBAAkB;IAI1D,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,kBAAkB;IAInF;;OAEG;IACH,SAAS,IAAI,WAAW;IAIxB;;OAEG;IACH,QAAQ,IAAI,KAAK,CAAC,YAAY;IAI9B;;;;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,yBAAyB,IAAI,kBAAkB,CAE9D;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,kBAAkB,CAE5B"}

package/dist/field/features/horizontalrule/nodes/HorizontalRuleNode.js

@@ -0,0 +1,89 @@
+import lexicalImport from 'lexical';
+const { $applyNodeReplacement, DecoratorNode, createCommand } = lexicalImport;
+import * as React from 'react';
+const HorizontalRuleComponent = /*#__PURE__*/ React.lazy(()=>import('../component/index.js').then((module)=>({
+            default: module.HorizontalRuleComponent
+        })));
+export const INSERT_HORIZONTAL_RULE_COMMAND = createCommand('INSERT_HORIZONTAL_RULE_COMMAND');
+/**
+ * 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 class HorizontalRuleNode extends DecoratorNode {
+    static clone(node) {
+        return new HorizontalRuleNode(node.__key);
+    }
+    static getType() {
+        return 'horizontalrule';
+    }
+    /**
+   * 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() {
+        return {
+            hr: ()=>({
+                    conversion: convertHorizontalRuleElement,
+                    priority: 0
+                })
+        };
+    }
+    /**
+   * 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();
+    }
+    /**
+   * Determines how the hr element is rendered in the lexical editor. This is only the "initial" / "outer" HTML element.
+   */ createDOM() {
+        return document.createElement('hr');
+    }
+    /**
+   * Allows you to render a React component within whatever createDOM returns.
+   */ decorate() {
+        return /*#__PURE__*/ React.createElement(HorizontalRuleComponent, {
+            nodeKey: this.__key
+        });
+    }
+    /**
+   * 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() {
+        return {
+            element: document.createElement('hr')
+        };
+    }
+    /**
+   * Opposite of importJSON. This determines what data is saved in the database / in the lexical editor state.
+   */ exportJSON() {
+        return {
+            type: 'horizontalrule',
+            version: 1
+        };
+    }
+    getTextContent() {
+        return '\n';
+    }
+    isInline() {
+        return false;
+    }
+    updateDOM() {
+        return false;
+    }
+}
+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/field/features/horizontalrule/nodes/HorizontalRuleNode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/horizontalrule/nodes/HorizontalRuleNode.tsx"],"sourcesContent":["import type {\n  DOMConversionMap,\n  DOMConversionOutput,\n  DOMExportOutput,\n  LexicalCommand,\n  LexicalNode,\n  SerializedLexicalNode,\n} from 'lexical'\n\nimport lexicalImport from 'lexical'\nconst { $applyNodeReplacement, DecoratorNode, createCommand } = lexicalImport\nimport * as React from 'react'\n\nconst HorizontalRuleComponent = React.lazy(() =>\n  import('../component/index.js').then((module) => ({\n    default: module.HorizontalRuleComponent,\n  })),\n)\n\n/**\n * Serialized representation of a horizontal rule node. Serialized = converted to JSON. This is what is stored in the database / in the lexical editor state.\n */\nexport type SerializedHorizontalRuleNode = SerializedLexicalNode\n\nexport const INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void> = createCommand(\n  'INSERT_HORIZONTAL_RULE_COMMAND',\n)\n\n/**\n * This node is a DecoratorNode. DecoratorNodes allow you to render React components in the editor.\n *\n * They need both createDom and decorate functions. createDom => outside of the html. decorate => React Component inside of the html.\n *\n * If we used DecoratorBlockNode instead, we would only need a decorate method\n */\nexport class HorizontalRuleNode extends DecoratorNode<React.ReactElement> {\n  static clone(node: HorizontalRuleNode): HorizontalRuleNode {\n    return new HorizontalRuleNode(node.__key)\n  }\n\n  static getType(): string {\n    return 'horizontalrule'\n  }\n\n  /**\n   * Defines what happens if you copy an hr element from another page and paste it into the lexical editor\n   *\n   * This also determines the behavior of lexical's internal HTML -> Lexical converter\n   */\n  static importDOM(): DOMConversionMap | null {\n    return {\n      hr: () => ({\n        conversion: convertHorizontalRuleElement,\n        priority: 0,\n      }),\n    }\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   * Determines how the hr element is rendered in the lexical editor. This is only the \"initial\" / \"outer\" HTML element.\n   */\n  createDOM(): HTMLElement {\n    return document.createElement('hr')\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  /**\n   * Opposite of importDOM, this function defines what happens when you copy an hr element from the lexical editor and paste it into another page.\n   *\n   * This also determines the behavior of lexical's internal Lexical -> HTML converter\n   */\n  exportDOM(): DOMExportOutput {\n    return { element: document.createElement('hr') }\n  }\n  /**\n   * Opposite of importJSON. This determines what data is saved in the database / in the lexical editor state.\n   */\n  exportJSON(): SerializedLexicalNode {\n    return {\n      type: 'horizontalrule',\n      version: 1,\n    }\n  }\n\n  getTextContent(): string {\n    return '\\n'\n  }\n\n  isInline(): false {\n    return false\n  }\n\n  updateDOM(): boolean {\n    return false\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"],"names":["lexicalImport","$applyNodeReplacement","DecoratorNode","createCommand","React","HorizontalRuleComponent","lazy","then","module","default","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRuleNode","clone","node","__key","getType","importDOM","hr","conversion","convertHorizontalRuleElement","priority","importJSON","serializedNode","$createHorizontalRuleNode","createDOM","document","createElement","decorate","nodeKey","exportDOM","element","exportJSON","type","version","getTextContent","isInline","updateDOM","$isHorizontalRuleNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AASA,OAAOA,mBAAmB,UAAS;AACnC,MAAM,EAAEC,qBAAqB,EAAEC,aAAa,EAAEC,aAAa,EAAE,GAAGH;AAChE,YAAYI,WAAW,QAAO;AAE9B,MAAMC,wCAA0BD,MAAME,IAAI,CAAC,IACzC,MAAM,CAAC,yBAAyBC,IAAI,CAAC,CAACC,SAAY,CAAA;YAChDC,SAASD,OAAOH,uBAAuB;QACzC,CAAA;AAQF,OAAO,MAAMK,iCAAuDP,cAClE,kCACD;AAED;;;;;;CAMC,GACD,OAAO,MAAMQ,2BAA2BT;IACtC,OAAOU,MAAMC,IAAwB,EAAsB;QACzD,OAAO,IAAIF,mBAAmBE,KAAKC,KAAK;IAC1C;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA;;;;GAIC,GACD,OAAOC,YAAqC;QAC1C,OAAO;YACLC,IAAI,IAAO,CAAA;oBACTC,YAAYC;oBACZC,UAAU;gBACZ,CAAA;QACF;IACF;IAEA;;GAEC,GACD,OAAOC,WAAWC,cAA4C,EAAsB;QAClF,OAAOC;IACT;IAEA;;GAEC,GACDC,YAAyB;QACvB,OAAOC,SAASC,aAAa,CAAC;IAChC;IAEA;;GAEC,GACDC,WAA+B;QAC7B,qBAAO,oBAACtB;YAAwBuB,SAAS,IAAI,CAACd,KAAK;;IACrD;IAEA;;;;GAIC,GACDe,YAA6B;QAC3B,OAAO;YAAEC,SAASL,SAASC,aAAa,CAAC;QAAM;IACjD;IACA;;GAEC,GACDK,aAAoC;QAClC,OAAO;YACLC,MAAM;YACNC,SAAS;QACX;IACF;IAEAC,iBAAyB;QACvB,OAAO;IACT;IAEAC,WAAkB;QAChB,OAAO;IACT;IAEAC,YAAqB;QACnB,OAAO;IACT;AACF;AAEA,SAASjB;IACP,OAAO;QAAEN,MAAMU;IAA4B;AAC7C;AAEA,OAAO,SAASA;IACd,OAAOtB,sBAAsB,IAAIU;AACnC;AAEA,OAAO,SAAS0B,sBACdxB,IAAoC;IAEpC,OAAOA,gBAAgBF;AACzB"}

package/dist/field/features/horizontalrule/plugin/index.d.ts

@@ -0,0 +1,6 @@
+import './index.scss';
+/**
+ * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.
+ */
+export declare function HorizontalRulePlugin(): null;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/horizontalrule/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/horizontalrule/plugin/index.tsx"],"names":[],"mappings":"AAeA,OAAO,cAAc,CAAA;AAErB;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CA2B3C"}

package/dist/field/features/horizontalrule/plugin/index.js

@@ -0,0 +1,34 @@
+'use client';
+import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
+const { useLexicalComposerContext } = lexicalComposerContextImport;
+import lexicalUtilsImport from '@lexical/utils';
+const { $insertNodeToNearestRoot } = lexicalUtilsImport;
+import lexicalImport from 'lexical';
+const { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } = lexicalImport;
+import { useEffect } from 'react';
+import { $createHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from '../nodes/HorizontalRuleNode.js';
+import './index.scss';
+/**
+ * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.
+ */ export function HorizontalRulePlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(()=>{
+        return 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);
+    }, [
+        editor
+    ]);
+    return null;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/field/features/horizontalrule/plugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/horizontalrule/plugin/index.tsx"],"sourcesContent":["'use client'\n\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\nimport lexicalUtilsImport from '@lexical/utils'\nconst { $insertNodeToNearestRoot } = lexicalUtilsImport\n\nimport lexicalImport from 'lexical'\nconst { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } = lexicalImport\nimport { useEffect } from 'react'\n\nimport {\n  $createHorizontalRuleNode,\n  INSERT_HORIZONTAL_RULE_COMMAND,\n} 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 function HorizontalRulePlugin(): null {\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"],"names":["lexicalComposerContextImport","useLexicalComposerContext","lexicalUtilsImport","$insertNodeToNearestRoot","lexicalImport","$getSelection","$isRangeSelection","COMMAND_PRIORITY_EDITOR","useEffect","$createHorizontalRuleNode","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRulePlugin","editor","registerCommand","type","selection","focusNode","focus","getNode","horizontalRuleNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,OAAOA,kCAAkC,2CAA0C;AACnF,MAAM,EAAEC,yBAAyB,EAAE,GAAGD;AACtC,OAAOE,wBAAwB,iBAAgB;AAC/C,MAAM,EAAEC,wBAAwB,EAAE,GAAGD;AAErC,OAAOE,mBAAmB,UAAS;AACnC,MAAM,EAAEC,aAAa,EAAEC,iBAAiB,EAAEC,uBAAuB,EAAE,GAAGH;AACtE,SAASI,SAAS,QAAQ,QAAO;AAEjC,SACEC,yBAAyB,EACzBC,8BAA8B,QACzB,iCAAgC;AACvC,OAAO,eAAc;AAErB;;CAEC,GACD,OAAO,SAASC;IACd,MAAM,CAACC,OAAO,GAAGX;IAEjBO,UAAU;QACR,OAAOI,OAAOC,eAAe,CAC3BH,gCACA,CAACI;YACC,MAAMC,YAAYV;YAElB,IAAI,CAACC,kBAAkBS,YAAY;gBACjC,OAAO;YACT;YAEA,MAAMC,YAAYD,UAAUE,KAAK,CAACC,OAAO;YAEzC,IAAIF,cAAc,MAAM;gBACtB,MAAMG,qBAAqBV;gBAC3BN,yBAAyBgB;YAC3B;YAEA,OAAO;QACT,GACAZ;IAEJ,GAAG;QAACK;KAAO;IAEX,OAAO;AACT"}

package/dist/field/features/horizontalrule/plugin/index.scss

@@ -0,0 +1,20 @@
+@import '../../../../scss/styles.scss';
+
+hr {
+  padding: 2px 2px;
+  border: none;
+  margin: 1rem 0;
+  cursor: pointer;
+}
+
+hr:after {
+  content: '';
+  display: block;
+  height: 2px;
+  background-color: var(--theme-elevation-250);
+}
+
+hr.selected {
+  outline: 2px solid var(--theme-success-500);
+  user-select: none;
+}

package/dist/field/lexical/config/server/default.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAEnF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAuBlF,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAmB1E,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,kBAGjC,CAAA;AAED,eAAO,MAAM,kCAAkC,EAAE,2BACA,CAAA"}
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAEnF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAwBlF,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAoB1E,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,kBAGjC,CAAA;AAED,eAAO,MAAM,kCAAkC,EAAE,2BACA,CAAA"}

package/dist/field/lexical/config/server/default.js

@@ -8,6 +8,7 @@ import { SubscriptFeature } from '../../../features/format/subscript/feature.ser
 import { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js';
 import { UnderlineFeature } from '../../../features/format/underline/feature.server.js';
 import { HeadingFeature } from '../../../features/heading/feature.server.js';
+import { HorizontalRuleFeature } from '../../../features/horizontalrule/feature.server.js';
 import { IndentFeature } from '../../../features/indent/feature.server.js';
 import { LinkFeature } from '../../../features/link/feature.server.js';
 import { CheckListFeature } from '../../../features/lists/checklist/feature.server.js';
@@ -40,7 +41,8 @@ export const defaultEditorFeatures = [
     LinkFeature(),
     RelationshipFeature(),
     BlockQuoteFeature(),
-    UploadFeature()
+    UploadFeature(),
+    HorizontalRuleFeature()
 ];
 export const defaultEditorConfig = {
     features: defaultEditorFeatures,

package/dist/field/lexical/config/server/default.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/server/default.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\n\nimport type { FeatureProviderServer } from '../../../features/types.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { AlignFeature } from '../../../features/align/feature.server.js'\nimport { BlockQuoteFeature } from '../../../features/blockquote/feature.server.js'\nimport { BoldFeature } from '../../../features/format/bold/feature.server.js'\nimport { InlineCodeFeature } from '../../../features/format/inlinecode/feature.server.js'\nimport { ItalicFeature } from '../../../features/format/italic/feature.server.js'\nimport { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server.js'\nimport { SubscriptFeature } from '../../../features/format/subscript/feature.server.js'\nimport { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js'\nimport { UnderlineFeature } from '../../../features/format/underline/feature.server.js'\nimport { HeadingFeature } from '../../../features/heading/feature.server.js'\nimport { IndentFeature } from '../../../features/indent/feature.server.js'\nimport { LinkFeature } from '../../../features/link/feature.server.js'\nimport { CheckListFeature } from '../../../features/lists/checklist/feature.server.js'\nimport { OrderedListFeature } from '../../../features/lists/orderedlist/feature.server.js'\nimport { UnorderedListFeature } from '../../../features/lists/unorderedlist/feature.server.js'\nimport { ParagraphFeature } from '../../../features/paragraph/feature.server.js'\nimport { RelationshipFeature } from '../../../features/relationship/feature.server.js'\nimport { UploadFeature } from '../../../features/upload/feature.server.js'\nimport { LexicalEditorTheme } from '../../theme/EditorTheme.js'\nimport { sanitizeServerEditorConfig } from './sanitize.js'\n\nexport const defaultEditorLexicalConfig: LexicalEditorConfig = {\n  namespace: 'lexical',\n  theme: LexicalEditorTheme,\n}\n\nexport const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[] = [\n  BoldFeature(),\n  ItalicFeature(),\n  UnderlineFeature(),\n  StrikethroughFeature(),\n  SubscriptFeature(),\n  SuperscriptFeature(),\n  InlineCodeFeature(),\n  ParagraphFeature(),\n  HeadingFeature(),\n  AlignFeature(),\n  IndentFeature(),\n  UnorderedListFeature(),\n  OrderedListFeature(),\n  CheckListFeature(),\n  LinkFeature(),\n  RelationshipFeature(),\n  BlockQuoteFeature(),\n  UploadFeature(),\n]\n\nexport const defaultEditorConfig: ServerEditorConfig = {\n  features: defaultEditorFeatures,\n  lexical: defaultEditorLexicalConfig,\n}\n\nexport const defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig =\n  sanitizeServerEditorConfig(defaultEditorConfig)\n"],"names":["AlignFeature","BlockQuoteFeature","BoldFeature","InlineCodeFeature","ItalicFeature","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","IndentFeature","LinkFeature","CheckListFeature","OrderedListFeature","UnorderedListFeature","ParagraphFeature","RelationshipFeature","UploadFeature","LexicalEditorTheme","sanitizeServerEditorConfig","defaultEditorLexicalConfig","namespace","theme","defaultEditorFeatures","defaultEditorConfig","features","lexical","defaultSanitizedServerEditorConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,YAAY,QAAQ,4CAA2C;AACxE,SAASC,iBAAiB,QAAQ,iDAAgD;AAClF,SAASC,WAAW,QAAQ,kDAAiD;AAC7E,SAASC,iBAAiB,QAAQ,wDAAuD;AACzF,SAASC,aAAa,QAAQ,oDAAmD;AACjF,SAASC,oBAAoB,QAAQ,2DAA0D;AAC/F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,kBAAkB,QAAQ,yDAAwD;AAC3F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,cAAc,QAAQ,8CAA6C;AAC5E,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,WAAW,QAAQ,2CAA0C;AACtE,SAASC,gBAAgB,QAAQ,sDAAqD;AACtF,SAASC,kBAAkB,QAAQ,wDAAuD;AAC1F,SAASC,oBAAoB,QAAQ,0DAAyD;AAC9F,SAASC,gBAAgB,QAAQ,gDAA+C;AAChF,SAASC,mBAAmB,QAAQ,mDAAkD;AACtF,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,kBAAkB,QAAQ,6BAA4B;AAC/D,SAASC,0BAA0B,QAAQ,gBAAe;AAE1D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOJ;AACT,EAAC;AAED,OAAO,MAAMK,wBAAmE;IAC9ErB;IACAE;IACAI;IACAH;IACAC;IACAC;IACAJ;IACAY;IACAN;IACAT;IACAU;IACAI;IACAD;IACAD;IACAD;IACAK;IACAf;IACAgB;CACD,CAAA;AAED,OAAO,MAAMO,sBAA0C;IACrDC,UAAUF;IACVG,SAASN;AACX,EAAC;AAED,OAAO,MAAMO,qCACXR,2BAA2BK,qBAAoB"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/server/default.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\n\nimport type { FeatureProviderServer } from '../../../features/types.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { AlignFeature } from '../../../features/align/feature.server.js'\nimport { BlockQuoteFeature } from '../../../features/blockquote/feature.server.js'\nimport { BoldFeature } from '../../../features/format/bold/feature.server.js'\nimport { InlineCodeFeature } from '../../../features/format/inlinecode/feature.server.js'\nimport { ItalicFeature } from '../../../features/format/italic/feature.server.js'\nimport { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server.js'\nimport { SubscriptFeature } from '../../../features/format/subscript/feature.server.js'\nimport { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js'\nimport { UnderlineFeature } from '../../../features/format/underline/feature.server.js'\nimport { HeadingFeature } from '../../../features/heading/feature.server.js'\nimport { HorizontalRuleFeature } from '../../../features/horizontalrule/feature.server.js'\nimport { IndentFeature } from '../../../features/indent/feature.server.js'\nimport { LinkFeature } from '../../../features/link/feature.server.js'\nimport { CheckListFeature } from '../../../features/lists/checklist/feature.server.js'\nimport { OrderedListFeature } from '../../../features/lists/orderedlist/feature.server.js'\nimport { UnorderedListFeature } from '../../../features/lists/unorderedlist/feature.server.js'\nimport { ParagraphFeature } from '../../../features/paragraph/feature.server.js'\nimport { RelationshipFeature } from '../../../features/relationship/feature.server.js'\nimport { UploadFeature } from '../../../features/upload/feature.server.js'\nimport { LexicalEditorTheme } from '../../theme/EditorTheme.js'\nimport { sanitizeServerEditorConfig } from './sanitize.js'\n\nexport const defaultEditorLexicalConfig: LexicalEditorConfig = {\n  namespace: 'lexical',\n  theme: LexicalEditorTheme,\n}\n\nexport const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[] = [\n  BoldFeature(),\n  ItalicFeature(),\n  UnderlineFeature(),\n  StrikethroughFeature(),\n  SubscriptFeature(),\n  SuperscriptFeature(),\n  InlineCodeFeature(),\n  ParagraphFeature(),\n  HeadingFeature(),\n  AlignFeature(),\n  IndentFeature(),\n  UnorderedListFeature(),\n  OrderedListFeature(),\n  CheckListFeature(),\n  LinkFeature(),\n  RelationshipFeature(),\n  BlockQuoteFeature(),\n  UploadFeature(),\n  HorizontalRuleFeature(),\n]\n\nexport const defaultEditorConfig: ServerEditorConfig = {\n  features: defaultEditorFeatures,\n  lexical: defaultEditorLexicalConfig,\n}\n\nexport const defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig =\n  sanitizeServerEditorConfig(defaultEditorConfig)\n"],"names":["AlignFeature","BlockQuoteFeature","BoldFeature","InlineCodeFeature","ItalicFeature","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","HorizontalRuleFeature","IndentFeature","LinkFeature","CheckListFeature","OrderedListFeature","UnorderedListFeature","ParagraphFeature","RelationshipFeature","UploadFeature","LexicalEditorTheme","sanitizeServerEditorConfig","defaultEditorLexicalConfig","namespace","theme","defaultEditorFeatures","defaultEditorConfig","features","lexical","defaultSanitizedServerEditorConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,YAAY,QAAQ,4CAA2C;AACxE,SAASC,iBAAiB,QAAQ,iDAAgD;AAClF,SAASC,WAAW,QAAQ,kDAAiD;AAC7E,SAASC,iBAAiB,QAAQ,wDAAuD;AACzF,SAASC,aAAa,QAAQ,oDAAmD;AACjF,SAASC,oBAAoB,QAAQ,2DAA0D;AAC/F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,kBAAkB,QAAQ,yDAAwD;AAC3F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,cAAc,QAAQ,8CAA6C;AAC5E,SAASC,qBAAqB,QAAQ,qDAAoD;AAC1F,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,WAAW,QAAQ,2CAA0C;AACtE,SAASC,gBAAgB,QAAQ,sDAAqD;AACtF,SAASC,kBAAkB,QAAQ,wDAAuD;AAC1F,SAASC,oBAAoB,QAAQ,0DAAyD;AAC9F,SAASC,gBAAgB,QAAQ,gDAA+C;AAChF,SAASC,mBAAmB,QAAQ,mDAAkD;AACtF,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,kBAAkB,QAAQ,6BAA4B;AAC/D,SAASC,0BAA0B,QAAQ,gBAAe;AAE1D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOJ;AACT,EAAC;AAED,OAAO,MAAMK,wBAAmE;IAC9EtB;IACAE;IACAI;IACAH;IACAC;IACAC;IACAJ;IACAa;IACAP;IACAT;IACAW;IACAI;IACAD;IACAD;IACAD;IACAK;IACAhB;IACAiB;IACAR;CACD,CAAA;AAED,OAAO,MAAMe,sBAA0C;IACrDC,UAAUF;IACVG,SAASN;AACX,EAAC;AAED,OAAO,MAAMO,qCACXR,2BAA2BK,qBAAoB"}

package/dist/field/lexical/plugins/handles/AddBlockHandlePlugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/handles/AddBlockHandlePlugin/index.tsx"],"names":[],"mappings":";AAoBA,OAAO,cAAc,CAAA;AAwSrB,wBAAgB,oBAAoB,CAAC,EACnC,UAA0B,GAC3B,EAAE;IACD,UAAU,CAAC,EAAE,WAAW,CAAA;CACzB,GAAG,GAAG,CAAC,OAAO,CAGd"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/handles/AddBlockHandlePlugin/index.tsx"],"names":[],"mappings":";AAoBA,OAAO,cAAc,CAAA;AA4SrB,wBAAgB,oBAAoB,CAAC,EACnC,UAA0B,GAC3B,EAAE;IACD,UAAU,CAAC,EAAE,WAAW,CAAA;CACzB,GAAG,GAAG,CAAC,OAAO,CAGd"}

package/dist/field/lexical/plugins/handles/AddBlockHandlePlugin/index.js

@@ -122,7 +122,9 @@ function useAddBlockHandle(editor, anchorElem, isEditable) {
                 const adjustedTop = top + window.scrollY;
                 const adjustedBottom = bottom + window.scrollY;
                 if (pageY < adjustedTop - verticalBuffer || pageY > adjustedBottom + verticalBuffer || pageX < left - horizontalBuffer || pageX > right + horizontalBuffer) {
-                    setHoveredElement(null);
+                    if (hoveredElement !== null) {
+                        setHoveredElement(null);
+                    }
                     return;
                 }
                 // This is used to allow the _emptyBlockElem to be found when the mouse is in the
@@ -138,10 +140,12 @@ function useAddBlockHandle(editor, anchorElem, isEditable) {
             if (!_emptyBlockElem) {
                 return;
             }
-            setHoveredElement({
-                elem: _emptyBlockElem,
-                node: blockNode
-            });
+            if (hoveredElement?.node !== blockNode || hoveredElement?.elem !== _emptyBlockElem) {
+                setHoveredElement({
+                    elem: _emptyBlockElem,
+                    node: blockNode
+                });
+            }
         }
         // Since the draggableBlockElem is outside the actual editor, we need to listen to the document
         // to be able to detect when the mouse is outside the editor and respect a buffer around
@@ -153,7 +157,8 @@ function useAddBlockHandle(editor, anchorElem, isEditable) {
     }, [
         scrollerElem,
         anchorElem,
-        editor
+        editor,
+        hoveredElement
     ]);
     useEffect(()=>{
         if (menuRef.current && hoveredElement?.node) {