"use strict";

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); }
Object.defineProperty(exports, "__esModule", {
  value: true
});
var _exportNames = {
  getPageQuery: true,
  toHump: true,
  downloadFile: true,
  splitArrayToSum: true,
  checkFileSize: true,
  formatNumber: true,
  isFileTypeAccepted: true,
  excludeProps: true
};
exports.toHump = exports.splitArrayToSum = exports.isFileTypeAccepted = exports.getPageQuery = exports.formatNumber = exports.excludeProps = exports.downloadFile = exports.checkFileSize = void 0;
var _qs = require("qs");
var _getParentNodes = require("./getParentNodes");
Object.keys(_getParentNodes).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _getParentNodes[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _getParentNodes[key];
    }
  });
});
var _ValueFormat = require("./ValueFormat");
Object.keys(_ValueFormat).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _ValueFormat[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _ValueFormat[key];
    }
  });
});
var _dictSelectUtil = require("./dictSelectUtil");
Object.keys(_dictSelectUtil).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _dictSelectUtil[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _dictSelectUtil[key];
    }
  });
});
var _fileConvert = require("./fileConvert");
Object.keys(_fileConvert).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _fileConvert[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _fileConvert[key];
    }
  });
});
var _urlUtils = require("./urlUtils");
Object.keys(_urlUtils).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _urlUtils[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _urlUtils[key];
    }
  });
});
var _regExp = require("./regExp");
Object.keys(_regExp).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _regExp[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _regExp[key];
    }
  });
});
var _response = require("./response");
Object.keys(_response).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _response[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _response[key];
    }
  });
});
var _util = require("../RefactorTree/util");
Object.keys(_util).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _util[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _util[key];
    }
  });
});
var _transArrayToPage = require("./transArrayToPage");
Object.keys(_transArrayToPage).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _transArrayToPage[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _transArrayToPage[key];
    }
  });
});
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } // @ts-nocheck
var getPageQuery = exports.getPageQuery = function getPageQuery() {
  return (0, _qs.parse)(window.location.search, {
    ignoreQueryPrefix: true
  });
};

/**
 * @param {string} str 字符串
 * @param {string} separator 分割符(默认"-")
 * @param {boolean}  topIsCapital 开头是否大写(默认是)
 *
 * @result {string}
 */

var toHump = exports.toHump = function toHump(str) {
  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "-";
  var topIsCapital = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
  var strAry = str.split(separator);
  return strAry.map(function (item, index) {
    if (!topIsCapital && index == 0) return item;
    // @ts-ignore
    return item.replace(/^./, item.match(/^./)[0].toLocaleUpperCase());
  }).join("");
};

/**
 * 下载文件
 * @param {string} filename
 * @param {blob} file
 * @param {string} type 文件类型（直接用.xls或者对应的MIMETYPE都可以）
 *  .xls 'application/vnd.ms-excel'
 *  .xlsx 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
 */
var downloadFile = exports.downloadFile = function downloadFile(filename, file, type) {
  // 设置文件后缀 MIME TYPE
  var getMIMETYPE = function getMIMETYPE(typeKey) {
    // 直接使用这里面的
    var types = [{
      type: '.xls',
      mimeType: 'application/vnd.ms-excel'
    }, {
      type: '.xlsx',
      mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
    }];
    var matchType = types.find(function (item) {
      return item.type === typeKey;
    });
    if (matchType) {
      return matchType.mimeType;
    } else {
      // 直接使用对应的值
      return typeKey;
    }
  };
  var blob = new Blob([file], {
    type: getMIMETYPE(type)
  });
  var downloadUrl = URL.createObjectURL(blob);
  var a = document.createElement('a');
  a.style = 'display: none';
  a.href = downloadUrl;
  a.download = filename;
  document.body.appendChild(a);
  a.click();
  setTimeout(function () {
    document.body.removeChild(a);
    URL.revokeObjectURL(downloadUrl);
  }, 500);
};
/**
 * 将给定的数组拆分成多个子数组，每个子数组的元素之和尽可能接近 24，但不超过 24。如果某个元素无法放入当前子数组而不超过 24，则会创建一个新的子数组。
 * splitArrayToSum 函数：这个函数接受两个参数，arr 是输入的数组，targetSum 是目标值（在这个例子中是 24）。
 * result 数组：用于存储最终的子数组。
 * currentArray 数组：当前正在处理的子数组。
 * currentSum 变量：当前子数组的和。
 * 循环遍历输入数组：对于每个元素，检查是否可以将其加入当前子数组而不超过目标值。如果可以，则将其加入当前子数组并更新 currentSum；否则，将当前子数组加入 result，并开始一个新的子数组。
 * 最后处理：在循环结束后，将最后一个子数组加入 result。
 * */
var splitArrayToSum = exports.splitArrayToSum = function splitArrayToSum(arr, targetSum) {
  var result = []; // 用于存储最终的子数组
  var currentArray = []; // 当前正在处理的子数组
  var currentSum = 0; // 当前子数组的和

  for (var i = 0; i < arr.length; i++) {
    // 如果当前元素加上当前子数组的和不超过目标值，则将其加入当前子数组
    if (currentSum + arr[i] <= targetSum) {
      currentArray.push(arr[i]);
      currentSum += arr[i];
    } else {
      // 如果当前元素无法加入当前子数组，则将当前子数组加入结果数组
      result.push(currentArray);
      // 开始一个新的子数组，并将当前元素加入
      currentArray = [arr[i]];
      currentSum = arr[i];
    }
  }

  // 将最后一个子数组加入结果数组
  if (currentArray.length > 0) {
    result.push(currentArray);
  }
  return result;
};

