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

package/dist/Tree/utils/pickAttrs.js

@@ -0,0 +1,79 @@
+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/Tree/utils/pickAttrs.ts
+var pickAttrs_exports = {};
+__export(pickAttrs_exports, {
+  default: () => pickAttrs
+});
+module.exports = __toCommonJS(pickAttrs_exports);
+var attributes = `accept acceptCharset accessKey action allowFullScreen allowTransparency
+    alt async autoComplete autoFocus autoPlay capture cellPadding cellSpacing challenge
+    charSet checked classID className colSpan cols content contentEditable contextMenu
+    controls coords crossOrigin data dateTime default defer dir disabled download draggable
+    encType form formAction formEncType formMethod formNoValidate formTarget frameBorder
+    headers height hidden high href hrefLang htmlFor httpEquiv icon id inputMode integrity
+    is keyParams keyType kind label lang list loop low manifest marginHeight marginWidth max maxLength media
+    mediaGroup method min minLength multiple muted name noValidate nonce open
+    optimum pattern placeholder poster preload radioGroup readOnly rel required
+    reversed role rowSpan rows sandbox scope scoped scrolling seamless selected
+    shape size sizes span spellCheck src srcDoc srcLang srcSet start step style
+    summary tabIndex target title type useMap value width wmode wrap`;
+var eventsName = `onCopy onCut onPaste onCompositionEnd onCompositionStart onCompositionUpdate onKeyDown
+    onKeyPress onKeyUp onFocus onBlur onChange onInput onSubmit onClick onContextMenu onDoubleClick
+    onDrag onDragEnd onDragEnter onDragExit onDragLeave onDragOver onDragStart onDrop onMouseDown
+    onMouseEnter onMouseLeave onMouseMove onMouseOut onMouseOver onMouseUp onSelect onTouchCancel
+    onTouchEnd onTouchMove onTouchStart onScroll onWheel onAbort onCanPlay onCanPlayThrough
+    onDurationChange onEmptied onEncrypted onEnded onError onLoadedData onLoadedMetadata
+    onLoadStart onPause onPlay onPlaying onProgress onRateChange onSeeked onSeeking onStalled onSuspend onTimeUpdate onVolumeChange onWaiting onLoad onError`;
+var propList = `${attributes} ${eventsName}`.split(/[\s\n]+/);
+var ariaPrefix = "aria-";
+var dataPrefix = "data-";
+function match(key, prefix) {
+  return key.indexOf(prefix) === 0;
+}
+function pickAttrs(props, ariaOnly = false) {
+  let mergedConfig;
+  if (ariaOnly === false) {
+    mergedConfig = {
+      aria: true,
+      data: true,
+      attr: true
+    };
+  } else if (ariaOnly === true) {
+    mergedConfig = {
+      aria: true
+    };
+  } else {
+    mergedConfig = {
+      ...ariaOnly
+    };
+  }
+  const attrs = {};
+  Object.keys(props).forEach((key) => {
+    if (
+      // Aria
+      mergedConfig.aria && (key === "role" || match(key, ariaPrefix)) || // Data
+      mergedConfig.data && match(key, dataPrefix) || // Attr
+      mergedConfig.attr && propList.includes(key)
+    ) {
+      attrs[key] = props[key];
+    }
+  });
+  return attrs;
+}

