@nickeylin/antd-mobile-pro 2.0.0

package/dist/cjs/components/table/index.js

@@ -0,0 +1,27 @@
+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/table/index.ts
+var table_exports = {};
+__export(table_exports, {
+  default: () => table_default
+});
+module.exports = __toCommonJS(table_exports);
+var import_table = require("./table");
+var import_table2 = require("./table.less");
+var table_default = import_table.Table;

package/dist/cjs/components/table/table.d.ts

@@ -0,0 +1,4 @@
+import React, { FunctionComponent } from 'react';
+import { BasicTableProps } from './types';
+export type TableProps = BasicTableProps;
+export declare const Table: FunctionComponent<Partial<TableProps> & React.HTMLAttributes<HTMLDivElement>>;

package/dist/cjs/components/table/table.js

@@ -0,0 +1,154 @@
+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/components/table/table.tsx
+var table_exports = {};
+__export(table_exports, {
+  Table: () => Table
+});
+module.exports = __toCommonJS(table_exports);
+var import_native_props = require("antd-mobile/es/utils/native-props");
+var import_with_default_props = require("antd-mobile/es/utils/with-default-props");
+var import_antd_mobile_icons = require("antd-mobile-icons");
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var defaultProps = {
+  columns: [],
+  data: [],
+  bordered: true,
+  striped: false,
+  noData: "",
+  sorterIcon: null,
+  showHeader: true
+};
+var Table = (p) => {
+  const props = (0, import_with_default_props.mergeProps)(defaultProps, p);
+  const {
+    children,
+    className,
+    style,
+    columns,
+    data,
+    bordered,
+    summary,
+    striped,
+    noData,
+    sorterIcon,
+    showHeader,
+    onSort,
+    ...rest
+  } = {
+    ...props
+  };
+  const [curData, setCurData] = (0, import_react.useState)(data);
+  (0, import_react.useEffect)(() => {
+    if (data && String(data) !== String(curData)) {
+      setCurData(data);
+    }
+  }, [data]);
+  const classPrefix = "amd-table";
+  const headerClassPrefix = `${classPrefix}__main__head__tr`;
+  const bodyClassPrefix = `${classPrefix}__main__body__tr`;
+  const cls = (0, import_classnames.default)(classPrefix, className);
+  const handleSorterClick = (item) => {
+    if (item.sorter) {
+      onSort && onSort(item, curData);
+      if (typeof item.sorter === "function") {
+        setCurData(curData.sort(item.sorter));
+      } else {
+        setCurData(item.sorter === "default" ? curData.sort() : curData);
+      }
+    }
+  };
+  const cellClasses = (item) => {
+    return {
+      [`${headerClassPrefix}--border`]: props.bordered,
+      [`${headerClassPrefix}--align${item.align ? item.align : ""}`]: true
+    };
+  };
+  const getColumnItem = (value) => {
+    return columns.filter((item) => item.key === value)[0];
+  };
+  const renderHeadCells = () => {
+    return columns.map((item, index) => {
+      return /* @__PURE__ */ import_react.default.createElement(
+        "span",
+        {
+          className: (0, import_classnames.default)(`${headerClassPrefix}__th`, cellClasses(item)),
+          key: item.key ?? index,
+          onClick: () => handleSorterClick(item)
+        },
+        item.title,
+        " ",
+        item.sorter && (sorterIcon || /* @__PURE__ */ import_react.default.createElement(import_antd_mobile_icons.DownFill, { fontSize: 12 }))
+      );
+    });
+  };
+  const sortDataItem = () => {
+    return columns.map((columns2) => {
+      return [columns2.key, columns2.render];
+    });
+  };
+  const renderBodyTds = (item) => {
+    return sortDataItem().map(([value, render], index) => {
+      return /* @__PURE__ */ import_react.default.createElement(
+        "span",
+        {
+          className: (0, import_classnames.default)(
+            `${bodyClassPrefix}__td`,
+            cellClasses(getColumnItem(value))
+          ),
+          key: value ?? index
+        },
+        typeof item[value] === "function" || typeof render === "function" ? /* @__PURE__ */ import_react.default.createElement("div", null, render ? render(item) : item[value](item)) : item[value]
+      );
+    });
+  };
+  const renderBoyTrs = () => {
+    return curData.map((item, index) => {
+      return /* @__PURE__ */ import_react.default.createElement("div", { className: bodyClassPrefix, key: index }, renderBodyTds(item));
+    });
+  };
+  return (0, import_native_props.withNativeProps)(
+    props,
+    /* @__PURE__ */ import_react.default.createElement("div", { className: cls, style, ...rest }, /* @__PURE__ */ import_react.default.createElement(
+      "div",
+      {
+        className: (0, import_classnames.default)(`${classPrefix}__main`, {
+          [`${classPrefix}__main--striped`]: striped
+        })
+      },
+      showHeader && /* @__PURE__ */ import_react.default.createElement("div", { className: `${classPrefix}__main__head` }, /* @__PURE__ */ import_react.default.createElement("div", { className: headerClassPrefix }, renderHeadCells())),
+      /* @__PURE__ */ import_react.default.createElement("div", { className: `${classPrefix}__main__body` }, renderBoyTrs())
+    ), (summary || curData.length === 0) && /* @__PURE__ */ import_react.default.createElement("div", { className: `${classPrefix}__summary` }, summary || noData))
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Table
+});

