@tiny-codes/react-easy 1.3.1 → 1.4.0

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>;
+}

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

@@ -0,0 +1,116 @@
+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/base.ts
+var base_exports = {};
+__export(base_exports, {
+  BaseDecoratorNode: () => BaseDecoratorNode,
+  BaseElementNode: () => BaseElementNode,
+  BaseNodeHelper: () => BaseNodeHelper
+});
+module.exports = __toCommonJS(base_exports);
+var import_lexical = require("lexical");
+var BaseNodeHelper = class {
+  constructor(props, superMethods) {
+    this.hooks = {
+      remove: (preserveEmptyParent) => {
+        var _a;
+        if (((_a = this.__props) == null ? void 0 : _a.canBeRemoved) === false) {
+          return;
+        }
+        this.__superMethods.remove(preserveEmptyParent);
+      },
+      replace: (replaceWith, includeChildren) => {
+        var _a;
+        if (((_a = this.__props) == null ? void 0 : _a.canBeReplaced) === false) {
+          return this;
+        }
+        return this.__superMethods.replace(replaceWith, includeChildren);
+      }
+    };
+    this.__props = props;
+    this.__superMethods = superMethods;
+  }
+  getUnderlyingProps(props) {
+    const { canBeRemoved, canBeReplaced, ...restProps } = props;
+    return restProps;
+  }
+};
+var BaseElementNode = class extends import_lexical.ElementNode {
+  constructor(props) {
+    const { key, ...restProps } = props || {};
+    super(key);
+    this.__props = restProps;
+    this.__base = new 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);
+      }
+    });
+  }
+  canBeEmpty() {
+    var _a;
+    return ((_a = this.__props) == null ? void 0 : _a.canBeEmpty) ?? false;
+  }
+  canInsertTextBefore() {
+    var _a;
+    return ((_a = this.__props) == null ? void 0 : _a.canInsertTextBefore) ?? true;
+  }
+  canInsertTextAfter() {
+    var _a;
+    return ((_a = this.__props) == null ? void 0 : _a.canInsertTextAfter) ?? true;
+  }
+  getUnderlyingProps(props) {
+    const baseProps = this.__base.getUnderlyingProps(props ?? {});
+    const { canBeEmpty, canInsertTextBefore, canInsertTextAfter, ...restProps } = baseProps;
+    return restProps;
+  }
+};
+var BaseDecoratorNode = class extends import_lexical.DecoratorNode {
+  constructor(props) {
+    const { key, ...restProps } = props || {};
+    super(key);
+    this.__props = restProps;
+    this.__base = new 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);
+      }
+    });
+  }
+  getUnderlyingProps(props) {
+    const baseProps = this.__base.getUnderlyingProps(props ?? {});
+    const { ...restProps } = baseProps;
+    return restProps;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseDecoratorNode,
+  BaseElementNode,
+  BaseNodeHelper
+});
+//# sourceMappingURL=base.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/components/Lexical/nodes/base.ts"],
+  "sourcesContent": ["import type { LexicalNode } from 'lexical';\nimport { DecoratorNode, ElementNode } from 'lexical';\n\nexport interface BaseNodeProps {\n  /** 是否可被删除，默认 `true` */\n  canBeRemoved?: boolean;\n  /** 是否可被替换，默认 `true` */\n  canBeReplaced?: boolean;\n}\nexport interface BaseElementProps extends BaseNodeProps {\n  /**\n   * 是否允许节点为空，默认 `false`\n   *\n   * - `true` - 允许节点为空\n   * - `false` - 不允许节点为空，当最后一个子节点被删除后，节点也会被删除\n   */\n  canBeEmpty?: boolean;\n  /** 是否允许在节点内的起始位置插入文本，默认 `true` */\n  canInsertTextBefore?: boolean;\n  /** 是否允许在节点内的结束位置插入文本，默认 `true` */\n  canInsertTextAfter?: boolean;\n}\n\nexport type BaseDecoratorNodeProps = BaseNodeProps;\n\nexport class BaseNodeHelper<P extends BaseNodeProps> {\n  __props: (P & BaseNodeProps) | undefined;\n  __superMethods: Pick<LexicalNode, 'replace' | 'remove'>;\n\n  constructor(props: P | undefined, superMethods: Pick<LexicalNode, 'replace' | 'remove'>) {\n    this.__props = props as P & BaseNodeProps;\n    this.__superMethods = superMethods;\n  }\n\n  hooks = {\n    remove: (preserveEmptyParent?: boolean): void => {\n      if (this.__props?.canBeRemoved === false) {\n        return;\n      }\n      this.__superMethods.remove(preserveEmptyParent);\n    },\n\n    replace: <N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N => {\n      if (this.__props?.canBeReplaced === false) {\n        return this as unknown as N;\n      }\n      return this.__superMethods.replace(replaceWith, includeChildren);\n    },\n  };\n  getUnderlyingProps(props: P & BaseNodeProps): Omit<P, keyof BaseNodeProps> {\n    /* eslint-disable @typescript-eslint/no-unused-vars */\n    const { canBeRemoved, canBeReplaced, ...restProps } = props;\n    /* eslint-enable @typescript-eslint/no-unused-vars */\n    return restProps as P;\n  }\n}\n\nexport class BaseElementNode<P extends BaseElementProps> extends ElementNode {\n  __props: P | undefined;\n  __base: BaseNodeHelper<P>;\n\n  constructor(props?: P & { key?: string }) {\n    const { key, ...restProps } = props || {};\n    super(key);\n    this.__props = restProps as P;\n    this.__base = new BaseNodeHelper<P>(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  }\n\n  canBeEmpty(): boolean {\n    return this.__props?.canBeEmpty ?? false;\n  }\n\n  canInsertTextBefore(): boolean {\n    return this.__props?.canInsertTextBefore ?? true;\n  }\n\n  canInsertTextAfter(): boolean {\n    return this.__props?.canInsertTextAfter ?? true;\n  }\n\n  getUnderlyingProps(props: P | undefined): Omit<P, keyof BaseElementProps> {\n    const baseProps = this.__base.getUnderlyingProps(props ?? ({} as P));\n    /* eslint-disable @typescript-eslint/no-unused-vars */\n    const { canBeEmpty, canInsertTextBefore, canInsertTextAfter, ...restProps } = baseProps;\n    /* eslint-enable @typescript-eslint/no-unused-vars */\n    return restProps as P;\n  }\n}\n\nexport class BaseDecoratorNode<T, P extends BaseDecoratorNodeProps> extends DecoratorNode<T> {\n  __props: P | undefined;\n  __base: BaseNodeHelper<P>;\n\n  constructor(props?: P & { key?: string }) {\n    const { key, ...restProps } = props || {};\n    super(key);\n    this.__props = restProps as P;\n\n    this.__base = new BaseNodeHelper<P>(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  }\n\n  getUnderlyingProps(props: P | undefined): Omit<P, keyof BaseDecoratorNodeProps> {\n    const baseProps = this.__base.getUnderlyingProps(props ?? ({} as P));\n    /* eslint-disable @typescript-eslint/no-unused-vars */\n    const { ...restProps } = baseProps;\n    /* eslint-enable @typescript-eslint/no-unused-vars */\n    return restProps as P;\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,qBAA2C;AAwBpC,IAAM,iBAAN,MAA8C;AAAA,EAInD,YAAY,OAAsB,cAAuD;AAKzF,iBAAQ;AAAA,MACN,QAAQ,CAAC,wBAAwC;AAnCrD;AAoCM,cAAI,UAAK,YAAL,mBAAc,kBAAiB,OAAO;AACxC;AAAA,QACF;AACA,aAAK,eAAe,OAAO,mBAAmB;AAAA,MAChD;AAAA,MAEA,SAAS,CAAwB,aAAgB,oBAAiC;AA1CtF;AA2CM,cAAI,UAAK,YAAL,mBAAc,mBAAkB,OAAO;AACzC,iBAAO;AAAA,QACT;AACA,eAAO,KAAK,eAAe,QAAQ,aAAa,eAAe;AAAA,MACjE;AAAA,IACF;AAlBE,SAAK,UAAU;AACf,SAAK,iBAAiB;AAAA,EACxB;AAAA,EAiBA,mBAAmB,OAAwD;AAEzE,UAAM,EAAE,cAAc,eAAe,GAAG,UAAU,IAAI;AAEtD,WAAO;AAAA,EACT;AACF;AAEO,IAAM,kBAAN,cAA0D,2BAAY;AAAA,EAI3E,YAAY,OAA8B;AACxC,UAAM,EAAE,KAAK,GAAG,UAAU,IAAI,SAAS,CAAC;AACxC,UAAM,GAAG;AACT,SAAK,UAAU;AACf,SAAK,SAAS,IAAI,eAAkB,KAAK,SAAS;AAAA,MAChD,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;AAAA,EACH;AAAA,EAEA,aAAsB;AA9ExB;AA+EI,aAAO,UAAK,YAAL,mBAAc,eAAc;AAAA,EACrC;AAAA,EAEA,sBAA+B;AAlFjC;AAmFI,aAAO,UAAK,YAAL,mBAAc,wBAAuB;AAAA,EAC9C;AAAA,EAEA,qBAA8B;AAtFhC;AAuFI,aAAO,UAAK,YAAL,mBAAc,uBAAsB;AAAA,EAC7C;AAAA,EAEA,mBAAmB,OAAuD;AACxE,UAAM,YAAY,KAAK,OAAO,mBAAmB,SAAU,CAAC,CAAO;AAEnE,UAAM,EAAE,YAAY,qBAAqB,oBAAoB,GAAG,UAAU,IAAI;AAE9E,WAAO;AAAA,EACT;AACF;AAEO,IAAM,oBAAN,cAAqE,6BAAiB;AAAA,EAI3F,YAAY,OAA8B;AACxC,UAAM,EAAE,KAAK,GAAG,UAAU,IAAI,SAAS,CAAC;AACxC,UAAM,GAAG;AACT,SAAK,UAAU;AAEf,SAAK,SAAS,IAAI,eAAkB,KAAK,SAAS;AAAA,MAChD,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;AAAA,EACH;AAAA,EAEA,mBAAmB,OAA6D;AAC9E,UAAM,YAAY,KAAK,OAAO,mBAAmB,SAAU,CAAC,CAAO;AAEnE,UAAM,EAAE,GAAG,UAAU,IAAI;AAEzB,WAAO;AAAA,EACT;AACF;",
+  "names": ["key"]
+}