package/dist/Tree/utils/treeUtil.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+import { TreeNodeProps } from '../TreeNode';
+import { BasicDataNode, DataEntity, DataNode, EventDataNode, FieldNames, FlattenNode, GetKey, Key } from '../typings';
+export declare function getKey(key: Key, pos: string): Key;
+export declare function fillFieldNames(fieldNames?: FieldNames): Required<FieldNames>;
+export declare function warningWithoutKey(treeData: DataNode[], fieldNames: FieldNames): void;
+export declare function convertTreeToData<T = DataNode>(rootNodes: React.ReactElement): T[];
+export declare function flattenTreeData(treeNodeList: DataNode[], expandedKeys: Key[] | true, fieldNames: FieldNames): FlattenNode[];
+type ExternalGetKey = GetKey<DataNode> | string;
+interface TraverseDataNodesConfig {
+    childrenPropName?: string;
+    externalGetKey?: ExternalGetKey;
+    fieldNames?: FieldNames;
+}
+export declare function traverseDataNodes<T = DataNode>(dataNodes: T[], callback: (data: {
+    node: T;
+    index: number;
+    pos: string;
+    key: Key;
+    parentPos: string | number;
+    level: number;
+    nodes: T[];
+}) => void, config?: TraverseDataNodesConfig | string): void;
+interface Wrapper {
+    posEntities: Record<string, DataEntity>;
+    keyEntities: Record<Key, DataEntity>;
+}
+export declare function convertDataToEntities<T = DataNode>(dataNodes: T[], { initWrapper, processEntity, onProcessFinished, externalGetKey, childrenPropName, fieldNames, }?: {
+    initWrapper?: (wrapper: Wrapper) => Wrapper;
+    processEntity?: (entity: DataEntity, wrapper: Wrapper) => void;
+    onProcessFinished?: (wrapper: Wrapper) => void;
+    externalGetKey?: ExternalGetKey;
+    childrenPropName?: string;
+    fieldNames?: FieldNames;
+}, legacyExternalGetKey?: ExternalGetKey): {
+    posEntities: {};
+    keyEntities: {};
+};
+export interface TreeNodeRequiredProps<TreeDataType extends BasicDataNode = DataNode> {
+    expandedKeys: Key[];
+    selectedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    keyEntities: Record<Key, DataEntity<TreeDataType>>;
+}
+export declare function getTreeNodeProps<TreeDataType extends BasicDataNode = DataNode>(key: Key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities }: TreeNodeRequiredProps<TreeDataType>): {
+    eventKey: Key;
+    expanded: boolean;
+    selected: boolean;
+    loaded: boolean;
+    loading: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    pos: string;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+};
+export declare function convertNodePropsToEventData<TreeDataType extends BasicDataNode = DataNode>(props: TreeNodeProps<TreeDataType>): EventDataNode;
+export {};

package/dist/Tree/utils/treeUtil.js

