@tiny-codes/react-easy 1.3.0 → 1.4.0

package/lib/components/Lexical/index.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/Lexical/index.ts
+var Lexical_exports = {};
+module.exports = __toCommonJS(Lexical_exports);
+__reExport(Lexical_exports, require("./helpers"), module.exports);
+__reExport(Lexical_exports, require("./nodes/base"), module.exports);
+__reExport(Lexical_exports, require("./nodes/DivNode"), module.exports);
+__reExport(Lexical_exports, require("./nodes/SelectNode"), module.exports);
+__reExport(Lexical_exports, require("./nodes/ExtendTextNode"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./helpers"),
+  ...require("./nodes/base"),
+  ...require("./nodes/DivNode"),
+  ...require("./nodes/SelectNode"),
+  ...require("./nodes/ExtendTextNode")
+});
+//# sourceMappingURL=index.js.map

package/lib/components/Lexical/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/components/Lexical/index.ts"],
+  "sourcesContent": ["export * from './helpers';\nexport * from './nodes/base';\nexport * from './nodes/DivNode';\nexport * from './nodes/SelectNode';\nexport * from './nodes/ExtendTextNode';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,4BAAc,sBAAd;AACA,4BAAc,yBADd;AAEA,4BAAc,4BAFd;AAGA,4BAAc,+BAHd;AAIA,4BAAc,mCAJd;",
+  "names": []
+}

package/lib/components/Lexical/nodes/DivNode.d.ts

@@ -0,0 +1,25 @@
+import type { CSSProperties, HtmlHTMLAttributes } from 'react';
+import type { DOMConversionMap, DOMExportOutput, LexicalNode, SerializedElementNode, Spread } from 'lexical';
+import { BaseElementNode, type BaseElementProps } from './base';
+export interface DivNodeProps extends HtmlHTMLAttributes<HTMLDivElement>, BaseElementProps {
+}
+export type SerializedDivNode = Spread<{
+    props?: DivNodeProps;
+}, SerializedElementNode>;
+export declare class DivNode extends BaseElementNode<DivNodeProps> {
+    static getType(): string;
+    static clone(node: DivNode): DivNode;
+    protected getForceDisplay(): CSSProperties['display'];
+    createDOM(): HTMLElement;
+    updateDOM(prevNode: DivNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedDivNode): DivNode;
+    exportJSON(): SerializedDivNode;
+    exportDOM(): DOMExportOutput;
+    isInline(): boolean;
+    getPropValue<K extends keyof DivNodeProps>(key: K): DivNodeProps[K] | undefined;
+    setProps(props: DivNodeProps): void;
+    private shallowEqual;
+}
+export declare function $createDivNode(props?: DivNodeProps): DivNode;
+export declare function $isDivNode(node: LexicalNode | null | undefined): node is DivNode;

package/lib/components/Lexical/nodes/DivNode.js

