@ekz/lexical-react 0.40.0

package/LexicalHorizontalRuleNode.dev.mjs

@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { HorizontalRuleNode as HorizontalRuleNode$1 } from '@ekz/lexical-extension';
+export { $isHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from '@ekz/lexical-extension';
+import { useLexicalComposerContext } from '@ekz/lexical-react/LexicalComposerContext';
+import { useLexicalNodeSelection } from '@ekz/lexical-react/useLexicalNodeSelection';
+import { mergeRegister, addClassNamesToElement, removeClassNamesFromElement } from '@ekz/lexical-utils';
+import { $applyNodeReplacement, CLICK_COMMAND, COMMAND_PRIORITY_LOW } from '@ekz/lexical';
+import { useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+function HorizontalRuleComponent({
+  nodeKey
+}) {
+  const [editor] = useLexicalComposerContext();
+  const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(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));
+  }, [clearSelection, editor, isSelected, nodeKey, setSelected]);
+  useEffect(() => {
+    const hrElem = editor.getElementByKey(nodeKey);
+    const isSelectedClassName = editor._config.theme.hrSelected ?? 'selected';
+    if (hrElem !== null) {
+      if (isSelected) {
+        addClassNamesToElement(hrElem, isSelectedClassName);
+      } else {
+        removeClassNamesFromElement(hrElem, isSelectedClassName);
+      }
+    }
+  }, [editor, isSelected, nodeKey]);
+  return null;
+}
+
+/**
+ * @deprecated A pure Lexical implementation is available in `@lexical/extension` as HorizontalRuleExtension
+ */
+class HorizontalRuleNode extends HorizontalRuleNode$1 {
+  static getType() {
+    return 'horizontalrule';
+  }
+  static clone(node) {
+    return new HorizontalRuleNode(node.__key);
+  }
+  static importJSON(serializedNode) {
+    return $createHorizontalRuleNode().updateFromJSON(serializedNode);
+  }
+  static importDOM() {
+    return {
+      hr: () => ({
+        conversion: $convertHorizontalRuleElement,
+        priority: 0
+      })
+    };
+  }
+  decorate() {
+    return /*#__PURE__*/jsx(HorizontalRuleComponent, {
+      nodeKey: this.__key
+    });
+  }
+}
+function $convertHorizontalRuleElement() {
+  return {
+    node: $createHorizontalRuleNode()
+  };
+}
+
+/**
+ * @deprecated A pure Lexical implementation is available in `@lexical/extension` as HorizontalRuleExtension
+ */
+function $createHorizontalRuleNode() {
+  return $applyNodeReplacement(new HorizontalRuleNode());
+}
+
+export { $createHorizontalRuleNode, HorizontalRuleNode };

package/LexicalHorizontalRuleNode.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+'use strict'
+const LexicalHorizontalRuleNode = process.env.NODE_ENV !== 'production' ? require('./LexicalHorizontalRuleNode.dev.js') : require('./LexicalHorizontalRuleNode.prod.js');
+module.exports = LexicalHorizontalRuleNode;

package/LexicalHorizontalRuleNode.js.flow

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+
+import type {LexicalNode, LexicalCommand, SerializedLexicalNode} from '@ekz/lexical';
+import {DecoratorNode} from '@ekz/lexical';
+export type SerializedHorizontalRuleNode = SerializedLexicalNode;
+declare export class HorizontalRuleNode extends DecoratorNode<React.Node> {
+  static getType(): string;
+  static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+  createDOM(): HTMLElement;
+  getTextContent(): '\n';
+  updateDOM(): false;
+  decorate(): React.Node;
+}
+
+declare export function $createHorizontalRuleNode(): HorizontalRuleNode;
+declare export function $isHorizontalRuleNode(
+  node: ?LexicalNode,
+): node is HorizontalRuleNode;
+
+declare export var INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;

package/LexicalHorizontalRuleNode.mjs

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import * as modDev from './LexicalHorizontalRuleNode.dev.mjs';
+import * as modProd from './LexicalHorizontalRuleNode.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const $createHorizontalRuleNode = mod.$createHorizontalRuleNode;
+export const $isHorizontalRuleNode = mod.$isHorizontalRuleNode;
+export const HorizontalRuleNode = mod.HorizontalRuleNode;
+export const INSERT_HORIZONTAL_RULE_COMMAND = mod.INSERT_HORIZONTAL_RULE_COMMAND;

package/LexicalHorizontalRuleNode.node.mjs

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalHorizontalRuleNode.dev.mjs') : import('./LexicalHorizontalRuleNode.prod.mjs'));
+export const $createHorizontalRuleNode = mod.$createHorizontalRuleNode;
+export const $isHorizontalRuleNode = mod.$isHorizontalRuleNode;
+export const HorizontalRuleNode = mod.HorizontalRuleNode;
+export const INSERT_HORIZONTAL_RULE_COMMAND = mod.INSERT_HORIZONTAL_RULE_COMMAND;

