@zhenliang/sheet 0.2.4 → 0.2.5-beta.0

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

@@ -0,0 +1,333 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * 词法分析器：分词
+ */
+var Lexer = /*#__PURE__*/function () {
+  function Lexer(input) {
+    _classCallCheck(this, Lexer);
+    this.input = input;
+    this.pos = 0;
+    this.tokens = [];
+  }
+
+  // 词法规则：NUMBER
+  _createClass(Lexer, [{
+    key: "isNumberStart",
+    value: function isNumberStart(char) {
+      return char >= '0' && char <= '9';
+    }
+  }, {
+    key: "isDigit",
+    value: function isDigit(char) {
+      return char >= '0' && char <= '9';
+    }
+
+    // 词法规则：REFVAR
+  }, {
+    key: "isIdentifierStart",
+    value: function isIdentifierStart(char) {
+      return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_';
+    }
+  }, {
+    key: "isIdentifierChar",
+    value: function isIdentifierChar(char) {
+      return this.isIdentifierStart(char) || this.isDigit(char);
+    }
+
+    // 词法规则：PERCENT
+  }, {
+    key: "isPercent",
+    value: function isPercent(char) {
+      return char === '%';
+    }
+
+    // 执行词法分析
+  }, {
+    key: "tokenize",
+    value: function tokenize() {
+      while (this.pos < this.input.length) {
+        var char = this.input[this.pos];
+
+        // 跳过空白字符
+        if (char === ' ' || char === '\t' || char === '\r' || char === '\n') {
+          this.pos++;
+          continue;
+        }
+
+        // 尝试解析 NUMBER 或 PERCENT
+        if (this.isNumberStart(char)) {
+          var start = this.pos;
+          var hasDecimal = false;
+
+          // 匹配整数部分
+          if (char === '0') {
+            this.pos++;
+          } else {
+            while (this.pos < this.input.length && this.isDigit(this.input[this.pos])) {
+              this.pos++;
+            }
+          }
+
+          // 匹配小数部分
+          if (this.pos < this.input.length && this.input[this.pos] === '.') {
+            hasDecimal = true;
+            this.pos++;
+            if (this.pos < this.input.length && this.isDigit(this.input[this.pos])) {
+              while (this.pos < this.input.length && this.isDigit(this.input[this.pos])) {
+                this.pos++;
+              }
+            } else {
+              // 小数点后没有数字，语法错误
+              this.pos = start + 1; // 回退到起始位置之后
+              return false;
+            }
+          }
+
+          // 检查是否是 PERCENT
+          if (this.pos < this.input.length && this.input[this.pos] === '%') {
+            this.tokens.push({
+              type: 'PERCENT',
+              value: this.input.substring(start, this.pos + 1)
+            });
+            this.pos++;
+          } else {
+            this.tokens.push({
+              type: 'NUMBER',
+              value: this.input.substring(start, this.pos)
+            });
+          }
+          continue;
+        }
+
+        // 尝试解析 REFVAR
+        if (this.isIdentifierStart(char)) {
+          var _start = this.pos;
+          while (this.pos < this.input.length && this.isIdentifierChar(this.input[this.pos])) {
+            this.pos++;
+          }
+          this.tokens.push({
+            type: 'REFVAR',
+            value: this.input.substring(_start, this.pos)
+          });
+          continue;
+        }
+
+        // 解析运算符
+        if (char === '(') {
+          this.tokens.push({
+            type: 'LPAREN',
+            value: '('
+          });
+          this.pos++;
+          continue;
+        }
+        if (char === ')') {
+          this.tokens.push({
+            type: 'RPAREN',
+            value: ')'
+          });
+          this.pos++;
+          continue;
+        }
+        if (char === '*') {
+          this.tokens.push({
+            type: 'MUL',
+            value: '*'
+          });
+          this.pos++;
+          continue;
+        }
+        if (char === '/') {
+          this.tokens.push({
+            type: 'DIV',
+            value: '/'
+          });
+          this.pos++;
+          continue;
+        }
+        if (char === '+') {
+          this.tokens.push({
+            type: 'ADD',
+            value: '+'
+          });
+          this.pos++;
+          continue;
+        }
+        if (char === '-') {
+          this.tokens.push({
+            type: 'SUB',
+            value: '-'
+          });
+          this.pos++;
+          continue;
+        }
+
+        // 无法识别的字符
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "getTokens",
+    value: function getTokens() {
+      return this.tokens;
+    }
+  }]);
+  return Lexer;
+}();
+/**
+ * 语法分析器：递归下降解析器
+ * 实现标准优先级爬山算法处理运算符优先级
+ */
+var Parser = /*#__PURE__*/function () {
+  function Parser(tokens) {
+    _classCallCheck(this, Parser);
+    this.tokens = tokens;
+    this.pos = 0;
+  }
+
+  // prog: expr EOF
+  _createClass(Parser, [{
+    key: "parseProg",
+    value: function parseProg() {
+      var result = this.parseExpr();
+      if (!result) return false;
+
+      // 检查是否解析完所有 token
+      return this.pos >= this.tokens.length;
+    }
+
+    // 入口表达式解析（处理最低优先级的加减运算）
+  }, {
+    key: "parseExpr",
+    value: function parseExpr() {
+      return this.parseAddSub();
+    }
+
+    // 解析加减表达式（优先级低于乘除）
+    // expr: expr ('+' | '-') expr | term
+  }, {
+    key: "parseAddSub",
+    value: function parseAddSub() {
+      // 先解析左操作数
+      var left = this.parseMulDiv();
+      if (!left) return false;
+
+      // 用循环处理多个连续的加减运算符
+      while (true) {
+        var token = this.currentToken();
+        if (token && (token.type === 'ADD' || token.type === 'SUB')) {
+          this.pos++;
+          // 解析右操作数（使用更高优先级的规则）
+          var right = this.parseMulDiv();
+          if (!right) return false;
+        } else {
+          break;
+        }
+      }
+      return true;
+    }
+
+    // 解析乘除表达式（优先级高于加减）
+    // term: term ('*' | '/') factor | factor
+  }, {
+    key: "parseMulDiv",
+    value: function parseMulDiv() {
+      // 先解析左操作数
+      var left = this.parseFactor();
+      if (!left) return false;
+
+      // 用循环处理多个连续的乘除运算符
+      while (true) {
+        var token = this.currentToken();
+        if (token && (token.type === 'MUL' || token.type === 'DIV')) {
+          this.pos++;
+          // 解析右操作数
+          var right = this.parseFactor();
+          if (!right) return false;
+        } else {
+          break;
+        }
+      }
+      return true;
+    }
+
+    // 解析基本表达式（括号、数字、百分比、变量）
+    // factor: '(' expr ')' | NUMBER | PERCENT | REFVAR
+  }, {
+    key: "parseFactor",
+    value: function parseFactor() {
+      var token = this.currentToken();
+      if (!token) return false;
+
+      // 处理括号表达式
+      if (token.type === 'LPAREN') {
+        this.pos++;
+        var exprResult = this.parseExpr();
+        if (!exprResult) return false;
+        var closeToken = this.currentToken();
+        if (!closeToken || closeToken.type !== 'RPAREN') return false;
+        this.pos++;
+        return true;
+      }
+
+      // 处理数字
+      if (token.type === 'NUMBER') {
+        this.pos++;
+        return true;
+      }
+
+      // 处理百分比数字
+      if (token.type === 'PERCENT') {
+        this.pos++;
+        return true;
+      }
+
+      // 处理引用变量
+      if (token.type === 'REFVAR') {
+        this.pos++;
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "currentToken",
+    value: function currentToken() {
+      return this.tokens[this.pos];
+    }
+  }]);
+  return Parser;
+}();
+/**
+ * 校验主函数
+ * @param {string} input - 要校验的表达式字符串
+ * @returns {boolean} - 校验通过返回 true，失败返回 false
+ */
+function validateCalculationExpr(input) {
+  // 输入验证
+  if (!input || typeof input !== 'string') {
+    return false;
+  }
+
+  // 词法分析
+  var lexer = new Lexer(input);
+  if (!lexer.tokenize()) {
+    return false;
+  }
+  var tokens = lexer.getTokens();
+
+  // 检查是否有有效 token
+  if (tokens.length === 0) {
+    return false;
+  }
+
+  // 语法分析
+  var parser = new Parser(tokens);
+  return parser.parseProg();
+}
+export default validateCalculationExpr;

package/dist/core/editor/index.d.ts

@@ -3,3 +3,4 @@ export { getDateEditor } from './dateEditor';
 export { getNumberEditor, NumberEditor } from './numberEditor';
 export { default as getSelectEditor } from './selectEditor';
 export { default as getInputSelectEditor } from './inputSelectEditor/inputSelect';
+export { default as getFormulaInputEditor } from './InputOptionsEditor';

package/dist/core/editor/index.js

@@ -2,4 +2,5 @@ export { default as getCascaderEditor } from "./cascaderEditor";
 export { getDateEditor } from "./dateEditor";
 export { getNumberEditor, NumberEditor } from "./numberEditor";
 export { default as getSelectEditor } from "./selectEditor";
-export { default as getInputSelectEditor } from "./inputSelectEditor/inputSelect";
+export { default as getInputSelectEditor } from "./inputSelectEditor/inputSelect";
+export { default as getFormulaInputEditor } from "./InputOptionsEditor";

package/dist/example/basic.d.ts

@@ -1,4 +1,5 @@
 import 'antd/dist/antd.css';
 import React from 'react';
+import './index.less';
 declare const App: React.FC;
 export default App;

package/dist/example/basic.js

@@ -14,10 +14,11 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 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; }
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-import { Table, getNumberEditor, getInputSelectEditor } from "./..";
-import { Space, Tag, Select } from 'antd';
+import { Table, getFormulaInputEditor, getInputSelectEditor, getNumberEditor } from "./..";
+import { Select, Space, Tag } from 'antd';
 import 'antd/dist/antd.css';
 import React, { useCallback, useState } from 'react';
+import "./index.less";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Fragment as _Fragment } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
@@ -64,6 +65,35 @@ var columns = [{
     min: 0,
     precision: 2
   })
+}, {
+  title: 'Formula',
+  dataIndex: 'formula',
+  key: 'formula',
+  width: 200,
+  cellConfig: {
+    className: 'testCell'
+  },
+  editor: getFormulaInputEditor([{
+    label: '单价',
+    value: 'price'
+  }, {
+    label: '数量',
+    value: 'qty'
+  }, {
+    label: '折扣',
+    value: 'discount',
+    info: '注意这个有点皮'
+  }, {
+    label: '价格相关',
+    value: 'priceGroup',
+    children: [{
+      label: '成本价',
+      value: 'cost'
+    }, {
+      label: '批发价',
+      value: 'wholesale'
+    }]
+  }])
 }, {
   title: 'Address',
   editable: false,
@@ -111,19 +141,36 @@ var data = [{
   name: 'John Brown',
   age: 32,
   address: 'New York No. 1 Lake Park',
-  tags: ['nice', 'developer']
+  tags: ['nice', 'developer'],
+  formula: '=price*qty'
 }, {
   key: '2',
   name: 'Jim Green',
   age: 42,
   address: 'London No. 1 Lake Park',
-  tags: ['loser']
+  tags: ['loser'],
+  formula: '=price+discount'
 }, {
   key: '3',
   name: 'Joe Black',
   age: 32,
   address: 'Sidney No. 1 Lake Park',
-  tags: ['cool', 'teacher']
+  tags: ['cool', 'teacher'],
+  formula: '=123* 4569797 * discount*123* 4569797 * discount*123* 4569797 * discount*123* 4569797 * discount*123* 4569797 * discount*123* 4569797 * discount*123* 4569797 * discount'
+}, {
+  key: '4',
+  name: 'Joe ll',
+  age: 92,
+  address: 'Sidney No. 1 Lake Park',
+  tags: ['cool', 'teacher'],
+  formula: '=(123 + 456) * price'
+}, {
+  key: '5',
+  name: 'Joe ll',
+  age: 37,
+  address: 'Sidney No. 1 Lake Park',
+  tags: ['cool', 'teacher'],
+  formula: '=(123 + 456) * price + 888'
 }];
 var App = function App() {
   var _useState = useState(data),

package/dist/example/index.less

@@ -1,5 +1,8 @@
-.excel-sheet{
-  --row-height:30px;
-  --line-height:30px;
+.excel-sheet {
+  --row-height: 30px;
+  --line-height: 30px;
   --cell-inner-height: 29px;
-}
+}
+.testCell {
+  position: relative !important;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhenliang/sheet",
-  "version": "0.2.4",
+  "version": "0.2.5-beta.0",
   "description": "A react library developed with dumi",
   "license": "MIT",
   "module": "dist/index.js",