@fmdevui/fm-dev 1.0.112 → 1.0.114

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/number.js

@@ -0,0 +1,565 @@
+'use strict';
+
+var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+var RADIAN_EPSILON = 1e-4;
+// Although chrome already enlarge this number to 100 for `toFixed`, but
+// we sill follow the spec for compatibility.
+var ROUND_SUPPORTED_PRECISION_MAX = 20;
+function _trim(str) {
+  return str.replace(/^\s+|\s+$/g, '');
+}
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathAbs = Math.abs;
+/**
+ * Linear mapping a value from domain to range
+ * @param  val
+ * @param  domain Domain extent domain[0] can be bigger than domain[1]
+ * @param  range  Range extent range[0] can be bigger than range[1]
+ * @param  clamp Default to be false
+ */
+function linearMap(val, domain, range, clamp) {
+  var d0 = domain[0];
+  var d1 = domain[1];
+  var r0 = range[0];
+  var r1 = range[1];
+  var subDomain = d1 - d0;
+  var subRange = r1 - r0;
+  if (subDomain === 0) {
+    return subRange === 0 ? r0 : (r0 + r1) / 2;
+  }
+  // Avoid accuracy problem in edge, such as
+  // 146.39 - 62.83 === 83.55999999999999.
+  // See echarts/test/ut/spec/util/number.js#linearMap#accuracyError
+  // It is a little verbose for efficiency considering this method
+  // is a hotspot.
+  if (clamp) {
+    if (subDomain > 0) {
+      if (val <= d0) {
+        return r0;
+      } else if (val >= d1) {
+        return r1;
+      }
+    } else {
+      if (val >= d0) {
+        return r0;
+      } else if (val <= d1) {
+        return r1;
+      }
+    }
+  } else {
+    if (val === d0) {
+      return r0;
+    }
+    if (val === d1) {
+      return r1;
+    }
+  }
+  return (val - d0) / subDomain * subRange + r0;
+}
+/**
+ * Preserve the name `parsePercent` for backward compatibility,
+ * and it's effectively published as `echarts.number.parsePercent`.
+ */
+var parsePercent = parsePositionOption;
+/**
+ * @see {parsePositionSizeOption} and also accept a string preset.
+ * @see {PositionSizeOption}
+ */
+function parsePositionOption(option, percentBase, percentOffset) {
+  switch (option) {
+    case 'center':
+    case 'middle':
+      option = '50%';
+      break;
+    case 'left':
+    case 'top':
+      option = '0%';
+      break;
+    case 'right':
+    case 'bottom':
+      option = '100%';
+      break;
+  }
+  return parsePositionSizeOption(option, percentBase, percentOffset);
+}
+/**
+ * Accept number, or numeric stirng (`'123'`), or percentage ('100%'), as x/y/width/height pixel number.
+ * If null/undefined or invalid, return NaN.
+ * (But allow JS type coercion (`+option`) due to backward compatibility)
+ * @see {PositionSizeOption}
+ */
+function parsePositionSizeOption(option, percentBase, percentOffset) {
+  if (util.isString(option)) {
+    if (_trim(option).match(/%$/)) {
+      return parseFloat(option) / 100 * percentBase + (percentOffset || 0);
+    }
+    return parseFloat(option);
+  }
+  // Allow flexible input due to backward compatibility.
+  return option == null ? NaN : +option;
+}
+function round(x, precision, returnStr) {
+  if (precision == null) {
+    // FIXME: the default precision should not be provided, since there is no universally adaptable
+    //  precision. The caller need to input a precision according to the scenarios.
+    precision = 10;
+  }
+  // Avoid range error
+  precision = Math.min(Math.max(0, precision), ROUND_SUPPORTED_PRECISION_MAX);
+  // PENDING: 1.005.toFixed(2) is '1.00' rather than '1.01'
+  x = (+x).toFixed(precision);
+  return returnStr ? x : +x;
+}
+/**
+ * Inplacd asc sort arr.
+ * The input arr will be modified.
+ */
+function asc(arr) {
+  arr.sort(function (a, b) {
+    return a - b;
+  });
+  return arr;
+}
+/**
+ * Get precision.
+ */
+function getPrecision(val) {
+  val = +val;
+  if (isNaN(val)) {
+    return 0;
+  }
+  // It is much faster than methods converting number to string as follows
+  //      let tmp = val.toString();
+  //      return tmp.length - 1 - tmp.indexOf('.');
+  // especially when precision is low
+  // Notice:
+  // (1) If the loop count is over about 20, it is slower than `getPrecisionSafe`.
+  //     (see https://jsbench.me/2vkpcekkvw/1)
+  // (2) If the val is less than for example 1e-15, the result may be incorrect.
+  //     (see test/ut/spec/util/number.test.ts `getPrecision_equal_random`)
+  if (val > 1e-14) {
+    var e = 1;
+    for (var i = 0; i < 15; i++, e *= 10) {
+      if (Math.round(val * e) / e === val) {
+        return i;
+      }
+    }
+  }
+  return getPrecisionSafe(val);
+}
+/**
+ * Get precision with slow but safe method
+ */
+function getPrecisionSafe(val) {
+  // toLowerCase for: '3.4E-12'
+  var str = val.toString().toLowerCase();
+  // Consider scientific notation: '3.4e-12' '3.4e+12'
+  var eIndex = str.indexOf('e');
+  var exp = eIndex > 0 ? +str.slice(eIndex + 1) : 0;
+  var significandPartLen = eIndex > 0 ? eIndex : str.length;
+  var dotIndex = str.indexOf('.');
+  var decimalPartLen = dotIndex < 0 ? 0 : significandPartLen - 1 - dotIndex;
+  return Math.max(0, decimalPartLen - exp);
+}
+/**
+ * Minimal dicernible data precisioin according to a single pixel.
+ */
+function getPixelPrecision(dataExtent, pixelExtent) {
+  var log = Math.log;
+  var LN10 = Math.LN10;
+  var dataQuantity = Math.floor(log(dataExtent[1] - dataExtent[0]) / LN10);
+  var sizeQuantity = Math.round(log(mathAbs(pixelExtent[1] - pixelExtent[0])) / LN10);
+  // toFixed() digits argument must be between 0 and 20.
+  var precision = Math.min(Math.max(-dataQuantity + sizeQuantity, 0), 20);
+  return !isFinite(precision) ? 20 : precision;
+}
+/**
+ * Get a data of given precision, assuring the sum of percentages
+ * in valueList is 1.
+ * The largest remainder method is used.
+ * https://en.wikipedia.org/wiki/Largest_remainder_method
+ *
+ * @param valueList a list of all data
+ * @param idx index of the data to be processed in valueList
+ * @param precision integer number showing digits of precision
+ * @return percent ranging from 0 to 100
+ */
+function getPercentWithPrecision(valueList, idx, precision) {
+  if (!valueList[idx]) {
+    return 0;
+  }
+  var seats = getPercentSeats(valueList, precision);
+  return seats[idx] || 0;
+}
+/**
+ * Get a data of given precision, assuring the sum of percentages
+ * in valueList is 1.
+ * The largest remainder method is used.
+ * https://en.wikipedia.org/wiki/Largest_remainder_method
+ *
+ * @param valueList a list of all data
+ * @param precision integer number showing digits of precision
+ * @return {Array<number>}
+ */
+function getPercentSeats(valueList, precision) {
+  var sum = util.reduce(valueList, function (acc, val) {
+    return acc + (isNaN(val) ? 0 : val);
+  }, 0);
+  if (sum === 0) {
+    return [];
+  }
+  var digits = Math.pow(10, precision);
+  var votesPerQuota = util.map(valueList, function (val) {
+    return (isNaN(val) ? 0 : val) / sum * digits * 100;
+  });
+  var targetSeats = digits * 100;
+  var seats = util.map(votesPerQuota, function (votes) {
+    // Assign automatic seats.
+    return Math.floor(votes);
+  });
+  var currentSum = util.reduce(seats, function (acc, val) {
+    return acc + val;
+  }, 0);
+  var remainder = util.map(votesPerQuota, function (votes, idx) {
+    return votes - seats[idx];
+  });
+  // Has remainding votes.
+  while (currentSum < targetSeats) {
+    // Find next largest remainder.
+    var max = Number.NEGATIVE_INFINITY;
+    var maxId = null;
+    for (var i = 0, len = remainder.length; i < len; ++i) {
+      if (remainder[i] > max) {
+        max = remainder[i];
+        maxId = i;
+      }
+    }
+    // Add a vote to max remainder.
+    ++seats[maxId];
+    remainder[maxId] = 0;
+    ++currentSum;
+  }
+  return util.map(seats, function (seat) {
+    return seat / digits;
+  });
+}
+/**
+ * Solve the floating point adding problem like 0.1 + 0.2 === 0.30000000000000004
+ * See <http://0.30000000000000004.com/>
+ */
+function addSafe(val0, val1) {
+  var maxPrecision = Math.max(getPrecision(val0), getPrecision(val1));
+  // const multiplier = Math.pow(10, maxPrecision);
+  // return (Math.round(val0 * multiplier) + Math.round(val1 * multiplier)) / multiplier;
+  var sum = val0 + val1;
+  // // PENDING: support more?
+  return maxPrecision > ROUND_SUPPORTED_PRECISION_MAX ? sum : round(sum, maxPrecision);
+}
+// Number.MAX_SAFE_INTEGER, ie do not support.
+var MAX_SAFE_INTEGER = 9007199254740991;
+/**
+ * To 0 - 2 * PI, considering negative radian.
+ */
+function remRadian(radian) {
+  var pi2 = Math.PI * 2;
+  return (radian % pi2 + pi2) % pi2;
+}
+/**
+ * @param {type} radian
+ * @return {boolean}
+ */
+function isRadianAroundZero(val) {
+  return val > -RADIAN_EPSILON && val < RADIAN_EPSILON;
+}
+// eslint-disable-next-line
+var TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/; // jshint ignore:line
+/**
+ * @param value valid type: number | string | Date, otherwise return `new Date(NaN)`
+ *   These values can be accepted:
+ *   + An instance of Date, represent a time in its own time zone.
+ *   + Or string in a subset of ISO 8601, only including:
+ *     + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06',
+ *     + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123',
+ *     + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00',
+ *     all of which will be treated as local time if time zone is not specified
+ *     (see <https://momentjs.com/>).
+ *   + Or other string format, including (all of which will be treated as local time):
+ *     '2012', '2012-3-1', '2012/3/1', '2012/03/01',
+ *     '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123'
+ *   + a timestamp, which represent a time in UTC.
+ * @return date Never be null/undefined. If invalid, return `new Date(NaN)`.
+ */
+function parseDate(value) {
+  if (value instanceof Date) {
+    return value;
+  } else if (util.isString(value)) {
+    // Different browsers parse date in different way, so we parse it manually.
+    // Some other issues:
+    // new Date('1970-01-01') is UTC,
+    // new Date('1970/01/01') and new Date('1970-1-01') is local.
+    // See issue #3623
+    var match = TIME_REG.exec(value);
+    if (!match) {
+      // return Invalid Date.
+      return new Date(NaN);
+    }
+    // Use local time when no timezone offset is specified.
+    if (!match[8]) {
+      // match[n] can only be string or undefined.
+      // But take care of '12' + 1 => '121'.
+      return new Date(+match[1], +(match[2] || 1) - 1, +match[3] || 1, +match[4] || 0, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0);
+    }
+    // Timezoneoffset of Javascript Date has considered DST (Daylight Saving Time,
+    // https://tc39.github.io/ecma262/#sec-daylight-saving-time-adjustment).
+    // For example, system timezone is set as "Time Zone: America/Toronto",
+    // then these code will get different result:
+    // `new Date(1478411999999).getTimezoneOffset();  // get 240`
+    // `new Date(1478412000000).getTimezoneOffset();  // get 300`
+    // So we should not use `new Date`, but use `Date.UTC`.
+    else {
+      var hour = +match[4] || 0;
+      if (match[8].toUpperCase() !== 'Z') {
+        hour -= +match[8].slice(0, 3);
+      }
+      return new Date(Date.UTC(+match[1], +(match[2] || 1) - 1, +match[3] || 1, hour, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0));
+    }
+  } else if (value == null) {
+    return new Date(NaN);
+  }
+  return new Date(Math.round(value));
+}
+/**
+ * Quantity of a number. e.g. 0.1, 1, 10, 100
+ *
+ * @param val
+ * @return
+ */
+function quantity(val) {
+  return Math.pow(10, quantityExponent(val));
+}
+/**
+ * Exponent of the quantity of a number
+ * e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3
+ *
+ * @param val non-negative value
+ * @return
+ */
+function quantityExponent(val) {
+  if (val === 0) {
+    return 0;
+  }
+  var exp = Math.floor(Math.log(val) / Math.LN10);
+  /**
+   * exp is expected to be the rounded-down result of the base-10 log of val.
+   * But due to the precision loss with Math.log(val), we need to restore it
+   * using 10^exp to make sure we can get val back from exp. #11249
+   */
+  if (val / Math.pow(10, exp) >= 10) {
+    exp++;
+  }
+  return exp;
+}
+/**
+ * find a “nice” number approximately equal to x. Round the number if round = true,
+ * take ceiling if round = false. The primary observation is that the “nicest”
+ * numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers.
+ *
+ * See "Nice Numbers for Graph Labels" of Graphic Gems.
+ *
+ * @param  val Non-negative value.
+ * @param  round
+ * @return Niced number
+ */
+function nice(val, round) {
+  var exponent = quantityExponent(val);
+  var exp10 = Math.pow(10, exponent);
+  var f = val / exp10; // 1 <= f < 10
+  var nf;
+  if (round) {
+    if (f < 1.5) {
+      nf = 1;
+    } else if (f < 2.5) {
+      nf = 2;
+    } else if (f < 4) {
+      nf = 3;
+    } else if (f < 7) {
+      nf = 5;
+    } else {
+      nf = 10;
+    }
+  } else {
+    if (f < 1) {
+      nf = 1;
+    } else if (f < 2) {
+      nf = 2;
+    } else if (f < 3) {
+      nf = 3;
+    } else if (f < 5) {
+      nf = 5;
+    } else {
+      nf = 10;
+    }
+  }
+  val = nf * exp10;
+  // Fix 3 * 0.1 === 0.30000000000000004 issue (see IEEE 754).
+  // 20 is the uppper bound of toFixed.
+  return exponent >= -20 ? +val.toFixed(exponent < 0 ? -exponent : 0) : val;
+}
+/**
+ * This code was copied from "d3.js"
+ * <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/arrays/quantile.js>.
+ * See the license statement at the head of this file.
+ * @param ascArr
+ */
+function quantile(ascArr, p) {
+  var H = (ascArr.length - 1) * p + 1;
+  var h = Math.floor(H);
+  var v = +ascArr[h - 1];
+  var e = H - h;
+  return e ? v + e * (ascArr[h] - v) : v;
+}
+/**
+ * Order intervals asc, and split them when overlap.
+ * expect(numberUtil.reformIntervals([
+ *     {interval: [18, 62], close: [1, 1]},
+ *     {interval: [-Infinity, -70], close: [0, 0]},
+ *     {interval: [-70, -26], close: [1, 1]},
+ *     {interval: [-26, 18], close: [1, 1]},
+ *     {interval: [62, 150], close: [1, 1]},
+ *     {interval: [106, 150], close: [1, 1]},
+ *     {interval: [150, Infinity], close: [0, 0]}
+ * ])).toEqual([
+ *     {interval: [-Infinity, -70], close: [0, 0]},
+ *     {interval: [-70, -26], close: [1, 1]},
+ *     {interval: [-26, 18], close: [0, 1]},
+ *     {interval: [18, 62], close: [0, 1]},
+ *     {interval: [62, 150], close: [0, 1]},
+ *     {interval: [150, Infinity], close: [0, 0]}
+ * ]);
+ * @param list, where `close` mean open or close
+ *        of the interval, and Infinity can be used.
+ * @return The origin list, which has been reformed.
+ */
+function reformIntervals(list) {
+  list.sort(function (a, b) {
+    return littleThan(a, b, 0) ? -1 : 1;
+  });
+  var curr = -Infinity;
+  var currClose = 1;
+  for (var i = 0; i < list.length;) {
+    var interval = list[i].interval;
+    var close_1 = list[i].close;
+    for (var lg = 0; lg < 2; lg++) {
+      if (interval[lg] <= curr) {
+        interval[lg] = curr;
+        close_1[lg] = !lg ? 1 - currClose : 1;
+      }
+      curr = interval[lg];
+      currClose = close_1[lg];
+    }
+    if (interval[0] === interval[1] && close_1[0] * close_1[1] !== 1) {
+      list.splice(i, 1);
+    } else {
+      i++;
+    }
+  }
+  return list;
+  function littleThan(a, b, lg) {
+    return a.interval[lg] < b.interval[lg] || a.interval[lg] === b.interval[lg] && (a.close[lg] - b.close[lg] === (!lg ? 1 : -1) || !lg && littleThan(a, b, 1));
+  }
+}
+/**
+ * [Numeric is defined as]:
+ *     `parseFloat(val) == val`
+ * For example:
+ * numeric:
+ *     typeof number except NaN, '-123', '123', '2e3', '-2e3', '011', 'Infinity', Infinity,
+ *     and they rounded by white-spaces or line-terminal like ' -123 \n ' (see es spec)
+ * not-numeric:
+ *     null, undefined, [], {}, true, false, 'NaN', NaN, '123ab',
+ *     empty string, string with only white-spaces or line-terminal (see es spec),
+ *     0x12, '0x12', '-0x12', 012, '012', '-012',
+ *     non-string, ...
+ *
+ * @test See full test cases in `test/ut/spec/util/number.js`.
+ * @return Must be a typeof number. If not numeric, return NaN.
+ */
+function numericToNumber(val) {
+  var valFloat = parseFloat(val);
+  return valFloat == val // eslint-disable-line eqeqeq
+  && (valFloat !== 0 || !util.isString(val) || val.indexOf('x') <= 0) // For case ' 0x0 '.
+  ? valFloat : NaN;
+}
+/**
+ * Definition of "numeric": see `numericToNumber`.
+ */
+function isNumeric(val) {
+  return !isNaN(numericToNumber(val));
+}
+/**
+ * Use random base to prevent users hard code depending on
+ * this auto generated marker id.
+ * @return An positive integer.
+ */
+function getRandomIdBase() {
+  return Math.round(Math.random() * 9);
+}
+/**
+ * Get the greatest common divisor.
+ *
+ * @param {number} a one number
+ * @param {number} b the other number
+ */
+function getGreatestCommonDividor(a, b) {
+  if (b === 0) {
+    return a;
+  }
+  return getGreatestCommonDividor(b, a % b);
+}
+/**
+ * Get the least common multiple.
+ *
+ * @param {number} a one number
+ * @param {number} b the other number
+ */
+function getLeastCommonMultiple(a, b) {
+  if (a == null) {
+    return b;
+  }
+  if (b == null) {
+    return a;
+  }
+  return a * b / getGreatestCommonDividor(a, b);
+}
+
+exports.MAX_SAFE_INTEGER = MAX_SAFE_INTEGER;
+exports.addSafe = addSafe;
+exports.asc = asc;
+exports.getGreatestCommonDividor = getGreatestCommonDividor;
+exports.getLeastCommonMultiple = getLeastCommonMultiple;
+exports.getPercentSeats = getPercentSeats;
+exports.getPercentWithPrecision = getPercentWithPrecision;
+exports.getPixelPrecision = getPixelPrecision;
+exports.getPrecision = getPrecision;
+exports.getPrecisionSafe = getPrecisionSafe;
+exports.getRandomIdBase = getRandomIdBase;
+exports.isNumeric = isNumeric;
+exports.isRadianAroundZero = isRadianAroundZero;
+exports.linearMap = linearMap;
+exports.mathAbs = mathAbs;
+exports.mathMax = mathMax;
+exports.mathMin = mathMin;
+exports.nice = nice;
+exports.numericToNumber = numericToNumber;
+exports.parseDate = parseDate;
+exports.parsePercent = parsePercent;
+exports.parsePositionOption = parsePositionOption;
+exports.parsePositionSizeOption = parsePositionSizeOption;
+exports.quantile = quantile;
+exports.quantity = quantity;
+exports.quantityExponent = quantityExponent;
+exports.reformIntervals = reformIntervals;
+exports.remRadian = remRadian;
+exports.round = round;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/shape/sausage.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+require('../graphic.js');
+var Path = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Path.js');
+
+/**
+ * Sausage: similar to sector, but have half circle on both sides
+ */
+var SausageShape = /** @class */function () {
+  function SausageShape() {
+    this.cx = 0;
+    this.cy = 0;
+    this.r0 = 0;
+    this.r = 0;
+    this.startAngle = 0;
+    this.endAngle = Math.PI * 2;
+    this.clockwise = true;
+  }
+  return SausageShape;
+}();
+var SausagePath = /** @class */function (_super) {
+  tslib_es6.__extends(SausagePath, _super);
+  function SausagePath(opts) {
+    var _this = _super.call(this, opts) || this;
+    _this.type = 'sausage';
+    return _this;
+  }
+  SausagePath.prototype.getDefaultShape = function () {
+    return new SausageShape();
+  };
+  SausagePath.prototype.buildPath = function (ctx, shape) {
+    var cx = shape.cx;
+    var cy = shape.cy;
+    var r0 = Math.max(shape.r0 || 0, 0);
+    var r = Math.max(shape.r, 0);
+    var dr = (r - r0) * 0.5;
+    var rCenter = r0 + dr;
+    var startAngle = shape.startAngle;
+    var endAngle = shape.endAngle;
+    var clockwise = shape.clockwise;
+    var PI2 = Math.PI * 2;
+    var lessThanCircle = clockwise ? endAngle - startAngle < PI2 : startAngle - endAngle < PI2;
+    if (!lessThanCircle) {
+      // Normalize angles
+      startAngle = endAngle - (clockwise ? PI2 : -PI2);
+    }
+    var unitStartX = Math.cos(startAngle);
+    var unitStartY = Math.sin(startAngle);
+    var unitEndX = Math.cos(endAngle);
+    var unitEndY = Math.sin(endAngle);
+    if (lessThanCircle) {
+      ctx.moveTo(unitStartX * r0 + cx, unitStartY * r0 + cy);
+      ctx.arc(unitStartX * rCenter + cx, unitStartY * rCenter + cy, dr, -Math.PI + startAngle, startAngle, !clockwise);
+    } else {
+      ctx.moveTo(unitStartX * r + cx, unitStartY * r + cy);
+    }
+    ctx.arc(cx, cy, r, startAngle, endAngle, !clockwise);
+    ctx.arc(unitEndX * rCenter + cx, unitEndY * rCenter + cy, dr, endAngle - Math.PI * 2, endAngle - Math.PI, !clockwise);
+    if (r0 !== 0) {
+      ctx.arc(cx, cy, r0, endAngle, startAngle, clockwise);
+    }
+    // ctx.closePath();
+  };
+  return SausagePath;
+}(Path.default);
+
+exports.default = SausagePath;