@fecp/mobile 1.0.79 → 1.1.0

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/Path.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Displayable = require("./Displayable.js");
+const PathProxy = require("../core/PathProxy.js");
+const path = require("../contain/path.js");
+const util = require("../core/util.js");
+const color = require("../tool/color.js");
+const config = require("../config.js");
+const constants = require("./constants.js");
+const Transformable = require("../core/Transformable.js");
+var DEFAULT_PATH_STYLE = util.defaults({
+  fill: "#000",
+  stroke: null,
+  strokePercent: 1,
+  fillOpacity: 1,
+  strokeOpacity: 1,
+  lineDashOffset: 0,
+  lineWidth: 1,
+  lineCap: "butt",
+  miterLimit: 10,
+  strokeNoScale: false,
+  strokeFirst: false
+}, Displayable.DEFAULT_COMMON_STYLE);
+var DEFAULT_PATH_ANIMATION_PROPS = {
+  style: util.defaults({
+    fill: true,
+    stroke: true,
+    strokePercent: true,
+    fillOpacity: true,
+    strokeOpacity: true,
+    lineDashOffset: true,
+    lineWidth: true,
+    miterLimit: true
+  }, Displayable.DEFAULT_COMMON_ANIMATION_PROPS.style)
+};
+var pathCopyParams = Transformable.TRANSFORMABLE_PROPS.concat([
+  "invisible",
+  "culling",
+  "z",
+  "z2",
+  "zlevel",
+  "parent"
+]);
+var Path = function(_super) {
+  tslib_es6.__extends(Path2, _super);
+  function Path2(opts) {
+    return _super.call(this, opts) || this;
+  }
+  Path2.prototype.update = function() {
+    var _this = this;
+    _super.prototype.update.call(this);
+    var style = this.style;
+    if (style.decal) {
+      var decalEl = this._decalEl = this._decalEl || new Path2();
+      if (decalEl.buildPath === Path2.prototype.buildPath) {
+        decalEl.buildPath = function(ctx) {
+          _this.buildPath(ctx, _this.shape);
+        };
+      }
+      decalEl.silent = true;
+      var decalElStyle = decalEl.style;
+      for (var key in style) {
+        if (decalElStyle[key] !== style[key]) {
+          decalElStyle[key] = style[key];
+        }
+      }
+      decalElStyle.fill = style.fill ? style.decal : null;
+      decalElStyle.decal = null;
+      decalElStyle.shadowColor = null;
+      style.strokeFirst && (decalElStyle.stroke = null);
+      for (var i = 0; i < pathCopyParams.length; ++i) {
+        decalEl[pathCopyParams[i]] = this[pathCopyParams[i]];
+      }
+      decalEl.__dirty |= constants.REDRAW_BIT;
+    } else if (this._decalEl) {
+      this._decalEl = null;
+    }
+  };
+  Path2.prototype.getDecalElement = function() {
+    return this._decalEl;
+  };
+  Path2.prototype._init = function(props) {
+    var keysArr = util.keys(props);
+    this.shape = this.getDefaultShape();
+    var defaultStyle = this.getDefaultStyle();
+    if (defaultStyle) {
+      this.useStyle(defaultStyle);
+    }
+    for (var i = 0; i < keysArr.length; i++) {
+      var key = keysArr[i];
+      var value = props[key];
+      if (key === "style") {
+        if (!this.style) {
+          this.useStyle(value);
+        } else {
+          util.extend(this.style, value);
+        }
+      } else if (key === "shape") {
+        util.extend(this.shape, value);
+      } else {
+        _super.prototype.attrKV.call(this, key, value);
+      }
+    }
+    if (!this.style) {
+      this.useStyle({});
+    }
+  };
+  Path2.prototype.getDefaultStyle = function() {
+    return null;
+  };
+  Path2.prototype.getDefaultShape = function() {
+    return {};
+  };
+  Path2.prototype.canBeInsideText = function() {
+    return this.hasFill();
+  };
+  Path2.prototype.getInsideTextFill = function() {
+    var pathFill = this.style.fill;
+    if (pathFill !== "none") {
+      if (util.isString(pathFill)) {
+        var fillLum = color.lum(pathFill, 0);
+        if (fillLum > 0.5) {
+          return config.DARK_LABEL_COLOR;
+        } else if (fillLum > 0.2) {
+          return config.LIGHTER_LABEL_COLOR;
+        }
+        return config.LIGHT_LABEL_COLOR;
+      } else if (pathFill) {
+        return config.LIGHT_LABEL_COLOR;
+      }
+    }
+    return config.DARK_LABEL_COLOR;
+  };
+  Path2.prototype.getInsideTextStroke = function(textFill) {
+    var pathFill = this.style.fill;
+    if (util.isString(pathFill)) {
+      var zr = this.__zr;
+      var isDarkMode = !!(zr && zr.isDarkMode());
+      var isDarkLabel = color.lum(textFill, 0) < config.DARK_MODE_THRESHOLD;
+      if (isDarkMode === isDarkLabel) {
+        return pathFill;
+      }
+    }
+  };
+  Path2.prototype.buildPath = function(ctx, shapeCfg, inBatch) {
+  };
+  Path2.prototype.pathUpdated = function() {
+    this.__dirty &= -5;
+  };
+  Path2.prototype.getUpdatedPathProxy = function(inBatch) {
+    !this.path && this.createPathProxy();
+    this.path.beginPath();
+    this.buildPath(this.path, this.shape, inBatch);
+    return this.path;
+  };
+  Path2.prototype.createPathProxy = function() {
+    this.path = new PathProxy.default(false);
+  };
+  Path2.prototype.hasStroke = function() {
+    var style = this.style;
+    var stroke = style.stroke;
+    return !(stroke == null || stroke === "none" || !(style.lineWidth > 0));
+  };
+  Path2.prototype.hasFill = function() {
+    var style = this.style;
+    var fill = style.fill;
+    return fill != null && fill !== "none";
+  };
+  Path2.prototype.getBoundingRect = function() {
+    var rect = this._rect;
+    var style = this.style;
+    var needsUpdateRect = !rect;
+    if (needsUpdateRect) {
+      var firstInvoke = false;
+      if (!this.path) {
+        firstInvoke = true;
+        this.createPathProxy();
+      }
+      var path2 = this.path;
+      if (firstInvoke || this.__dirty & constants.SHAPE_CHANGED_BIT) {
+        path2.beginPath();
+        this.buildPath(path2, this.shape, false);
+        this.pathUpdated();
+      }
+      rect = path2.getBoundingRect();
+    }
+    this._rect = rect;
+    if (this.hasStroke() && this.path && this.path.len() > 0) {
+      var rectStroke = this._rectStroke || (this._rectStroke = rect.clone());
+      if (this.__dirty || needsUpdateRect) {
+        rectStroke.copy(rect);
+        var lineScale = style.strokeNoScale ? this.getLineScale() : 1;
+        var w = style.lineWidth;
+        if (!this.hasFill()) {
+          var strokeContainThreshold = this.strokeContainThreshold;
+          w = Math.max(w, strokeContainThreshold == null ? 4 : strokeContainThreshold);
+        }
+        if (lineScale > 1e-10) {
+          rectStroke.width += w / lineScale;
+          rectStroke.height += w / lineScale;
+          rectStroke.x -= w / lineScale / 2;
+          rectStroke.y -= w / lineScale / 2;
+        }
+      }
+      return rectStroke;
+    }
+    return rect;
+  };
+  Path2.prototype.contain = function(x, y) {
+    var localPos = this.transformCoordToLocal(x, y);
+    var rect = this.getBoundingRect();
+    var style = this.style;
+    x = localPos[0];
+    y = localPos[1];
+    if (rect.contain(x, y)) {
+      var pathProxy = this.path;
+      if (this.hasStroke()) {
+        var lineWidth = style.lineWidth;
+        var lineScale = style.strokeNoScale ? this.getLineScale() : 1;
+        if (lineScale > 1e-10) {
+          if (!this.hasFill()) {
+            lineWidth = Math.max(lineWidth, this.strokeContainThreshold);
+          }
+          if (path.containStroke(pathProxy, lineWidth / lineScale, x, y)) {
+            return true;
+          }
+        }
+      }
+      if (this.hasFill()) {
+        return path.contain(pathProxy, x, y);
+      }
+    }
+    return false;
+  };
+  Path2.prototype.dirtyShape = function() {
+    this.__dirty |= constants.SHAPE_CHANGED_BIT;
+    if (this._rect) {
+      this._rect = null;
+    }
+    if (this._decalEl) {
+      this._decalEl.dirtyShape();
+    }
+    this.markRedraw();
+  };
+  Path2.prototype.dirty = function() {
+    this.dirtyStyle();
+    this.dirtyShape();
+  };
+  Path2.prototype.animateShape = function(loop) {
+    return this.animate("shape", loop);
+  };
+  Path2.prototype.updateDuringAnimation = function(targetKey) {
+    if (targetKey === "style") {
+      this.dirtyStyle();
+    } else if (targetKey === "shape") {
+      this.dirtyShape();
+    } else {
+      this.markRedraw();
+    }
+  };
+  Path2.prototype.attrKV = function(key, value) {
+    if (key === "shape") {
+      this.setShape(value);
+    } else {
+      _super.prototype.attrKV.call(this, key, value);
+    }
+  };
+  Path2.prototype.setShape = function(keyOrObj, value) {
+    var shape = this.shape;
+    if (!shape) {
+      shape = this.shape = {};
+    }
+    if (typeof keyOrObj === "string") {
+      shape[keyOrObj] = value;
+    } else {
+      util.extend(shape, keyOrObj);
+    }
+    this.dirtyShape();
+    return this;
+  };
+  Path2.prototype.shapeChanged = function() {
+    return !!(this.__dirty & constants.SHAPE_CHANGED_BIT);
+  };
+  Path2.prototype.createStyle = function(obj) {
+    return util.createObject(DEFAULT_PATH_STYLE, obj);
+  };
+  Path2.prototype._innerSaveToNormal = function(toState) {
+    _super.prototype._innerSaveToNormal.call(this, toState);
+    var normalState = this._normalState;
+    if (toState.shape && !normalState.shape) {
+      normalState.shape = util.extend({}, this.shape);
+    }
+  };
+  Path2.prototype._applyStateObj = function(stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
+    _super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg);
+    var needsRestoreToNormal = !(state && keepCurrentStates);
+    var targetShape;
+    if (state && state.shape) {
+      if (transition) {
+        if (keepCurrentStates) {
+          targetShape = state.shape;
+        } else {
+          targetShape = util.extend({}, normalState.shape);
+          util.extend(targetShape, state.shape);
+        }
+      } else {
+        targetShape = util.extend({}, keepCurrentStates ? this.shape : normalState.shape);
+        util.extend(targetShape, state.shape);
+      }
+    } else if (needsRestoreToNormal) {
+      targetShape = normalState.shape;
+    }
+    if (targetShape) {
+      if (transition) {
+        this.shape = util.extend({}, this.shape);
+        var targetShapePrimaryProps = {};
+        var shapeKeys = util.keys(targetShape);
+        for (var i = 0; i < shapeKeys.length; i++) {
+          var key = shapeKeys[i];
+          if (typeof targetShape[key] === "object") {
+            this.shape[key] = targetShape[key];
+          } else {
+            targetShapePrimaryProps[key] = targetShape[key];
+          }
+        }
+        this._transitionState(stateName, {
+          shape: targetShapePrimaryProps
+        }, animationCfg);
+      } else {
+        this.shape = targetShape;
+        this.dirtyShape();
+      }
+    }
+  };
+  Path2.prototype._mergeStates = function(states) {
+    var mergedState = _super.prototype._mergeStates.call(this, states);
+    var mergedShape;
+    for (var i = 0; i < states.length; i++) {
+      var state = states[i];
+      if (state.shape) {
+        mergedShape = mergedShape || {};
+        this._mergeStyle(mergedShape, state.shape);
+      }
+    }
+    if (mergedShape) {
+      mergedState.shape = mergedShape;
+    }
+    return mergedState;
+  };
+  Path2.prototype.getAnimationStyleProps = function() {
+    return DEFAULT_PATH_ANIMATION_PROPS;
+  };
+  Path2.prototype.isZeroArea = function() {
+    return false;
+  };
+  Path2.extend = function(defaultProps) {
+    var Sub = function(_super2) {
+      tslib_es6.__extends(Sub2, _super2);
+      function Sub2(opts) {
+        var _this = _super2.call(this, opts) || this;
+        defaultProps.init && defaultProps.init.call(_this, opts);
+        return _this;
+      }
+      Sub2.prototype.getDefaultStyle = function() {
+        return util.clone(defaultProps.style);
+      };
+      Sub2.prototype.getDefaultShape = function() {
+        return util.clone(defaultProps.shape);
+      };
+      return Sub2;
+    }(Path2);
+    for (var key in defaultProps) {
+      if (typeof defaultProps[key] === "function") {
+        Sub.prototype[key] = defaultProps[key];
+      }
+    }
+    return Sub;
+  };
+  Path2.initDefaultProps = function() {
+    var pathProto = Path2.prototype;
+    pathProto.type = "path";
+    pathProto.strokeContainThreshold = 5;
+    pathProto.segmentIgnoreThreshold = 0;
+    pathProto.subPixelOptimize = false;
+    pathProto.autoBatch = false;
+    pathProto.__dirty = constants.REDRAW_BIT | constants.STYLE_CHANGED_BIT | constants.SHAPE_CHANGED_BIT;
+  }();
+  return Path2;
+}(Displayable.default);
+exports.DEFAULT_PATH_ANIMATION_PROPS = DEFAULT_PATH_ANIMATION_PROPS;
+exports.DEFAULT_PATH_STYLE = DEFAULT_PATH_STYLE;
+exports.default = Path;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/RadialGradient.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Gradient = require("./Gradient.js");
+var RadialGradient = function(_super) {
+  tslib_es6.__extends(RadialGradient2, _super);
+  function RadialGradient2(x, y, r, colorStops, globalCoord) {
+    var _this = _super.call(this, colorStops) || this;
+    _this.x = x == null ? 0.5 : x;
+    _this.y = y == null ? 0.5 : y;
+    _this.r = r == null ? 0.5 : r;
+    _this.type = "radial";
+    _this.global = globalCoord || false;
+    return _this;
+  }
+  return RadialGradient2;
+}(Gradient.default);
+exports.default = RadialGradient;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/TSpan.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Displayable = require("./Displayable.js");
+const text = require("../contain/text.js");
+const Path = require("./Path.js");
+const util = require("../core/util.js");
+const platform = require("../core/platform.js");
+var DEFAULT_TSPAN_STYLE = util.defaults({
+  strokeFirst: true,
+  font: platform.DEFAULT_FONT,
+  x: 0,
+  y: 0,
+  textAlign: "left",
+  textBaseline: "top",
+  miterLimit: 2
+}, Path.DEFAULT_PATH_STYLE);
+var TSpan = function(_super) {
+  tslib_es6.__extends(TSpan2, _super);
+  function TSpan2() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  TSpan2.prototype.hasStroke = function() {
+    var style = this.style;
+    var stroke = style.stroke;
+    return stroke != null && stroke !== "none" && style.lineWidth > 0;
+  };
+  TSpan2.prototype.hasFill = function() {
+    var style = this.style;
+    var fill = style.fill;
+    return fill != null && fill !== "none";
+  };
+  TSpan2.prototype.createStyle = function(obj) {
+    return util.createObject(DEFAULT_TSPAN_STYLE, obj);
+  };
+  TSpan2.prototype.setBoundingRect = function(rect) {
+    this._rect = rect;
+  };
+  TSpan2.prototype.getBoundingRect = function() {
+    var style = this.style;
+    if (!this._rect) {
+      var text$1 = style.text;
+      text$1 != null ? text$1 += "" : text$1 = "";
+      var rect = text.getBoundingRect(text$1, style.font, style.textAlign, style.textBaseline);
+      rect.x += style.x || 0;
+      rect.y += style.y || 0;
+      if (this.hasStroke()) {
+        var w = style.lineWidth;
+        rect.x -= w / 2;
+        rect.y -= w / 2;
+        rect.width += w;
+        rect.height += w;
+      }
+      this._rect = rect;
+    }
+    return this._rect;
+  };
+  TSpan2.initDefaultProps = function() {
+    var tspanProto = TSpan2.prototype;
+    tspanProto.dirtyRectTolerance = 10;
+  }();
+  return TSpan2;
+}(Displayable.default);
+TSpan.prototype.type = "tspan";
+exports.DEFAULT_TSPAN_STYLE = DEFAULT_TSPAN_STYLE;
+exports.default = TSpan;