/***
 * 上传文件大小限制检查，支持按kb、mb、 gb单位进行提示提示：
 * // 限制5MB，自动使用MB提示
 * file: 文件对象（来自input[type=file]）
 * limitSize: 限制大小数值（如：2）
 * limitUnit: 限制单位（'K'、'M' 或 'G'）
 * displayUnit（可选）: 提示信息的单位（默认使用limitUnit）
 *
 * @example 示例
 * checkFileSize(file, 5, 'M'); // 限制5MB，自动使用MB提示
 * checkFileSize(file, 500, 'K', 'M'); // 限制500KB，但用MB提示
 * checkFileSize(file, 1, 'G'); // 限制1GB，用GB提示
 */
var checkFileSize = exports.checkFileSize = function checkFileSize(file, _ref, msgCallback) {
  var limitSize = _ref.limitSize,
    limitUnit = _ref.limitUnit,
    displayUnit = _ref.displayUnit;
  var units = {
    'K': 1024,
    'M': Math.pow(1024, 2),
    'G': Math.pow(1024, 3)
  };
  // 统一转换单位为大写
  var limitUnitUpper = limitUnit.toUpperCase().trim();
  var displayUnitUpper = (displayUnit || limitUnit).toUpperCase().trim();

  // 计算限制大小的字节数
  var limitBytes = limitSize * units[limitUnitUpper];
  if (file.size > limitBytes) {
    // 计算实际文件和限制大小的显示数值
    var divisor = units[displayUnitUpper];
    var displayFileSize = formatNumber(file.size / divisor);
    var displayLimitSize = formatNumber(limitBytes / divisor);
    msgCallback ? msgCallback === null || msgCallback === void 0 ? void 0 : msgCallback({
      displayFileSize: displayFileSize,
      displayLimitSize: displayLimitSize,
      displayUnitUpper: displayUnitUpper
    }) : null;
    // alert(`文件大小 ${displayFileSize}${displayUnitUpper} 超过限制（${displayLimitSize}${displayUnitUpper}）`);
    return false;
  }
  return true;
};
var formatNumber = exports.formatNumber = function formatNumber(num) {
  // 保留两位小数并去除末尾零
  return parseFloat(num.toFixed(2));
};

// export const checkFileType = (fileType, accept) => {
//   const contentType = {
//     // 文本类
//     '.txt': 'text/plain',
//     '.html': 'text/html',
//     '.htm': 'text/html',
//     '.css': 'text/css',
//     '.csv': 'text/csv',
//     '.js': ['text/javascript', 'application/javascript'],
//     // 图像类
//     '.jpg': 'image/jpeg',
//     '.jpeg': 'image/jpeg',
//     '.png': 'image/png',
//     '.gif': 'image/gif',
//     '.webp': 'image/webp',
//     '.svg': 'image/svg+xml',
//     '.ico': 'image/x-icon',
//     '.bmp': 'image/bmp',
//     '.avif': 'image/avif', // （新兴格式，逐步支持中）
//   }
//   const acceptTypes = accept.split(',')
//   console.log('acceptTypes', acceptTypes)
//   return true
// }

/**
 * 检查文件类型是否符合指定的Accept规则
 * @param {File} file - 文件对象
 * @param {string} accept - 允许的MIME类型或后缀，逗号分隔（如 "image/*, .pdf"）
 * @returns {boolean} - 是否通过验证
 */
var isFileTypeAccepted = exports.isFileTypeAccepted = function isFileTypeAccepted(file, accept) {
  if (!accept || accept === '*') return true; // 未限制类型时直接通过

  // 拆分并处理所有Accept规则
  var rules = accept.split(',').map(function (rule) {
    return rule.trim();
  }).filter(function (rule) {
    return rule;
  }); // 移除空值

  // 分离后缀规则和MIME类型规则
  var extRules = [];
  var mimeRules = [];
  rules.forEach(function (rule) {
    if (rule.startsWith('.')) {
      extRules.push(rule.slice(1).toLowerCase());
    } else {
      mimeRules.push(rule.toLowerCase());
    }
  });

  // 获取文件信息（小写处理）
  var fileName = file.name.toLowerCase();
  var fileExt = fileName.slice(fileName.lastIndexOf('.') + 1);
  var fileType = file.type.toLowerCase();

  // 检查后缀匹配
  if (extRules.length > 0 && extRules.includes(fileExt)) {
    return true;
  }

  // 检查MIME类型匹配
  return mimeRules.some(function (rule) {
    if (rule === '*/*') return true; // 允许所有类型

    var _rule$split = rule.split('/'),
      _rule$split2 = _slicedToArray(_rule$split, 2),
      typeMain = _rule$split2[0],
      typeSub = _rule$split2[1];
    var _fileType$split = fileType.split('/'),
      _fileType$split2 = _slicedToArray(_fileType$split, 2),
      fileTypeMain = _fileType$split2[0],
      fileTypeSub = _fileType$split2[1];

    // 处理通配符（如 image/* 或 */png）
    var mainMatch = typeMain === '*' || typeMain === fileTypeMain;
    var subMatch = typeSub === '*' || typeSub === fileTypeSub;
    return mainMatch && subMatch;
  });
};
/**
 * 对象值中排除多个字段
 * @param {} props
 *
 * 使用
 * <MyComponent {...excludeProps(defaultProps, 'viewOnlyHides')} />;
 * 排除多个
 * <MyComponent {...excludeProps(defaultProps, 'viewOnlyHides', 'anotherField')} />
 * */

var excludeProps = exports.excludeProps = function excludeProps(props) {
  var result = _objectSpread({}, props);
  for (var _len = arguments.length, keysToExclude = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    keysToExclude[_key - 1] = arguments[_key];
  }
  keysToExclude.forEach(function (key) {
    return delete result[key];
  });
  return result;
};