package/LexicalHorizontalRuleNode.prod.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+"use strict";var e=require("@ekz/lexical-extension"),t=require("@ekz/lexical-react/LexicalComposerContext"),r=require("@ekz/lexical-react/useLexicalNodeSelection"),o=require("@ekz/lexical-utils"),n=require("@ekz/lexical"),i=require("react"),l=require("react/jsx-runtime");function s({nodeKey:e}){const[l]=t.useLexicalComposerContext(),[s,a,c]=r.useLexicalNodeSelection(e);return i.useEffect(()=>o.mergeRegister(l.registerCommand(n.CLICK_COMMAND,t=>{const r=l.getElementByKey(e);return t.target===r&&(t.shiftKey||c(),a(!s),!0)},n.COMMAND_PRIORITY_LOW)),[c,l,s,e,a]),i.useEffect(()=>{const t=l.getElementByKey(e),r=l._config.theme.hrSelected??"selected";null!==t&&(s?o.addClassNamesToElement(t,r):o.removeClassNamesFromElement(t,r))},[l,s,e]),null}class a extends e.HorizontalRuleNode{static getType(){return"horizontalrule"}static clone(e){return new a(e.__key)}static importJSON(e){return u().updateFromJSON(e)}static importDOM(){return{hr:()=>({conversion:c,priority:0})}}decorate(){return l.jsx(s,{nodeKey:this.__key})}}function c(){return{node:u()}}function u(){return n.$applyNodeReplacement(new a)}exports.$isHorizontalRuleNode=e.$isHorizontalRuleNode,exports.INSERT_HORIZONTAL_RULE_COMMAND=e.INSERT_HORIZONTAL_RULE_COMMAND,exports.$createHorizontalRuleNode=u,exports.HorizontalRuleNode=a;

package/LexicalHorizontalRuleNode.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import{HorizontalRuleNode as e}from"@ekz/lexical-extension";export{$isHorizontalRuleNode,INSERT_HORIZONTAL_RULE_COMMAND}from"@ekz/lexical-extension";import{useLexicalComposerContext as t}from"@ekz/lexical-react/LexicalComposerContext";import{useLexicalNodeSelection as r}from"@ekz/lexical-react/useLexicalNodeSelection";import{mergeRegister as o,addClassNamesToElement as n,removeClassNamesFromElement as i}from"@ekz/lexical-utils";import{$applyNodeReplacement as l,CLICK_COMMAND as c,COMMAND_PRIORITY_LOW as a}from"@ekz/lexical";import{useEffect as m}from"react";import{jsx as s}from"react/jsx-runtime";function u({nodeKey:e}){const[l]=t(),[s,u,p]=r(e);return m(()=>o(l.registerCommand(c,t=>{const r=l.getElementByKey(e);return t.target===r&&(t.shiftKey||p(),u(!s),!0)},a)),[p,l,s,e,u]),m(()=>{const t=l.getElementByKey(e),r=l._config.theme.hrSelected??"selected";null!==t&&(s?n(t,r):i(t,r))},[l,s,e]),null}class p extends e{static getType(){return"horizontalrule"}static clone(e){return new p(e.__key)}static importJSON(e){return f().updateFromJSON(e)}static importDOM(){return{hr:()=>({conversion:x,priority:0})}}decorate(){return s(u,{nodeKey:this.__key})}}function x(){return{node:f()}}function f(){return l(new p)}export{f as $createHorizontalRuleNode,p as HorizontalRuleNode};

package/LexicalHorizontalRulePlugin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export declare function HorizontalRulePlugin(): null;

package/LexicalHorizontalRulePlugin.dev.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+'use strict';
+
+var LexicalComposerContext = require('@ekz/lexical-react/LexicalComposerContext');
+var LexicalHorizontalRuleNode = require('@ekz/lexical-react/LexicalHorizontalRuleNode');
+var lexicalUtils = require('@ekz/lexical-utils');
+var lexical = require('@ekz/lexical');
+var react = require('react');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+function HorizontalRulePlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    return editor.registerCommand(LexicalHorizontalRuleNode.INSERT_HORIZONTAL_RULE_COMMAND, type => {
+      const selection = lexical.$getSelection();
+      if (!lexical.$isRangeSelection(selection)) {
+        return false;
+      }
+      const focusNode = selection.focus.getNode();
+      if (focusNode !== null) {
+        const horizontalRuleNode = LexicalHorizontalRuleNode.$createHorizontalRuleNode();
+        lexicalUtils.$insertNodeToNearestRoot(horizontalRuleNode);
+      }
+      return true;
+    }, lexical.COMMAND_PRIORITY_EDITOR);
+  }, [editor]);
+  return null;
+}
+
+exports.HorizontalRulePlugin = HorizontalRulePlugin;

