@fecp/mobile 1.0.78 → 1.1.0

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/helper/parseText.mjs

@@ -0,0 +1,474 @@
+import { findExistImage, isImageReady } from "./image.mjs";
+import { retrieve2, retrieve3, extend, reduce } from "../../core/util.mjs";
+import { getLineHeight, getWidth, parsePercent } from "../../contain/text.mjs";
+var STYLE_REG = /\{([a-zA-Z0-9_]+)\|([^}]*)\}/g;
+function truncateText(text, containerWidth, font, ellipsis, options) {
+  var out = {};
+  truncateText2(out, text, containerWidth, font, ellipsis, options);
+  return out.text;
+}
+function truncateText2(out, text, containerWidth, font, ellipsis, options) {
+  if (!containerWidth) {
+    out.text = "";
+    out.isTruncated = false;
+    return;
+  }
+  var textLines = (text + "").split("\n");
+  options = prepareTruncateOptions(containerWidth, font, ellipsis, options);
+  var isTruncated = false;
+  var truncateOut = {};
+  for (var i = 0, len = textLines.length; i < len; i++) {
+    truncateSingleLine(truncateOut, textLines[i], options);
+    textLines[i] = truncateOut.textLine;
+    isTruncated = isTruncated || truncateOut.isTruncated;
+  }
+  out.text = textLines.join("\n");
+  out.isTruncated = isTruncated;
+}
+function prepareTruncateOptions(containerWidth, font, ellipsis, options) {
+  options = options || {};
+  var preparedOpts = extend({}, options);
+  preparedOpts.font = font;
+  ellipsis = retrieve2(ellipsis, "...");
+  preparedOpts.maxIterations = retrieve2(options.maxIterations, 2);
+  var minChar = preparedOpts.minChar = retrieve2(options.minChar, 0);
+  preparedOpts.cnCharWidth = getWidth("国", font);
+  var ascCharWidth = preparedOpts.ascCharWidth = getWidth("a", font);
+  preparedOpts.placeholder = retrieve2(options.placeholder, "");
+  var contentWidth = containerWidth = Math.max(0, containerWidth - 1);
+  for (var i = 0; i < minChar && contentWidth >= ascCharWidth; i++) {
+    contentWidth -= ascCharWidth;
+  }
+  var ellipsisWidth = getWidth(ellipsis, font);
+  if (ellipsisWidth > contentWidth) {
+    ellipsis = "";
+    ellipsisWidth = 0;
+  }
+  contentWidth = containerWidth - ellipsisWidth;
+  preparedOpts.ellipsis = ellipsis;
+  preparedOpts.ellipsisWidth = ellipsisWidth;
+  preparedOpts.contentWidth = contentWidth;
+  preparedOpts.containerWidth = containerWidth;
+  return preparedOpts;
+}
+function truncateSingleLine(out, textLine, options) {
+  var containerWidth = options.containerWidth;
+  var font = options.font;
+  var contentWidth = options.contentWidth;
+  if (!containerWidth) {
+    out.textLine = "";
+    out.isTruncated = false;
+    return;
+  }
+  var lineWidth = getWidth(textLine, font);
+  if (lineWidth <= containerWidth) {
+    out.textLine = textLine;
+    out.isTruncated = false;
+    return;
+  }
+  for (var j = 0; ; j++) {
+    if (lineWidth <= contentWidth || j >= options.maxIterations) {
+      textLine += options.ellipsis;
+      break;
+    }
+    var subLength = j === 0 ? estimateLength(textLine, contentWidth, options.ascCharWidth, options.cnCharWidth) : lineWidth > 0 ? Math.floor(textLine.length * contentWidth / lineWidth) : 0;
+    textLine = textLine.substr(0, subLength);
+    lineWidth = getWidth(textLine, font);
+  }
+  if (textLine === "") {
+    textLine = options.placeholder;
+  }
+  out.textLine = textLine;
+  out.isTruncated = true;
+}
+function estimateLength(text, contentWidth, ascCharWidth, cnCharWidth) {
+  var width = 0;
+  var i = 0;
+  for (var len = text.length; i < len && width < contentWidth; i++) {
+    var charCode = text.charCodeAt(i);
+    width += 0 <= charCode && charCode <= 127 ? ascCharWidth : cnCharWidth;
+  }
+  return i;
+}
+function parsePlainText(text, style) {
+  text != null && (text += "");
+  var overflow = style.overflow;
+  var padding = style.padding;
+  var font = style.font;
+  var truncate = overflow === "truncate";
+  var calculatedLineHeight = getLineHeight(font);
+  var lineHeight = retrieve2(style.lineHeight, calculatedLineHeight);
+  var bgColorDrawn = !!style.backgroundColor;
+  var truncateLineOverflow = style.lineOverflow === "truncate";
+  var isTruncated = false;
+  var width = style.width;
+  var lines;
+  if (width != null && (overflow === "break" || overflow === "breakAll")) {
+    lines = text ? wrapText(text, style.font, width, overflow === "breakAll", 0).lines : [];
+  } else {
+    lines = text ? text.split("\n") : [];
+  }
+  var contentHeight = lines.length * lineHeight;
+  var height = retrieve2(style.height, contentHeight);
+  if (contentHeight > height && truncateLineOverflow) {
+    var lineCount = Math.floor(height / lineHeight);
+    isTruncated = isTruncated || lines.length > lineCount;
+    lines = lines.slice(0, lineCount);
+  }
+  if (text && truncate && width != null) {
+    var options = prepareTruncateOptions(width, font, style.ellipsis, {
+      minChar: style.truncateMinChar,
+      placeholder: style.placeholder
+    });
+    var singleOut = {};
+    for (var i = 0; i < lines.length; i++) {
+      truncateSingleLine(singleOut, lines[i], options);
+      lines[i] = singleOut.textLine;
+      isTruncated = isTruncated || singleOut.isTruncated;
+    }
+  }
+  var outerHeight = height;
+  var contentWidth = 0;
+  for (var i = 0; i < lines.length; i++) {
+    contentWidth = Math.max(getWidth(lines[i], font), contentWidth);
+  }
+  if (width == null) {
+    width = contentWidth;
+  }
+  var outerWidth = contentWidth;
+  if (padding) {
+    outerHeight += padding[0] + padding[2];
+    outerWidth += padding[1] + padding[3];
+    width += padding[1] + padding[3];
+  }
+  if (bgColorDrawn) {
+    outerWidth = width;
+  }
+  return {
+    lines,
+    height,
+    outerWidth,
+    outerHeight,
+    lineHeight,
+    calculatedLineHeight,
+    contentWidth,
+    contentHeight,
+    width,
+    isTruncated
+  };
+}
+var RichTextToken = /* @__PURE__ */ function() {
+  function RichTextToken2() {
+  }
+  return RichTextToken2;
+}();
+var RichTextLine = /* @__PURE__ */ function() {
+  function RichTextLine2(tokens) {
+    this.tokens = [];
+    if (tokens) {
+      this.tokens = tokens;
+    }
+  }
+  return RichTextLine2;
+}();
+var RichTextContentBlock = /* @__PURE__ */ function() {
+  function RichTextContentBlock2() {
+    this.width = 0;
+    this.height = 0;
+    this.contentWidth = 0;
+    this.contentHeight = 0;
+    this.outerWidth = 0;
+    this.outerHeight = 0;
+    this.lines = [];
+    this.isTruncated = false;
+  }
+  return RichTextContentBlock2;
+}();
+function parseRichText(text, style) {
+  var contentBlock = new RichTextContentBlock();
+  text != null && (text += "");
+  if (!text) {
+    return contentBlock;
+  }
+  var topWidth = style.width;
+  var topHeight = style.height;
+  var overflow = style.overflow;
+  var wrapInfo = (overflow === "break" || overflow === "breakAll") && topWidth != null ? { width: topWidth, accumWidth: 0, breakAll: overflow === "breakAll" } : null;
+  var lastIndex = STYLE_REG.lastIndex = 0;
+  var result;
+  while ((result = STYLE_REG.exec(text)) != null) {
+    var matchedIndex = result.index;
+    if (matchedIndex > lastIndex) {
+      pushTokens(contentBlock, text.substring(lastIndex, matchedIndex), style, wrapInfo);
+    }
+    pushTokens(contentBlock, result[2], style, wrapInfo, result[1]);
+    lastIndex = STYLE_REG.lastIndex;
+  }
+  if (lastIndex < text.length) {
+    pushTokens(contentBlock, text.substring(lastIndex, text.length), style, wrapInfo);
+  }
+  var pendingList = [];
+  var calculatedHeight = 0;
+  var calculatedWidth = 0;
+  var stlPadding = style.padding;
+  var truncate = overflow === "truncate";
+  var truncateLine = style.lineOverflow === "truncate";
+  var tmpTruncateOut = {};
+  function finishLine(line2, lineWidth2, lineHeight2) {
+    line2.width = lineWidth2;
+    line2.lineHeight = lineHeight2;
+    calculatedHeight += lineHeight2;
+    calculatedWidth = Math.max(calculatedWidth, lineWidth2);
+  }
+  outer: for (var i = 0; i < contentBlock.lines.length; i++) {
+    var line = contentBlock.lines[i];
+    var lineHeight = 0;
+    var lineWidth = 0;
+    for (var j = 0; j < line.tokens.length; j++) {
+      var token = line.tokens[j];
+      var tokenStyle = token.styleName && style.rich[token.styleName] || {};
+      var textPadding = token.textPadding = tokenStyle.padding;
+      var paddingH = textPadding ? textPadding[1] + textPadding[3] : 0;
+      var font = token.font = tokenStyle.font || style.font;
+      token.contentHeight = getLineHeight(font);
+      var tokenHeight = retrieve2(tokenStyle.height, token.contentHeight);
+      token.innerHeight = tokenHeight;
+      textPadding && (tokenHeight += textPadding[0] + textPadding[2]);
+      token.height = tokenHeight;
+      token.lineHeight = retrieve3(tokenStyle.lineHeight, style.lineHeight, tokenHeight);
+      token.align = tokenStyle && tokenStyle.align || style.align;
+      token.verticalAlign = tokenStyle && tokenStyle.verticalAlign || "middle";
+      if (truncateLine && topHeight != null && calculatedHeight + token.lineHeight > topHeight) {
+        var originalLength = contentBlock.lines.length;
+        if (j > 0) {
+          line.tokens = line.tokens.slice(0, j);
+          finishLine(line, lineWidth, lineHeight);
+          contentBlock.lines = contentBlock.lines.slice(0, i + 1);
+        } else {
+          contentBlock.lines = contentBlock.lines.slice(0, i);
+        }
+        contentBlock.isTruncated = contentBlock.isTruncated || contentBlock.lines.length < originalLength;
+        break outer;
+      }
+      var styleTokenWidth = tokenStyle.width;
+      var tokenWidthNotSpecified = styleTokenWidth == null || styleTokenWidth === "auto";
+      if (typeof styleTokenWidth === "string" && styleTokenWidth.charAt(styleTokenWidth.length - 1) === "%") {
+        token.percentWidth = styleTokenWidth;
+        pendingList.push(token);
+        token.contentWidth = getWidth(token.text, font);
+      } else {
+        if (tokenWidthNotSpecified) {
+          var textBackgroundColor = tokenStyle.backgroundColor;
+          var bgImg = textBackgroundColor && textBackgroundColor.image;
+          if (bgImg) {
+            bgImg = findExistImage(bgImg);
+            if (isImageReady(bgImg)) {
+              token.width = Math.max(token.width, bgImg.width * tokenHeight / bgImg.height);
+            }
+          }
+        }
+        var remainTruncWidth = truncate && topWidth != null ? topWidth - lineWidth : null;
+        if (remainTruncWidth != null && remainTruncWidth < token.width) {
+          if (!tokenWidthNotSpecified || remainTruncWidth < paddingH) {
+            token.text = "";
+            token.width = token.contentWidth = 0;
+          } else {
+            truncateText2(tmpTruncateOut, token.text, remainTruncWidth - paddingH, font, style.ellipsis, { minChar: style.truncateMinChar });
+            token.text = tmpTruncateOut.text;
+            contentBlock.isTruncated = contentBlock.isTruncated || tmpTruncateOut.isTruncated;
+            token.width = token.contentWidth = getWidth(token.text, font);
+          }
+        } else {
+          token.contentWidth = getWidth(token.text, font);
+        }
+      }
+      token.width += paddingH;
+      lineWidth += token.width;
+      tokenStyle && (lineHeight = Math.max(lineHeight, token.lineHeight));
+    }
+    finishLine(line, lineWidth, lineHeight);
+  }
+  contentBlock.outerWidth = contentBlock.width = retrieve2(topWidth, calculatedWidth);
+  contentBlock.outerHeight = contentBlock.height = retrieve2(topHeight, calculatedHeight);
+  contentBlock.contentHeight = calculatedHeight;
+  contentBlock.contentWidth = calculatedWidth;
+  if (stlPadding) {
+    contentBlock.outerWidth += stlPadding[1] + stlPadding[3];
+    contentBlock.outerHeight += stlPadding[0] + stlPadding[2];
+  }
+  for (var i = 0; i < pendingList.length; i++) {
+    var token = pendingList[i];
+    var percentWidth = token.percentWidth;
+    token.width = parseInt(percentWidth, 10) / 100 * contentBlock.width;
+  }
+  return contentBlock;
+}
+function pushTokens(block, str, style, wrapInfo, styleName) {
+  var isEmptyStr = str === "";
+  var tokenStyle = styleName && style.rich[styleName] || {};
+  var lines = block.lines;
+  var font = tokenStyle.font || style.font;
+  var newLine = false;
+  var strLines;
+  var linesWidths;
+  if (wrapInfo) {
+    var tokenPadding = tokenStyle.padding;
+    var tokenPaddingH = tokenPadding ? tokenPadding[1] + tokenPadding[3] : 0;
+    if (tokenStyle.width != null && tokenStyle.width !== "auto") {
+      var outerWidth_1 = parsePercent(tokenStyle.width, wrapInfo.width) + tokenPaddingH;
+      if (lines.length > 0) {
+        if (outerWidth_1 + wrapInfo.accumWidth > wrapInfo.width) {
+          strLines = str.split("\n");
+          newLine = true;
+        }
+      }
+      wrapInfo.accumWidth = outerWidth_1;
+    } else {
+      var res = wrapText(str, font, wrapInfo.width, wrapInfo.breakAll, wrapInfo.accumWidth);
+      wrapInfo.accumWidth = res.accumWidth + tokenPaddingH;
+      linesWidths = res.linesWidths;
+      strLines = res.lines;
+    }
+  } else {
+    strLines = str.split("\n");
+  }
+  for (var i = 0; i < strLines.length; i++) {
+    var text = strLines[i];
+    var token = new RichTextToken();
+    token.styleName = styleName;
+    token.text = text;
+    token.isLineHolder = !text && !isEmptyStr;
+    if (typeof tokenStyle.width === "number") {
+      token.width = tokenStyle.width;
+    } else {
+      token.width = linesWidths ? linesWidths[i] : getWidth(text, font);
+    }
+    if (!i && !newLine) {
+      var tokens = (lines[lines.length - 1] || (lines[0] = new RichTextLine())).tokens;
+      var tokensLen = tokens.length;
+      tokensLen === 1 && tokens[0].isLineHolder ? tokens[0] = token : (text || !tokensLen || isEmptyStr) && tokens.push(token);
+    } else {
+      lines.push(new RichTextLine([token]));
+    }
+  }
+}
+function isAlphabeticLetter(ch) {
+  var code = ch.charCodeAt(0);
+  return code >= 32 && code <= 591 || code >= 880 && code <= 4351 || code >= 4608 && code <= 5119 || code >= 7680 && code <= 8303;
+}
+var breakCharMap = reduce(",&?/;] ".split(""), function(obj, ch) {
+  obj[ch] = true;
+  return obj;
+}, {});
+function isWordBreakChar(ch) {
+  if (isAlphabeticLetter(ch)) {
+    if (breakCharMap[ch]) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+function wrapText(text, font, lineWidth, isBreakAll, lastAccumWidth) {
+  var lines = [];
+  var linesWidths = [];
+  var line = "";
+  var currentWord = "";
+  var currentWordWidth = 0;
+  var accumWidth = 0;
+  for (var i = 0; i < text.length; i++) {
+    var ch = text.charAt(i);
+    if (ch === "\n") {
+      if (currentWord) {
+        line += currentWord;
+        accumWidth += currentWordWidth;
+      }
+      lines.push(line);
+      linesWidths.push(accumWidth);
+      line = "";
+      currentWord = "";
+      currentWordWidth = 0;
+      accumWidth = 0;
+      continue;
+    }
+    var chWidth = getWidth(ch, font);
+    var inWord = isBreakAll ? false : !isWordBreakChar(ch);
+    if (!lines.length ? lastAccumWidth + accumWidth + chWidth > lineWidth : accumWidth + chWidth > lineWidth) {
+      if (!accumWidth) {
+        if (inWord) {
+          lines.push(currentWord);
+          linesWidths.push(currentWordWidth);
+          currentWord = ch;
+          currentWordWidth = chWidth;
+        } else {
+          lines.push(ch);
+          linesWidths.push(chWidth);
+        }
+      } else if (line || currentWord) {
+        if (inWord) {
+          if (!line) {
+            line = currentWord;
+            currentWord = "";
+            currentWordWidth = 0;
+            accumWidth = currentWordWidth;
+          }
+          lines.push(line);
+          linesWidths.push(accumWidth - currentWordWidth);
+          currentWord += ch;
+          currentWordWidth += chWidth;
+          line = "";
+          accumWidth = currentWordWidth;
+        } else {
+          if (currentWord) {
+            line += currentWord;
+            currentWord = "";
+            currentWordWidth = 0;
+          }
+          lines.push(line);
+          linesWidths.push(accumWidth);
+          line = ch;
+          accumWidth = chWidth;
+        }
+      }
+      continue;
+    }
+    accumWidth += chWidth;
+    if (inWord) {
+      currentWord += ch;
+      currentWordWidth += chWidth;
+    } else {
+      if (currentWord) {
+        line += currentWord;
+        currentWord = "";
+        currentWordWidth = 0;
+      }
+      line += ch;
+    }
+  }
+  if (!lines.length && !line) {
+    line = text;
+    currentWord = "";
+    currentWordWidth = 0;
+  }
+  if (currentWord) {
+    line += currentWord;
+  }
+  if (line) {
+    lines.push(line);
+    linesWidths.push(accumWidth);
+  }
+  if (lines.length === 1) {
+    accumWidth += lastAccumWidth;
+  }
+  return {
+    accumWidth,
+    lines,
+    linesWidths
+  };
+}
+export {
+  RichTextContentBlock,
+  parsePlainText,
+  parseRichText,
+  truncateText
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/helper/poly.mjs

@@ -0,0 +1,27 @@
+import smoothBezier from "./smoothBezier.mjs";
+function buildPath(ctx, shape, closePath) {
+  var smooth = shape.smooth;
+  var points = shape.points;
+  if (points && points.length >= 2) {
+    if (smooth) {
+      var controlPoints = smoothBezier(points, smooth, closePath, shape.smoothConstraint);
+      ctx.moveTo(points[0][0], points[0][1]);
+      var len = points.length;
+      for (var i = 0; i < (closePath ? len : len - 1); i++) {
+        var cp1 = controlPoints[i * 2];
+        var cp2 = controlPoints[i * 2 + 1];
+        var p = points[(i + 1) % len];
+        ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]);
+      }
+    } else {
+      ctx.moveTo(points[0][0], points[0][1]);
+      for (var i = 1, l = points.length; i < l; i++) {
+        ctx.lineTo(points[i][0], points[i][1]);
+      }
+    }
+    closePath && ctx.closePath();
+  }
+}
+export {
+  buildPath
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/helper/roundRect.mjs

@@ -0,0 +1,73 @@
+function buildPath(ctx, shape) {
+  var x = shape.x;
+  var y = shape.y;
+  var width = shape.width;
+  var height = shape.height;
+  var r = shape.r;
+  var r1;
+  var r2;
+  var r3;
+  var r4;
+  if (width < 0) {
+    x = x + width;
+    width = -width;
+  }
+  if (height < 0) {
+    y = y + height;
+    height = -height;
+  }
+  if (typeof r === "number") {
+    r1 = r2 = r3 = r4 = r;
+  } else if (r instanceof Array) {
+    if (r.length === 1) {
+      r1 = r2 = r3 = r4 = r[0];
+    } else if (r.length === 2) {
+      r1 = r3 = r[0];
+      r2 = r4 = r[1];
+    } else if (r.length === 3) {
+      r1 = r[0];
+      r2 = r4 = r[1];
+      r3 = r[2];
+    } else {
+      r1 = r[0];
+      r2 = r[1];
+      r3 = r[2];
+      r4 = r[3];
+    }
+  } else {
+    r1 = r2 = r3 = r4 = 0;
+  }
+  var total;
+  if (r1 + r2 > width) {
+    total = r1 + r2;
+    r1 *= width / total;
+    r2 *= width / total;
+  }
+  if (r3 + r4 > width) {
+    total = r3 + r4;
+    r3 *= width / total;
+    r4 *= width / total;
+  }
+  if (r2 + r3 > height) {
+    total = r2 + r3;
+    r2 *= height / total;
+    r3 *= height / total;
+  }
+  if (r1 + r4 > height) {
+    total = r1 + r4;
+    r1 *= height / total;
+    r4 *= height / total;
+  }
+  ctx.moveTo(x + r1, y);
+  ctx.lineTo(x + width - r2, y);
+  r2 !== 0 && ctx.arc(x + width - r2, y + r2, r2, -Math.PI / 2, 0);
+  ctx.lineTo(x + width, y + height - r3);
+  r3 !== 0 && ctx.arc(x + width - r3, y + height - r3, r3, 0, Math.PI / 2);
+  ctx.lineTo(x + r4, y + height);
+  r4 !== 0 && ctx.arc(x + r4, y + height - r4, r4, Math.PI / 2, Math.PI);
+  ctx.lineTo(x, y + r1);
+  r1 !== 0 && ctx.arc(x + r1, y + r1, r1, Math.PI, Math.PI * 1.5);
+}
+export {
+  buildPath
+};