@cloudpss/expression 0.6.0-alpha.1

package/src/migrator/state.ts

@@ -0,0 +1,262 @@
+import { createVmContext, type VmContext } from '@mirascript/mirascript';
+import { parse } from './parser.js';
+import {
+    type AssignmentNode,
+    type FunctionAssignmentNode,
+    isAssignmentNode,
+    isBlockNode,
+    isFunctionAssignmentNode,
+    isSymbolNode,
+    type MathNode,
+} from 'mathjs';
+import type { Result } from './interface.js';
+import { migrateAtomic } from './node.js';
+import { toBoolean } from './to-type.js';
+import { constantValue, symbolName, unsupportedNode } from './utils.js';
+import { migrateAccess } from './access.js';
+import { specialMigrate } from './special.js';
+
+/** 转换 AST */
+function migrateLast(state: State, node: MathNode): Result {
+    if (isAssignmentNode(node)) {
+        if (node.index == null && isSymbolNode(node.object)) {
+            state.loose();
+            node = node.value;
+        } else {
+            return migrateAssignment(state, node);
+        }
+    }
+    if (state.condition) {
+        if (constantValue(node) === null) return migrateAtomic(state, node);
+        return toBoolean(state, node);
+    } else {
+        return migrateAtomic(state, node);
+    }
+}
+/** 转换赋值语句 */
+function migrateAssignment(state: State, node: AssignmentNode): Result {
+    const { object, index, value } = node;
+    const name = symbolName(object);
+    if (name && index == null) {
+        // name = xxx;
+        if (state.locals.has(name)) {
+            state.err(`不支持局部变量重新赋值: ${name}'`);
+            return {
+                code: `${name} = ${migrateAtomic(state, value).code}`,
+            };
+        }
+        const expr = migrateAtomic(state, value);
+        state.locals.set(name, expr);
+        return {
+            code: `let ${name} = ${expr.code};`,
+        };
+    }
+    if (index != null) {
+        state.loose();
+        const access = migrateAccess(state, node);
+        return {
+            code: `${access.code} = ${migrateAtomic(state, value).code};`,
+        };
+    }
+    return unsupportedNode(state, node);
+}
+/** 转换函数定义语句 */
+function migrateFunctionAssignment(state: State, node: FunctionAssignmentNode): Result {
+    state.loose();
+    const { name, params, expr } = node;
+    if (state.locals.has(name)) {
+        state.err(`重复定义函数: ${name}`);
+    }
+    const fState = new FunctionState(state, params);
+    let body = migrateAtomic(fState, expr);
+    if (!(body.code.startsWith('{') && body.code.endsWith('}'))) {
+        body = { ...body, code: `{ ${body.code} }` };
+    }
+    state.locals.set(name, {
+        type: 'function',
+        code: body.code,
+    });
+    return {
+        code: `fn ${name}(${params.join(', ')}) ${body.code}`,
+    };
+}
+
+/** 转换状态 */
+export class BaseState {
+    constructor(
+        private readonly expr: string,
+        readonly condition: boolean,
+        /** 可识别的全局环境 */
+        readonly globals: VmContext = createVmContext(),
+    ) {}
+    /** 帮助函数 */
+    private readonly helpers = new Set<string>();
+    /** 添加帮助函数 */
+    helper(code: string): void {
+        this.helpers.add(code);
+    }
+    /** 产生的警告 */
+    private readonly warnings = new Set<string>();
+    /** 产生的错误 */
+    private readonly errors = new Set<string>();
+    /** 产生的失败 */
+    private readonly critical = new Set<string>();
+    /** 声明的本地变量 / 函数 */
+    readonly locals = new Map<string, Result>();
+    /** 标记为非精确转换 */
+    loose(): void {
+        this.warnings.add(`使用了非精确转换的语法或函数，结果可能不准确`);
+    }
+    /** 标记为非精确转换 */
+    warn(message: string): void {
+        this.warnings.add(message);
+    }
+    /** 标记为非精确转换 */
+    err(message: string): void {
+        this.errors.add(message);
+    }
+    /** 标记为转换失败 */
+    crit(message: string): void {
+        this.critical.add(message);
+    }
+    private readonly ret: string[] = [];
+    /** 转换一个语句 */
+    private migrateStmt(migrator: typeof migrateLast, stmt: boolean, node: MathNode): void {
+        const isFunc = isFunctionAssignmentNode(node);
+        const r = isFunc ? migrateFunctionAssignment(this, node) : migrator(this, node);
+        let { code } = r;
+        if (stmt && !isFunc && !code.endsWith(';')) code += ';';
+        if (node.comment) code += ' //' + node.comment;
+        this.ret.push(code);
+    }
+    /** 转换 */
+    migrate(): void {
+        let ast;
+        try {
+            const e = this.expr.startsWith('=') ? this.expr.slice(1) : this.expr;
+            ast = parse(e);
+        } catch (ex) {
+            this.crit(`解析 math.js 失败: ${(ex as Error).message || String(ex)}`);
+            return;
+        }
+        try {
+            const sp = specialMigrate(this.expr, ast);
+            if (sp != null) {
+                this.ret.push(sp);
+                this.loose();
+                return;
+            }
+            if (isBlockNode(ast)) {
+                const { blocks } = ast;
+                for (const [index, block] of blocks.entries()) {
+                    if (index !== blocks.length - 1 || !block.visible) {
+                        this.migrateStmt(
+                            isAssignmentNode(block.node) ? (migrateAssignment as typeof migrateAtomic) : migrateAtomic,
+                            true,
+                            block.node,
+                        );
+                    } else {
+                        this.migrateStmt(migrateLast, false, block.node);
+                    }
+                }
+                return;
+            } else {
+                this.migrateStmt(migrateLast, false, ast);
+                return;
+            }
+        } catch (ex) {
+            this.crit(`转换失败: ${String(ex)}`.replaceAll('\n', ' '));
+            return;
+        }
+    } /** 获取结果 */
+    result(): string {
+        // 精确转换：产生了结果，没有帮助方法，且未产生错误和警告
+        if (this.ret.length && !this.helpers.size && !this.errors.size && !this.warnings.size && !this.critical.size) {
+            return this.ret.join('\n');
+        }
+
+        // 写入原始 math.js 作为注释
+        const lines = this.expr.split('\n').map((line) => `// ${line}`);
+        lines.unshift(`// # 原始 math.js 表达式`);
+        if (this.errors.size || this.warnings.size || this.critical.size) {
+            const warnings = [...this.warnings];
+            for (let i = warnings.length - 1; i >= 0; i--) {
+                const warn = warnings[i]!;
+                lines.unshift(`// - W: ${warn}`);
+            }
+            const errors = [...this.errors];
+            for (let i = errors.length - 1; i >= 0; i--) {
+                const err = errors[i]!;
+                lines.unshift(`// - E: ${err}`);
+            }
+            const critical = [...this.critical];
+            for (let i = critical.length - 1; i >= 0; i--) {
+                const crit = critical[i]!;
+                lines.unshift(`// - C: ${crit}`);
+            }
+            lines.unshift(`// # 转换日志`);
+        }
+        // 写入转换结果
+        if (this.ret.length) {
+            for (const value of this.helpers) {
+                lines.unshift(value);
+            }
+            if (this.helpers.size) {
+                lines.unshift(`// # 帮助函数`);
+            }
+            for (let i = this.ret.length - 1; i >= 0; i--) {
+                const value = this.ret[i]!;
+                const explicitRet = this.helpers.size && i === this.ret.length - 1 && !value.endsWith(';');
+                const retExpr = explicitRet ? `return ${value};` : value;
+                lines.unshift(retExpr);
+            }
+        }
+        // 添加异常
+        if (!this.ret.length || this.critical.size) {
+            lines.unshift(`panic("无法从 math.js 转换为 MiraScript")`);
+        }
+        return lines.join('\n');
+    }
+}
+/** 转换状态 */
+export type State = Omit<{ [K in keyof BaseState]: BaseState[K] }, 'migrate' | 'result'>;
+/** 函数状态 */
+export class FunctionState implements State {
+    constructor(
+        readonly baseState: State,
+        params: readonly string[],
+    ) {
+        this.locals = new Map(baseState.locals);
+        for (const p of params) {
+            this.locals.set(p, { code: p });
+        }
+    }
+    /** @inheritdoc */
+    readonly condition = false;
+    /** @inheritdoc */
+    get globals(): VmContext {
+        return this.baseState.globals;
+    }
+    /** @inheritdoc */
+    helper(code: string): void {
+        this.baseState.helper(code);
+    }
+    /** @inheritdoc */
+    readonly locals: Map<string, Result>;
+    /** @inheritdoc */
+    loose(): void {
+        this.baseState.loose();
+    }
+    /** @inheritdoc */
+    warn(message: string): void {
+        this.baseState.warn(message);
+    }
+    /** @inheritdoc */
+    err(message: string): void {
+        this.baseState.err(message);
+    }
+    /** @inheritdoc */
+    crit(message: string): void {
+        this.baseState.crit(message);
+    }
+}

