@fmdevui/fm-dev 1.0.113 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/styleCompat.mjs

@@ -0,0 +1,187 @@
+import { hasOwn, each } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import tokens from '../visual/tokens.mjs';
+
+var deprecatedLogs = {};
+/**
+ * Whether need to call `convertEC4CompatibleStyle`.
+ */
+function isEC4CompatibleStyle(style, elType, hasOwnTextContentOption, hasOwnTextConfig) {
+  // Since echarts5, `RectText` is separated from its host element and style.text
+  // does not exist any more. The compat work brings some extra burden on performance.
+  // So we provide:
+  // `legacy: true` force make compat.
+  // `legacy: false`, force do not compat.
+  // `legacy` not set: auto detect whether legacy.
+  //     But in this case we do not compat (difficult to detect and rare case):
+  //     Because custom series and graphic component support "merge", users may firstly
+  //     only set `textStrokeWidth` style or secondly only set `text`.
+  return style && (style.legacy || style.legacy !== false && !hasOwnTextContentOption && !hasOwnTextConfig && elType !== 'tspan'
+  // Difficult to detect whether legacy for a "text" el.
+  && (elType === 'text' || hasOwn(style, 'text')));
+}
+/**
+ * `EC4CompatibleStyle` is style that might be in echarts4 format or echarts5 format.
+ * @param hostStyle The properties might be modified.
+ * @return If be text el, `textContentStyle` and `textConfig` will not be returned.
+ *         Otherwise a `textContentStyle` and `textConfig` will be created, whose props area
+ *         retried from the `hostStyle`.
+ */
+function convertFromEC4CompatibleStyle(hostStyle, elType, isNormal) {
+  var srcStyle = hostStyle;
+  var textConfig;
+  var textContent;
+  var textContentStyle;
+  if (elType === 'text') {
+    textContentStyle = srcStyle;
+  } else {
+    textContentStyle = {};
+    hasOwn(srcStyle, 'text') && (textContentStyle.text = srcStyle.text);
+    hasOwn(srcStyle, 'rich') && (textContentStyle.rich = srcStyle.rich);
+    hasOwn(srcStyle, 'textFill') && (textContentStyle.fill = srcStyle.textFill);
+    hasOwn(srcStyle, 'textStroke') && (textContentStyle.stroke = srcStyle.textStroke);
+    hasOwn(srcStyle, 'fontFamily') && (textContentStyle.fontFamily = srcStyle.fontFamily);
+    hasOwn(srcStyle, 'fontSize') && (textContentStyle.fontSize = srcStyle.fontSize);
+    hasOwn(srcStyle, 'fontStyle') && (textContentStyle.fontStyle = srcStyle.fontStyle);
+    hasOwn(srcStyle, 'fontWeight') && (textContentStyle.fontWeight = srcStyle.fontWeight);
+    textContent = {
+      type: 'text',
+      style: textContentStyle,
+      // ec4 does not support rectText trigger.
+      // And when text position is different in normal and emphasis
+      // => hover text trigger emphasis;
+      // => text position changed, leave mouse pointer immediately;
+      // That might cause incorrect state.
+      silent: true
+    };
+    textConfig = {};
+    var hasOwnPos = hasOwn(srcStyle, 'textPosition');
+    if (isNormal) {
+      textConfig.position = hasOwnPos ? srcStyle.textPosition : 'inside';
+    } else {
+      hasOwnPos && (textConfig.position = srcStyle.textPosition);
+    }
+    hasOwn(srcStyle, 'textPosition') && (textConfig.position = srcStyle.textPosition);
+    hasOwn(srcStyle, 'textOffset') && (textConfig.offset = srcStyle.textOffset);
+    hasOwn(srcStyle, 'textRotation') && (textConfig.rotation = srcStyle.textRotation);
+    hasOwn(srcStyle, 'textDistance') && (textConfig.distance = srcStyle.textDistance);
+  }
+  convertEC4CompatibleRichItem(textContentStyle, hostStyle);
+  each(textContentStyle.rich, function (richItem) {
+    convertEC4CompatibleRichItem(richItem, richItem);
+  });
+  return {
+    textConfig: textConfig,
+    textContent: textContent
+  };
+}
+/**
+ * The result will be set to `out`.
+ */
+function convertEC4CompatibleRichItem(out, richItem) {
+  if (!richItem) {
+    return;
+  }
+  // (1) For simplicity, make textXXX properties (deprecated since ec5) has
+  // higher priority. For example, consider in ec4 `borderColor: 5, textBorderColor: 10`
+  // on a rect means `borderColor: 4` on the rect and `borderColor: 10` on an attached
+  // richText in ec5.
+  // (2) `out === richItem` if and only if `out` is text el or rich item.
+  // So we can overwrite existing props in `out` since textXXX has higher priority.
+  richItem.font = richItem.textFont || richItem.font;
+  hasOwn(richItem, 'textStrokeWidth') && (out.lineWidth = richItem.textStrokeWidth);
+  hasOwn(richItem, 'textAlign') && (out.align = richItem.textAlign);
+  hasOwn(richItem, 'textVerticalAlign') && (out.verticalAlign = richItem.textVerticalAlign);
+  hasOwn(richItem, 'textLineHeight') && (out.lineHeight = richItem.textLineHeight);
+  hasOwn(richItem, 'textWidth') && (out.width = richItem.textWidth);
+  hasOwn(richItem, 'textHeight') && (out.height = richItem.textHeight);
+  hasOwn(richItem, 'textBackgroundColor') && (out.backgroundColor = richItem.textBackgroundColor);
+  hasOwn(richItem, 'textPadding') && (out.padding = richItem.textPadding);
+  hasOwn(richItem, 'textBorderColor') && (out.borderColor = richItem.textBorderColor);
+  hasOwn(richItem, 'textBorderWidth') && (out.borderWidth = richItem.textBorderWidth);
+  hasOwn(richItem, 'textBorderRadius') && (out.borderRadius = richItem.textBorderRadius);
+  hasOwn(richItem, 'textBoxShadowColor') && (out.shadowColor = richItem.textBoxShadowColor);
+  hasOwn(richItem, 'textBoxShadowBlur') && (out.shadowBlur = richItem.textBoxShadowBlur);
+  hasOwn(richItem, 'textBoxShadowOffsetX') && (out.shadowOffsetX = richItem.textBoxShadowOffsetX);
+  hasOwn(richItem, 'textBoxShadowOffsetY') && (out.shadowOffsetY = richItem.textBoxShadowOffsetY);
+}
+/**
+ * Convert to pure echarts4 format style.
+ * `itemStyle` will be modified, added with ec4 style properties from
+ * `textStyle` and `textConfig`.
+ *
+ * [Caveat]: For simplicity, `insideRollback` in ec4 does not compat, where
+ * `styleEmphasis: {textFill: 'red'}` will remove the normal auto added stroke.
+ */
+function convertToEC4StyleForCustomSerise(itemStl, txStl, txCfg) {
+  var out = itemStl;
+  // See `custom.ts`, a trick to set extra `textPosition` firstly.
+  out.textPosition = out.textPosition || txCfg.position || 'inside';
+  txCfg.offset != null && (out.textOffset = txCfg.offset);
+  txCfg.rotation != null && (out.textRotation = txCfg.rotation);
+  txCfg.distance != null && (out.textDistance = txCfg.distance);
+  var isInside = out.textPosition.indexOf('inside') >= 0;
+  var hostFill = itemStl.fill || tokens.color.neutral99;
+  convertToEC4RichItem(out, txStl);
+  var textFillNotSet = out.textFill == null;
+  if (isInside) {
+    if (textFillNotSet) {
+      out.textFill = txCfg.insideFill || tokens.color.neutral00;
+      !out.textStroke && txCfg.insideStroke && (out.textStroke = txCfg.insideStroke);
+      !out.textStroke && (out.textStroke = hostFill);
+      out.textStrokeWidth == null && (out.textStrokeWidth = 2);
+    }
+  } else {
+    if (textFillNotSet) {
+      out.textFill = itemStl.fill || txCfg.outsideFill || tokens.color.neutral00;
+    }
+    !out.textStroke && txCfg.outsideStroke && (out.textStroke = txCfg.outsideStroke);
+  }
+  out.text = txStl.text;
+  out.rich = txStl.rich;
+  each(txStl.rich, function (richItem) {
+    convertToEC4RichItem(richItem, richItem);
+  });
+  return out;
+}
+function convertToEC4RichItem(out, richItem) {
+  if (!richItem) {
+    return;
+  }
+  hasOwn(richItem, 'fill') && (out.textFill = richItem.fill);
+  hasOwn(richItem, 'stroke') && (out.textStroke = richItem.fill);
+  hasOwn(richItem, 'lineWidth') && (out.textStrokeWidth = richItem.lineWidth);
+  hasOwn(richItem, 'font') && (out.font = richItem.font);
+  hasOwn(richItem, 'fontStyle') && (out.fontStyle = richItem.fontStyle);
+  hasOwn(richItem, 'fontWeight') && (out.fontWeight = richItem.fontWeight);
+  hasOwn(richItem, 'fontSize') && (out.fontSize = richItem.fontSize);
+  hasOwn(richItem, 'fontFamily') && (out.fontFamily = richItem.fontFamily);
+  hasOwn(richItem, 'align') && (out.textAlign = richItem.align);
+  hasOwn(richItem, 'verticalAlign') && (out.textVerticalAlign = richItem.verticalAlign);
+  hasOwn(richItem, 'lineHeight') && (out.textLineHeight = richItem.lineHeight);
+  hasOwn(richItem, 'width') && (out.textWidth = richItem.width);
+  hasOwn(richItem, 'height') && (out.textHeight = richItem.height);
+  hasOwn(richItem, 'backgroundColor') && (out.textBackgroundColor = richItem.backgroundColor);
+  hasOwn(richItem, 'padding') && (out.textPadding = richItem.padding);
+  hasOwn(richItem, 'borderColor') && (out.textBorderColor = richItem.borderColor);
+  hasOwn(richItem, 'borderWidth') && (out.textBorderWidth = richItem.borderWidth);
+  hasOwn(richItem, 'borderRadius') && (out.textBorderRadius = richItem.borderRadius);
+  hasOwn(richItem, 'shadowColor') && (out.textBoxShadowColor = richItem.shadowColor);
+  hasOwn(richItem, 'shadowBlur') && (out.textBoxShadowBlur = richItem.shadowBlur);
+  hasOwn(richItem, 'shadowOffsetX') && (out.textBoxShadowOffsetX = richItem.shadowOffsetX);
+  hasOwn(richItem, 'shadowOffsetY') && (out.textBoxShadowOffsetY = richItem.shadowOffsetY);
+  hasOwn(richItem, 'textShadowColor') && (out.textShadowColor = richItem.textShadowColor);
+  hasOwn(richItem, 'textShadowBlur') && (out.textShadowBlur = richItem.textShadowBlur);
+  hasOwn(richItem, 'textShadowOffsetX') && (out.textShadowOffsetX = richItem.textShadowOffsetX);
+  hasOwn(richItem, 'textShadowOffsetY') && (out.textShadowOffsetY = richItem.textShadowOffsetY);
+}
+function warnDeprecated(deprecated, insteadApproach) {
+  if (process.env.NODE_ENV !== 'production') {
+    var key = deprecated + '^_^' + insteadApproach;
+    if (!deprecatedLogs[key]) {
+      console.warn("[ECharts] DEPRECATED: \"" + deprecated + "\" has been deprecated. " + insteadApproach);
+      deprecatedLogs[key] = true;
+    }
+  }
+}
+
+export { convertFromEC4CompatibleStyle, convertToEC4StyleForCustomSerise, isEC4CompatibleStyle, warnDeprecated };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/symbol.mjs

