@qsxy/element-plus-react 1.0.0-next.1

package/dist/hooks/popperPropsUtils.js

@@ -0,0 +1,71 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/popperPropsUtils.ts
+var popperPropsUtils_exports = {};
+__export(popperPropsUtils_exports, {
+  partitionPopperPropsUtils: () => partitionPopperPropsUtils,
+  popperAllProps: () => popperAllProps
+});
+module.exports = __toCommonJS(popperPropsUtils_exports);
+var import_forEach = __toESM(require("lodash/forEach"));
+var import_includes = __toESM(require("lodash/includes"));
+var popperAllProps = [
+  "popperInstRef",
+  "offset",
+  "placement",
+  "arrowOffset",
+  "showArrow",
+  "popperClass",
+  "popperStyle",
+  "name",
+  "display",
+  "unmountOnExit",
+  "transitionAppear",
+  "duration",
+  "gpuAcceleration",
+  "strategy",
+  "appendToBody",
+  "appendTo",
+  "popperOptions"
+];
+var partitionPopperPropsUtils = (props, options = {}) => {
+  const { popperProps = popperAllProps } = options;
+  const inputProps = {};
+  const rest = {};
+  (0, import_forEach.default)(props, (val, prop) => {
+    const target = (0, import_includes.default)(popperProps, prop) ? inputProps : rest;
+    target[prop] = val;
+  });
+  return [inputProps, rest];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  partitionPopperPropsUtils,
+  popperAllProps
+});

package/dist/hooks/prefix.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="lodash" />
+export declare const globalKey = "el";
+export declare const getClassNamePrefix: () => string;
+export declare const defaultClassPrefix: (name: string) => string;
+export type ISplitCode = '-' | '__' | '--';
+export declare function prefix(pre: string, className: string | string[], split?: ISplitCode): string;
+declare const _default: import("lodash").CurriedFunction2<string, string | string[], string>;
+export default _default;

package/dist/hooks/prefix.js

@@ -0,0 +1,62 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/prefix.ts
+var prefix_exports = {};
+__export(prefix_exports, {
+  default: () => prefix_default,
+  defaultClassPrefix: () => defaultClassPrefix,
+  getClassNamePrefix: () => getClassNamePrefix,
+  globalKey: () => globalKey,
+  prefix: () => prefix
+});
+module.exports = __toCommonJS(prefix_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_curry = __toESM(require("lodash/curry"));
+var globalKey = "el";
+var getClassNamePrefix = () => {
+  return globalKey + "-";
+};
+var defaultClassPrefix = (name) => `${getClassNamePrefix()}${name}`;
+function prefix(pre, className, split = "-") {
+  if (!pre || !className) {
+    return "";
+  }
+  if (Array.isArray(className)) {
+    return (0, import_classnames.default)(className.filter((name) => !!name).map((name) => `${pre}-${name}`));
+  }
+  return `${pre}${split}${className}`;
+}
+var prefix_default = (0, import_curry.default)(prefix);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultClassPrefix,
+  getClassNamePrefix,
+  globalKey,
+  prefix
+});

package/dist/hooks/treePropsUtils.d.ts

@@ -0,0 +1,3 @@
+import { DirectoryTreeProps } from '../Tree';
+export declare const treeAllProps: string[];
+export declare const partitionTreePropsUtils: (props: any, options?: any) => [DirectoryTreeProps<any>, any];

package/dist/hooks/treePropsUtils.js