package/dist/cjs/components/table/table.less

@@ -0,0 +1,101 @@
+@class-prefix-table: ~'amd-table';
+
+.@{class-prefix-table} {
+  display: flex;
+  width: 100%;
+  flex-direction: column;
+  font-size: var(--adm-font-size-6);
+  color: var(--adm-color-text);
+  --table-border-color: #ececec;
+  --table-cols-padding: 10px;
+  --table-tr-even-bg-color: #f4f4f4;
+  --table-tr-odd-bg-color: #fffff;
+
+  &__main {
+    display: table;
+    width: 100%;
+    border-collapse: collapse;
+    overflow-x: hidden;
+    color: var(--adm-color-text);
+    background-color: var(--adm-color-white);
+
+    &--striped {
+      .amd-table__main__head {
+        &__tr {
+          background-color: var(--table-tr-even-bg-color);
+        }
+      }
+
+      .amd-table__main__body {
+        &__tr:nth-child(odd) {
+          background-color: var(--table-tr-odd-bg-color);
+        }
+      }
+
+      .amd-table__main__body {
+        &__tr:nth-child(even) {
+          background-color: var(--table-tr-even-bg-color);
+        }
+      }
+    }
+
+    &__head,
+    &__body {
+      &__tr {
+        display: table-row;
+
+        &__th {
+          display: table-cell;
+          padding: var(--table-cols-padding);
+        }
+
+        &__td {
+          display: table-cell;
+          padding: var(--table-cols-padding);
+
+          &__nodata {
+            display: flex;
+            height: 50px;
+            align-items: center;
+            justify-content: center;
+          }
+        }
+
+        &--border {
+          border: 1px solid var(--table-border-color);
+        }
+
+        &--alignleft,
+        &--align {
+          text-align: left;
+        }
+
+        &--aligncenter {
+          text-align: center;
+        }
+
+        &--alignright {
+          text-align: right;
+        }
+      }
+    }
+
+    &__head {
+      display: table-header-group;
+    }
+
+    &__body {
+      display: table-row-group;
+    }
+  }
+
+  &__summary {
+    color: #262626;
+    background-color: #ffffff;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 30px;
+    padding: var(--table-cols-padding);
+  }
+}

package/dist/cjs/components/table/types.d.ts