@@ -0,0 +1,139 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/Lexical/nodes/DivNode.tsx
+var DivNode_exports = {};
+__export(DivNode_exports, {
+  $createDivNode: () => $createDivNode,
+  $isDivNode: () => $isDivNode,
+  DivNode: () => DivNode
+});
+module.exports = __toCommonJS(DivNode_exports);
+var import_helpers = require("../helpers");
+var import_base = require("./base");
+var DivNode = class extends import_base.BaseElementNode {
+  static getType() {
+    return "html.div";
+  }
+  static clone(node) {
+    return new DivNode({ ...node.__props, key: node.getKey() });
+  }
+  getForceDisplay() {
+    return void 0;
+  }
+  createDOM() {
+    const div = document.createElement("div");
+    const domProps = this.getUnderlyingProps(this.__props);
+    if (domProps) {
+      (0, import_helpers.updateDomProps)(div, domProps);
+    }
+    return div;
+  }
+  updateDOM(prevNode, dom) {
+    const prevProps = prevNode.__props;
+    const currentProps = this.__props;
+    const propsChanged = !this.shallowEqual(prevProps, currentProps);
+    if (propsChanged) {
+      (0, import_helpers.updateDomProps)(dom, this.getUnderlyingProps(currentProps));
+    }
+    return false;
+  }
+  static importDOM() {
+    return {
+      div: (node) => ({
+        conversion: convertDivElement,
+        priority: 1
+      })
+    };
+  }
+  static importJSON(serializedNode) {
+    return $createDivNode(serializedNode.props);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      props: this.__props,
+      type: this.getType()
+    };
+  }
+  exportDOM() {
+    const element = this.createDOM();
+    return { element };
+  }
+  isInline() {
+    var _a, _b;
+    const display = (_b = (_a = this.__props) == null ? void 0 : _a.style) == null ? void 0 : _b.display;
+    return display === "inline" || display === "inline-flex" || display === "inline-block" || display === "inline-grid" || display === "inline-table" || display === "inline-list-item";
+  }
+  getPropValue(key) {
+    var _a;
+    return (_a = this.__props) == null ? void 0 : _a[key];
+  }
+  setProps(props) {
+    var _a;
+    const writable = this.getWritable();
+    writable.__props = {
+      ...writable.__props,
+      ...props,
+      style: {
+        ...(_a = writable.__props) == null ? void 0 : _a.style,
+        ...props.style
+      }
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  shallowEqual(obj1, obj2) {
+    if (obj1 === obj2)
+      return true;
+    if (!obj1 || !obj2)
+      return false;
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+      return false;
+    for (const key of keys1) {
+      if (key === "style") {
+        if (!this.shallowEqual(obj1[key], obj2[key]))
+          return false;
+      } else if (obj1[key] !== obj2[key]) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+function convertDivElement(domNode) {
+  const element = domNode;
+  if (element.nodeName === "DIV") {
+    return { node: $createDivNode() };
+  }
+  return { node: null };
+}
+function $createDivNode(props) {
+  return new DivNode(props);
+}
+function $isDivNode(node) {
+  return node instanceof DivNode;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $createDivNode,
+  $isDivNode,
+  DivNode
+});
+//# sourceMappingURL=DivNode.js.map

package/lib/components/Lexical/nodes/DivNode.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/components/Lexical/nodes/DivNode.tsx"],
+  "sourcesContent": ["import type { CSSProperties, HtmlHTMLAttributes } from 'react';\nimport type {\n  DOMConversionMap,\n  DOMConversionOutput,\n  DOMExportOutput,\n  LexicalNode,\n  SerializedElementNode,\n  Spread,\n} from 'lexical';\nimport { updateDomProps } from '../helpers';\nimport { BaseElementNode, type BaseElementProps } from './base';\n\nexport interface DivNodeProps extends HtmlHTMLAttributes<HTMLDivElement>, BaseElementProps {}\n\nexport type SerializedDivNode = Spread<\n  {\n    props?: DivNodeProps;\n  },\n  SerializedElementNode\n>;\n\nexport class DivNode extends BaseElementNode<DivNodeProps> {\n  static getType(): string {\n    return 'html.div';\n  }\n\n  static clone(node: DivNode): DivNode {\n    return new DivNode({ ...node.__props, key: node.getKey() });\n  }\n\n  protected getForceDisplay(): CSSProperties['display'] {\n    return undefined;\n  }\n\n  createDOM(): HTMLElement {\n    const div = document.createElement('div');\n    const domProps = this.getUnderlyingProps(this.__props);\n    if (domProps) {\n      updateDomProps(div, domProps);\n    }\n    return div;\n  }\n\n  updateDOM(prevNode: DivNode, dom: HTMLElement): boolean {\n    const prevProps = prevNode.__props;\n    const currentProps = this.__props;\n    const propsChanged = !this.shallowEqual(prevProps, currentProps);\n    if (propsChanged) {\n      updateDomProps(dom, this.getUnderlyingProps(currentProps));\n    }\n    // 不重新创建\n    return false;\n  }\n\n  static importDOM(): DOMConversionMap | null {\n    return {\n      div: (node: Node) => ({\n        conversion: convertDivElement,\n        priority: 1,\n      }),\n    };\n  }\n\n  static importJSON(serializedNode: SerializedDivNode): DivNode {\n    return $createDivNode(serializedNode.props);\n  }\n\n  exportJSON(): SerializedDivNode {\n    return {\n      ...super.exportJSON(),\n      props: this.__props,\n      type: this.getType(),\n    };\n  }\n\n  exportDOM(): DOMExportOutput {\n    const element = this.createDOM();\n    return { element };\n  }\n\n  isInline(): boolean {\n    const display = this.__props?.style?.display;\n    return (\n      display === 'inline' ||\n      display === 'inline-flex' ||\n      display === 'inline-block' ||\n      display === 'inline-grid' ||\n      display === 'inline-table' ||\n      display === 'inline-list-item'\n    );\n  }\n\n  getPropValue<K extends keyof DivNodeProps>(key: K): DivNodeProps[K] | undefined {\n    return this.__props?.[key];\n  }\n  setProps(props: DivNodeProps): void {\n    const writable = this.getWritable();\n    writable.__props = {\n      ...writable.__props,\n      ...props,\n      style: {\n        ...writable.__props?.style,\n        ...props.style,\n      },\n    };\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private shallowEqual(obj1: any, obj2: any): boolean {\n    if (obj1 === obj2) return true;\n    if (!obj1 || !obj2) return false;\n\n    const keys1 = Object.keys(obj1);\n    const keys2 = Object.keys(obj2);\n\n    if (keys1.length !== keys2.length) return false;\n\n    for (const key of keys1) {\n      if (key === 'style') {\n        // 特殊处理 style 对象\n        if (!this.shallowEqual(obj1[key], obj2[key])) return false;\n      } else if (obj1[key] !== obj2[key]) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n}\n\nfunction convertDivElement(domNode: Node): DOMConversionOutput {\n  const element = domNode as HTMLElement;\n  if (element.nodeName === 'DIV') {\n    return { node: $createDivNode() };\n  }\n  return { node: null };\n}\n\nexport function $createDivNode(props?: DivNodeProps): DivNode {\n  return new DivNode(props);\n}\n\nexport function $isDivNode(node: LexicalNode | null | undefined): node is DivNode {\n  return node instanceof DivNode;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/lib/components/Lexical/nodes/ExtendTextNode.d.ts

@@ -0,0 +1,24 @@
+import type { LexicalNode, NodeKey, SerializedTextNode, Spread } from 'lexical';
+import { TextNode } from 'lexical';
+import type { BaseNodeProps } from './base';
+import { BaseNodeHelper } from './base';
+export interface ExtendTextNodeProps extends BaseNodeProps {
+    text?: string;
+}
+export declare class ExtendTextNode extends TextNode {
+    __props: ExtendTextNodeProps | undefined;
+    __base: BaseNodeHelper<ExtendTextNodeProps>;
+    constructor(props?: ExtendTextNodeProps & {
+        key?: NodeKey;
+    });
+    static getType(): string;
+    static clone(node: ExtendTextNode): ExtendTextNode;
+    static importJSON(serializedNode: SerializedExtendTextNode): ExtendTextNode;
+    exportJSON(): SerializedExtendTextNode;
+}
+export type SerializedExtendTextNode = Spread<{
+    props?: ExtendTextNodeProps;
+    text: string;
+}, SerializedTextNode>;
+export declare function $createExtendTextNode(props?: ExtendTextNodeProps): ExtendTextNode;
+export declare function $isExtendTextNode(node: LexicalNode | null | undefined): node is ExtendTextNode;

package/lib/components/Lexical/nodes/ExtendTextNode.js

@@ -0,0 +1,87 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/Lexical/nodes/ExtendTextNode.tsx
+var ExtendTextNode_exports = {};
+__export(ExtendTextNode_exports, {
+  $createExtendTextNode: () => $createExtendTextNode,
+  $isExtendTextNode: () => $isExtendTextNode,
+  ExtendTextNode: () => ExtendTextNode
+});
+module.exports = __toCommonJS(ExtendTextNode_exports);
+var import_lexical = require("lexical");
+var import_base = require("./base");
+var ExtendTextNode = class extends import_lexical.TextNode {
+  constructor(props) {
+    const { key, ...restProps } = props || {};
+    super(props == null ? void 0 : props.text, key);
+    this.__props = restProps;
+    this.__base = new import_base.BaseNodeHelper(this.__props, {
+      remove: () => super.remove(),
+      replace: (replaceWith, includeChildren) => super.replace(replaceWith, includeChildren)
+    });
+    Object.keys(this.__base.hooks).forEach((key2) => {
+      const method = this.__base.hooks[key2];
+      if (typeof method === "function") {
+        this[key2] = method.bind(this.__base);
+      }
+    });
+    this.replace = (replaceWith, includeChildren) => {
+      var _a, _b;
+      if (((_a = this.__props) == null ? void 0 : _a.canBeReplaced) === false) {
+        this.setTextContent(((_b = this.__props) == null ? void 0 : _b.text) || "");
+        this.selectNext();
+        return this;
+      }
+      return super.replace(replaceWith, includeChildren);
+    };
+  }
+  static getType() {
+    return "html.TextNode";
+  }
+  static clone(node) {
+    return new ExtendTextNode({ ...node.__props, text: node.__text, key: node.getKey() });
+  }
+  static importJSON(serializedNode) {
+    return $createExtendTextNode({
+      ...serializedNode.props,
+      text: serializedNode.text
+    });
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      props: this.__props,
+      text: this.__text,
+      type: this.getType()
+    };
+  }
+};
+function $createExtendTextNode(props) {
+  return new ExtendTextNode(props);
+}
+function $isExtendTextNode(node) {
+  return node instanceof ExtendTextNode;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $createExtendTextNode,
+  $isExtendTextNode,
+  ExtendTextNode
+});
+//# sourceMappingURL=ExtendTextNode.js.map

package/lib/components/Lexical/nodes/ExtendTextNode.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/components/Lexical/nodes/ExtendTextNode.tsx"],
+  "sourcesContent": ["import type { LexicalNode, NodeKey, SerializedTextNode, Spread } from 'lexical';\nimport { TextNode } from 'lexical';\nimport type { BaseNodeProps } from './base';\nimport { BaseNodeHelper } from './base';\n\nexport interface ExtendTextNodeProps extends BaseNodeProps {\n  text?: string;\n}\n\nexport class ExtendTextNode extends TextNode {\n  __props: ExtendTextNodeProps | undefined;\n  __base: BaseNodeHelper<ExtendTextNodeProps>;\n\n  constructor(props?: ExtendTextNodeProps & { key?: NodeKey }) {\n    const { key, ...restProps } = props || {};\n    super(props?.text, key);\n    this.__props = restProps;\n    this.__base = new BaseNodeHelper<ExtendTextNodeProps>(this.__props, {\n      remove: () => super.remove(),\n      replace: (replaceWith, includeChildren) => super.replace(replaceWith, includeChildren),\n    });\n    Object.keys(this.__base.hooks).forEach((key) => {\n      const method = this.__base.hooks[key as keyof typeof this.__base.hooks];\n      if (typeof method === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        this[key as keyof this] = method.bind(this.__base) as any;\n      }\n    });\n    this.replace = <N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N => {\n      if (this.__props?.canBeReplaced === false) {\n        this.setTextContent(this.__props?.text || '');\n        this.selectNext();\n        return this as unknown as N;\n      }\n      return super.replace(replaceWith, includeChildren);\n    };\n  }\n\n  static getType(): string {\n    return 'html.TextNode';\n  }\n\n  static clone(node: ExtendTextNode): ExtendTextNode {\n    return new ExtendTextNode({ ...node.__props, text: node.__text, key: node.getKey() });\n  }\n\n  static importJSON(serializedNode: SerializedExtendTextNode): ExtendTextNode {\n    return $createExtendTextNode({\n      ...serializedNode.props,\n      text: serializedNode.text,\n    });\n  }\n\n  exportJSON(): SerializedExtendTextNode {\n    return {\n      ...super.exportJSON(),\n      props: this.__props,\n      text: this.__text,\n      type: this.getType(),\n    };\n  }\n}\n\nexport type SerializedExtendTextNode = Spread<\n  {\n    props?: ExtendTextNodeProps;\n    text: string;\n  },\n  SerializedTextNode\n>;\n\nexport function $createExtendTextNode(props?: ExtendTextNodeProps): ExtendTextNode {\n  return new ExtendTextNode(props);\n}\n\nexport function $isExtendTextNode(node: LexicalNode | null | undefined): node is ExtendTextNode {\n  return node instanceof ExtendTextNode;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,qBAAyB;AAEzB,kBAA+B;AAMxB,IAAM,iBAAN,cAA6B,wBAAS;AAAA,EAI3C,YAAY,OAAiD;AAC3D,UAAM,EAAE,KAAK,GAAG,UAAU,IAAI,SAAS,CAAC;AACxC,UAAM,+BAAO,MAAM,GAAG;AACtB,SAAK,UAAU;AACf,SAAK,SAAS,IAAI,2BAAoC,KAAK,SAAS;AAAA,MAClE,QAAQ,MAAM,MAAM,OAAO;AAAA,MAC3B,SAAS,CAAC,aAAa,oBAAoB,MAAM,QAAQ,aAAa,eAAe;AAAA,IACvF,CAAC;AACD,WAAO,KAAK,KAAK,OAAO,KAAK,EAAE,QAAQ,CAACA,SAAQ;AAC9C,YAAM,SAAS,KAAK,OAAO,MAAMA,IAAqC;AACtE,UAAI,OAAO,WAAW,YAAY;AAEhC,aAAKA,IAAiB,IAAI,OAAO,KAAK,KAAK,MAAM;AAAA,MACnD;AAAA,IACF,CAAC;AACD,SAAK,UAAU,CAAwB,aAAgB,oBAAiC;AA5B5F;AA6BM,YAAI,UAAK,YAAL,mBAAc,mBAAkB,OAAO;AACzC,aAAK,iBAAe,UAAK,YAAL,mBAAc,SAAQ,EAAE;AAC5C,aAAK,WAAW;AAChB,eAAO;AAAA,MACT;AACA,aAAO,MAAM,QAAQ,aAAa,eAAe;AAAA,IACnD;AAAA,EACF;AAAA,EAEA,OAAO,UAAkB;AACvB,WAAO;AAAA,EACT;AAAA,EAEA,OAAO,MAAM,MAAsC;AACjD,WAAO,IAAI,eAAe,EAAE,GAAG,KAAK,SAAS,MAAM,KAAK,QAAQ,KAAK,KAAK,OAAO,EAAE,CAAC;AAAA,EACtF;AAAA,EAEA,OAAO,WAAW,gBAA0D;AAC1E,WAAO,sBAAsB;AAAA,MAC3B,GAAG,eAAe;AAAA,MAClB,MAAM,eAAe;AAAA,IACvB,CAAC;AAAA,EACH;AAAA,EAEA,aAAuC;AACrC,WAAO;AAAA,MACL,GAAG,MAAM,WAAW;AAAA,MACpB,OAAO,KAAK;AAAA,MACZ,MAAM,KAAK;AAAA,MACX,MAAM,KAAK,QAAQ;AAAA,IACrB;AAAA,EACF;AACF;AAUO,SAAS,sBAAsB,OAA6C;AACjF,SAAO,IAAI,eAAe,KAAK;AACjC;AAEO,SAAS,kBAAkB,MAA8D;AAC9F,SAAO,gBAAgB;AACzB;",
+  "names": ["key"]
+}

package/lib/components/Lexical/nodes/SelectNode.d.ts

@@ -0,0 +1,44 @@
+import { type CSSProperties, type ReactNode } from 'react';
+import type { SelectProps } from 'antd';
+import type { BaseOptionType, DefaultOptionType } from 'antd/es/select';
+import type { LexicalEditor, LexicalNode, SerializedLexicalNode, Spread } from 'lexical';
+import type { BaseDecoratorNodeProps } from './base';
+import { BaseDecoratorNode } from './base';
+export interface SelectNodeProps<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType> extends SelectProps<ValueType, OptionType>, BaseDecoratorNodeProps {
+    /**
+     * 在获取editor的textContent时，是否将选项的label作为文本内容插入到编辑器中，默认 `value`
+     *
+     * - `label` - 将选项的label作为文本内容
+     * - `value` - 将选项的value作为文本内容
+     */
+    textContentMode?: 'label' | 'value';
+    /** 是否在`textContext`两边添加一个空格，默认`true` */
+    spaceAround?: boolean;
+    /** 容器样式 */
+    containerStyle?: CSSProperties;
+}
+export declare class SelectNode<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType> extends BaseDecoratorNode<ReactNode, SelectNodeProps<ValueType, OptionType>> {
+    __value: ValueType | undefined;
+    constructor(props?: SelectNodeProps<ValueType, OptionType> & {
+        key?: string;
+    });
+    static getType(): string;
+    static clone<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>(node: SelectNode<ValueType, OptionType>): SelectNode<ValueType, OptionType>;
+    static importJSON<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>(serializedNode: SerializedSelectNode<ValueType, OptionType>): SelectNode<ValueType, OptionType>;
+    exportJSON(): SerializedSelectNode<ValueType, OptionType>;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    decorate(): ReactNode;
+    isInline(): boolean;
+    getTextContent(): string;
+    getValue(): ValueType | undefined;
+    setValue(value: ValueType | undefined): void;
+    getPropValue(propName: keyof SelectNodeProps<ValueType, OptionType>): any;
+    setProps(props: SelectNodeProps<ValueType, OptionType>): void;
+}
+export declare function $createSelectNode<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>(props?: SelectNodeProps<ValueType, OptionType>): SelectNode<ValueType, OptionType>;
+export declare function $isSelectNode(node: LexicalNode | null | undefined): node is SelectNode<any, any>;
+export declare function $insertSelectNode<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>(editor: LexicalEditor, props: SelectNodeProps<ValueType, OptionType>): void;
+export type SerializedSelectNode<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType> = Spread<{
+    props?: SelectNodeProps<ValueType, OptionType>;
+}, SerializedLexicalNode>;

package/lib/components/Lexical/nodes/SelectNode.js

@@ -0,0 +1,157 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/Lexical/nodes/SelectNode.tsx
+var SelectNode_exports = {};
+__export(SelectNode_exports, {
+  $createSelectNode: () => $createSelectNode,
+  $insertSelectNode: () => $insertSelectNode,
+  $isSelectNode: () => $isSelectNode,
+  SelectNode: () => SelectNode
+});
+module.exports = __toCommonJS(SelectNode_exports);
+var import_react = require("react");
+var import_LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+var import_antd = require("antd");
+var import_helpers = require("../helpers");
+var import_base = require("./base");
+var SelectNode = class extends import_base.BaseDecoratorNode {
+  constructor(props) {
+    super(props);
+    this.__value = (props == null ? void 0 : props.defaultValue) ?? void 0;
+  }
+  static getType() {
+    return "antd.Select";
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static clone(node) {
+    return new SelectNode({ ...node.__props, key: node.getKey() });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static importJSON(serializedNode) {
+    return $createSelectNode(serializedNode.props);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      props: this.__props,
+      type: this.getType(),
+      version: 1
+    };
+  }
+  createDOM() {
+    var _a;
+    const span = document.createElement("span");
+    (0, import_helpers.updateDomStyle)(span, (_a = this.__props) == null ? void 0 : _a.containerStyle);
+    return span;
+  }
+  updateDOM() {
+    return false;
+  }
+  decorate() {
+    return /* @__PURE__ */ React.createElement(SelectComponent, { node: this });
+  }
+  isInline() {
+    return true;
+  }
+  getTextContent() {
+    var _a, _b, _c, _d;
+    let content;
+    const valueContent = this.__value ? String(this.__value) : "";
+    if (((_a = this.__props) == null ? void 0 : _a.textContentMode) === "label") {
+      const option = (_c = (_b = this.__props) == null ? void 0 : _b.options) == null ? void 0 : _c.find((opt) => opt.value === this.__value);
+      content = (option == null ? void 0 : option.label) ? String(option.label) : valueContent;
+    } else {
+      content = valueContent;
+    }
+    if (((_d = this.__props) == null ? void 0 : _d.spaceAround) !== false) {
+      return ` ${content} `;
+    }
+    return content;
+  }
+  getValue() {
+    return this.__value;
+  }
+  setValue(value) {
+    const writable = this.getWritable();
+    writable.__value = value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  getPropValue(propName) {
+    var _a;
+    return (_a = this.__props) == null ? void 0 : _a[propName];
+  }
+  setProps(props) {
+    const writable = this.getWritable();
+    writable.__props = {
+      ...writable.__props,
+      ...props
+    };
+  }
+};
+function SelectComponent({
+  node
+}) {
+  const { textContentMode, spaceAround, containerStyle, ...selectProps } = node.__props || {};
+  const [editor] = (0, import_LexicalComposerContext.useLexicalComposerContext)();
+  const handleChange = (0, import_react.useCallback)(
+    (value, options) => {
+      editor.update(() => {
+        var _a, _b;
+        node.setValue(value);
+        (_b = (_a = node.__props) == null ? void 0 : _a.onChange) == null ? void 0 : _b.call(_a, value, options);
+      });
+    },
+    [editor, node]
+  );
+  const handleClear = (0, import_react.useCallback)(() => {
+    editor.update(() => {
+      var _a, _b;
+      node.setValue(void 0);
+      (_b = (_a = node.__props) == null ? void 0 : _a.onClear) == null ? void 0 : _b.call(_a);
+    });
+  }, [editor, node]);
+  return /* @__PURE__ */ React.createElement(import_antd.Select, { ...selectProps, value: node.getValue(), onChange: handleChange, onClear: handleClear });
+}
+function $createSelectNode(props) {
+  return new SelectNode(props);
+}
+function $isSelectNode(node) {
+  return node instanceof SelectNode;
+}
+function $insertSelectNode(editor, props) {
+  editor.update(() => {
+    const selectNode = $createSelectNode({
+      ...props,
+      containerStyle: {
+        paddingLeft: "8px",
+        paddingRight: "8px",
+        ...props.containerStyle
+      }
+    });
+    (0, import_helpers.insertNodeAtCursor)(editor, selectNode);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $createSelectNode,
+  $insertSelectNode,
+  $isSelectNode,
+  SelectNode
+});
+//# sourceMappingURL=SelectNode.js.map

package/lib/components/Lexical/nodes/SelectNode.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/components/Lexical/nodes/SelectNode.tsx"],
+  "sourcesContent": ["import { type CSSProperties, type ReactNode, useCallback } from 'react';\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';\nimport { Select } from 'antd';\nimport type { SelectProps } from 'antd';\nimport type { BaseOptionType, DefaultOptionType } from 'antd/es/select';\nimport type { LexicalEditor, LexicalNode, SerializedLexicalNode, Spread } from 'lexical';\nimport { insertNodeAtCursor, updateDomStyle } from '../helpers';\nimport type { BaseDecoratorNodeProps } from './base';\nimport { BaseDecoratorNode } from './base';\n\nexport interface SelectNodeProps<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ValueType = any,\n  OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType,\n> extends SelectProps<ValueType, OptionType>,\n    BaseDecoratorNodeProps {\n  /**\n   * 在获取editor的textContent时，是否将选项的label作为文本内容插入到编辑器中，默认 `value`\n   *\n   * - `label` - 将选项的label作为文本内容\n   * - `value` - 将选项的value作为文本内容\n   */\n  textContentMode?: 'label' | 'value';\n  /** 是否在`textContext`两边添加一个空格，默认`true` */\n  spaceAround?: boolean;\n  /** 容器样式 */\n  containerStyle?: CSSProperties;\n}\n\nexport class SelectNode<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ValueType = any,\n  OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType,\n> extends BaseDecoratorNode<ReactNode, SelectNodeProps<ValueType, OptionType>> {\n  __value: ValueType | undefined;\n\n  constructor(props?: SelectNodeProps<ValueType, OptionType> & { key?: string }) {\n    super(props);\n    this.__value = props?.defaultValue ?? undefined;\n  }\n  static getType(): string {\n    return 'antd.Select';\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static clone<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>(\n    node: SelectNode<ValueType, OptionType>\n  ): SelectNode<ValueType, OptionType> {\n    return new SelectNode<ValueType, OptionType>({ ...node.__props, key: node.getKey() });\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static importJSON<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>(\n    serializedNode: SerializedSelectNode<ValueType, OptionType>\n  ): SelectNode<ValueType, OptionType> {\n    return $createSelectNode(serializedNode.props);\n  }\n\n  exportJSON(): SerializedSelectNode<ValueType, OptionType> {\n    return {\n      ...super.exportJSON(),\n      props: this.__props,\n      type: this.getType(),\n      version: 1,\n    };\n  }\n\n  createDOM(): HTMLElement {\n    const span = document.createElement('span');\n    updateDomStyle(span, this.__props?.containerStyle);\n    return span;\n  }\n\n  updateDOM(): false {\n    return false;\n  }\n\n  decorate(): ReactNode {\n    return <SelectComponent node={this} />;\n  }\n\n  isInline(): boolean {\n    return true;\n  }\n\n  getTextContent(): string {\n    let content: string;\n    const valueContent = this.__value ? String(this.__value) : '';\n    if (this.__props?.textContentMode === 'label') {\n      const option = this.__props?.options?.find((opt) => opt.value === this.__value);\n      content = option?.label ? String(option.label) : valueContent;\n    } else {\n      content = valueContent;\n    }\n    if (this.__props?.spaceAround !== false) {\n      return ` ${content} `;\n    }\n    return content;\n  }\n\n  getValue(): ValueType | undefined {\n    return this.__value;\n  }\n\n  setValue(value: ValueType | undefined): void {\n    const writable = this.getWritable();\n    writable.__value = value;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  getPropValue(propName: keyof SelectNodeProps<ValueType, OptionType>): any {\n    return this.__props?.[propName];\n  }\n\n  setProps(props: SelectNodeProps<ValueType, OptionType>): void {\n    const writable = this.getWritable();\n    writable.__props = {\n      ...writable.__props,\n      ...props,\n    };\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction SelectComponent<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>({\n  node,\n}: SelectComponentProps<ValueType, OptionType>): ReactNode {\n  /* eslint-disable @typescript-eslint/no-unused-vars */\n  const { textContentMode, spaceAround, containerStyle, ...selectProps } = node.__props || {};\n  /* eslint-enable @typescript-eslint/no-unused-vars */\n  const [editor] = useLexicalComposerContext();\n\n  const handleChange = useCallback<NonNullable<SelectNodeProps<ValueType, OptionType>['onChange']>>(\n    (value, options) => {\n      editor.update(() => {\n        node.setValue(value);\n        node.__props?.onChange?.(value, options);\n      });\n    },\n    [editor, node]\n  );\n\n  const handleClear = useCallback(() => {\n    editor.update(() => {\n      node.setValue(undefined);\n      node.__props?.onClear?.();\n    });\n  }, [editor, node]);\n\n  return <Select {...selectProps} value={node.getValue()} onChange={handleChange} onClear={handleClear} />;\n}\n\nexport function $createSelectNode<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ValueType = any,\n  OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType,\n>(props?: SelectNodeProps<ValueType, OptionType>): SelectNode<ValueType, OptionType> {\n  return new SelectNode<ValueType, OptionType>(props);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function $isSelectNode(node: LexicalNode | null | undefined): node is SelectNode<any, any> {\n  return node instanceof SelectNode;\n}\n\nexport function $insertSelectNode<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ValueType = any,\n  OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType,\n>(editor: LexicalEditor, props: SelectNodeProps<ValueType, OptionType>): void {\n  editor.update(() => {\n    const selectNode = $createSelectNode<ValueType, OptionType>({\n      ...props,\n      containerStyle: {\n        paddingLeft: '8px',\n        paddingRight: '8px',\n        ...props.containerStyle,\n      },\n    });\n    insertNodeAtCursor(editor, selectNode);\n  });\n}\n\ninterface SelectComponentProps<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ValueType = any,\n  OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType,\n> {\n  node: SelectNode<ValueType, OptionType>;\n}\nexport type SerializedSelectNode<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ValueType = any,\n  OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType,\n> = Spread<\n  {\n    props?: SelectNodeProps<ValueType, OptionType>;\n  },\n  SerializedLexicalNode\n>;\n"],
+  "mappings": "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",
+  "names": []
+}

package/lib/components/Lexical/nodes/base.d.ts

@@ -0,0 +1,51 @@
+import type { LexicalNode } from 'lexical';
+import { DecoratorNode, ElementNode } from 'lexical';
+export interface BaseNodeProps {
+    /** 是否可被删除，默认 `true` */
+    canBeRemoved?: boolean;
+    /** 是否可被替换，默认 `true` */
+    canBeReplaced?: boolean;
+}
+export interface BaseElementProps extends BaseNodeProps {
+    /**
+     * 是否允许节点为空，默认 `false`
+     *
+     * - `true` - 允许节点为空
+     * - `false` - 不允许节点为空，当最后一个子节点被删除后，节点也会被删除
+     */
+    canBeEmpty?: boolean;
+    /** 是否允许在节点内的起始位置插入文本，默认 `true` */
+    canInsertTextBefore?: boolean;
+    /** 是否允许在节点内的结束位置插入文本，默认 `true` */
+    canInsertTextAfter?: boolean;
+}
+export type BaseDecoratorNodeProps = BaseNodeProps;
+export declare class BaseNodeHelper<P extends BaseNodeProps> {
+    __props: (P & BaseNodeProps) | undefined;
+    __superMethods: Pick<LexicalNode, 'replace' | 'remove'>;
+    constructor(props: P | undefined, superMethods: Pick<LexicalNode, 'replace' | 'remove'>);
+    hooks: {
+        remove: (preserveEmptyParent?: boolean) => void;
+        replace: <N extends LexicalNode>(replaceWith: N, includeChildren?: boolean) => N;
+    };
+    getUnderlyingProps(props: P & BaseNodeProps): Omit<P, keyof BaseNodeProps>;
+}
+export declare class BaseElementNode<P extends BaseElementProps> extends ElementNode {
+    __props: P | undefined;
+    __base: BaseNodeHelper<P>;
+    constructor(props?: P & {
+        key?: string;
+    });
+    canBeEmpty(): boolean;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+    getUnderlyingProps(props: P | undefined): Omit<P, keyof BaseElementProps>;
+}
+export declare class BaseDecoratorNode<T, P extends BaseDecoratorNodeProps> extends DecoratorNode<T> {
+    __props: P | undefined;
+    __base: BaseNodeHelper<P>;
+    constructor(props?: P & {
+        key?: string;
+    });
+    getUnderlyingProps(props: P | undefined): Omit<P, keyof BaseDecoratorNodeProps>;
+}