@@ -0,0 +1,107 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/treePropsUtils.ts
+var treePropsUtils_exports = {};
+__export(treePropsUtils_exports, {
+  partitionTreePropsUtils: () => partitionTreePropsUtils,
+  treeAllProps: () => treeAllProps
+});
+module.exports = __toCommonJS(treePropsUtils_exports);
+var import_forEach = __toESM(require("lodash/forEach"));
+var import_includes = __toESM(require("lodash/includes"));
+var treeAllProps = [
+  "showLine",
+  "multiple",
+  "selectedKeys",
+  "filterAntTreeNode",
+  "showIcon",
+  "switcherIcon",
+  "children",
+  "blockNode",
+  "prefixCls",
+  "focusable",
+  "activeKey",
+  "tabIndex",
+  "treeData",
+  "fieldNames",
+  "icon",
+  "selectable",
+  "disabled",
+  "checkable",
+  "checkStrictly",
+  "draggable",
+  "defaultExpandParent",
+  "autoExpandParent",
+  "defaultExpandAll",
+  "defaultExpandedKeys",
+  "expandedKeys",
+  "defaultCheckedKeys",
+  "checkedKeys",
+  "defaultSelectedKeys",
+  "allowDrop",
+  "titleRender",
+  "dropIndicatorRender",
+  "onFocus",
+  "onBlur",
+  "onKeyDown",
+  "onContextMenu",
+  "onClick",
+  "onDoubleClick",
+  "onScroll",
+  "onExpand",
+  "onCheck",
+  "onSelect",
+  "onLoad",
+  "loadData",
+  "loadedKeys",
+  "onMouseEnter",
+  "onMouseLeave",
+  "onRightClick",
+  "onDragStart",
+  "onDragEnter",
+  "onDragOver",
+  "onDragLeave",
+  "onDragEnd",
+  "onDrop"
+];
+var partitionTreePropsUtils = (props, options = {}) => {
+  const { treeProps = treeAllProps } = options;
+  const inputProps = {};
+  const rest = {};
+  (0, import_forEach.default)(props, (val, prop) => {
+    const target = (0, import_includes.default)(treeProps, prop) ? inputProps : rest;
+    target[prop] = val;
+  });
+  return [inputProps, rest];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  partitionTreePropsUtils,
+  treeAllProps
+});

package/dist/hooks/useChildrenInstance.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ComponentChildren } from '../types/common';
+declare function useChildrenInstance<T, S = T>(compName: string | string[], ...virtualCompName: string[]): (componentChildren: ComponentChildren) => React.ReactElement<S>[];
+export default useChildrenInstance;

package/dist/hooks/useChildrenInstance.js

@@ -0,0 +1,66 @@
+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/hooks/useChildrenInstance.ts
+var useChildrenInstance_exports = {};
+__export(useChildrenInstance_exports, {
+  default: () => useChildrenInstance_default
+});
+module.exports = __toCommonJS(useChildrenInstance_exports);
+var import_react = require("react");
+function useChildrenInstance(compName, ...virtualCompName) {
+  const result = (0, import_react.useRef)([]);
+  virtualCompName = ["Fragment", ...virtualCompName];
+  if (typeof compName === "string") {
+    compName = [compName];
+  }
+  const getInstanceFromChildren = (0, import_react.useCallback)(
+    (_children) => {
+      import_react.Children.forEach(_children, (node) => {
+        let nodeType = node == null ? void 0 : node.type;
+        nodeType = (nodeType == null ? void 0 : nodeType.displayName) || nodeType;
+        if (typeof nodeType === "string" && compName.includes(nodeType)) {
+          const temp = node;
+          result.current.push(temp);
+        } else if (typeof nodeType === "string" && virtualCompName.includes(nodeType)) {
+          getInstanceFromChildren(node.props.children);
+        } else if (nodeType === import_react.Fragment) {
+          getInstanceFromChildren(node.props.children);
+        } else if (node instanceof Array) {
+          getInstanceFromChildren(node);
+        } else {
+          return true;
+        }
+      });
+    },
+    [compName, virtualCompName]
+  );
+  const getValue = (0, import_react.useCallback)(
+    (componentChildren) => {
+      if (componentChildren) {
+        result.current = [];
+        getInstanceFromChildren(componentChildren);
+        return result.current;
+      }
+      return [];
+    },
+    [getInstanceFromChildren]
+  );
+  return getValue;
+}
+var useChildrenInstance_default = useChildrenInstance;

package/dist/hooks/useClassNames.d.ts

