@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/layout/barGrid.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const number = require("../util/number.js");
+const dataStackHelper = require("../data/helper/dataStackHelper.js");
+const createRenderPlanner = require("../chart/helper/createRenderPlanner.js");
+const vendor = require("../util/vendor.js");
+var STACK_PREFIX = "__ec_stack_";
+function getSeriesStackId(seriesModel) {
+  return seriesModel.get("stack") || STACK_PREFIX + seriesModel.seriesIndex;
+}
+function getAxisKey(axis) {
+  return axis.dim + axis.index;
+}
+function prepareLayoutBarSeries(seriesType, ecModel) {
+  var seriesModels = [];
+  ecModel.eachSeriesByType(seriesType, function(seriesModel) {
+    if (isOnCartesian(seriesModel)) {
+      seriesModels.push(seriesModel);
+    }
+  });
+  return seriesModels;
+}
+function getValueAxesMinGaps(barSeries) {
+  var axisValues = {};
+  util.each(barSeries, function(seriesModel) {
+    var cartesian = seriesModel.coordinateSystem;
+    var baseAxis = cartesian.getBaseAxis();
+    if (baseAxis.type !== "time" && baseAxis.type !== "value") {
+      return;
+    }
+    var data = seriesModel.getData();
+    var key2 = baseAxis.dim + "_" + baseAxis.index;
+    var dimIdx = data.getDimensionIndex(data.mapDimension(baseAxis.dim));
+    var store = data.getStore();
+    for (var i = 0, cnt = store.count(); i < cnt; ++i) {
+      var value = store.get(dimIdx, i);
+      if (!axisValues[key2]) {
+        axisValues[key2] = [value];
+      } else {
+        axisValues[key2].push(value);
+      }
+    }
+  });
+  var axisMinGaps = {};
+  for (var key in axisValues) {
+    if (axisValues.hasOwnProperty(key)) {
+      var valuesInAxis = axisValues[key];
+      if (valuesInAxis) {
+        valuesInAxis.sort(function(a, b) {
+          return a - b;
+        });
+        var min = null;
+        for (var j = 1; j < valuesInAxis.length; ++j) {
+          var delta = valuesInAxis[j] - valuesInAxis[j - 1];
+          if (delta > 0) {
+            min = min === null ? delta : Math.min(min, delta);
+          }
+        }
+        axisMinGaps[key] = min;
+      }
+    }
+  }
+  return axisMinGaps;
+}
+function makeColumnLayout(barSeries) {
+  var axisMinGaps = getValueAxesMinGaps(barSeries);
+  var seriesInfoList = [];
+  util.each(barSeries, function(seriesModel) {
+    var cartesian = seriesModel.coordinateSystem;
+    var baseAxis = cartesian.getBaseAxis();
+    var axisExtent = baseAxis.getExtent();
+    var bandWidth;
+    if (baseAxis.type === "category") {
+      bandWidth = baseAxis.getBandWidth();
+    } else if (baseAxis.type === "value" || baseAxis.type === "time") {
+      var key = baseAxis.dim + "_" + baseAxis.index;
+      var minGap = axisMinGaps[key];
+      var extentSpan = Math.abs(axisExtent[1] - axisExtent[0]);
+      var scale = baseAxis.scale.getExtent();
+      var scaleSpan = Math.abs(scale[1] - scale[0]);
+      bandWidth = minGap ? extentSpan / scaleSpan * minGap : extentSpan;
+    } else {
+      var data = seriesModel.getData();
+      bandWidth = Math.abs(axisExtent[1] - axisExtent[0]) / data.count();
+    }
+    var barWidth = number.parsePercent(seriesModel.get("barWidth"), bandWidth);
+    var barMaxWidth = number.parsePercent(seriesModel.get("barMaxWidth"), bandWidth);
+    var barMinWidth = number.parsePercent(
+      // barMinWidth by default is 0.5 / 1 in cartesian. Because in value axis,
+      // the auto-calculated bar width might be less than 0.5 / 1.
+      seriesModel.get("barMinWidth") || (isInLargeMode(seriesModel) ? 0.5 : 1),
+      bandWidth
+    );
+    var barGap = seriesModel.get("barGap");
+    var barCategoryGap = seriesModel.get("barCategoryGap");
+    seriesInfoList.push({
+      bandWidth,
+      barWidth,
+      barMaxWidth,
+      barMinWidth,
+      barGap,
+      barCategoryGap,
+      axisKey: getAxisKey(baseAxis),
+      stackId: getSeriesStackId(seriesModel)
+    });
+  });
+  return doCalBarWidthAndOffset(seriesInfoList);
+}
+function doCalBarWidthAndOffset(seriesInfoList) {
+  var columnsMap = {};
+  util.each(seriesInfoList, function(seriesInfo, idx) {
+    var axisKey = seriesInfo.axisKey;
+    var bandWidth = seriesInfo.bandWidth;
+    var columnsOnAxis = columnsMap[axisKey] || {
+      bandWidth,
+      remainedWidth: bandWidth,
+      autoWidthCount: 0,
+      categoryGap: null,
+      gap: "20%",
+      stacks: {}
+    };
+    var stacks = columnsOnAxis.stacks;
+    columnsMap[axisKey] = columnsOnAxis;
+    var stackId = seriesInfo.stackId;
+    if (!stacks[stackId]) {
+      columnsOnAxis.autoWidthCount++;
+    }
+    stacks[stackId] = stacks[stackId] || {
+      width: 0,
+      maxWidth: 0
+    };
+    var barWidth = seriesInfo.barWidth;
+    if (barWidth && !stacks[stackId].width) {
+      stacks[stackId].width = barWidth;
+      barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
+      columnsOnAxis.remainedWidth -= barWidth;
+    }
+    var barMaxWidth = seriesInfo.barMaxWidth;
+    barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
+    var barMinWidth = seriesInfo.barMinWidth;
+    barMinWidth && (stacks[stackId].minWidth = barMinWidth);
+    var barGap = seriesInfo.barGap;
+    barGap != null && (columnsOnAxis.gap = barGap);
+    var barCategoryGap = seriesInfo.barCategoryGap;
+    barCategoryGap != null && (columnsOnAxis.categoryGap = barCategoryGap);
+  });
+  var result = {};
+  util.each(columnsMap, function(columnsOnAxis, coordSysName) {
+    result[coordSysName] = {};
+    var stacks = columnsOnAxis.stacks;
+    var bandWidth = columnsOnAxis.bandWidth;
+    var categoryGapPercent = columnsOnAxis.categoryGap;
+    if (categoryGapPercent == null) {
+      var columnCount = util.keys(stacks).length;
+      categoryGapPercent = Math.max(35 - columnCount * 4, 15) + "%";
+    }
+    var categoryGap = number.parsePercent(categoryGapPercent, bandWidth);
+    var barGapPercent = number.parsePercent(columnsOnAxis.gap, 1);
+    var remainedWidth = columnsOnAxis.remainedWidth;
+    var autoWidthCount = columnsOnAxis.autoWidthCount;
+    var autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+    autoWidth = Math.max(autoWidth, 0);
+    util.each(stacks, function(column) {
+      var maxWidth = column.maxWidth;
+      var minWidth = column.minWidth;
+      if (!column.width) {
+        var finalWidth = autoWidth;
+        if (maxWidth && maxWidth < finalWidth) {
+          finalWidth = Math.min(maxWidth, remainedWidth);
+        }
+        if (minWidth && minWidth > finalWidth) {
+          finalWidth = minWidth;
+        }
+        if (finalWidth !== autoWidth) {
+          column.width = finalWidth;
+          remainedWidth -= finalWidth + barGapPercent * finalWidth;
+          autoWidthCount--;
+        }
+      } else {
+        var finalWidth = column.width;
+        if (maxWidth) {
+          finalWidth = Math.min(finalWidth, maxWidth);
+        }
+        if (minWidth) {
+          finalWidth = Math.max(finalWidth, minWidth);
+        }
+        column.width = finalWidth;
+        remainedWidth -= finalWidth + barGapPercent * finalWidth;
+        autoWidthCount--;
+      }
+    });
+    autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+    autoWidth = Math.max(autoWidth, 0);
+    var widthSum = 0;
+    var lastColumn;
+    util.each(stacks, function(column, idx) {
+      if (!column.width) {
+        column.width = autoWidth;
+      }
+      lastColumn = column;
+      widthSum += column.width * (1 + barGapPercent);
+    });
+    if (lastColumn) {
+      widthSum -= lastColumn.width * barGapPercent;
+    }
+    var offset = -widthSum / 2;
+    util.each(stacks, function(column, stackId) {
+      result[coordSysName][stackId] = result[coordSysName][stackId] || {
+        bandWidth,
+        offset,
+        width: column.width
+      };
+      offset += column.width * (1 + barGapPercent);
+    });
+  });
+  return result;
+}
+function retrieveColumnLayout(barWidthAndOffset, axis, seriesModel) {
+  if (barWidthAndOffset && axis) {
+    var result = barWidthAndOffset[getAxisKey(axis)];
+    return result;
+  }
+}
+function layout(seriesType, ecModel) {
+  var seriesModels = prepareLayoutBarSeries(seriesType, ecModel);
+  var barWidthAndOffset = makeColumnLayout(seriesModels);
+  util.each(seriesModels, function(seriesModel) {
+    var data = seriesModel.getData();
+    var cartesian = seriesModel.coordinateSystem;
+    var baseAxis = cartesian.getBaseAxis();
+    var stackId = getSeriesStackId(seriesModel);
+    var columnLayoutInfo = barWidthAndOffset[getAxisKey(baseAxis)][stackId];
+    var columnOffset = columnLayoutInfo.offset;
+    var columnWidth = columnLayoutInfo.width;
+    data.setLayout({
+      bandWidth: columnLayoutInfo.bandWidth,
+      offset: columnOffset,
+      size: columnWidth
+    });
+  });
+}
+function createProgressiveLayout(seriesType) {
+  return {
+    seriesType,
+    plan: createRenderPlanner.default(),
+    reset: function(seriesModel) {
+      if (!isOnCartesian(seriesModel)) {
+        return;
+      }
+      var data = seriesModel.getData();
+      var cartesian = seriesModel.coordinateSystem;
+      var baseAxis = cartesian.getBaseAxis();
+      var valueAxis = cartesian.getOtherAxis(baseAxis);
+      var valueDimIdx = data.getDimensionIndex(data.mapDimension(valueAxis.dim));
+      var baseDimIdx = data.getDimensionIndex(data.mapDimension(baseAxis.dim));
+      var drawBackground = seriesModel.get("showBackground", true);
+      var valueDim = data.mapDimension(valueAxis.dim);
+      var stackResultDim = data.getCalculationInfo("stackResultDimension");
+      var stacked = dataStackHelper.isDimensionStacked(data, valueDim) && !!data.getCalculationInfo("stackedOnSeries");
+      var isValueAxisH = valueAxis.isHorizontal();
+      var valueAxisStart = getValueAxisStart(baseAxis, valueAxis);
+      var isLarge = isInLargeMode(seriesModel);
+      var barMinHeight = seriesModel.get("barMinHeight") || 0;
+      var stackedDimIdx = stackResultDim && data.getDimensionIndex(stackResultDim);
+      var columnWidth = data.getLayout("size");
+      var columnOffset = data.getLayout("offset");
+      return {
+        progress: function(params, data2) {
+          var count = params.count;
+          var largePoints = isLarge && vendor.createFloat32Array(count * 3);
+          var largeBackgroundPoints = isLarge && drawBackground && vendor.createFloat32Array(count * 3);
+          var largeDataIndices = isLarge && vendor.createFloat32Array(count);
+          var coordLayout = cartesian.master.getRect();
+          var bgSize = isValueAxisH ? coordLayout.width : coordLayout.height;
+          var dataIndex;
+          var store = data2.getStore();
+          var idxOffset = 0;
+          while ((dataIndex = params.next()) != null) {
+            var value = store.get(stacked ? stackedDimIdx : valueDimIdx, dataIndex);
+            var baseValue = store.get(baseDimIdx, dataIndex);
+            var baseCoord = valueAxisStart;
+            var stackStartValue = void 0;
+            if (stacked) {
+              stackStartValue = +value - store.get(valueDimIdx, dataIndex);
+            }
+            var x = void 0;
+            var y = void 0;
+            var width = void 0;
+            var height = void 0;
+            if (isValueAxisH) {
+              var coord = cartesian.dataToPoint([value, baseValue]);
+              if (stacked) {
+                var startCoord = cartesian.dataToPoint([stackStartValue, baseValue]);
+                baseCoord = startCoord[0];
+              }
+              x = baseCoord;
+              y = coord[1] + columnOffset;
+              width = coord[0] - baseCoord;
+              height = columnWidth;
+              if (Math.abs(width) < barMinHeight) {
+                width = (width < 0 ? -1 : 1) * barMinHeight;
+              }
+            } else {
+              var coord = cartesian.dataToPoint([baseValue, value]);
+              if (stacked) {
+                var startCoord = cartesian.dataToPoint([baseValue, stackStartValue]);
+                baseCoord = startCoord[1];
+              }
+              x = coord[0] + columnOffset;
+              y = baseCoord;
+              width = columnWidth;
+              height = coord[1] - baseCoord;
+              if (Math.abs(height) < barMinHeight) {
+                height = (height <= 0 ? -1 : 1) * barMinHeight;
+              }
+            }
+            if (!isLarge) {
+              data2.setItemLayout(dataIndex, {
+                x,
+                y,
+                width,
+                height
+              });
+            } else {
+              largePoints[idxOffset] = x;
+              largePoints[idxOffset + 1] = y;
+              largePoints[idxOffset + 2] = isValueAxisH ? width : height;
+              if (largeBackgroundPoints) {
+                largeBackgroundPoints[idxOffset] = isValueAxisH ? coordLayout.x : x;
+                largeBackgroundPoints[idxOffset + 1] = isValueAxisH ? y : coordLayout.y;
+                largeBackgroundPoints[idxOffset + 2] = bgSize;
+              }
+              largeDataIndices[dataIndex] = dataIndex;
+            }
+            idxOffset += 3;
+          }
+          if (isLarge) {
+            data2.setLayout({
+              largePoints,
+              largeDataIndices,
+              largeBackgroundPoints,
+              valueAxisHorizontal: isValueAxisH
+            });
+          }
+        }
+      };
+    }
+  };
+}
+function isOnCartesian(seriesModel) {
+  return seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === "cartesian2d";
+}
+function isInLargeMode(seriesModel) {
+  return seriesModel.pipelineContext && seriesModel.pipelineContext.large;
+}
+function getValueAxisStart(baseAxis, valueAxis) {
+  var startValue = valueAxis.model.get("startValue");
+  if (!startValue) {
+    startValue = 0;
+  }
+  return valueAxis.toGlobalCoord(valueAxis.dataToCoord(valueAxis.type === "log" ? startValue > 0 ? startValue : 1 : startValue));
+}
+exports.createProgressiveLayout = createProgressiveLayout;
+exports.layout = layout;
+exports.makeColumnLayout = makeColumnLayout;
+exports.prepareLayoutBarSeries = prepareLayoutBarSeries;
+exports.retrieveColumnLayout = retrieveColumnLayout;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/layout/points.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const createRenderPlanner = require("../chart/helper/createRenderPlanner.js");
+const dataStackHelper = require("../data/helper/dataStackHelper.js");
+const vendor = require("../util/vendor.js");
+function pointsLayout(seriesType, forceStoreInTypedArray) {
+  return {
+    seriesType,
+    plan: createRenderPlanner.default(),
+    reset: function(seriesModel) {
+      var data = seriesModel.getData();
+      var coordSys = seriesModel.coordinateSystem;
+      seriesModel.pipelineContext;
+      if (!coordSys) {
+        return;
+      }
+      var dims = util.map(coordSys.dimensions, function(dim) {
+        return data.mapDimension(dim);
+      }).slice(0, 2);
+      var dimLen = dims.length;
+      var stackResultDim = data.getCalculationInfo("stackResultDimension");
+      if (dataStackHelper.isDimensionStacked(data, dims[0])) {
+        dims[0] = stackResultDim;
+      }
+      if (dataStackHelper.isDimensionStacked(data, dims[1])) {
+        dims[1] = stackResultDim;
+      }
+      var store = data.getStore();
+      var dimIdx0 = data.getDimensionIndex(dims[0]);
+      var dimIdx1 = data.getDimensionIndex(dims[1]);
+      return dimLen && {
+        progress: function(params, data2) {
+          var segCount = params.end - params.start;
+          var points = vendor.createFloat32Array(segCount * dimLen);
+          var tmpIn = [];
+          var tmpOut = [];
+          for (var i = params.start, offset = 0; i < params.end; i++) {
+            var point = void 0;
+            if (dimLen === 1) {
+              var x = store.get(dimIdx0, i);
+              point = coordSys.dataToPoint(x, null, tmpOut);
+            } else {
+              tmpIn[0] = store.get(dimIdx0, i);
+              tmpIn[1] = store.get(dimIdx1, i);
+              point = coordSys.dataToPoint(tmpIn, null, tmpOut);
+            }
+            {
+              points[offset++] = point[0];
+              points[offset++] = point[1];
+            }
+          }
+          data2.setLayout("points", points);
+        }
+      };
+    }
+  };
+}
+exports.default = pointsLayout;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/legacy/dataSelectAction.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const model = require("../util/model.js");
+function createLegacyDataSelectAction(seriesType, ecRegisterAction) {
+  function getSeriesIndices(ecModel, payload) {
+    var seriesIndices = [];
+    ecModel.eachComponent({
+      mainType: "series",
+      subType: seriesType,
+      query: payload
+    }, function(seriesModel) {
+      seriesIndices.push(seriesModel.seriesIndex);
+    });
+    return seriesIndices;
+  }
+  util.each([[seriesType + "ToggleSelect", "toggleSelect"], [seriesType + "Select", "select"], [seriesType + "UnSelect", "unselect"]], function(eventsMap) {
+    ecRegisterAction(eventsMap[0], function(payload, ecModel, api) {
+      payload = util.extend({}, payload);
+      api.dispatchAction(util.extend(payload, {
+        type: eventsMap[1],
+        seriesIndex: getSeriesIndices(ecModel, payload)
+      }));
+    });
+  });
+}
+function handleSeriesLegacySelectEvents(type, eventPostfix, ecIns, ecModel, payload) {
+  var legacyEventName = type + eventPostfix;
+  if (!ecIns.isSilent(legacyEventName)) {
+    ecModel.eachComponent({
+      mainType: "series",
+      subType: "pie"
+    }, function(seriesModel) {
+      var seriesIndex = seriesModel.seriesIndex;
+      var selectedMap = seriesModel.option.selectedMap;
+      var selected = payload.selected;
+      for (var i = 0; i < selected.length; i++) {
+        if (selected[i].seriesIndex === seriesIndex) {
+          var data = seriesModel.getData();
+          var dataIndex = model.queryDataIndex(data, payload.fromActionPayload);
+          ecIns.trigger(legacyEventName, {
+            type: legacyEventName,
+            seriesId: seriesModel.id,
+            name: util.isArray(dataIndex) ? data.getName(dataIndex[0]) : data.getName(dataIndex),
+            selected: util.isString(selectedMap) ? selectedMap : util.extend({}, selectedMap)
+          });
+        }
+      }
+    });
+  }
+}
+function handleLegacySelectEvents(messageCenter, ecIns, api) {
+  messageCenter.on("selectchanged", function(params) {
+    var ecModel = api.getModel();
+    if (params.isFromClick) {
+      handleSeriesLegacySelectEvents("map", "selectchanged", ecIns, ecModel, params);
+      handleSeriesLegacySelectEvents("pie", "selectchanged", ecIns, ecModel, params);
+    } else if (params.fromAction === "select") {
+      handleSeriesLegacySelectEvents("map", "selected", ecIns, ecModel, params);
+      handleSeriesLegacySelectEvents("pie", "selected", ecIns, ecModel, params);
+    } else if (params.fromAction === "unselect") {
+      handleSeriesLegacySelectEvents("map", "unselected", ecIns, ecModel, params);
+      handleSeriesLegacySelectEvents("pie", "unselected", ecIns, ecModel, params);
+    }
+  });
+}
+exports.createLegacyDataSelectAction = createLegacyDataSelectAction;
+exports.handleLegacySelectEvents = handleLegacySelectEvents;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/legacy/getTextRect.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../util/graphic.js");
+const Text = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Text.js");
+function getTextRect(text, font, align, verticalAlign, padding, rich, truncate, lineHeight) {
+  var textEl = new Text.default({
+    style: {
+      text,
+      font,
+      align,
+      verticalAlign,
+      padding,
+      rich,
+      overflow: truncate ? "truncate" : null,
+      lineHeight
+    }
+  });
+  return textEl.getBoundingRect();
+}
+exports.getTextRect = getTextRect;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/loading/default.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const Group = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.js");
+const Rect = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Rect.js");
+const Text = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Text.js");
+const Arc = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Arc.js");
+var PI = Math.PI;
+function defaultLoading(api, opts) {
+  opts = opts || {};
+  util.defaults(opts, {
+    text: "loading",
+    textColor: "#000",
+    fontSize: 12,
+    fontWeight: "normal",
+    fontStyle: "normal",
+    fontFamily: "sans-serif",
+    maskColor: "rgba(255, 255, 255, 0.8)",
+    showSpinner: true,
+    color: "#5470c6",
+    spinnerRadius: 10,
+    lineWidth: 5,
+    zlevel: 0
+  });
+  var group = new Group.default();
+  var mask = new Rect.default({
+    style: {
+      fill: opts.maskColor
+    },
+    zlevel: opts.zlevel,
+    z: 1e4
+  });
+  group.add(mask);
+  var textContent = new Text.default({
+    style: {
+      text: opts.text,
+      fill: opts.textColor,
+      fontSize: opts.fontSize,
+      fontWeight: opts.fontWeight,
+      fontStyle: opts.fontStyle,
+      fontFamily: opts.fontFamily
+    },
+    zlevel: opts.zlevel,
+    z: 10001
+  });
+  var labelRect = new Rect.default({
+    style: {
+      fill: "none"
+    },
+    textContent,
+    textConfig: {
+      position: "right",
+      distance: 10
+    },
+    zlevel: opts.zlevel,
+    z: 10001
+  });
+  group.add(labelRect);
+  var arc;
+  if (opts.showSpinner) {
+    arc = new Arc.default({
+      shape: {
+        startAngle: -PI / 2,
+        endAngle: -PI / 2 + 0.1,
+        r: opts.spinnerRadius
+      },
+      style: {
+        stroke: opts.color,
+        lineCap: "round",
+        lineWidth: opts.lineWidth
+      },
+      zlevel: opts.zlevel,
+      z: 10001
+    });
+    arc.animateShape(true).when(1e3, {
+      endAngle: PI * 3 / 2
+    }).start("circularInOut");
+    arc.animateShape(true).when(1e3, {
+      startAngle: PI * 3 / 2
+    }).delay(300).start("circularInOut");
+    group.add(arc);
+  }
+  group.resize = function() {
+    var textWidth = textContent.getBoundingRect().width;
+    var r = opts.showSpinner ? opts.spinnerRadius : 0;
+    var cx = (api.getWidth() - r * 2 - (opts.showSpinner && textWidth ? 10 : 0) - textWidth) / 2 - (opts.showSpinner && textWidth ? 0 : 5 + textWidth / 2) + (opts.showSpinner ? 0 : textWidth / 2) + (textWidth ? 0 : r);
+    var cy = api.getHeight() / 2;
+    opts.showSpinner && arc.setShape({
+      cx,
+      cy
+    });
+    labelRect.setShape({
+      x: cx - r,
+      y: cy - r,
+      width: r * 2,
+      height: r * 2
+    });
+    mask.setShape({
+      x: 0,
+      y: 0,
+      width: api.getWidth(),
+      height: api.getHeight()
+    });
+  };
+  group.resize();
+  return group;
+}
+exports.default = defaultLoading;