@vtx/components 4.0.0-beta.1 → 4.0.0-beta.3

package/es/utils/proFieldParsingText/index.js

@@ -1,161 +0,0 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-import { Badge, Space } from 'antd';
-import React from 'react';
-
-/**
- * 获取类型的 type
- *
- * @param obj
- */
-import { jsx as _jsx } from "react/jsx-runtime";
-function getType(obj) {
-  // @ts-ignore
-  var type = Object.prototype.toString.call(obj).match(/^\[object (.*)\]$/)[1].toLowerCase();
-  if (type === 'string' && _typeof(obj) === 'object') return 'object'; // Let "new String('')" return 'object'
-  if (obj === null) return 'null'; // PhantomJS has type "DOMWindow" for null
-  if (obj === undefined) return 'undefined'; // PhantomJS has type "DOMWindow" for undefined
-  return type;
-}
-export var ProFieldBadgeColor = function ProFieldBadgeColor(_ref) {
-  var color = _ref.color,
-    children = _ref.children;
-  return /*#__PURE__*/_jsx(Badge, {
-    color: color,
-    text: children
-  });
-};
-export var objectToMap = function objectToMap(value) {
-  if (getType(value) === 'map') {
-    return value;
-  }
-  return new Map(Object.entries(value || {}));
-};
-var TableStatus = {
-  Success: function Success(_ref2) {
-    var children = _ref2.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "success",
-      text: children
-    });
-  },
-  Error: function Error(_ref3) {
-    var children = _ref3.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "error",
-      text: children
-    });
-  },
-  Default: function Default(_ref4) {
-    var children = _ref4.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "default",
-      text: children
-    });
-  },
-  Processing: function Processing(_ref5) {
-    var children = _ref5.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "processing",
-      text: children
-    });
-  },
-  Warning: function Warning(_ref6) {
-    var children = _ref6.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "warning",
-      text: children
-    });
-  },
-  success: function success(_ref7) {
-    var children = _ref7.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "success",
-      text: children
-    });
-  },
-  error: function error(_ref8) {
-    var children = _ref8.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "error",
-      text: children
-    });
-  },
-  default: function _default(_ref9) {
-    var children = _ref9.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "default",
-      text: children
-    });
-  },
-  processing: function processing(_ref10) {
-    var children = _ref10.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "processing",
-      text: children
-    });
-  },
-  warning: function warning(_ref11) {
-    var children = _ref11.children;
-    return /*#__PURE__*/_jsx(Badge, {
-      status: "warning",
-      text: children
-    });
-  }
-};
-
-/**
- * 转化 text 和 valueEnum 通过 type 来添加 Status
- *
- * @param text
- * @param valueEnum
- * @param pure 纯净模式，不增加 status
- */
-export var proFieldParsingText = function proFieldParsingText(text, valueEnumParams, key) {
-  if (Array.isArray(text)) {
-    return /*#__PURE__*/_jsx(Space, {
-      split: ",",
-      size: 2,
-      wrap: true,
-      children: text.map(function (value, index) {
-        return (
-          // @ts-ignore
-          proFieldParsingText(value, valueEnumParams, index)
-        );
-      })
-    }, key);
-  }
-  var valueEnum = objectToMap(valueEnumParams);
-  if (!valueEnum.has(text) && !valueEnum.has("".concat(text))) {
-    // @ts-ignore
-    return (text === null || text === void 0 ? void 0 : text.label) || text;
-  }
-  var domText = valueEnum.get(text) || valueEnum.get("".concat(text));
-  if (!domText) {
-    // @ts-ignore
-    return /*#__PURE__*/_jsx(React.Fragment, {
-      children: (text === null || text === void 0 ? void 0 : text.label) || text
-    }, key);
-  }
-  var status = domText.status,
-    color = domText.color;
-  var Status = TableStatus[status || 'Init'];
-
-  // 如果类型存在优先使用类型
-  if (Status) {
-    return /*#__PURE__*/_jsx(Status, {
-      children: domText.text
-    }, key);
-  }
-
-  // 如果不存在使用颜色
-  if (color) {
-    return /*#__PURE__*/_jsx(ProFieldBadgeColor, {
-      color: color,
-      children: domText.text
-    }, key);
-  }
-  // 什么都没有使用 text
-  return /*#__PURE__*/_jsx(React.Fragment, {
-    children: domText.text || domText
-  }, key);
-};