package/src/migrator/symbol.ts

@@ -0,0 +1,53 @@
+import type { SymbolNode } from 'mathjs';
+import type { Result } from './interface.js';
+import type { State } from './state.js';
+import { operations } from '@mirascript/mirascript/subtle';
+
+/** 处理符号名称 */
+export function migrateSymbol(state: State, node: SymbolNode, migrateConst: boolean): Result {
+    const { name } = node;
+    const local = state.locals.get(name);
+    if (local) {
+        return {
+            ...local,
+            code: name,
+        };
+    }
+    const global = state.globals.get(name);
+    if (global != null) {
+        return {
+            type: operations.$Type(global),
+            code: name,
+        };
+    }
+    if (name.startsWith('$') || name.startsWith('@')) {
+        return {
+            code: name,
+        };
+    }
+    if (migrateConst) {
+        if (name === 'i') {
+            state.err(`不支持复数`);
+            return {
+                type: 'number',
+                code: `i`,
+            };
+        }
+        if (name === 'pi' || name === 'PI') {
+            return {
+                type: 'number',
+                code: `@pi`,
+            };
+        }
+        if (name === 'e' || name === 'E') {
+            return {
+                type: 'number',
+                code: `@e`,
+            };
+        }
+    }
+    state.warn(`符号 '${name}' 未定义`);
+    return {
+        code: name,
+    };
+}

