tntd/lib/icon/components/utils.js

tntd是基于 TNT Design 设计体系的 React UI 组件库，主要用于研发企业级中后台产品。

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.MiniMap = void 0;
exports.generate = generate;
exports.getSecondaryColor = getSecondaryColor;
exports.isIconDefinition = isIconDefinition;
exports.log = log;
exports.normalizeAttrs = normalizeAttrs;
exports.withSuffix = withSuffix;
var _colors = require("@ant-design/colors");
var React = _interopRequireWildcard(require("react"));
function _getRequireWildcardCache(e) {
  if ("function" != typeof WeakMap) return null;
  var r = new WeakMap(),
    t = new WeakMap();
  return (_getRequireWildcardCache = function _getRequireWildcardCache(e) {
    return e ? t : r;
  })(e);
}
function _interopRequireWildcard(e, r) {
  if (!r && e && e.__esModule) return e;
  if (null === e || "object" != _typeof(e) && "function" != typeof e) return {
    "default": e
  };
  var t = _getRequireWildcardCache(r);
  if (t && t.has(e)) return t.get(e);
  var n = {
      __proto__: null
    },
    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
  for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
    var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
    i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
  }
  return n["default"] = e, t && t.set(e, n), n;
}
function _classCallCheck(a, n) {
  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _defineProperties(e, r) {
  for (var t = 0; t < r.length; t++) {
    var o = r[t];
    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
  }
}
function _createClass(e, r, t) {
  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
    writable: !1
  }), e;
}
function _toPropertyKey(t) {
  var i = _toPrimitive(t, "string");
  return "symbol" == _typeof(i) ? i : 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 _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);
}
function log(message) {
  if (!(process && process.env && process.env.NODE_ENV === 'production')) {
    console.error("[@ant-design/icons-react]: ".concat(message, "."));
  }
}
function isIconDefinition(target) {
  return _typeof(target) === 'object' && typeof target.name === 'string' && typeof target.theme === 'string' && (_typeof(target.icon) === 'object' || typeof target.icon === 'function');
}
function normalizeAttrs() {
  var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return Object.keys(attrs).reduce(function (acc, key) {
    var val = attrs[key];
    switch (key) {
      case 'class':
        acc.className = val;
        delete acc["class"];
        break;
      default:
        acc[key] = val;
    }
    return acc;
  }, {});
}
var MiniMap = exports.MiniMap = /*#__PURE__*/function () {
  function MiniMap() {
    _classCallCheck(this, MiniMap);
    Object.defineProperty(this, "collection", {
      enumerable: true,
      configurable: true,
      writable: true,
      value: {}
    });
  }
  return _createClass(MiniMap, [{
    key: "size",
    get: function get() {
      return Object.keys(this.collection).length;
    }
  }, {
    key: "clear",
    value: function clear() {
      this.collection = {};
    }
  }, {
    key: "delete",
    value: function _delete(key) {
      return delete this.collection[key];
    }
  }, {
    key: "get",
    value: function get(key) {
      return this.collection[key];
    }
  }, {
    key: "has",
    value: function has(key) {
      return Boolean(this.collection[key]);
    }
  }, {
    key: "set",
    value: function set(key, value) {
      this.collection[key] = value;
      return this;
    }
  }]);
}();
function generate(node, key, rootProps) {
  if (!rootProps) {
    return React.createElement(node.tag, Object.assign({
      key: key
    }, normalizeAttrs(node.attrs)), (node.children || []).map(function (child, index) {
      return generate(child, "".concat(key, "-").concat(node.tag, "-").concat(index));
    }));
  }
  return React.createElement(node.tag, Object.assign(Object.assign({
    key: key
  }, normalizeAttrs(node.attrs)), rootProps), (node.children || []).map(function (child, index) {
    return generate(child, "".concat(key, "-").concat(node.tag, "-").concat(index));
  }));
}
function getSecondaryColor(primaryColor) {
  // choose the second color
  return (0, _colors.generate)(primaryColor)[0];
}
function withSuffix(name, theme) {
  switch (theme) {
    case 'fill':
      return "".concat(name, "-fill");
    case 'outline':
      return "".concat(name, "-o");
    case 'twotone':
      return "".concat(name, "-twotone");
    default:
      throw new TypeError("Unknown theme type: ".concat(theme, ", name: ").concat(name));
  }
}