package/es/utils/runFunction/index.js

@@ -1,10 +0,0 @@
-/** 如果是个方法执行一下它 */
-export function runFunction(valueEnum) {
-  if (typeof valueEnum === 'function') {
-    for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      rest[_key - 1] = arguments[_key];
-    }
-    return valueEnum.apply(void 0, rest);
-  }
-  return valueEnum;
-}

package/es/utils/sortByGivenOrder.js

@@ -1,36 +0,0 @@
-export function sortByGivenOrder(originalArray, orderArray) {
-  // 创建一个映射，记录orderArray中元素的顺序
-  var orderMap = new Map();
-  orderArray.forEach(function (item, index) {
-    orderMap.set(item, index);
-  });
-
-  // 分离需要排序的元素和不需要排序的元素
-  var orderedItems = [];
-  var remainingItems = [];
-  originalArray.forEach(function (item) {
-    if (orderMap.has(item)) {
-      orderedItems.push(item);
-    } else {
-      remainingItems.push(item);
-    }
-  });
-
-  // 对需要排序的元素按照指定顺序排序
-  orderedItems.sort(function (a, b) {
-    return orderMap.get(a) - orderMap.get(b);
-  });
-
-  // 重新构建数组，保持原有位置结构
-  var result = [];
-  var orderedIndex = 0;
-  originalArray.forEach(function (item) {
-    if (orderMap.has(item)) {
-      result.push(orderedItems[orderedIndex]);
-      orderedIndex++;
-    } else {
-      result.push(item);
-    }
-  });
-  return result;
-}

package/es/utils/sortByKeyArrayExtract.js

@@ -1,38 +0,0 @@
-export function sortByKeyArrayExtract(data, keyArray, columnsMap, keyField) {
-  var dataMap = new Map(data.map(function (item) {
-    return [item[keyField], item];
-  }));
-  var result = [];
-  // 按照 keyArray 顺序提取数据
-  keyArray.forEach(function (key) {
-    if (dataMap.has(key)) {
-      result.push(dataMap.get(key));
-      dataMap.delete(key);
-    }
-  });
-  // 将剩余的数据添加到末尾
-  dataMap.forEach(function (item) {
-    return result.push(item);
-  });
-  return result.sort(function (a, b) {
-    var _columnsMap$aKey, _columnsMap$bKey;
-    var aFixed = a.fixed,
-      aIndex = a.index;
-    var bFixed = b.fixed,
-      bIndex = b.index;
-    if (aFixed === 'left' && bFixed !== 'left' || bFixed === 'right' && aFixed !== 'right') {
-      return -2;
-    }
-    if (bFixed === 'left' && aFixed !== 'left' || aFixed === 'right' && bFixed !== 'right') {
-      return 2;
-    }
-    // 如果没有index，在 dataIndex 或者 key 不存在的时候他会报错
-    var aKey = a.key || "".concat(aIndex);
-    var bKey = b.key || "".concat(bIndex);
-    if ((_columnsMap$aKey = columnsMap[aKey]) !== null && _columnsMap$aKey !== void 0 && _columnsMap$aKey.order || (_columnsMap$bKey = columnsMap[bKey]) !== null && _columnsMap$bKey !== void 0 && _columnsMap$bKey.order) {
-      var _columnsMap$aKey2, _columnsMap$bKey2;
-      return (((_columnsMap$aKey2 = columnsMap[aKey]) === null || _columnsMap$aKey2 === void 0 ? void 0 : _columnsMap$aKey2.order) || 0) - (((_columnsMap$bKey2 = columnsMap[bKey]) === null || _columnsMap$bKey2 === void 0 ? void 0 : _columnsMap$bKey2.order) || 0);
-    }
-    return (a.index || 0) - (b.index || 0);
-  });
-}

package/es/utils/stringify/index.js

@@ -1,10 +0,0 @@
-import { configure } from 'safe-stable-stringify';
-var stringify = configure({
-  bigint: true,
-  circularValue: 'Magic circle!',
-  deterministic: false,
-  maximumDepth: 4
-  //   maximumBreadth: 4,
-});
-export { configure, stringify };
-export default stringify;

