sh-tools 2.3.6 → 2.3.7

package/package.json

@@ -1,9 +1,10 @@
 {
 	"name": "sh-tools",
-	"version": "2.3.6",
+	"version": "2.3.7",
 	"description": "基于fetch和xe-utils二次封装，支持宏公式计算",
 	"main": "packages/index.js",
 	"scripts": {
+		"serve": "vue-cli-service serve",
 		"lib": "vue-cli-service build --target lib packages/index.js --name sh-tools --dest lib"
 	},
 	"keywords": [
@@ -12,7 +13,6 @@
 	"author": "神秘的sh",
 	"license": "ISC",
 	"dependencies": {
-		"hot-formula-parser": "^4.0.0",
 		"xe-utils": "^3.8.2"
 	},
 	"devDependencies": {

package/packages/expr/index.js

@@ -0,0 +1,516 @@
+import utilsModule from '../utils'
+
+/**
+ * 常量定义：分类管理内置方法名
+ */
+const MATH_METHODS = ['abs', 'sin', 'cos', 'tan', 'log', 'exp', 'pow']
+const UTIL_METHODS = {
+	base: [
+		'isNaN',
+		'isFinite',
+		'isArray',
+		'isFloat',
+		'isInteger',
+		'isBoolean',
+		'isString',
+		'isNumber',
+		'isPlainObject',
+		'isDate',
+		'isEmpty',
+		'isNull',
+		'isMatch',
+		'isEqual',
+		'getSize',
+		'first',
+		'last'
+	],
+	object: ['has', 'get', 'assign', 'merge', 'pick', 'omit'],
+	array: [
+		'slice',
+		'indexOf',
+		'includes',
+		'includeArrays',
+		'sum',
+		'mean',
+		'zip',
+		'unzip',
+		'uniq',
+		'union',
+		'flatten',
+		'pluck',
+		'invoke',
+		'orderBy',
+		'groupBy',
+		'countBy',
+		'toArrayTree',
+		'toTreeArray'
+	],
+	date: [
+		'now',
+		'timestamp',
+		'toStringDate',
+		'toDateString',
+		'getWhatYear',
+		'getWhatMonth',
+		'getWhatWeek',
+		'getWhatDay',
+		'getDayOfYear',
+		'getYearDay',
+		'getYearWeek',
+		'getMonthWeek',
+		'getDayOfMonth'
+	],
+	number: ['random', 'min', 'max', 'ceil', 'floor', 'round', 'truncate', 'toFixed', 'toNumber', 'toNumberString', 'toInteger', 'add', 'subtract', 'multiply', 'divide'],
+	string: ['toValueString', 'trim', 'trimLeft', 'trimRight', 'camelCase', 'kebabCase', 'startsWith', 'endsWith']
+}
+
+// ========== 核心修复1：正则新增字符串字面量匹配（优先识别） ==========
+// 改动点：
+// 1. 最前面新增 ("[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*') 匹配单/双引号字符串
+// 2. 处理转义字符（如 \' / \"），兼容带转义的字符串
+const TOKEN_REG = /\s*((?:"[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*')|(if|else)|[a-zA-Z_$][a-zA-Z0-9_$]*|[\d.]+|,|==|===|!=|!==|<=|>=|<<|>>|>>>|\|\||&&|\*\*|[-+*/%^&|<>!=?:()\[\]])\s*/g
+
+// 运算符映射（原有逻辑不变）
+const UNARY_OP_MAP = { '+': 'unary +', '-': 'unary -', '!': '!', '~': '~' }
+const EQUALITY_OP_MAP = { '==': true, '!=': true, '===': true, '!==': true }
+const RELATIONAL_OP_MAP = { '<': true, '>': true, '<=': true, '>=': true }
+const SHIFT_OP_MAP = { '<<': true, '>>': true, '>>>': true }
+const ARITHMETIC_OP_MAP = { '+': true, '-': true, '*': true, '/': true, '%': true }
+
+/**
+ * 表达式求值器（最终完整版：支持if-else+换行+字符串字面量）
+ */
+class ExprEvaluator {
+	constructor() {
+		this.functions = {}
+		this.operators = {}
+		this._isInited = false
+		this._initParseFunctions()
+	}
+
+	/**
+	 * 懒加载初始化（原有逻辑不变）
+	 */
+	_lazyInit() {
+		if (this._isInited) return
+		const utils = utilsModule.__esModule ? utilsModule.default : utilsModule
+
+		const funcs = {}
+		for (const method of MATH_METHODS) funcs[method] = Math[method]
+
+		// 提前扁平化方法列表（轻量化优化）
+		const ALL_UTIL_METHODS = Object.values(UTIL_METHODS).flat()
+		for (const method of ALL_UTIL_METHODS) {
+			if (typeof utils[method] === 'function') {
+				// sum函数兼容包装（解决sum(1,2,3)返回0的问题）
+				if (method === 'sum') {
+					funcs[method] = (...args) => {
+						if (args.length === 1 && Array.isArray(args[0])) {
+							return utils.sum(args[0])
+						}
+						return utils.sum(args)
+					}
+				} else {
+					funcs[method] = utils[method]
+				}
+			} else if (process.env.NODE_ENV === 'development') {
+				console.warn(`[ExprEvaluator] utils方法不存在: ${method}`)
+			}
+		}
+		this.functions = funcs
+
+		// 初始化运算符（原有逻辑不变）
+		this.operators = {
+			'?:': { precedence: 1, associativity: 'right', ternary: true, fn: (c, a, b) => (c ? a : b) },
+			'||': { precedence: 1, associativity: 'left', fn: (a, b) => a || b },
+			'&&': { precedence: 2, associativity: 'left', fn: (a, b) => a && b },
+			'|': { precedence: 3, associativity: 'left', fn: (a, b) => a | b },
+			'^': { precedence: 4, associativity: 'left', fn: (a, b) => a ^ b },
+			'&': { precedence: 5, associativity: 'left', fn: (a, b) => a & b },
+			'==': { precedence: 6, associativity: 'left', fn: (a, b) => a == b },
+			'!=': { precedence: 6, associativity: 'left', fn: (a, b) => a != b },
+			'===': { precedence: 6, associativity: 'left', fn: (a, b) => a === b },
+			'!==': { precedence: 6, associativity: 'left', fn: (a, b) => a !== b },
+			'<': { precedence: 7, associativity: 'left', fn: (a, b) => a < b },
+			'>': { precedence: 7, associativity: 'left', fn: (a, b) => a > b },
+			'<=': { precedence: 7, associativity: 'left', fn: (a, b) => a <= b },
+			'>=': { precedence: 7, associativity: 'left', fn: (a, b) => a >= b },
+			'<<': { precedence: 8, associativity: 'left', fn: (a, b) => a << b },
+			'>>': { precedence: 8, associativity: 'left', fn: (a, b) => a >> b },
+			'>>>': { precedence: 8, associativity: 'left', fn: (a, b) => a >>> b },
+			'+': { precedence: 9, associativity: 'left', fn: utils.add },
+			'-': { precedence: 9, associativity: 'left', fn: utils.subtract },
+			'*': { precedence: 10, associativity: 'left', fn: utils.multiply },
+			'/': { precedence: 10, associativity: 'left', fn: utils.divide },
+			'%': { precedence: 10, associativity: 'left', fn: (a, b) => a % b },
+			'**': { precedence: 11, associativity: 'right', fn: Math.pow },
+			'unary +': { precedence: 12, associativity: 'right', prefix: true, fn: a => +a },
+			'unary -': { precedence: 12, associativity: 'right', prefix: true, fn: a => -a },
+			'!': { precedence: 12, associativity: 'right', prefix: true, fn: a => !a },
+			'~': { precedence: 12, associativity: 'right', prefix: true, fn: a => ~a }
+		}
+
+		this._isInited = true
+	}
+
+	/**
+	 * 初始化解析函数（原有逻辑不变，仅扩展parsePrimary支持字符串）
+	 */
+	_initParseFunctions() {
+		let tokens, pos
+		const self = this
+
+		// 函数参数解析（不变）
+		const parseFunctionArgs = closeChar => {
+			const args = []
+			pos++ // 跳过左括号 ( 或 [
+
+			if (tokens[pos] !== closeChar) {
+				args.push(parseTernary())
+				while (tokens[pos] === ',') {
+					pos++ // 跳过逗号
+					if (tokens[pos] === closeChar) break // 处理多余逗号：sum(1,)
+					args.push(parseTernary())
+				}
+			}
+
+			if (tokens[pos] !== closeChar) {
+				throw new Error(`函数参数未闭合：缺少 ${closeChar}（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
+			}
+			pos++ // 跳过右括号 ) 或 ]
+			return args
+		}
+
+		// 数组字面量解析（不变）
+		const parseArrayLiteral = () => {
+			const startPos = pos
+			pos++ // 跳过左中括号 [
+			const arr = []
+
+			if (tokens[pos] !== ']') {
+				arr.push(parseTernary())
+				while (tokens[pos] === ',') {
+					pos++ // 跳过逗号
+					if (tokens[pos] === ']') break // 处理多余逗号：[1,]
+					arr.push(parseTernary())
+				}
+			}
+
+			if (tokens[pos] !== ']') {
+				throw new Error(`数组未闭合：在位置 ${startPos} 开始的数组缺少 ]（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
+			}
+			pos++ // 跳过右中括号 ]
+			return arr
+		}
+
+		// ========== 核心修复2：扩展parsePrimary支持字符串字面量 ==========
+		const parsePrimary = () => {
+			if (pos >= tokens.length) throw new Error('表达式意外结束')
+			const currentToken = tokens[pos]
+
+			// 新增：字符串字面量解析（单/双引号）
+			if (typeof currentToken === 'string' && (currentToken.startsWith('"') || currentToken.startsWith("'"))) {
+				const strValue = currentToken.slice(1, -1) // 去掉首尾引号
+				pos++
+				return strValue // 返回纯字符串内容
+			}
+
+			// 数组字面量
+			if (currentToken === '[') {
+				return parseArrayLiteral()
+			}
+
+			// 括号表达式 (a + b)
+			if (currentToken === '(') {
+				pos++
+				const res = parseTernary()
+				if (tokens[pos] !== ')') {
+					throw new Error(`括号未闭合：缺少 )（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
+				}
+				pos++
+				return res
+			}
+
+			// 函数调用（支持 () 和 [] 两种写法）
+			if (typeof currentToken === 'string' && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(currentToken)) {
+				const funcName = currentToken
+				pos++
+
+				// 圆括号调用：sum(1,2,3)
+				if (tokens[pos] === '(') {
+					const args = parseFunctionArgs(')')
+					if (!self.functions[funcName]) throw new Error(`未定义函数: ${funcName}`)
+					return self.functions[funcName](...args)
+				}
+
+				// 中括号调用：sum[1,2,3]
+				if (tokens[pos] === '[') {
+					const args = parseFunctionArgs(']')
+					if (!self.functions[funcName]) throw new Error(`未定义函数: ${funcName}`)
+					return self.functions[funcName](...args)
+				}
+
+				throw new Error(`不支持变量: ${funcName}（仅支持函数调用）`)
+			}
+
+			// 数字
+			if (typeof currentToken === 'number') {
+				const num = currentToken
+				pos++
+				return num
+			}
+
+			throw new Error(`无效Token: ${currentToken}（位置：${pos}）`)
+		}
+
+		// 一元运算符解析（不变）
+		const parseUnary = () => {
+			const token = tokens[pos]
+			if (UNARY_OP_MAP[token]) {
+				const opName = UNARY_OP_MAP[token]
+				pos++
+				return self.operators[opName].fn(parsePrimary())
+			}
+			return parsePrimary()
+		}
+
+		// 幂运算解析（不变）
+		const parseExponential = () => {
+			let res = parseUnary()
+			while (tokens[pos] === '**') {
+				pos++
+				res = self.operators['**'].fn(res, parseUnary())
+			}
+			return res
+		}
+
+		// 乘除取模解析（不变）
+		const parseMultiplicative = () => {
+			let res = parseExponential()
+			while (ARITHMETIC_OP_MAP[tokens[pos]] && ['*', '/', '%'].includes(tokens[pos])) {
+				const op = tokens[pos]
+				pos++
+				res = self.operators[op].fn(res, parseExponential())
+			}
+			return res
+		}
+
+		// 加减解析（不变）
+		const parseAdditive = () => {
+			let res = parseMultiplicative()
+			while (ARITHMETIC_OP_MAP[tokens[pos]] && ['+', '-'].includes(tokens[pos])) {
+				const op = tokens[pos]
+				pos++
+				res = self.operators[op].fn(res, parseMultiplicative())
+			}
+			return res
+		}
+
+		// 位移解析（不变）
+		const parseShift = () => {
+			let res = parseAdditive()
+			while (SHIFT_OP_MAP[tokens[pos]]) {
+				const op = tokens[pos]
+				pos++
+				res = self.operators[op].fn(res, parseAdditive())
+			}
+			return res
+		}
+
+		// 关系运算符解析（不变）
+		const parseRelational = () => {
+			let res = parseShift()
+			while (RELATIONAL_OP_MAP[tokens[pos]]) {
+				const op = tokens[pos]
+				pos++
+				res = self.operators[op].fn(res, parseShift())
+			}
+			return res
+		}
+
+		// 相等性解析（不变）
+		const parseEquality = () => {
+			let res = parseRelational()
+			while (EQUALITY_OP_MAP[tokens[pos]]) {
+				const op = tokens[pos]
+				pos++
+				res = self.operators[op].fn(res, parseRelational())
+			}
+			return res
+		}
+
+		// 按位与解析（不变）
+		const parseBitwiseAnd = () => {
+			let res = parseEquality()
+			while (tokens[pos] === '&') {
+				pos++
+				res = self.operators['&'].fn(res, parseEquality())
+			}
+			return res
+		}
+
+		// 按位异或解析（不变）
+		const parseBitwiseXor = () => {
+			let res = parseBitwiseAnd()
+			while (tokens[pos] === '^') {
+				pos++
+				res = self.operators['^'].fn(res, parseBitwiseAnd())
+			}
+			return res
+		}
+
+		// 按位或解析（不变）
+		const parseBitwiseOr = () => {
+			let res = parseBitwiseXor()
+			while (tokens[pos] === '|') {
+				pos++
+				res = self.operators['|'].fn(res, parseBitwiseXor())
+			}
+			return res
+		}
+
+		// 逻辑与解析（不变）
+		const parseLogicalAnd = () => {
+			let res = parseBitwiseOr()
+			while (tokens[pos] === '&&') {
+				pos++
+				res = self.operators['&&'].fn(res, parseBitwiseOr())
+			}
+			return res
+		}
+
+		// 逻辑或解析（不变）
+		const parseLogicalOr = () => {
+			let res = parseLogicalAnd()
+			while (tokens[pos] === '||') {
+				pos++
+				res = self.operators['||'].fn(res, parseLogicalAnd())
+			}
+			return res
+		}
+
+		// if-else 解析（不变）
+		const parseIfElse = () => {
+			// 第一步：判断当前Token是否是if
+			if (tokens[pos] !== 'if') {
+				// 不是if，走原有三元运算符解析逻辑
+				return parseTernaryCore()
+			}
+
+			// 第二步：解析if关键字
+			pos++ // 跳过if关键字
+
+			// 第三步：解析if后面的括号条件，比如 if (2>1) 中的 (2>1)
+			if (tokens[pos] !== '(') {
+				throw new Error(`if语法错误：缺少左括号（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
+			}
+			pos++ // 跳过左括号(
+			const condition = parseTernaryCore() // 解析条件表达式（支持所有原有运算符）
+			if (tokens[pos] !== ')') {
+				throw new Error(`if语法错误：缺少右括号（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
+			}
+			pos++ // 跳过右括号)
+
+			// 第四步：解析if的结果（then分支），比如 if (2>1) 9 中的 9
+			const thenValue = parseTernaryCore()
+
+			// 第五步：解析else关键字
+			if (tokens[pos] !== 'else') {
+				throw new Error(`if语法错误：缺少else关键字（当前Token：${tokens[pos] || '空'}, 位置：${pos}）`)
+			}
+			pos++ // 跳过else关键字
+
+			// 第六步：解析else的结果（else分支），比如 if (2>1)9 else10 中的10
+			const elseValue = parseTernaryCore()
+
+			// 第七步：返回最终结果（条件为true返回thenValue，否则返回elseValue）
+			return condition ? thenValue : elseValue
+		}
+
+		// 三元运算符核心解析（不变）
+		const parseTernaryCore = () => {
+			let res = parseLogicalOr()
+			if (tokens[pos] === '?') {
+				pos++
+				const a = parseTernaryCore()
+				if (tokens[pos] !== ':') throw new Error('三元运算符缺少冒号')
+				pos++
+				const b = parseTernaryCore()
+				res = self.operators['?:'].fn(res, a, b)
+			}
+			return res
+		}
+
+		// 三元运算符入口（不变）
+		const parseTernary = () => {
+			// 先解析if-else，再解析三元运算符
+			return parseIfElse()
+		}
+
+		// 解析入口（不变）
+		this._parseEntry = inputTokens => {
+			tokens = inputTokens
+			pos = 0
+			const result = parseTernary()
+			if (pos < tokens.length) {
+				throw new Error(`表达式多余内容: ${tokens.slice(pos).join('')}（位置：${pos}）`)
+			}
+			return result
+		}
+	}
+
+	/**
+	 * 分词器（扩展支持字符串字面量，原有逻辑不变）
+	 */
+	_tokenize(expr) {
+		const tokens = []
+		TOKEN_REG.lastIndex = 0
+		let match
+		const utils = utilsModule.__esModule ? utilsModule.default : utilsModule
+
+		while ((match = TOKEN_REG.exec(expr)) !== null) {
+			const token = match[1]
+			// 1. 字符串字面量：直接保留（后续在parsePrimary中去掉引号）
+			if (token.startsWith('"') || token.startsWith("'")) {
+				tokens.push(token)
+			}
+			// 2. 数字转换（兼容整数/小数）
+			else if (/^\d+(\.\d+)?$/.test(token)) {
+				tokens.push(utils.toNumber(token))
+			}
+			// 3. 其他Token（关键字/运算符/标识符）：原样保留
+			else {
+				tokens.push(token)
+			}
+		}
+
+		if (tokens.length === 0) throw new Error('表达式为空')
+		return tokens
+	}
+
+	/**
+	 * 对外核心方法（兼容换行符，原有逻辑不变）
+	 */
+	evaluate(expr) {
+		this._lazyInit()
+
+		if (typeof expr !== 'string') throw new Error('表达式必须是字符串')
+
+		// 替换所有换行符（\n/\r/\r\n）为空格，兼容换行
+		const normalizedExpr = expr.replace(/[\n\r]/g, ' ')
+		const trimmed = normalizedExpr.trim()
+
+		if (!trimmed) throw new Error('表达式不能为空')
+
+		try {
+			const tokens = this._tokenize(trimmed)
+			return this._parseEntry(tokens)
+		} catch (error) {
+			throw new Error(`表达式计算失败: ${error.message}（原表达式：${expr}）`)
+		}
+	}
+}
+
+// 单例导出
+const evaluator = new ExprEvaluator()
+export default evaluator

package/packages/index.js

@@ -1,5 +1,5 @@
 import http from './api'
 import utils from './utils'
-import parser from './parser'
+import expr from './expr'
 
-export { http, utils, parser }
+export default { http, utils, expr }

package/packages/utils/index.js

@@ -24,4 +24,6 @@ XEUtils.mixin({
 	...pattern
 })
 
+window.$vUtils = XEUtils
+
 export default XEUtils

package/packages/utils/number.js

@@ -1,6 +1,6 @@
 import XEUtils from 'xe-utils'
 import stringUtil from './string'
-import formulaParser from '../parser'
+import formulaParser from '../expr'
 
 export default {
 	truncate(num, digits) {
@@ -17,7 +17,6 @@ export default {
 		if (data && XEUtils.isPlainObject(data)) {
 			formula = stringUtil.format(formula, data, true)
 		}
-		let { result } = formulaParser.parse(formula)
-		return result
+		return formulaParser.evaluate(formula)
 	}
 }

package/packages/parser/index.js

@@ -1,4 +0,0 @@
-import { Parser } from 'hot-formula-parser'
-const formulaParser = new Parser()
-
-export default formulaParser