package/lib/hooks/useRefValue.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import type { RefObject } from 'react';
 /**
  * - **EN:** Get a mutable ref object and automatically update the value change
  * - **CN:** 获取一个可变的ref对象，并自动更新值变化
@@ -7,5 +7,5 @@
  *
  * @returns A mutable ref object, but the reference is immutable | 可变的ref对象，但引用不可变
  */
-declare const useRefValue: <T>(value: T) => import("react").RefObject<T>;
+declare const useRefValue: <T>(value: T) => RefObject<T>;
 export default useRefValue;

package/lib/hooks/useRefValue.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/hooks/useRefValue.ts"],
-  "sourcesContent": ["import { useRef } from 'react';\n\n/**\n * - **EN:** Get a mutable ref object and automatically update the value change\n * - **CN:** 获取一个可变的ref对象，并自动更新值变化\n *\n * @param value the wrapped value | 被包装的值\n *\n * @returns A mutable ref object, but the reference is immutable | 可变的ref对象，但引用不可变\n */\nconst useRefValue = <T>(value: T) => {\n  const ref = useRef<T>(value);\n  ref.current = value;\n  return ref;\n};\n\nexport default useRefValue;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAuB;AAUvB,IAAM,cAAc,CAAI,UAAa;AACnC,QAAM,UAAM,qBAAU,KAAK;AAC3B,MAAI,UAAU;AACd,SAAO;AACT;AAEA,IAAO,sBAAQ;",
+  "sourcesContent": ["import type { RefObject } from 'react';\nimport { useRef } from 'react';\n\n/**\n * - **EN:** Get a mutable ref object and automatically update the value change\n * - **CN:** 获取一个可变的ref对象，并自动更新值变化\n *\n * @param value the wrapped value | 被包装的值\n *\n * @returns A mutable ref object, but the reference is immutable | 可变的ref对象，但引用不可变\n */\nconst useRefValue = <T>(value: T): RefObject<T> => {\n  const ref = useRef<T>(value);\n  ref.current = value;\n  return ref;\n};\n\nexport default useRefValue;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAAuB;AAUvB,IAAM,cAAc,CAAI,UAA2B;AACjD,QAAM,UAAM,qBAAU,KAAK;AAC3B,MAAI,UAAU;AACd,SAAO;AACT;AAEA,IAAO,sBAAQ;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-codes/react-easy",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Simplify React and AntDesign development with practical components and hooks",
   "keywords": [
     "react",
@@ -20,6 +20,23 @@
   },
   "license": "MIT",
   "author": "李凤宝(Leo) <shijistar@gmail.com>",
+  "exports": {
+    ".": {
+      "import": "./es/index.js",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js",
+      "node": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    },
+    "./lexical": {
+      "import": "./es/components/Lexical/index.js",
+      "require": "./lib/components/Lexical/index.js",
+      "default": "./lib/components/Lexical/index.js",
+      "node": "./lib/components/Lexical/index.js",
+      "types": "./lib/components/Lexical/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
   "main": "lib/index.js",
   "module": "es/index.js",
   "types": "lib/index.d.ts",
@@ -36,7 +53,9 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@lexical/react": "^0.33.1",
     "i18next": "^24.2.3",
+    "lexical": "^0.33.1",
     "react-contexify": "^6.0.0"
   },
   "devDependencies": {