@@ -0,0 +1,20 @@
+import { NativeProps } from 'antd-mobile/es/utils/native-props';
+import React from 'react';
+export interface BasicTableProps extends NativeProps<'--table-border-color' | '--table-cols-padding' | '--table-tr-even-bg-color' | '--table-tr-odd-bg-color'> {
+    columns: Array<TableColumnProps>;
+    data: Array<any>;
+    bordered: boolean;
+    summary?: React.ReactNode;
+    striped?: boolean;
+    noData?: React.ReactNode;
+    sorterIcon?: React.ReactNode;
+    onSort?: (item: TableColumnProps, data: Array<any>) => void;
+    showHeader?: boolean;
+}
+export interface TableColumnProps {
+    key: string;
+    title?: string;
+    align?: string;
+    sorter?: ((a: any, b: any) => number) | boolean | string;
+    render?: (rowData?: any, rowIndex?: number) => string | React.ReactNode;
+}

package/dist/cjs/components/table/types.js

@@ -0,0 +1,17 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/table/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/components/toast/index.d.ts

@@ -0,0 +1,2 @@
+import Toast from './toast';
+export default Toast;

package/dist/cjs/components/toast/index.js

@@ -0,0 +1,36 @@
+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/components/toast/index.ts
+var toast_exports = {};
+__export(toast_exports, {
+  default: () => toast_default
+});
+module.exports = __toCommonJS(toast_exports);
+var import_toast = __toESM(require("./toast"));
+var toast_default = import_toast.default;

package/dist/cjs/components/toast/toast.d.ts

@@ -0,0 +1,13 @@
+import { ToastShowProps } from 'antd-mobile';
+import { ReactNode } from 'react';
+declare function loading(p?: string | (Omit<ToastShowProps, 'icon'> & {
+    icon?: ReactNode;
+})): import("antd-mobile/es/components/toast").ToastHandler;
+declare const _default: {
+    show: typeof import("antd-mobile/es/components/toast/methods").show;
+    clear: typeof import("antd-mobile/es/components/toast/methods").clear;
+    config: typeof import("antd-mobile/es/components/toast/methods").config;
+} & {
+    loading: typeof loading;
+};
+export default _default;

package/dist/cjs/components/toast/toast.js

@@ -0,0 +1,36 @@
+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/toast/toast.ts
+var toast_exports = {};
+__export(toast_exports, {
+  default: () => toast_default
+});
+module.exports = __toCommonJS(toast_exports);
+var import_antd_mobile = require("antd-mobile");
+function loading(p) {
+  const option = typeof p === "string" ? { content: p } : p ?? {};
+  return import_antd_mobile.Toast.show({
+    icon: "loading",
+    maskClickable: false,
+    content: "加载中…",
+    duration: 6e4,
+    ...option
+  });
+}
+var toast_default = Object.assign(import_antd_mobile.Toast, { loading });

package/dist/cjs/components/tree/DirectoryTree.d.ts

@@ -0,0 +1,21 @@
+import type RcTree from 'rc-tree';
+import type { BasicDataNode } from 'rc-tree';
+import type { DataNode, Key } from 'rc-tree/lib/interface';
+import * as React from 'react';
+import type { TreeProps } from './tree';
+export type ExpandAction = false | 'click' | 'doubleClick';
+export interface DirectoryTreeProps<T extends BasicDataNode = DataNode> extends TreeProps<T> {
+    expandAction?: ExpandAction;
+}
+type DirectoryTreeCompoundedComponent = (<T extends BasicDataNode | DataNode = DataNode>(props: React.PropsWithChildren<DirectoryTreeProps<T>> & {
+    ref?: React.Ref<RcTree>;
+}) => React.ReactElement) & {
+    defaultProps: Partial<React.PropsWithChildren<DirectoryTreeProps<any>>>;
+    displayName?: string;
+};
+export interface DirectoryTreeState {
+    expandedKeys?: Key[];
+    selectedKeys?: Key[];
+}
+declare const ForwardDirectoryTree: DirectoryTreeCompoundedComponent;
+export default ForwardDirectoryTree;

