first commit

frontend/node_modules/rc-tree-select/es/utils/legacyUtil.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { DataNode, ChangeEventExtra, SafeKey, FieldNames } from '../interface';
+export declare function convertChildrenToData(nodes: React.ReactNode): DataNode[];
+export declare function fillLegacyProps(dataNode: DataNode): DataNode;
+export declare function fillAdditionalInfo(extra: ChangeEventExtra, triggerValue: SafeKey, checkedValues: SafeKey[], treeData: DataNode[], showPosition: boolean, fieldNames: FieldNames): void;

frontend/node_modules/rc-tree-select/es/utils/legacyUtil.js

@@ -0,0 +1,117 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children", "value"];
+import * as React from 'react';
+import toArray from "rc-util/es/Children/toArray";
+import warning from "rc-util/es/warning";
+import TreeNode from "../TreeNode";
+export function convertChildrenToData(nodes) {
+  return toArray(nodes).map(function (node) {
+    if (! /*#__PURE__*/React.isValidElement(node) || !node.type) {
+      return null;
+    }
+    var _ref = node,
+      key = _ref.key,
+      _ref$props = _ref.props,
+      children = _ref$props.children,
+      value = _ref$props.value,
+      restProps = _objectWithoutProperties(_ref$props, _excluded);
+    var data = _objectSpread({
+      key: key,
+      value: value
+    }, restProps);
+    var childData = convertChildrenToData(children);
+    if (childData.length) {
+      data.children = childData;
+    }
+    return data;
+  }).filter(function (data) {
+    return data;
+  });
+}
+export function fillLegacyProps(dataNode) {
+  if (!dataNode) {
+    return dataNode;
+  }
+  var cloneNode = _objectSpread({}, dataNode);
+  if (!('props' in cloneNode)) {
+    Object.defineProperty(cloneNode, 'props', {
+      get: function get() {
+        warning(false, 'New `rc-tree-select` not support return node instance as argument anymore. Please consider to remove `props` access.');
+        return cloneNode;
+      }
+    });
+  }
+  return cloneNode;
+}
+export function fillAdditionalInfo(extra, triggerValue, checkedValues, treeData, showPosition, fieldNames) {
+  var triggerNode = null;
+  var nodeList = null;
+  function generateMap() {
+    function dig(list) {
+      var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '0';
+      var parentIncluded = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      return list.map(function (option, index) {
+        var pos = "".concat(level, "-").concat(index);
+        var value = option[fieldNames.value];
+        var included = checkedValues.includes(value);
+        var children = dig(option[fieldNames.children] || [], pos, included);
+        var node = /*#__PURE__*/React.createElement(TreeNode, option, children.map(function (child) {
+          return child.node;
+        }));
+
+        // Link with trigger node
+        if (triggerValue === value) {
+          triggerNode = node;
+        }
+        if (included) {
+          var checkedNode = {
+            pos: pos,
+            node: node,
+            children: children
+          };
+          if (!parentIncluded) {
+            nodeList.push(checkedNode);
+          }
+          return checkedNode;
+        }
+        return null;
+      }).filter(function (node) {
+        return node;
+      });
+    }
+    if (!nodeList) {
+      nodeList = [];
+      dig(treeData);
+
+      // Sort to keep the checked node length
+      nodeList.sort(function (_ref2, _ref3) {
+        var val1 = _ref2.node.props.value;
+        var val2 = _ref3.node.props.value;
+        var index1 = checkedValues.indexOf(val1);
+        var index2 = checkedValues.indexOf(val2);
+        return index1 - index2;
+      });
+    }
+  }
+  Object.defineProperty(extra, 'triggerNode', {
+    get: function get() {
+      warning(false, '`triggerNode` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+      return triggerNode;
+    }
+  });
+  Object.defineProperty(extra, 'allCheckedNodes', {
+    get: function get() {
+      warning(false, '`allCheckedNodes` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+      if (showPosition) {
+        return nodeList;
+      }
+      return nodeList.map(function (_ref4) {
+        var node = _ref4.node;
+        return node;
+      });
+    }
+  });
+}

frontend/node_modules/rc-tree-select/es/utils/strategyUtil.d.ts

@@ -0,0 +1,7 @@
+import type { DataEntity } from 'rc-tree/lib/interface';
+import type { SafeKey, FieldNames } from '../interface';
+export declare const SHOW_ALL = "SHOW_ALL";
+export declare const SHOW_PARENT = "SHOW_PARENT";
+export declare const SHOW_CHILD = "SHOW_CHILD";
+export type CheckedStrategy = typeof SHOW_ALL | typeof SHOW_PARENT | typeof SHOW_CHILD;
+export declare function formatStrategyValues(values: SafeKey[], strategy: CheckedStrategy, keyEntities: Record<SafeKey, DataEntity>, fieldNames: FieldNames): SafeKey[];

frontend/node_modules/rc-tree-select/es/utils/strategyUtil.js

@@ -0,0 +1,27 @@
+import { isCheckDisabled } from "./valueUtil";
+export var SHOW_ALL = 'SHOW_ALL';
+export var SHOW_PARENT = 'SHOW_PARENT';
+export var SHOW_CHILD = 'SHOW_CHILD';
+export function formatStrategyValues(values, strategy, keyEntities, fieldNames) {
+  var valueSet = new Set(values);
+  if (strategy === SHOW_CHILD) {
+    return values.filter(function (key) {
+      var entity = keyEntities[key];
+      return !entity || !entity.children || !entity.children.some(function (_ref) {
+        var node = _ref.node;
+        return valueSet.has(node[fieldNames.value]);
+      }) || !entity.children.every(function (_ref2) {
+        var node = _ref2.node;
+        return isCheckDisabled(node) || valueSet.has(node[fieldNames.value]);
+      });
+    });
+  }
+  if (strategy === SHOW_PARENT) {
+    return values.filter(function (key) {
+      var entity = keyEntities[key];
+      var parent = entity ? entity.parent : null;
+      return !parent || isCheckDisabled(parent.node) || !valueSet.has(parent.key);
+    });
+  }
+  return values;
+}

frontend/node_modules/rc-tree-select/es/utils/valueUtil.d.ts

@@ -0,0 +1,11 @@
+import type { DataNode, FieldNames, SafeKey } from '../interface';
+export declare const toArray: <T>(value: T | T[]) => T[];
+export declare const fillFieldNames: (fieldNames?: FieldNames) => {
+    _title: string[];
+    value: string;
+    key: string;
+    children: string;
+};
+export declare const isCheckDisabled: (node: DataNode) => boolean;
+export declare const getAllKeys: (treeData: DataNode[], fieldNames: FieldNames) => SafeKey[];
+export declare const isNil: (val: any) => boolean;

frontend/node_modules/rc-tree-select/es/utils/valueUtil.js

@@ -0,0 +1,35 @@
+export var toArray = function toArray(value) {
+  return Array.isArray(value) ? value : value !== undefined ? [value] : [];
+};
+export var fillFieldNames = function fillFieldNames(fieldNames) {
+  var _ref = fieldNames || {},
+    label = _ref.label,
+    value = _ref.value,
+    children = _ref.children;
+  return {
+    _title: label ? [label] : ['title', 'label'],
+    value: value || 'value',
+    key: value || 'value',
+    children: children || 'children'
+  };
+};
+export var isCheckDisabled = function isCheckDisabled(node) {
+  return !node || node.disabled || node.disableCheckbox || node.checkable === false;
+};
+export var getAllKeys = function getAllKeys(treeData, fieldNames) {
+  var keys = [];
+  var dig = function dig(list) {
+    list.forEach(function (item) {
+      var children = item[fieldNames.children];
+      if (children) {
+        keys.push(item[fieldNames.value]);
+        dig(children);
+      }
+    });
+  };
+  dig(treeData);
+  return keys;
+};
+export var isNil = function isNil(val) {
+  return val === null || val === undefined;
+};

frontend/node_modules/rc-tree-select/es/utils/warningPropsUtil.d.ts

@@ -0,0 +1,5 @@
+import type { TreeSelectProps } from '../TreeSelect';
+declare function warningProps(props: TreeSelectProps & {
+    searchPlaceholder?: string;
+}): void;
+export default warningProps;

frontend/node_modules/rc-tree-select/es/utils/warningPropsUtil.js

@@ -0,0 +1,31 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import warning from "rc-util/es/warning";
+import { toArray } from "./valueUtil";
+function warningProps(props) {
+  var searchPlaceholder = props.searchPlaceholder,
+    treeCheckStrictly = props.treeCheckStrictly,
+    treeCheckable = props.treeCheckable,
+    labelInValue = props.labelInValue,
+    value = props.value,
+    multiple = props.multiple,
+    showCheckedStrategy = props.showCheckedStrategy,
+    maxCount = props.maxCount;
+  warning(!searchPlaceholder, '`searchPlaceholder` has been removed.');
+  if (treeCheckStrictly && labelInValue === false) {
+    warning(false, '`treeCheckStrictly` will force set `labelInValue` to `true`.');
+  }
+  if (labelInValue || treeCheckStrictly) {
+    warning(toArray(value).every(function (val) {
+      return val && _typeof(val) === 'object' && 'value' in val;
+    }), 'Invalid prop `value` supplied to `TreeSelect`. You should use { label: string, value: string | number } or [{ label: string, value: string | number }] instead.');
+  }
+  if (treeCheckStrictly || multiple || treeCheckable) {
+    warning(!value || Array.isArray(value), '`value` should be an array when `TreeSelect` is checkable or multiple.');
+  } else {
+    warning(!Array.isArray(value), '`value` should not be array when `TreeSelect` is single mode.');
+  }
+  if (maxCount && (showCheckedStrategy === 'SHOW_ALL' && !treeCheckStrictly || showCheckedStrategy === 'SHOW_PARENT')) {
+    warning(false, '`maxCount` not work with `showCheckedStrategy=SHOW_ALL` (when `treeCheckStrictly=false`) or `showCheckedStrategy=SHOW_PARENT`.');
+  }
+}
+export default warningProps;