package/LexicalHorizontalRulePlugin.dev.mjs

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { useLexicalComposerContext } from '@ekz/lexical-react/LexicalComposerContext';
+import { INSERT_HORIZONTAL_RULE_COMMAND, $createHorizontalRuleNode } from '@ekz/lexical-react/LexicalHorizontalRuleNode';
+import { $insertNodeToNearestRoot } from '@ekz/lexical-utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from '@ekz/lexical';
+import { useEffect } from 'react';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+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;
+}
+
+export { HorizontalRulePlugin };

package/LexicalHorizontalRulePlugin.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+'use strict'
+const LexicalHorizontalRulePlugin = process.env.NODE_ENV !== 'production' ? require('./LexicalHorizontalRulePlugin.dev.js') : require('./LexicalHorizontalRulePlugin.prod.js');
+module.exports = LexicalHorizontalRulePlugin;

package/LexicalHorizontalRulePlugin.js.flow

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+
+type Props = $ReadOnly<{}>;
+
+declare export function HorizontalRulePlugin(props: Props): null;

package/LexicalHorizontalRulePlugin.mjs

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import * as modDev from './LexicalHorizontalRulePlugin.dev.mjs';
+import * as modProd from './LexicalHorizontalRulePlugin.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const HorizontalRulePlugin = mod.HorizontalRulePlugin;

package/LexicalHorizontalRulePlugin.node.mjs

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalHorizontalRulePlugin.dev.mjs') : import('./LexicalHorizontalRulePlugin.prod.mjs'));
+export const HorizontalRulePlugin = mod.HorizontalRulePlugin;

package/LexicalHorizontalRulePlugin.prod.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+"use strict";var e=require("@ekz/lexical-react/LexicalComposerContext"),r=require("@ekz/lexical-react/LexicalHorizontalRuleNode"),t=require("@ekz/lexical-utils"),o=require("@ekz/lexical"),i=require("react");exports.HorizontalRulePlugin=function(){const[l]=e.useLexicalComposerContext();return i.useEffect(()=>l.registerCommand(r.INSERT_HORIZONTAL_RULE_COMMAND,e=>{const i=o.$getSelection();if(!o.$isRangeSelection(i))return!1;if(null!==i.focus.getNode()){const e=r.$createHorizontalRuleNode();t.$insertNodeToNearestRoot(e)}return!0},o.COMMAND_PRIORITY_EDITOR),[l]),null};

package/LexicalHorizontalRulePlugin.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import{useLexicalComposerContext as e}from"@ekz/lexical-react/LexicalComposerContext";import{INSERT_HORIZONTAL_RULE_COMMAND as o,$createHorizontalRuleNode as r}from"@ekz/lexical-react/LexicalHorizontalRuleNode";import{$insertNodeToNearestRoot as t}from"@ekz/lexical-utils";import{$getSelection as i,$isRangeSelection as l,COMMAND_PRIORITY_EDITOR as c}from"@ekz/lexical";import{useEffect as m}from"react";function n(){const[n]=e();return m(()=>n.registerCommand(o,e=>{const o=i();if(!l(o))return!1;if(null!==o.focus.getNode()){const e=r();t(e)}return!0},c),[n]),null}export{n as HorizontalRulePlugin};

package/LexicalLinkPlugin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { type LinkAttributes } from '@ekz/lexical-link';
+type Props = {
+    validateUrl?: (url: string) => boolean;
+    attributes?: LinkAttributes;
+};
+export declare function LinkPlugin({ validateUrl, attributes }: Props): null;
+export {};

package/LexicalLinkPlugin.dev.js

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+'use strict';
+
+var lexicalExtension = require('@ekz/lexical-extension');
+var lexicalLink = require('@ekz/lexical-link');
+var LexicalComposerContext = require('@ekz/lexical-react/LexicalComposerContext');
+var react = require('react');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+function LinkPlugin({
+  validateUrl,
+  attributes
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    if (!editor.hasNodes([lexicalLink.LinkNode])) {
+      throw new Error('LinkPlugin: LinkNode not registered on editor');
+    }
+  });
+  react.useEffect(() => {
+    return lexicalLink.registerLink(editor, lexicalExtension.namedSignals({
+      attributes,
+      validateUrl
+    }));
+  }, [editor, validateUrl, attributes]);
+  return null;
+}
+
+exports.LinkPlugin = LinkPlugin;