package/src/migrator/to-type.ts

@@ -0,0 +1,93 @@
+import { isConstantNode, isNode, type MathNode } from 'mathjs';
+import type { Result } from './interface.js';
+import { serialize } from '@mirascript/mirascript/subtle';
+import type { State } from './state.js';
+import { migrateNode } from './node.js';
+
+/** 转换 AST */
+export function toBoolean(state: State, node: MathNode | Result): Result {
+    const helper = (): void => {
+        state.helper("fn @@to_boolean { it != '' && it != 0 && it is not nan && !!it }");
+    };
+    if (!isNode(node)) {
+        if (node.type === 'boolean') return node;
+        if (node.as_boolean) {
+            return {
+                type: 'boolean',
+                code: node.as_boolean,
+            };
+        }
+        helper();
+        return {
+            type: 'boolean',
+            code: `@@to_boolean(${node.code})`,
+        };
+    }
+    if (isConstantNode(node)) {
+        const lit = Boolean(node.value);
+        return {
+            type: 'boolean',
+            literal: lit,
+            code: serialize(lit),
+        };
+    }
+
+    const migrated = migrateNode(state, node, { format: 'no-paren' });
+    return toBoolean(state, migrated);
+}
+
+/** 转换 AST */
+export function toString(state: State, node: MathNode | Result): Result {
+    if (!isNode(node)) {
+        if (node.type === 'string') return node;
+        if (node.as_string) {
+            return {
+                type: 'string',
+                code: node.as_string,
+            };
+        }
+        return {
+            type: 'string',
+            code: `to_string(${node.code})`,
+        };
+    }
+    if (isConstantNode(node)) {
+        const lit = String(node.value);
+        return {
+            type: 'string',
+            literal: lit,
+            code: serialize(lit),
+        };
+    }
+
+    const migrated = migrateNode(state, node, { format: 'no-paren' });
+    return toString(state, migrated);
+}
+
+/** 转换 AST */
+export function toNumber(state: State, node: MathNode | Result): Result {
+    if (!isNode(node)) {
+        if (node.type === 'number') return node;
+        if (node.as_number) {
+            return {
+                type: 'number',
+                code: node.as_number,
+            };
+        }
+        return {
+            type: 'number',
+            code: `to_number(${node.code})`,
+        };
+    }
+    if (isConstantNode(node)) {
+        const lit = Number(node.value);
+        return {
+            type: 'number',
+            literal: lit,
+            code: serialize(lit),
+        };
+    }
+
+    const migrated = migrateNode(state, node, { format: 'no-paren' });
+    return toNumber(state, migrated);
+}