package/dist/cjs/components/tree/DirectoryTree.js

@@ -0,0 +1,176 @@
+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/components/tree/DirectoryTree.tsx
+var DirectoryTree_exports = {};
+__export(DirectoryTree_exports, {
+  default: () => DirectoryTree_default
+});
+module.exports = __toCommonJS(DirectoryTree_exports);
+var import_FileOutlined = __toESM(require("@ant-design/icons/FileOutlined"));
+var import_FolderOpenOutlined = __toESM(require("@ant-design/icons/FolderOpenOutlined"));
+var import_FolderOutlined = __toESM(require("@ant-design/icons/FolderOutlined"));
+var import_classnames = __toESM(require("classnames"));
+var import_util = require("rc-tree/lib/util");
+var import_treeUtil = require("rc-tree/lib/utils/treeUtil");
+var React = __toESM(require("react"));
+var import_tree = __toESM(require("./tree"));
+var import_dictUtil = require("./utils/dictUtil");
+function getIcon(props) {
+  const { isLeaf, expanded } = props;
+  if (isLeaf) {
+    return /* @__PURE__ */ React.createElement(import_FileOutlined.default, null);
+  }
+  return expanded ? /* @__PURE__ */ React.createElement(import_FolderOpenOutlined.default, null) : /* @__PURE__ */ React.createElement(import_FolderOutlined.default, null);
+}
+function getTreeData({ dataSource, children }) {
+  return dataSource || (0, import_treeUtil.convertTreeToData)(children);
+}
+var DirectoryTree = ({ defaultExpandAll, defaultExpandParent, defaultExpandedKeys, ...props }, ref) => {
+  const lastSelectedKey = React.useRef();
+  const cachedSelectedKeys = React.useRef();
+  const treeRef = React.createRef();
+  React.useImperativeHandle(ref, () => treeRef.current);
+  const getInitExpandedKeys = () => {
+    const { keyEntities } = (0, import_treeUtil.convertDataToEntities)(getTreeData(props));
+    let initExpandedKeys;
+    if (defaultExpandAll) {
+      initExpandedKeys = Object.keys(keyEntities);
+    } else if (defaultExpandParent) {
+      initExpandedKeys = (0, import_util.conductExpandParent)(
+        props.expandedKeys || defaultExpandedKeys || [],
+        keyEntities
+      );
+    } else {
+      initExpandedKeys = props.expandedKeys || defaultExpandedKeys;
+    }
+    return initExpandedKeys;
+  };
+  const [selectedKeys, setSelectedKeys] = React.useState(
+    props.selectedKeys || props.defaultSelectedKeys || []
+  );
+  const [expandedKeys, setExpandedKeys] = React.useState(getInitExpandedKeys());
+  React.useEffect(() => {
+    if (props.selectedKeys) {
+      setSelectedKeys(props.selectedKeys);
+    }
+  }, [props.selectedKeys]);
+  React.useEffect(() => {
+    if (props.expandedKeys) {
+      setExpandedKeys(props.expandedKeys);
+    }
+  }, [props.expandedKeys]);
+  const onExpand = (keys, info) => {
+    var _a;
+    if (!("expandedKeys" in props)) {
+      setExpandedKeys(keys);
+    }
+    return (_a = props.onExpand) == null ? void 0 : _a.call(props, keys, info);
+  };
+  const onSelect = (keys, event) => {
+    var _a;
+    const { multiple } = props;
+    const { node, nativeEvent } = event;
+    const { key = "" } = node;
+    const treeData = getTreeData(props);
+    const newEvent = {
+      ...event,
+      selected: true
+      // Directory selected always true
+    };
+    const ctrlPick = (nativeEvent == null ? void 0 : nativeEvent.ctrlKey) || (nativeEvent == null ? void 0 : nativeEvent.metaKey);
+    const shiftPick = nativeEvent == null ? void 0 : nativeEvent.shiftKey;
+    let newSelectedKeys;
+    if (multiple && ctrlPick) {
+      newSelectedKeys = keys;
+      lastSelectedKey.current = key;
+      cachedSelectedKeys.current = newSelectedKeys;
+      newEvent.selectedNodes = (0, import_dictUtil.convertDirectoryKeysToNodes)(
+        treeData,
+        newSelectedKeys
+      );
+    } else if (multiple && shiftPick) {
+      newSelectedKeys = Array.from(
+        /* @__PURE__ */ new Set([
+          ...cachedSelectedKeys.current || [],
+          ...(0, import_dictUtil.calcRangeKeys)({
+            treeData,
+            expandedKeys,
+            startKey: key,
+            endKey: lastSelectedKey.current
+          })
+        ])
+      );
+      newEvent.selectedNodes = (0, import_dictUtil.convertDirectoryKeysToNodes)(
+        treeData,
+        newSelectedKeys
+      );
+    } else {
+      newSelectedKeys = [key];
+      lastSelectedKey.current = key;
+      cachedSelectedKeys.current = newSelectedKeys;
+      newEvent.selectedNodes = (0, import_dictUtil.convertDirectoryKeysToNodes)(
+        treeData,
+        newSelectedKeys
+      );
+    }
+    (_a = props.onSelect) == null ? void 0 : _a.call(props, newSelectedKeys, newEvent);
+    if (!("selectedKeys" in props)) {
+      setSelectedKeys(newSelectedKeys);
+    }
+  };
+  const { prefixCls: _, className, ...otherProps } = props;
+  const prefixCls = "tree";
+  const connectClassName = (0, import_classnames.default)(`${prefixCls}-directory`, className);
+  return /* @__PURE__ */ React.createElement(
+    import_tree.default,
+    {
+      icon: getIcon,
+      treeRef,
+      blockNode: true,
+      ...otherProps,
+      prefixCls,
+      className: connectClassName,
+      expandedKeys,
+      selectedKeys,
+      onSelect,
+      onExpand
+    }
+  );
+};
+var ForwardDirectoryTree = React.forwardRef(
+  DirectoryTree
+);
+if (process.env.NODE_ENV !== "production") {
+  ForwardDirectoryTree.displayName = "DirectoryTree";
+}
+ForwardDirectoryTree.defaultProps = {
+  showIcon: true,
+  expandAction: "click"
+};
+var DirectoryTree_default = ForwardDirectoryTree;