@@ -0,0 +1,29 @@
+export type ClassValue = string | number | ClassDictionary | ClassArray | undefined | null | boolean;
+export interface ClassArray extends Array<ClassValue> {
+}
+export type ClassDictionary = Record<string, any>;
+export type ClassNameM = {
+    wb: (...classes: ClassValue[]) => string;
+    b: (...classes: ClassValue[]) => string;
+    e: (...classes: ClassValue[]) => string;
+    m: (...classes: ClassValue[]) => string;
+    be: (prefix: string, sub: string, compName?: boolean) => string;
+    em: (sub: string, modifier: string, compName?: boolean) => string;
+    bm: (prefix: string, modifier: string, compName?: boolean) => string;
+    bem: (prefix: string, sub: string, modifier: string, compName?: boolean) => string;
+    ebm: (sub: string, prefix: string, modifier: string, compName?: boolean) => string;
+    is: (...classes: ClassValue[]) => string;
+};
+declare function useClassNames(str: string, classPrefix?: string): {
+    wb: (...classes: ClassValue[]) => string;
+    b: (...classes: ClassValue[]) => string;
+    e: (...classes: ClassValue[]) => string;
+    m: (...classes: ClassValue[]) => string;
+    be: (prefix: string, sub: string, compName?: boolean) => string;
+    em: (sub: string, modifier: string, compName?: boolean) => string;
+    bm: (prefix: string, modifier: string, compName?: boolean) => string;
+    bem: (prefix: string, sub: string, modifier: string, compName?: boolean) => string;
+    ebm: (sub: string, prefix: string, modifier: string, compName?: boolean) => string;
+    is: (...classes: ClassValue[]) => string;
+};
+export default useClassNames;

package/dist/hooks/useClassNames.js