package/es/utils/transformKeySubmitValue/index.js

@@ -1,330 +0,0 @@
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-import { get } from '@rc-component/util';
-import React from 'react';
-import { isNil } from "../isNil";
-
-/**
- * 判断一个值是否为普通对象（可以被遍历的对象）
- * 暂时还不支持 Set 和 Map 结构
- *
- * @param itemValue - 要检查的值
- * @returns 如果是普通对象返回 true，否则返回 false
- */
-export function isPlainObj(itemValue) {
-  // 如果不是对象类型，直接返回 false
-  if (_typeof(itemValue) !== 'object') {
-    return false;
-  }
-
-  // Null 也要处理，不然 omit 空值会失效
-  if (itemValue === null) {
-    return true;
-  }
-
-  // 排除各种特殊对象类型
-  if ( /*#__PURE__*/React.isValidElement(itemValue)) return false;
-  if (itemValue.constructor === RegExp) return false;
-  if (itemValue instanceof Map) return false;
-  if (itemValue instanceof Set) return false;
-  if (itemValue instanceof HTMLElement) return false;
-  if (itemValue instanceof Blob) return false;
-  if (itemValue instanceof File) return false;
-  if (Array.isArray(itemValue)) return false;
-  return true;
-}
-
-/**
- * 将点号路径字符串转换为路径数组
- * 例如: 'users.0.name' => ['users', 0, 'name']
- *
- * @param dotPath - 点号分隔的路径字符串
- * @returns 路径数组，数字会被转换为数字类型
- */
-function parseDotPath(dotPath) {
-  return dotPath.split('.').map(function (segment) {
-    // 如果是纯数字，转换为数字类型用于数组索引
-    return /^\d+$/.test(segment) ? parseInt(segment, 10) : segment;
-  });
-}
-
-/**
- * 过滤掉空值的转换配置
- *
- * @param dataFormatMapRaw - 原始转换配置
- * @returns 过滤后的转换配置
- */
-function filterNilTransforms(dataFormatMapRaw) {
-  var filtered = {};
-  for (var key in dataFormatMapRaw) {
-    var value = dataFormatMapRaw[key];
-    if (!isNil(value)) {
-      filtered[key] = value;
-    }
-  }
-  return filtered;
-}
-
-/**
- * 将转换配置分为点号路径格式和传统嵌套对象格式
- *
- * @param dataFormatMapRaw - 原始转换配置
- * @returns 包含两种格式转换配置的对象
- */
-function separateTransformFormats(dataFormatMapRaw) {
-  var dotPathTransforms = {};
-  var objectTransforms = {};
-  for (var key in dataFormatMapRaw) {
-    var value = dataFormatMapRaw[key];
-    if (isNil(value)) continue;
-    if (key.includes('.')) {
-      dotPathTransforms[key] = value;
-    } else {
-      objectTransforms[key] = value;
-    }
-  }
-  return {
-    dotPathTransforms: dotPathTransforms,
-    objectTransforms: objectTransforms
-  };
-}
-
-/**
- * 处理点号路径格式的转换
- * 例如: 'users.0.name' => 转换 users[0].name 的值
- *
- * @param result - 要转换的数据对象
- * @param dotPathTransforms - 点号路径转换配置
- */
-function processDotPathTransforms(result, dotPathTransforms) {
-  for (var dotPath in dotPathTransforms) {
-    var transform = dotPathTransforms[dotPath];
-    if (typeof transform !== 'function') continue;
-
-    // 将点号路径转换为数组路径
-    var pathArray = parseDotPath(dotPath);
-
-    // 获取要转换的值
-    var currentValue = get(result, pathArray);
-    if (currentValue === undefined) continue;
-
-    // 执行转换
-    var transformed = transform(currentValue, pathArray.map(String), result);
-    if (_typeof(transformed) === 'object' && transformed !== null && !Array.isArray(transformed)) {
-      // 如果返回对象，删除原键并将对象的键值对合并到父级
-      var parentPath = pathArray.slice(0, -1);
-      var parentObj = parentPath.length > 0 ? get(result, parentPath) : result;
-      if (parentObj && _typeof(parentObj) === 'object') {
-        var keyToDelete = pathArray[pathArray.length - 1];
-        delete parentObj[keyToDelete];
-        Object.assign(parentObj, transformed);
-      }
-    } else {
-      // 如果返回原始值，直接替换
-      // 手动设置嵌套路径的值，确保数组索引正确处理
-      var current = result;
-      for (var i = 0; i < pathArray.length - 1; i++) {
-        var key = pathArray[i];
-        if (current[key] === undefined) {
-          // 如果下一个键是数字，创建数组，否则创建对象
-          var nextKey = pathArray[i + 1];
-          current[key] = typeof nextKey === 'number' ? [] : {};
-        }
-        current = current[key];
-      }
-      current[pathArray[pathArray.length - 1]] = transformed;
-    }
-  }
-}
-
-/**
- * 在嵌套转换配置中查找转换函数
- *
- * @param currentTransforms - 当前转换配置
- * @param parentsKey - 父级路径
- * @param entityKey - 当前实体键
- * @returns 找到的转换函数或 undefined
- */
-function findNestedTransformFunction(currentTransforms, parentsKey, entityKey) {
-  var nestedTransforms = currentTransforms;
-  var _iterator = _createForOfIteratorHelper(parentsKey),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var parentKey = _step.value;
-      var parentKeyStr = String(parentKey);
-      if (nestedTransforms && _typeof(nestedTransforms[parentKeyStr]) === 'object') {
-        nestedTransforms = nestedTransforms[parentKeyStr];
-      } else {
-        nestedTransforms = null;
-        break;
-      }
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  if (nestedTransforms && typeof nestedTransforms[entityKey] === 'function') {
-    return nestedTransforms[entityKey];
-  }
-  return undefined;
-}
-
-/**
- * 检查路径是否包含数组索引
- *
- * @param parentsKey - 父级路径数组
- * @returns 如果包含数组索引返回 true
- */
-function isInArrayPath(parentsKey) {
-  return parentsKey.some(function (key) {
-    return !isNaN(Number(key));
-  });
-}
-
-/**
- * 递归处理嵌套对象转换（传统格式）
- *
- * @param tempValues - 要处理的值
- * @param parentsKey - 父级路径
- * @param currentTransforms - 当前转换配置
- * @param rootMergeObjects - 存储需要在根级别合并的对象
- * @returns 处理后的结果
- */
-function processNestedObjectTransforms(tempValues, parentsKey, currentTransforms, rootMergeObjects) {
-  var isArrayValues = Array.isArray(tempValues);
-  var tempResult = isArrayValues ? [] : {};
-  if (tempValues == null || tempValues === undefined) {
-    return tempResult;
-  }
-
-  // 确定要处理的键
-  var keysToProcess = isArrayValues ? tempValues.map(function (_, index) {
-    return index.toString();
-  }) : Object.keys(tempValues);
-  var _iterator2 = _createForOfIteratorHelper(keysToProcess),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var entityKey = _step2.value;
-      var key = parentsKey ? [].concat(_toConsumableArray(parentsKey), [entityKey]) : [entityKey];
-      var itemValue = tempValues[entityKey];
-
-      // 查找转换函数
-      var transformFunction = currentTransforms[entityKey];
-
-      // 如果没找到并且是嵌套路径，尝试在嵌套对象中查找
-      if (!transformFunction && parentsKey) {
-        transformFunction = findNestedTransformFunction(currentTransforms, parentsKey, entityKey);
-      }
-      if (transformFunction && typeof transformFunction === 'function') {
-        // 执行转换
-        var transformed = transformFunction(itemValue, entityKey, tempValues);
-        if (_typeof(transformed) === 'object' && transformed !== null && !Array.isArray(transformed)) {
-          // 检查当前项是否在数组中
-          var isInArray = parentsKey ? isInArrayPath(parentsKey) : false;
-          if (isInArray) {
-            // 如果是数组元素内的转换，直接合并到当前结果
-            Object.assign(tempResult, transformed);
-          } else {
-            // 如果不是数组元素，将其存储到 rootMergeObjects 以便在根级别合并
-            rootMergeObjects.push(transformed);
-          }
-        } else {
-          // 如果返回原始值，用新键替换
-          tempResult[entityKey] = transformed;
-        }
-      } else if (isPlainObj(itemValue) && !isNil(itemValue)) {
-        // 递归处理嵌套对象（但跳过 null 值）
-        var nestedTransforms = currentTransforms[entityKey];
-        if (nestedTransforms && _typeof(nestedTransforms) === 'object') {
-          // 如果当前键有嵌套转换配置，传递嵌套配置
-          var nested = processNestedObjectTransforms(itemValue, key, nestedTransforms, rootMergeObjects);
-          // 检查是否有任何子属性被转换为对象（会被添加到 rootMergeObjects）
-          // 如果 nested 为空或只包含被转换的属性，我们不保留这个对象
-          var hasRemainingContent = Object.keys(nested).length > 0;
-          if (hasRemainingContent) {
-            tempResult[entityKey] = nested;
-          }
-        } else {
-          // 否则继续使用当前转换配置递归
-          var _nested = processNestedObjectTransforms(itemValue, key, currentTransforms, rootMergeObjects);
-          tempResult[entityKey] = _nested;
-        }
-      } else if (!isNil(itemValue)) {
-        // 保留非 null/undefined 原始值
-        tempResult[entityKey] = itemValue;
-      }
-    }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
-  }
-  return tempResult;
-}
-
-/**
- * 转换提交值中的键名
- * 支持两种格式的转换配置：
- * 1. 点号路径格式：'users.0.name' => 转换嵌套路径的值
- * 2. 传统嵌套对象格式：{ users: { 0: { name: transformFn } } }
- *
- * @param values - 要转换的值对象
- * @param dataFormatMapRaw - 转换配置映射
- * @returns 转换后的值对象
- */
-export var transformKeySubmitValue = function transformKeySubmitValue(values, dataFormatMapRaw) {
-  // 过滤掉空值的转换配置
-  var dataFormatMap = filterNilTransforms(dataFormatMapRaw);
-
-  // 如果没有有效的转换配置，直接返回原值
-  if (Object.keys(dataFormatMap).length < 1) {
-    return values;
-  }
-
-  // 在服务端环境下直接返回原值
-  if (typeof window === 'undefined') {
-    return values;
-  }
-
-  // 如果 value 是 string | null | Array | Blob 类型其中之一，直接返回
-  // 形如 {key: [File, File]} 的表单字段当进行第二次递归时会导致其直接越过 typeof value !== 'object' 这一判断
-  // https://github.com/ant-design/pro-components/issues/2071
-  if (_typeof(values) !== 'object' || isNil(values) || values instanceof Blob) {
-    return values;
-  }
-
-  // 创建一个深拷贝来避免修改原始数据
-  var result = JSON.parse(JSON.stringify(values));
-
-  // 分别处理不同格式的转换配置
-  var _separateTransformFor = separateTransformFormats(dataFormatMapRaw),
-    dotPathTransforms = _separateTransformFor.dotPathTransforms,
-    objectTransforms = _separateTransformFor.objectTransforms;
-
-  // 处理点号路径格式的转换（如 'users.0.name'）
-  processDotPathTransforms(result, dotPathTransforms);
-
-  // 存储需要在根级别合并的对象
-  var rootMergeObjects = [];
-
-  // 处理传统的嵌套对象格式转换（向后兼容）
-  if (Object.keys(objectTransforms).length > 0) {
-    result = processNestedObjectTransforms(result, undefined, objectTransforms, rootMergeObjects);
-  }
-
-  // 将所有根级别合并对象合并到最终结果
-  for (var _i = 0, _rootMergeObjects = rootMergeObjects; _i < _rootMergeObjects.length; _i++) {
-    var obj = _rootMergeObjects[_i];
-    Object.assign(result, obj);
-  }
-  return result;
-};

package/es/utils/useColSize.js

@@ -1,20 +0,0 @@
-import { useSize } from 'ahooks';
-var COL_SIZE = {
-  lg: 'lg',
-  md: 'md',
-  sm: 'sm'
-};
-export default (function (ref) {
-  var dom = (ref === null || ref === void 0 ? void 0 : ref.current) || document.querySelector('body');
-  var _ref = useSize(dom) || {},
-    width = _ref.width;
-  var size = COL_SIZE.lg;
-  if (width >= 1370) {
-    size = COL_SIZE.lg;
-  } else if (width >= 992) {
-    size = COL_SIZE.md;
-  } else {
-    size = COL_SIZE.sm;
-  }
-  return size;
-});