@zhenliang/sheet 0.2.4 → 0.2.5-beta.0

package/dist/core/editor/InputOptionsEditor/index.less

@@ -0,0 +1,57 @@
+.formula-editor {
+  display: flex;
+  align-items: center;
+  white-space: nowrap;
+  overflow: hidden;
+  outline: none;
+  min-width: 95%;
+  max-height: 100%;
+  box-shadow: inset 0 -100px 0 rgba(33, 133, 208, 15%);
+  position: absolute;
+  top: 0;
+  background: #fff;
+}
+
+.formula-editor-equal {
+  color: #000;
+}
+
+.formula-editor-token-label {
+  color: #0078e0;
+}
+
+.formula-editor-token-other {
+  color: #000;
+  min-height: 40px;
+  min-width: 1px;
+}
+
+.formula-editor-dropdown {
+  max-height: 300px;
+  overflow-y: auto;
+  background: #fff;
+  border-radius: 4px;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+
+  .formula-editor-dropdown-item {
+    padding: 8px 12px;
+    cursor: pointer;
+    transition: background 0.2s;
+
+    &:hover {
+      background: #f5f5f5;
+    }
+  }
+
+  .formula-editor-dropdown-no-data {
+    color: #999;
+    padding: 8px 12px;
+    display: block;
+    text-align: center;
+  }
+}
+
+.dropDownOffset {
+  min-width: 100px !important;
+  max-width: 200px !important;
+}

package/dist/core/editor/InputOptionsEditor/utils.d.ts

@@ -0,0 +1,59 @@
+export declare const OPERATORS: string[];
+export declare const VARIABLE_REGEX: RegExp;
+export declare const NUMBER_REGEX: RegExp;
+export interface Token {
+    text: string;
+    type: 'label' | 'operator' | 'other' | 'end';
+}
+/**
+ * 将表达式中的 value 替换为对应的 label
+ */
+export declare const replaceValuesWithLabels: (expr: string, flatOptions: {
+    label: string;
+    value: string;
+}[]) => string;
+/**
+ * 从表达式中提取所有变量名
+ */
+export declare const extractVariables: (expr: string) => string[];
+/**
+ * 将表达式解析为 token 数组，用于渲染带颜色的文本
+ * 自动将 value 转换为对应的 label
+ * 有效 label 为 type 'label'，其他为 'other'
+ */
+export declare const tokenize: (text: string, flatOptions: {
+    label: string;
+    value: string;
+}[]) => Token[];
+/**
+ * 将表达式中的 label 替换为对应的 value
+ */
+export declare const replaceLabelsWithValues: (expr: string, flatOptions: {
+    label: string;
+    value: string;
+}[]) => string;
+/**
+ * 校验表达式中的所有变量是否都在 options 中
+ */
+export declare const validateVariables: (expr: string, flatOptions: {
+    label: string;
+    value: string;
+}[]) => boolean;
+/**
+ * 扁平化选项列表（将 children 展开）
+ */
+export declare const flattenOptions: (options: {
+    label: string;
+    value: string;
+    children?: {
+        label: string;
+        value: string;
+    }[];
+}[]) => {
+    label: string;
+    value: string;
+}[];
+export declare const longestCommonSubsequence: (arr1: string, arr2: string) => string[];
+export declare const getStringDiff: (str1: any, str2: any, mode?: string) => any;
+export declare const replaceLongestDiff: (a: string, str: string, position: number) => string;
+export declare const getCursorPositionInSpan: (span: any) => any;

package/dist/core/editor/InputOptionsEditor/utils.js