package/LexicalLinkPlugin.dev.mjs

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { namedSignals } from '@ekz/lexical-extension';
+import { LinkNode, registerLink } from '@ekz/lexical-link';
+import { useLexicalComposerContext } from '@ekz/lexical-react/LexicalComposerContext';
+import { useEffect } from 'react';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+function LinkPlugin({
+  validateUrl,
+  attributes
+}) {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    if (!editor.hasNodes([LinkNode])) {
+      throw new Error('LinkPlugin: LinkNode not registered on editor');
+    }
+  });
+  useEffect(() => {
+    return registerLink(editor, namedSignals({
+      attributes,
+      validateUrl
+    }));
+  }, [editor, validateUrl, attributes]);
+  return null;
+}
+
+export { LinkPlugin };

package/LexicalLinkPlugin.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+'use strict'
+const LexicalLinkPlugin = process.env.NODE_ENV !== 'production' ? require('./LexicalLinkPlugin.dev.js') : require('./LexicalLinkPlugin.prod.js');
+module.exports = LexicalLinkPlugin;

package/LexicalLinkPlugin.js.flow

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+
+type LinkAttributes = {
+  rel?: null | string;
+  target?: null | string;
+  title?: null | string;
+};
+
+type Props = $ReadOnly<{
+  validateUrl?: (url: string) => boolean,
+  attributes?: LinkAttributes,
+}>;
+
+declare export function LinkPlugin(props: Props): null;

package/LexicalLinkPlugin.mjs

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import * as modDev from './LexicalLinkPlugin.dev.mjs';
+import * as modProd from './LexicalLinkPlugin.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const LinkPlugin = mod.LinkPlugin;

package/LexicalLinkPlugin.node.mjs

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalLinkPlugin.dev.mjs') : import('./LexicalLinkPlugin.prod.mjs'));
+export const LinkPlugin = mod.LinkPlugin;

package/LexicalLinkPlugin.prod.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+"use strict";var e=require("@ekz/lexical-extension"),r=require("@ekz/lexical-link"),i=require("@ekz/lexical-react/LexicalComposerContext"),t=require("react");exports.LinkPlugin=function({validateUrl:n,attributes:l}){const[o]=i.useLexicalComposerContext();return t.useEffect(()=>{if(!o.hasNodes([r.LinkNode]))throw new Error("LinkPlugin: LinkNode not registered on editor")}),t.useEffect(()=>r.registerLink(o,e.namedSignals({attributes:l,validateUrl:n})),[o,n,l]),null};

package/LexicalLinkPlugin.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import{namedSignals as e}from"@ekz/lexical-extension";import{LinkNode as r,registerLink as t}from"@ekz/lexical-link";import{useLexicalComposerContext as o}from"@ekz/lexical-react/LexicalComposerContext";import{useEffect as i}from"react";function l({validateUrl:l,attributes:n}){const[a]=o();return i(()=>{if(!a.hasNodes([r]))throw new Error("LinkPlugin: LinkNode not registered on editor")}),i(()=>t(a,e({attributes:n,validateUrl:l})),[a,l,n]),null}export{l as LinkPlugin};

package/LexicalListPlugin.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export interface ListPluginProps {
+    /**
+     * When `true`, enforces strict indentation rules for list items, ensuring consistent structure.
+     * When `false` (default), indentation is more flexible.
+     */
+    hasStrictIndent?: boolean;
+    /**
+     * When `true`, splitting a numbered list will preserve the numbering continuity.
+     * When `false` (default), the new split list resets to 1.
+     */
+    shouldPreserveNumbering?: boolean;
+}
+export declare function ListPlugin({ hasStrictIndent, shouldPreserveNumbering, }: ListPluginProps): null;

package/LexicalListPlugin.dev.js

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+'use strict';
+
+var lexicalList = require('@ekz/lexical-list');
+var LexicalComposerContext = require('@ekz/lexical-react/LexicalComposerContext');
+var lexical = require('@ekz/lexical');
+var react = require('react');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+function useList(editor) {
+  react.useEffect(() => {
+    return lexicalList.registerList(editor);
+  }, [editor]);
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+function ListPlugin({
+  hasStrictIndent = false,
+  shouldPreserveNumbering = false
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    if (!editor.hasNodes([lexicalList.ListNode, lexicalList.ListItemNode])) {
+      throw new Error('ListPlugin: ListNode and/or ListItemNode not registered on editor');
+    }
+  }, [editor]);
+  react.useEffect(() => {
+    return lexical.mergeRegister(lexicalList.registerList(editor), hasStrictIndent ? lexicalList.registerListStrictIndentTransform(editor) : () => {});
+  }, [editor, hasStrictIndent, shouldPreserveNumbering]);
+  useList(editor);
+  return null;
+}
+
+exports.ListPlugin = ListPlugin;