@@ -0,0 +1,283 @@
+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/Tree/utils/treeUtil.ts
+var treeUtil_exports = {};
+__export(treeUtil_exports, {
+  convertDataToEntities: () => convertDataToEntities,
+  convertNodePropsToEventData: () => convertNodePropsToEventData,
+  convertTreeToData: () => convertTreeToData,
+  fillFieldNames: () => fillFieldNames,
+  flattenTreeData: () => flattenTreeData,
+  getKey: () => getKey,
+  getTreeNodeProps: () => getTreeNodeProps,
+  traverseDataNodes: () => traverseDataNodes,
+  warningWithoutKey: () => warningWithoutKey
+});
+module.exports = __toCommonJS(treeUtil_exports);
+var import_Util = require("../../Util");
+var import_util = require("../util");
+function getKey(key, pos) {
+  if (key !== null && key !== void 0) {
+    return key;
+  }
+  return pos;
+}
+function fillFieldNames(fieldNames) {
+  const { title, _title, key, children } = fieldNames || {};
+  const mergedTitle = title || "title";
+  return {
+    title: mergedTitle,
+    _title: _title || [mergedTitle],
+    key: key || "key",
+    children: children || "children"
+  };
+}
+function warningWithoutKey(treeData, fieldNames) {
+  const keys = /* @__PURE__ */ new Map();
+  function dig(list, path = "") {
+    (list || []).forEach((treeNode) => {
+      const key = treeNode[fieldNames.key];
+      const children = treeNode[fieldNames.children];
+      (0, import_Util.warning)(key !== null && key !== void 0, `Tree node must have a certain key: [${path}${key}]`);
+      const recordKey = String(key);
+      (0, import_Util.warning)(!keys.has(recordKey) || key === null || key === void 0, `Same 'key' exist in the Tree: ${recordKey}`);
+      keys.set(recordKey, true);
+      dig(children, `${path}${recordKey} > `);
+    });
+  }
+  dig(treeData);
+}
+function convertTreeToData(rootNodes) {
+  function dig(node) {
+    const treeNodes = (0, import_util.toArray)(node);
+    return treeNodes.map((treeNode) => {
+      if (!(0, import_util.isTreeNode)(treeNode)) {
+        (0, import_Util.warning)(!treeNode, "Tree/TreeNode can only accept TreeNode as children.");
+        return null;
+      }
+      const { key } = treeNode;
+      const { children, ...rest } = treeNode.props;
+      const dataNode = {
+        key,
+        ...rest
+      };
+      const parsedChildren = dig(children);
+      if (parsedChildren.length) {
+        dataNode.children = parsedChildren;
+      }
+      return dataNode;
+    }).filter((dataNode) => dataNode);
+  }
+  return dig(rootNodes);
+}
+function flattenTreeData(treeNodeList, expandedKeys, fieldNames) {
+  const { _title: fieldTitles, key: fieldKey, children: fieldChildren } = fillFieldNames(fieldNames);
+  const expandedKeySet = new Set(expandedKeys === true ? [] : expandedKeys);
+  const flattenList = [];
+  function dig(list, parent = null) {
+    return list.map((treeNode, index) => {
+      const pos = (0, import_util.getPosition)(parent ? parent.pos : "0", index);
+      const mergedKey = getKey(treeNode[fieldKey], pos);
+      let mergedTitle;
+      for (let i = 0; i < fieldTitles.length; i += 1) {
+        const fieldTitle = fieldTitles[i];
+        if (treeNode[fieldTitle] !== void 0) {
+          mergedTitle = treeNode[fieldTitle];
+          break;
+        }
+      }
+      const flattenNode = {
+        ...(0, import_util.omit)(treeNode, [...fieldTitles, fieldKey, fieldChildren]),
+        title: mergedTitle,
+        key: mergedKey,
+        parent,
+        pos,
+        children: null,
+        data: treeNode,
+        isStart: [...parent ? parent.isStart : [], index === 0],
+        isEnd: [...parent ? parent.isEnd : [], index === list.length - 1]
+      };
+      flattenList.push(flattenNode);
+      if (expandedKeys === true || expandedKeySet.has(mergedKey)) {
+        flattenNode.children = dig(treeNode[fieldChildren] || [], flattenNode);
+      } else {
+        flattenNode.children = [];
+      }
+      return flattenNode;
+    });
+  }
+  dig(treeNodeList);
+  return flattenList;
+}
+function traverseDataNodes(dataNodes, callback, config) {
+  let mergedConfig = {};
+  if (typeof config === "object") {
+    mergedConfig = config;
+  } else {
+    mergedConfig = { externalGetKey: config };
+  }
+  mergedConfig = mergedConfig || {};
+  const { childrenPropName, externalGetKey, fieldNames } = mergedConfig;
+  const { key: fieldKey, children: fieldChildren } = fillFieldNames(fieldNames);
+  const mergeChildrenPropName = childrenPropName || fieldChildren;
+  let syntheticGetKey;
+  if (externalGetKey) {
+    if (typeof externalGetKey === "string") {
+      syntheticGetKey = (node) => node[externalGetKey];
+    } else if (typeof externalGetKey === "function") {
+      syntheticGetKey = (node) => externalGetKey(node);
+    }
+  } else {
+    syntheticGetKey = (node, pos) => getKey(node[fieldKey], pos);
+  }
+  function processNode(node, index, parent, pathNodes) {
+    const children = node ? node[mergeChildrenPropName] : dataNodes;
+    const pos = node ? (0, import_util.getPosition)(parent.pos, index) : "0";
+    const connectNodes = node ? [...pathNodes, node] : [];
+    if (node) {
+      const key = syntheticGetKey(node, pos);
+      const data = {
+        node,
+        index,
+        pos,
+        key,
+        parentPos: parent.node ? parent.pos : null,
+        level: parent.level + 1,
+        nodes: connectNodes
+      };
+      callback(data);
+    }
+    if (children) {
+      children.forEach((subNode, subIndex) => {
+        processNode(
+          subNode,
+          subIndex,
+          {
+            node,
+            pos,
+            level: parent ? parent.level + 1 : -1
+          },
+          connectNodes
+        );
+      });
+    }
+  }
+  processNode(null);
+}
+function convertDataToEntities(dataNodes, {
+  initWrapper,
+  processEntity,
+  onProcessFinished,
+  externalGetKey,
+  childrenPropName,
+  fieldNames
+} = {}, legacyExternalGetKey) {
+  const mergedExternalGetKey = externalGetKey || legacyExternalGetKey;
+  const posEntities = {};
+  const keyEntities = {};
+  let wrapper = {
+    posEntities,
+    keyEntities
+  };
+  if (initWrapper) {
+    wrapper = initWrapper(wrapper) || wrapper;
+  }
+  traverseDataNodes(
+    dataNodes,
+    (item) => {
+      const { node, index, pos, key, parentPos, level, nodes } = item;
+      const entity = { node, nodes, index, key, pos, level };
+      const mergedKey = getKey(key, pos);
+      posEntities[pos] = entity;
+      keyEntities[mergedKey] = entity;
+      entity.parent = posEntities[parentPos];
+      if (entity.parent) {
+        entity.parent.children = entity.parent.children || [];
+        entity.parent.children.push(entity);
+      }
+      if (processEntity) {
+        processEntity(entity, wrapper);
+      }
+    },
+    { externalGetKey: mergedExternalGetKey, childrenPropName, fieldNames }
+  );
+  if (onProcessFinished) {
+    onProcessFinished(wrapper);
+  }
+  return wrapper;
+}
+function getTreeNodeProps(key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities }) {
+  const entity = keyEntities[key];
+  const treeNodeProps = {
+    eventKey: key,
+    expanded: expandedKeys.indexOf(key) !== -1,
+    selected: selectedKeys.indexOf(key) !== -1,
+    loaded: loadedKeys.indexOf(key) !== -1,
+    loading: loadingKeys.indexOf(key) !== -1,
+    checked: checkedKeys.indexOf(key) !== -1,
+    halfChecked: halfCheckedKeys.indexOf(key) !== -1,
+    pos: String(entity ? entity.pos : ""),
+    // [Legacy] Drag props
+    // Since the interaction of drag is changed, the semantic of the props are
+    // not accuracy, I think it should be finally removed
+    dragOver: dragOverNodeKey === key && dropPosition === 0,
+    dragOverGapTop: dragOverNodeKey === key && dropPosition === -1,
+    dragOverGapBottom: dragOverNodeKey === key && dropPosition === 1
+  };
+  return treeNodeProps;
+}
+function convertNodePropsToEventData(props) {
+  const { data, expanded, selected, checked, loaded, loading, halfChecked, dragOver, dragOverGapTop, dragOverGapBottom, pos, active, eventKey } = props;
+  const eventData = {
+    ...data,
+    expanded,
+    selected,
+    checked,
+    loaded,
+    loading,
+    halfChecked,
+    dragOver,
+    dragOverGapTop,
+    dragOverGapBottom,
+    pos,
+    active,
+    key: eventKey
+  };
+  if (!("props" in eventData)) {
+    Object.defineProperty(eventData, "props", {
+      get() {
+        (0, import_Util.warning)(false, "Second param return from event is node data instead of TreeNode instance. Please read value directly instead of reading from `props`.");
+        return props;
+      }
+    });
+  }
+  return eventData;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertDataToEntities,
+  convertNodePropsToEventData,
+  convertTreeToData,
+  fillFieldNames,
+  flattenTreeData,
+  getKey,
+  getTreeNodeProps,
+  traverseDataNodes,
+  warningWithoutKey
+});

package/dist/TreeSelect/TreeSelect.d.ts

@@ -0,0 +1,12 @@
+import React, { RefObject } from 'react';
+import { TreeSelectProps, TreeSelectRef } from './typings';
+declare const ForwardTreeSelect: <RecordType extends object = any>(props: TreeSelectProps<RecordType, string | number | readonly string[]> & {
+    ref?: RefObject<TreeSelectRef>;
+}) => React.ReactElement;
+type InternalDirectoryTreeType = typeof ForwardTreeSelect;
+interface DirectoryTreeSelectInterface extends InternalDirectoryTreeType {
+    displayName?: string;
+    defaultProps?: Partial<TreeSelectProps<any>>;
+}
+declare const TreeSelect: DirectoryTreeSelectInterface;
+export default TreeSelect;