@@ -0,0 +1,335 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+// 运算符列表
+export var OPERATORS = ['+', '-', '*', '/'];
+
+// 变量名正则：匹配字母开头的标识符
+export var VARIABLE_REGEX = /[a-zA-Z_][a-zA-Z0-9_]*/g;
+
+// 数字正则
+export var NUMBER_REGEX = /^\d+(\.\d+)?/;
+
+// Token 类型
+
+/**
+ * 将表达式中的 value 替换为对应的 label
+ */
+export var replaceValuesWithLabels = function replaceValuesWithLabels(expr, flatOptions) {
+  // 按 value 长度降序排序，避免短 value 先匹配导致问题
+  var sortedOptions = _toConsumableArray(flatOptions).sort(function (a, b) {
+    return b.value.length - a.value.length;
+  });
+  var result = expr;
+  var _iterator = _createForOfIteratorHelper(sortedOptions),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var opt = _step.value;
+      // 全局替换 value 为 label
+      result = result.split(opt.value).join(opt.label);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result.replace(/\s/g, '');
+};
+
+/**
+ * 从表达式中提取所有变量名
+ */
+export var extractVariables = function extractVariables(expr) {
+  var matches = new Set(expr.match(VARIABLE_REGEX));
+  return matches ? _toConsumableArray(Array.from(matches)) : [];
+};
+
+/**
+ * 将混合 segment 按有效 label 拆分成多个 token
+ */
+var splitSegmentByLabels = function splitSegmentByLabels(segment, sortedLabels) {
+  var tokens = [];
+  var remaining = segment;
+  while (remaining.length > 0) {
+    // 找到剩余文本中第一个有效 label 的位置
+    var labelStart = -1;
+    var matchedLabel = '';
+    var _iterator2 = _createForOfIteratorHelper(sortedLabels),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var label = _step2.value;
+        var idx = remaining.indexOf(label);
+        if (idx !== -1 && (labelStart === -1 || idx < labelStart)) {
+          labelStart = idx;
+          matchedLabel = label;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    if (labelStart === -1) {
+      // 没有有效 label，整个为 'other'
+      if (remaining.trim()) {
+        tokens.push({
+          text: remaining.trim(),
+          type: 'other'
+        });
+      }
+      break;
+    }
+
+    // labelStart 前的部分为 'other'
+    if (labelStart > 0) {
+      var before = remaining.slice(0, labelStart);
+      if (before.trim()) {
+        tokens.push({
+          text: before.trim(),
+          type: 'other'
+        });
+      }
+    }
+
+    // 有效 label
+    tokens.push({
+      text: matchedLabel,
+      type: 'label'
+    });
+
+    // 剩余部分继续处理
+    remaining = remaining.slice(labelStart + matchedLabel.length);
+  }
+  return tokens;
+};
+
+/**
+ * 将表达式解析为 token 数组，用于渲染带颜色的文本
+ * 自动将 value 转换为对应的 label
+ * 有效 label 为 type 'label'，其他为 'other'
+ */
+export var tokenize = function tokenize(text, flatOptions) {
+  var tokens = [];
+
+  // 将 value 转换为 label
+  var labelExpr = replaceValuesWithLabels(text.slice(1), flatOptions);
+  tokens.push({
+    text: '=',
+    type: 'operator'
+  });
+  if (!labelExpr) {
+    return [];
+  }
+
+  // 按长度降序排序，用于匹配
+  var sortedLabels = flatOptions.map(function (opt) {
+    return opt.label;
+  }).sort(function (a, b) {
+    return b.length - a.length;
+  });
+
+  // 按运算符分割文本
+  var segments = labelExpr.split(/([=+\-*/])/);
+  var _iterator3 = _createForOfIteratorHelper(segments),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var segment = _step3.value;
+      if (!segment) continue;
+      if (OPERATORS.includes(segment)) {
+        tokens.push({
+          text: segment,
+          type: 'operator'
+        });
+      } else {
+        // 拆分混合 segment，如 "123苹果456" 拆成 ["123", "苹果", "456"]
+        var subTokens = splitSegmentByLabels(segment, sortedLabels);
+        tokens.push.apply(tokens, _toConsumableArray(subTokens));
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  tokens.push({
+    text: '',
+    type: 'end'
+  });
+  return tokens;
+};
+
+/**
+ * 将表达式中的 label 替换为对应的 value
+ */
+export var replaceLabelsWithValues = function replaceLabelsWithValues(expr, flatOptions) {
+  // 按 label 长度降序排序，避免短 label 先匹配导致问题
+  var sortedOptions = _toConsumableArray(flatOptions).sort(function (a, b) {
+    return b.label.length - a.label.length;
+  });
+  var result = expr;
+  var _iterator4 = _createForOfIteratorHelper(sortedOptions),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var opt = _step4.value;
+      // 全局替换 label 为 value
+      result = result.split(opt.label).join(opt.value);
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return result.replace(/\s/g, '');
+};
+
+/**
+ * 校验表达式中的所有变量是否都在 options 中
+ */
+export var validateVariables = function validateVariables(expr, flatOptions) {
+  var variables = extractVariables(expr);
+  var validValues = new Set(flatOptions.map(function (opt) {
+    return opt.value;
+  }));
+  return variables.every(function (v) {
+    return validValues.has(v);
+  });
+};
+
+/**
+ * 扁平化选项列表（将 children 展开）
+ */
+export var flattenOptions = function flattenOptions(options) {
+  var result = [];
+  var _iterator5 = _createForOfIteratorHelper(options),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var opt = _step5.value;
+      result.push({
+        label: opt.label,
+        value: opt.value
+      });
+      if (opt.children && opt.children.length > 0) {
+        result.push.apply(result, _toConsumableArray(flattenOptions(opt.children)));
+      }
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return result;
+};
+export var longestCommonSubsequence = function longestCommonSubsequence(arr1, arr2) {
+  var m = arr1.length;
+  var n = arr2.length;
+  var dp = Array(m + 1).fill(null).map(function () {
+    return Array(n + 1).fill(0);
+  });
+  for (var _i = 1; _i <= m; _i++) {
+    for (var _j = 1; _j <= n; _j++) {
+      if (arr1[_i - 1] === arr2[_j - 1]) {
+        dp[_i][_j] = dp[_i - 1][_j - 1] + 1;
+      } else {
+        dp[_i][_j] = Math.max(dp[_i - 1][_j], dp[_i][_j - 1]);
+      }
+    }
+  }
+
+  // 回溯找出 LCS
+  var lcs = [];
+  var i = m,
+    j = n;
+  while (i > 0 && j > 0) {
+    if (arr1[i - 1] === arr2[j - 1]) {
+      lcs.unshift(arr1[i - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return lcs;
+};
+export var getStringDiff = function getStringDiff(str1, str2) {
+  var mode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'char';
+  var arr1, arr2;
+  if (mode === 'word') {
+    arr1 = str1.split(/\s+/);
+    arr2 = str2.split(/\s+/);
+  } else {
+    arr1 = str1.split('');
+    arr2 = str2.split('');
+  }
+  var result = {
+    added: [],
+    // 新增部分
+    removed: [],
+    // 删除部分
+    unchanged: [] // 未变化部分
+  };
+
+  // 使用动态规划计算最长公共子序列
+  var lcs = longestCommonSubsequence(arr1, arr2);
+  var i = 0,
+    j = 0,
+    k = 0;
+  while (i < arr1.length || j < arr2.length) {
+    if (k < lcs.length) {
+      // 处理删除的部分
+      while (i < arr1.length && arr1[i] !== lcs[k]) {
+        result.removed.push(arr1[i]);
+        i++;
+      }
+      // 处理新增的部分
+      while (j < arr2.length && arr2[j] !== lcs[k]) {
+        result.added.push(arr2[j]);
+        j++;
+      }
+      // 相等的部分
+      if (i < arr1.length && j < arr2.length) {
+        result.unchanged.push(arr1[i]);
+        i++;
+        j++;
+        k++;
+      }
+    } else {
+      // 剩余的删除部分
+      while (i < arr1.length) {
+        result.removed.push(arr1[i]);
+        i++;
+      }
+      // 剩余的新增部分
+      while (j < arr2.length) {
+        result.added.push(arr2[j]);
+        j++;
+      }
+    }
+  }
+  return result;
+};
+export var replaceLongestDiff = function replaceLongestDiff(a, str, position) {
+  // 分割字符串：前半部分 + 替换内容 + 后半部分
+  var before = a.substring(0, position + 1);
+  var after = a.substring(position + 1);
+  return before + str + after;
+};
+export var getCursorPositionInSpan = function getCursorPositionInSpan(span) {
+  var selection = window.getSelection();
+  if (selection.rangeCount === 0) return 0;
+  var range = selection.getRangeAt(0);
+  var preCaretRange = range.cloneRange();
+  preCaretRange.selectNodeContents(span);
+  preCaretRange.setEnd(range.startContainer, range.startOffset);
+  return preCaretRange.toString().length;
+};