@@ -0,0 +1,298 @@
+import { each, isArray, retrieve2 } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { makeImage, makePath } from './graphic.mjs';
+import BoundingRect from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/BoundingRect.mjs';
+import { calculateTextPosition } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/contain/text.mjs';
+import { parsePercent } from './number.mjs';
+import tokens from '../visual/tokens.mjs';
+import Path from '../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Path.mjs';
+import Circle from '../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Circle.mjs';
+import Rect from '../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Rect.mjs';
+import Line from '../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Line.mjs';
+
+/**
+ * Triangle shape
+ * @inner
+ */
+var Triangle = Path.extend({
+  type: 'triangle',
+  shape: {
+    cx: 0,
+    cy: 0,
+    width: 0,
+    height: 0
+  },
+  buildPath: function (path, shape) {
+    var cx = shape.cx;
+    var cy = shape.cy;
+    var width = shape.width / 2;
+    var height = shape.height / 2;
+    path.moveTo(cx, cy - height);
+    path.lineTo(cx + width, cy + height);
+    path.lineTo(cx - width, cy + height);
+    path.closePath();
+  }
+});
+/**
+ * Diamond shape
+ * @inner
+ */
+var Diamond = Path.extend({
+  type: 'diamond',
+  shape: {
+    cx: 0,
+    cy: 0,
+    width: 0,
+    height: 0
+  },
+  buildPath: function (path, shape) {
+    var cx = shape.cx;
+    var cy = shape.cy;
+    var width = shape.width / 2;
+    var height = shape.height / 2;
+    path.moveTo(cx, cy - height);
+    path.lineTo(cx + width, cy);
+    path.lineTo(cx, cy + height);
+    path.lineTo(cx - width, cy);
+    path.closePath();
+  }
+});
+/**
+ * Pin shape
+ * @inner
+ */
+var Pin = Path.extend({
+  type: 'pin',
+  shape: {
+    // x, y on the cusp
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  buildPath: function (path, shape) {
+    var x = shape.x;
+    var y = shape.y;
+    var w = shape.width / 5 * 3;
+    // Height must be larger than width
+    var h = Math.max(w, shape.height);
+    var r = w / 2;
+    // Dist on y with tangent point and circle center
+    var dy = r * r / (h - r);
+    var cy = y - h + r + dy;
+    var angle = Math.asin(dy / r);
+    // Dist on x with tangent point and circle center
+    var dx = Math.cos(angle) * r;
+    var tanX = Math.sin(angle);
+    var tanY = Math.cos(angle);
+    var cpLen = r * 0.6;
+    var cpLen2 = r * 0.7;
+    path.moveTo(x - dx, cy + dy);
+    path.arc(x, cy, r, Math.PI - angle, Math.PI * 2 + angle);
+    path.bezierCurveTo(x + dx - tanX * cpLen, cy + dy + tanY * cpLen, x, y - cpLen2, x, y);
+    path.bezierCurveTo(x, y - cpLen2, x - dx + tanX * cpLen, cy + dy + tanY * cpLen, x - dx, cy + dy);
+    path.closePath();
+  }
+});
+/**
+ * Arrow shape
+ * @inner
+ */
+var Arrow = Path.extend({
+  type: 'arrow',
+  shape: {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  buildPath: function (ctx, shape) {
+    var height = shape.height;
+    var width = shape.width;
+    var x = shape.x;
+    var y = shape.y;
+    var dx = width / 3 * 2;
+    ctx.moveTo(x, y);
+    ctx.lineTo(x + dx, y + height);
+    ctx.lineTo(x, y + height / 4 * 3);
+    ctx.lineTo(x - dx, y + height);
+    ctx.lineTo(x, y);
+    ctx.closePath();
+  }
+});
+/**
+ * Map of path constructors
+ */
+// TODO Use function to build symbol path.
+var symbolCtors = {
+  line: Line,
+  rect: Rect,
+  roundRect: Rect,
+  square: Rect,
+  circle: Circle,
+  diamond: Diamond,
+  pin: Pin,
+  arrow: Arrow,
+  triangle: Triangle
+};
+var symbolShapeMakers = {
+  line: function (x, y, w, h, shape) {
+    shape.x1 = x;
+    shape.y1 = y + h / 2;
+    shape.x2 = x + w;
+    shape.y2 = y + h / 2;
+  },
+  rect: function (x, y, w, h, shape) {
+    shape.x = x;
+    shape.y = y;
+    shape.width = w;
+    shape.height = h;
+  },
+  roundRect: function (x, y, w, h, shape) {
+    shape.x = x;
+    shape.y = y;
+    shape.width = w;
+    shape.height = h;
+    shape.r = Math.min(w, h) / 4;
+  },
+  square: function (x, y, w, h, shape) {
+    var size = Math.min(w, h);
+    shape.x = x;
+    shape.y = y;
+    shape.width = size;
+    shape.height = size;
+  },
+  circle: function (x, y, w, h, shape) {
+    // Put circle in the center of square
+    shape.cx = x + w / 2;
+    shape.cy = y + h / 2;
+    shape.r = Math.min(w, h) / 2;
+  },
+  diamond: function (x, y, w, h, shape) {
+    shape.cx = x + w / 2;
+    shape.cy = y + h / 2;
+    shape.width = w;
+    shape.height = h;
+  },
+  pin: function (x, y, w, h, shape) {
+    shape.x = x + w / 2;
+    shape.y = y + h / 2;
+    shape.width = w;
+    shape.height = h;
+  },
+  arrow: function (x, y, w, h, shape) {
+    shape.x = x + w / 2;
+    shape.y = y + h / 2;
+    shape.width = w;
+    shape.height = h;
+  },
+  triangle: function (x, y, w, h, shape) {
+    shape.cx = x + w / 2;
+    shape.cy = y + h / 2;
+    shape.width = w;
+    shape.height = h;
+  }
+};
+var symbolBuildProxies = {};
+each(symbolCtors, function (Ctor, name) {
+  symbolBuildProxies[name] = new Ctor();
+});
+var SymbolClz = Path.extend({
+  type: 'symbol',
+  shape: {
+    symbolType: '',
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  calculateTextPosition: function (out, config, rect) {
+    var res = calculateTextPosition(out, config, rect);
+    var shape = this.shape;
+    if (shape && shape.symbolType === 'pin' && config.position === 'inside') {
+      res.y = rect.y + rect.height * 0.4;
+    }
+    return res;
+  },
+  buildPath: function (ctx, shape, inBundle) {
+    var symbolType = shape.symbolType;
+    if (symbolType !== 'none') {
+      var proxySymbol = symbolBuildProxies[symbolType];
+      if (!proxySymbol) {
+        // Default rect
+        symbolType = 'rect';
+        proxySymbol = symbolBuildProxies[symbolType];
+      }
+      symbolShapeMakers[symbolType](shape.x, shape.y, shape.width, shape.height, proxySymbol.shape);
+      proxySymbol.buildPath(ctx, proxySymbol.shape, inBundle);
+    }
+  }
+});
+// Provide setColor helper method to avoid determine if set the fill or stroke outside
+function symbolPathSetColor(color, innerColor) {
+  if (this.type !== 'image') {
+    var symbolStyle = this.style;
+    if (this.__isEmptyBrush) {
+      symbolStyle.stroke = color;
+      symbolStyle.fill = innerColor || tokens.color.neutral00;
+      // TODO Same width with lineStyle in LineView
+      symbolStyle.lineWidth = 2;
+    } else if (this.shape.symbolType === 'line') {
+      symbolStyle.stroke = color;
+    } else {
+      symbolStyle.fill = color;
+    }
+    this.markRedraw();
+  }
+}
+/**
+ * Create a symbol element with given symbol configuration: shape, x, y, width, height, color
+ */
+function createSymbol(symbolType, x, y, w, h, color,
+// whether to keep the ratio of w/h,
+keepAspect) {
+  // TODO Support image object, DynamicImage.
+  var isEmpty = symbolType.indexOf('empty') === 0;
+  if (isEmpty) {
+    symbolType = symbolType.substr(5, 1).toLowerCase() + symbolType.substr(6);
+  }
+  var symbolPath;
+  if (symbolType.indexOf('image://') === 0) {
+    symbolPath = makeImage(symbolType.slice(8), new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');
+  } else if (symbolType.indexOf('path://') === 0) {
+    symbolPath = makePath(symbolType.slice(7), {}, new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');
+  } else {
+    symbolPath = new SymbolClz({
+      shape: {
+        symbolType: symbolType,
+        x: x,
+        y: y,
+        width: w,
+        height: h
+      }
+    });
+  }
+  symbolPath.__isEmptyBrush = isEmpty;
+  // TODO Should deprecate setColor
+  symbolPath.setColor = symbolPathSetColor;
+  if (color) {
+    symbolPath.setColor(color);
+  }
+  return symbolPath;
+}
+function normalizeSymbolSize(symbolSize) {
+  if (!isArray(symbolSize)) {
+    symbolSize = [+symbolSize, +symbolSize];
+  }
+  return [symbolSize[0] || 0, symbolSize[1] || 0];
+}
+function normalizeSymbolOffset(symbolOffset, symbolSize) {
+  if (symbolOffset == null) {
+    return;
+  }
+  if (!isArray(symbolOffset)) {
+    symbolOffset = [symbolOffset, symbolOffset];
+  }
+  return [parsePercent(symbolOffset[0], symbolSize[0]) || 0, parsePercent(retrieve2(symbolOffset[1], symbolOffset[0]), symbolSize[1]) || 0];
+}
+
+export { createSymbol, normalizeSymbolOffset, normalizeSymbolSize, symbolBuildProxies };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/throttle.mjs

@@ -0,0 +1,173 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+var ORIGIN_METHOD = '\0__throttleOriginMethod';
+var RATE = '\0__throttleRate';
+var THROTTLE_TYPE = '\0__throttleType';
+;
+/**
+ * @public
+ * @param {(Function)} fn
+ * @param {number} [delay=0] Unit: ms.
+ * @param {boolean} [debounce=false]
+ *        true: If call interval less than `delay`, only the last call works.
+ *        false: If call interval less than `delay, call works on fixed rate.
+ * @return {(Function)} throttled fn.
+ */
+function throttle(fn, delay, debounce) {
+  var currCall;
+  var lastCall = 0;
+  var lastExec = 0;
+  var timer = null;
+  var diff;
+  var scope;
+  var args;
+  var debounceNextCall;
+  delay = delay || 0;
+  function exec() {
+    lastExec = new Date().getTime();
+    timer = null;
+    fn.apply(scope, args || []);
+  }
+  var cb = function () {
+    var cbArgs = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      cbArgs[_i] = arguments[_i];
+    }
+    currCall = new Date().getTime();
+    scope = this;
+    args = cbArgs;
+    var thisDelay = debounceNextCall || delay;
+    var thisDebounce = debounceNextCall || debounce;
+    debounceNextCall = null;
+    diff = currCall - (thisDebounce ? lastCall : lastExec) - thisDelay;
+    clearTimeout(timer);
+    // Here we should make sure that: the `exec` SHOULD NOT be called later
+    // than a new call of `cb`, that is, preserving the command order. Consider
+    // calculating "scale rate" when roaming as an example. When a call of `cb`
+    // happens, either the `exec` is called dierectly, or the call is delayed.
+    // But the delayed call should never be later than next call of `cb`. Under
+    // this assurance, we can simply update view state each time `dispatchAction`
+    // triggered by user roaming, but not need to add extra code to avoid the
+    // state being "rolled-back".
+    if (thisDebounce) {
+      timer = setTimeout(exec, thisDelay);
+    } else {
+      if (diff >= 0) {
+        exec();
+      } else {
+        timer = setTimeout(exec, -diff);
+      }
+    }
+    lastCall = currCall;
+  };
+  /**
+   * Clear throttle.
+   * @public
+   */
+  cb.clear = function () {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  /**
+   * Enable debounce once.
+   */
+  cb.debounceNextCall = function (debounceDelay) {
+    debounceNextCall = debounceDelay;
+  };
+  return cb;
+}
+/**
+ * Create throttle method or update throttle rate.
+ *
+ * @example
+ * ComponentView.prototype.render = function () {
+ *     ...
+ *     throttle.createOrUpdate(
+ *         this,
+ *         '_dispatchAction',
+ *         this.model.get('throttle'),
+ *         'fixRate'
+ *     );
+ * };
+ * ComponentView.prototype.remove = function () {
+ *     throttle.clear(this, '_dispatchAction');
+ * };
+ * ComponentView.prototype.dispose = function () {
+ *     throttle.clear(this, '_dispatchAction');
+ * };
+ *
+ */
+function createOrUpdate(obj, fnAttr, rate, throttleType) {
+  var fn = obj[fnAttr];
+  if (!fn) {
+    return;
+  }
+  var originFn = fn[ORIGIN_METHOD] || fn;
+  var lastThrottleType = fn[THROTTLE_TYPE];
+  var lastRate = fn[RATE];
+  if (lastRate !== rate || lastThrottleType !== throttleType) {
+    if (rate == null || !throttleType) {
+      return obj[fnAttr] = originFn;
+    }
+    fn = obj[fnAttr] = throttle(originFn, rate, throttleType === 'debounce');
+    fn[ORIGIN_METHOD] = originFn;
+    fn[THROTTLE_TYPE] = throttleType;
+    fn[RATE] = rate;
+  }
+  return fn;
+}
+/**
+ * Clear throttle. Example see throttle.createOrUpdate.
+ */
+function clear(obj, fnAttr) {
+  var fn = obj[fnAttr];
+  if (fn && fn[ORIGIN_METHOD]) {
+    // Clear throttle
+    fn.clear && fn.clear();
+    obj[fnAttr] = fn[ORIGIN_METHOD];
+  }
+}
+
+export { clear, createOrUpdate, throttle };