@@ -0,0 +1,210 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/useClassNames.ts
+var useClassNames_exports = {};
+__export(useClassNames_exports, {
+  default: () => useClassNames_default
+});
+module.exports = __toCommonJS(useClassNames_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_isBoolean = __toESM(require("lodash/isBoolean"));
+var import_last = __toESM(require("lodash/last"));
+var import_react = require("react");
+var import_prefix = require("./prefix");
+function useClassNames(str, classPrefix = import_prefix.globalKey) {
+  const componentName = (0, import_prefix.prefix)(classPrefix, str);
+  const prefixSplit = (0, import_react.useCallback)(
+    (splitCode, ...classes) => {
+      let compName = true;
+      if ((classes == null ? void 0 : classes.length) > 0) {
+        if ((0, import_isBoolean.default)((0, import_last.default)(classes))) {
+          compName = (0, import_last.default)(classes);
+        }
+      }
+      const mergeClasses = classes.length ? (0, import_classnames.default)(...classes).split(" ").map((item) => (0, import_prefix.prefix)(compName ? componentName : classPrefix, item, splitCode)) : [];
+      return mergeClasses.filter((cls) => cls).join(" ");
+    },
+    [classPrefix, componentName]
+  );
+  const b = (0, import_react.useCallback)(
+    (...classes) => {
+      let compName = true;
+      if ((classes == null ? void 0 : classes.length) > 0) {
+        if ((0, import_isBoolean.default)((0, import_last.default)(classes))) {
+          compName = (0, import_last.default)(classes);
+        }
+      }
+      const mergeClasses = classes.length ? (0, import_classnames.default)(...classes).split(" ").map((item) => (0, import_prefix.prefix)(compName ? componentName : classPrefix, item)) : [componentName];
+      return mergeClasses.filter((cls) => cls).join(" ");
+    },
+    [classPrefix, componentName]
+  );
+  const wb = (0, import_react.useCallback)(
+    (...classes) => {
+      let compName = true;
+      if ((classes == null ? void 0 : classes.length) > 0) {
+        if ((0, import_isBoolean.default)((0, import_last.default)(classes))) {
+          compName = (0, import_last.default)(classes);
+        }
+      }
+      const mergeClasses = b(classes, compName);
+      return mergeClasses ? `${componentName} ${mergeClasses}` : componentName;
+    },
+    [componentName, b]
+  );
+  const e = (0, import_react.useCallback)(
+    (...classes) => {
+      const mergeClasses = prefixSplit("__", ...classes);
+      return mergeClasses;
+    },
+    [prefixSplit]
+  );
+  const m = (0, import_react.useCallback)(
+    (...classes) => {
+      const mergeClasses = prefixSplit("--", ...classes);
+      return mergeClasses;
+    },
+    [prefixSplit]
+  );
+  const be = (0, import_react.useCallback)(
+    (prefix, sub, compName = true) => {
+      return `${compName ? componentName : classPrefix}-${prefix}__${sub}`;
+    },
+    [classPrefix, componentName]
+  );
+  const em = (0, import_react.useCallback)(
+    (sub, modifier, compName = true) => {
+      return `${compName ? componentName : classPrefix}__${sub}--${modifier}`;
+    },
+    [classPrefix, componentName]
+  );
+  const bm = (0, import_react.useCallback)(
+    (prefix, modifier, compName = true) => {
+      return `${compName ? componentName : classPrefix}-${prefix}--${modifier}`;
+    },
+    [classPrefix, componentName]
+  );
+  const bem = (0, import_react.useCallback)(
+    (prefix, sub, modifier, compName = true) => {
+      return `${compName ? componentName : classPrefix}-${prefix}__${sub}--${modifier}`;
+    },
+    [classPrefix, componentName]
+  );
+  const ebm = (0, import_react.useCallback)(
+    (sub, prefix, modifier, compName = true) => {
+      return `${compName ? componentName : classPrefix}__${sub}-${prefix}--${modifier}`;
+    },
+    [classPrefix, componentName]
+  );
+  const is = (0, import_react.useCallback)((...classes) => {
+    const mergeClasses = classes.length ? (0, import_classnames.default)(...classes).split(" ").filter((cls) => cls).map((item) => `is-${item}`) : [];
+    return mergeClasses.join(" ");
+  }, []);
+  return {
+    /**
+     * 如果组件前缀是'button':
+     *
+     * wb('red', { active: true }) => 'el-button el-button-red el-button-active'
+     *
+     * wb('red', { active: true }, false) => 'el-button el-red el-active'
+     */
+    wb,
+    /**
+     * 如果组件前缀是'button':
+     *
+     * b('red', { active: true }) => 'el-button-red el-button-active'
+     *
+     * b('red', { active: true }, false) => 'el-red el-active'
+     */
+    b,
+    /**
+     * 如果组件前缀是'button':
+     *
+     * e('red', { active: true }) => 'el-button__red el-button__active'
+     *
+     * e('red', { active: true }, false) => 'r__red r__active'
+     */
+    e,
+    /**
+     * 如果组件前缀是'button':
+     *
+     * m('red', { active: true }) => 'el-button--red el-button--active'
+     *
+     * m('red', { active: true }, false) => 'el--red el--active'
+     */
+    m,
+    /**
+     * 如果组件前缀是'button':
+     *
+     * be('red', 'active') => 'el-button-red__active'
+     *
+     * be('red', 'active', false) => 'el-red__active'
+     */
+    be,
+    /**
+     * 如果组件前缀是'button':
+     *
+     * em( 'color", 'active') => 'el-button__color--active'
+     *
+     * em( 'color", 'active', false) => 'r__color--active'
+     */
+    em,
+    /**
+     * 如果组件前缀是'button':
+     *
+     * be( 'color", 'active') => 'el-button-color--active'
+     *
+     * be( 'color", 'active', false) => 'el-color--active'
+     */
+    bm,
+    /**
+     * 如果组件前缀是'button':
+     *
+     * bem('red', 'color", 'active') => 'el-button-red__color--active'
+     *
+     * bem('red', 'color", 'active', false) => 'el-red__color--active'
+     */
+    bem,
+    /**
+     * 如果组件前缀是'button':
+     *
+     * ebm('close', 'icon", 'hidden') => 'el-button__close-icon--hidden'
+     *
+     * ebm('close', 'icon", 'hidden', false) => 'r__close-icon--hidden'
+     */
+    ebm,
+    /**
+     * 如果组件前缀是'button':
+     *
+     * is('block', { block: true }) => 'is-block'
+     */
+    is
+  };
+}
+var useClassNames_default = useClassNames;

package/dist/hooks/useClickOutside.d.ts

@@ -0,0 +1,9 @@
+import { RefObject } from 'react';
+interface DirectiveBinding<V = any> {
+    popperRef: HTMLDivElement;
+    value: V;
+    arg?: string;
+    visible?: boolean;
+}
+declare const useClickOutside: (el: RefObject<HTMLElement>, binding: DirectiveBinding) => void;
+export default useClickOutside;