@tiny-codes/react-easy 1.3.0 → 1.4.0

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.0",
+  "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": {