package/src/migrator/utils.ts

@@ -0,0 +1,67 @@
+import { type MathNode, isSymbolNode, isConstantNode } from 'mathjs';
+import type { Result } from './interface.js';
+import type { State } from './state.js';
+import { toString } from './to-type.js';
+import { migrateExpr } from './node.js';
+
+/** 获取 symbol name */
+export function symbolName(node: MathNode): string | undefined {
+    if (!isSymbolNode(node)) return undefined;
+    return node.name;
+}
+
+/** 获取 constant value */
+export function constantValue(node: MathNode): number | string | boolean | null | undefined {
+    if (!isConstantNode(node)) return undefined;
+    return node.value ?? null;
+}
+
+/** 添加转换错误 */
+export function unsupportedNode(state: State, node: MathNode): Result {
+    const str = node.toString();
+    state.crit(`不支持的节点类型 ${node.type}: ${str}`);
+    return {
+        code: `/* ${str} */`,
+    };
+}
+
+/** 可能是矩阵时报错 */
+export function scalar(op: string, state: State, re: Result): Result {
+    if (re.type === 'array') {
+        state.err(`'${op.trim()}' 不支持矩阵`);
+    } else if (!re.type) {
+        state.warn(`'${op.trim()}' 不支持矩阵，计算结果可能不一致`);
+    }
+    return re;
+}
+
+/** 是否可能通过其他类型 toString 得到 */
+function maybeToString(str: string): boolean {
+    // 布尔值和 null/undefined
+    if (str === 'true' || str === 'false' || str === 'null' || str === 'undefined') return true;
+    // 数字
+    if (!Number.isNaN(Number(str))) return true;
+    // Object.toString()
+    if (str.startsWith('[') && str.endsWith(']')) return true;
+    return false;
+}
+
+/** 比较字符串 */
+export function equalText(state: State, op: '==' | '!=', l: MathNode, r: MathNode): Result {
+    const lr = scalar(`${op}/equalText`, state, migrateExpr(state, l));
+    const rr = scalar(`${op}/equalText`, state, migrateExpr(state, r));
+    if (
+        (lr.type === 'string' && rr.type === 'string') ||
+        (typeof lr.literal == 'string' && rr.type !== 'array' && !maybeToString(lr.literal)) ||
+        (typeof rr.literal == 'string' && lr.type !== 'array' && !maybeToString(rr.literal))
+    ) {
+        return {
+            type: 'boolean',
+            code: `${lr.code} ${op} ${rr.code}`,
+        };
+    }
+    return {
+        type: 'boolean',
+        code: `${toString(state, lr).code} ${op} ${toString(state, rr).code}`,
+    };
+}

package/src/parser.ts

@@ -0,0 +1,69 @@
+import { compileSync, type VmScript } from '@mirascript/mirascript';
+import type { Context } from './context.js';
+/** 一般表达式 */
+export interface EvalExpressionCache {
+    /**
+     * 源码
+     */
+    source: string;
+    /**
+     * 求值函数
+     */
+    func: VmScript;
+    /**
+     * 编译错误
+     */
+    error: undefined;
+}
+/** 编译错误表达式 */
+export interface ErrorExpressionCache {
+    /**
+     * 源码
+     */
+    source: string;
+    /**
+     * 求值函数
+     */
+    func: undefined;
+    /**
+     * 编译错误
+     */
+    error: Error;
+}
+
+/**
+ * 表达式缓存
+ */
+export type ExpressionCache = ErrorExpressionCache | EvalExpressionCache;
+/**
+ * 编译表达式
+ */
+function compile(expression: string): ExpressionCache {
+    const compiled = {
+        source: expression,
+    } as ExpressionCache;
+    try {
+        const script = compileSync(expression);
+        compiled.func = script;
+    } catch (ex) {
+        compiled.error = ex as Error;
+    }
+    return compiled;
+}
+
+/**
+ * 解析表达式
+ */
+export function parse(context: Context, expression: string, throws: boolean): ExpressionCache {
+    if (typeof expression != 'string') {
+        throw new TypeError(`${String(expression)} is not a valid expression`);
+    }
+    const v = context.expressionCache.get(expression);
+    if (v) return v;
+    const complied = compile(expression);
+    if (complied.error) {
+        if (throws) throw complied.error;
+    }
+    context.expressionCache.set(expression, complied);
+    return complied;
+}