package/dist/cjs/components/tree/demo/data.d.ts

@@ -0,0 +1,6 @@
+import { TreeDataNode } from '../tree';
+declare const treeData: TreeDataNode<{
+    title: string;
+    key: string;
+}>[];
+export { treeData };

package/dist/cjs/components/tree/demo/data.js

@@ -0,0 +1,53 @@
+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/tree/demo/data.ts
+var data_exports = {};
+__export(data_exports, {
+  treeData: () => treeData
+});
+module.exports = __toCommonJS(data_exports);
+var x = 3;
+var y = 2;
+var z = 1;
+var treeData = [];
+var generateData = (_level, _preKey, _tns) => {
+  const preKey = _preKey || "0";
+  const tns = _tns || treeData;
+  const children = [];
+  for (let i = 0; i < x; i++) {
+    const key = `${preKey}-${i}`;
+    tns.push({ title: key, key });
+    if (i < y) {
+      children.push(key);
+    }
+  }
+  if (_level < 0) {
+    return tns;
+  }
+  const level = _level - 1;
+  children.forEach((key, index) => {
+    tns[index].children = [];
+    return generateData(level, key, tns[index].children);
+  });
+};
+generateData(z);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  treeData
+});

package/dist/cjs/components/tree/demo/demo.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const App: () => JSX.Element;
+export default App;