@cloudpss/expression 0.6.0-alpha.1

package/src/expression.ts

@@ -0,0 +1,62 @@
+import type { VmValue } from '@mirascript/mirascript';
+import type { Tagged } from 'type-fest';
+import type { LegacyType, TsTypeOf, TypeInfo } from './type.js';
+import type { Scope } from './scope.js';
+
+/** 表达式的标记属性 */
+export const ExpressionTag = 'ɵexp' as const;
+
+// 使用 `type` 确保 Expression 是一个 VmRecord
+/** 表示一个表达式 */
+export type Expression<T extends VmValue = VmValue> = {
+    /** 标记，表示求值结果的类型，"" 表示无需转换类型 */
+    readonly [ExpressionTag]: TypeInfo | LegacyType | '';
+    /** 表达式内容 */
+    readonly source: ExpressionSource<T>;
+};
+
+/**
+ * 编译后的表达式
+ */
+export interface CompiledExpression<T extends VmValue = VmValue> extends Expression<T> {
+    (scope: Scope, defaults: T): T;
+    (scope?: Scope): T | undefined;
+}
+
+/** 表示一个表达式内容 */
+export type ExpressionSource<T extends VmValue = VmValue> = Tagged<string, 'ExpressionResult', T>;
+
+/** 表示表达式或值 */
+export type ExpressionOrValue<T extends VmValue = VmValue> = Expression<T> | T;
+/** 创建一个指定类型的表达式 */
+export function Expression<S extends TypeInfo | LegacyType>(
+    source: string | Expression<TsTypeOf<S>>,
+    returnType: S,
+): Expression<TsTypeOf<S>>;
+/** 创建一个不转换结果类型的表达式 */
+export function Expression<T extends VmValue = VmValue>(source: string | Expression<T>): Expression<T>;
+
+/** 创建一个表达式 */
+export function Expression<T extends VmValue = VmValue>(
+    source: string | Expression<T>,
+    returnType: TypeInfo | LegacyType | '' = '',
+): Expression<T> {
+    if (!source) throw new Error(`Invalid expression ${String(source)}`);
+    const s = isExpression(source) ? source.source : source;
+    if (!s || typeof s != 'string') throw new Error(`Invalid expression ${String(s)}`);
+    return { [ExpressionTag]: returnType, source: s as ExpressionSource<T> };
+}
+
+/** 检查是否为表达式 */
+export function isExpression<T extends VmValue>(value: unknown): value is Expression<T> | CompiledExpression<T> {
+    if (value == null || (typeof value != 'object' && typeof value != 'function')) return false;
+    return ExpressionTag in value;
+}
+
+/** 表示一个表达式求值的结果 */
+export type ExpressionResult<T> = T extends Expression<infer R> ? R : T;
+
+/** 表示一个含表达式对象求值的结果 */
+export type ExpressionResultObject<T> = {
+    [K in keyof T]: ExpressionResult<T[K]>;
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+export type { Options, Context } from './context.js';
+export { Scope } from './scope.js';
+export { Evaluator } from './main.js';
+export * from './expression.js';
+export * from './type.js';

package/src/main.ts

@@ -0,0 +1,295 @@
+import type { LiteralUnion, SetFieldType } from 'type-fest';
+import { isVmArray, wrapToVmValue, type VmValue } from '@mirascript/mirascript';
+import { lib } from '@mirascript/mirascript/subtle';
+import { klona } from 'klona';
+import { Context, type Options } from './context.js';
+import { parse } from './parser.js';
+import { analyze } from './analyze.js';
+import {
+    type CompiledExpression,
+    Expression,
+    type ExpressionOrValue,
+    ExpressionTag,
+    isExpression,
+} from './expression.js';
+import { evaluate } from './eval.js';
+import { TypeInfo } from './type.js';
+import { Scope } from './scope.js';
+import type {
+    ArgumentMap,
+    ArgumentValue,
+    Choice,
+    ChoiceArgumentValue,
+    ConditionExpression,
+    Parameter,
+    ParameterFunction,
+    ParameterGroup,
+    ParameterMap,
+} from './definitions.js';
+const { isArray } = Array;
+const { to_number, to_string } = lib;
+
+/**
+ * 表达式求值
+ */
+export class Evaluator {
+    constructor(options?: Partial<Options>) {
+        this.context = new Context(options);
+    }
+    /** 选项 */
+    get options(): Options {
+        return this.context.options;
+    }
+
+    /** 上下文 */
+    private readonly context: Context;
+
+    /** 默认执行环境 */
+    private readonly scope = new Scope(undefined, false, '<evaluator>');
+
+    /** 导入到执行环境 */
+    import(values: Record<string, unknown>): void {
+        for (const [key, value] of Object.entries(values)) {
+            if (value === undefined) {
+                this.context.imported.delete(key);
+            } else {
+                this.context.imported.set(key, wrapToVmValue(value, null));
+            }
+        }
+    }
+
+    /**
+     * 编译表达式
+     */
+    compile<T extends VmValue>(expression: Expression<T>, throws = true): CompiledExpression<T> {
+        const value = parse(this.context, expression.source, throws);
+        const tag = expression[ExpressionTag];
+        const type = tag ? TypeInfo.parse(tag) : null;
+        const compiled = ((scope, defaults) => {
+            const ret = evaluate(this.context, value, type, scope, defaults);
+            return ret;
+        }) as CompiledExpression<T>;
+        Object.defineProperty(compiled, ExpressionTag, { value: type, enumerable: true });
+        Object.defineProperty(compiled, 'source', { value: value.source, enumerable: true });
+        return compiled;
+    }
+
+    /**
+     * 求值
+     */
+    evaluate<T extends VmValue>(expression: ExpressionOrValue<T> | undefined, scope?: Scope): T | undefined;
+    /**
+     * 求值
+     */
+    evaluate<T extends VmValue, D = T>(
+        expression: ExpressionOrValue<T> | undefined,
+        scope: Scope | undefined,
+        defaults: D,
+    ): T | D;
+    /**
+     * 求值
+     */
+    evaluate<T extends VmValue, D = T>(
+        expression: ExpressionOrValue<T> | undefined,
+        scope: Scope | undefined,
+        defaults?: D,
+    ): T | D | undefined {
+        if (expression == null) return defaults;
+        if (!isExpression(expression)) return expression;
+        const throws = scope?.throws ?? true;
+        const tag = expression[ExpressionTag];
+        const type = tag ? TypeInfo.parse(tag) : null;
+        const value = parse(this.context, expression.source, throws);
+        const result = evaluate<T, D | undefined>(this.context, value, type, scope ?? this.scope, defaults);
+        return result;
+    }
+
+    /** 求条件 */
+    evaluateCondition(condition: ConditionExpression | undefined, scope: Scope | undefined, defaults = true): boolean {
+        if (typeof condition == 'boolean') return condition;
+        if (condition == null) return defaults;
+        condition = (
+            typeof condition == 'string' ? condition : lib.to_string(condition)
+        ).trim() as ConditionExpression & string;
+        if (condition === '') return defaults;
+        if (condition === 'true') return true;
+        if (condition === 'false') return false;
+        try {
+            return this.evaluate(Expression(condition, 'boolean'), scope, defaults);
+        } catch (ex) {
+            if (scope?.throws) {
+                throw ex;
+            }
+            this.options.logger.warn(`Invalid condition`, ex);
+            return defaults;
+        }
+    }
+
+    /** 求选项列表 */
+    evaluateChoices<V extends ChoiceArgumentValue>(
+        choices: ExpressionOrValue<Array<Choice<V>>> | ParameterFunction<Array<Choice<V>>> | undefined,
+        scope: Scope | undefined,
+    ): ReadonlyArray<SetFieldType<Choice<V>, 'key', V>> {
+        if (choices == null) return [];
+        const result =
+            typeof choices == 'function' ? choices(scope ?? this.scope, this) : this.evaluate(choices, scope, []);
+        if (!isArray(result)) {
+            if (scope?.throws) {
+                throw new Error(`Choices is not an array`);
+            }
+            return [];
+        }
+        return result.map((item, index): SetFieldType<Choice<V>, 'key', V> => {
+            if (item == null) {
+                return { key: index as V, name: String(index), description: '' };
+            }
+            if (typeof item == 'string' || typeof item == 'number' || typeof item == 'boolean') {
+                return { key: item as V, name: String(item), description: '' };
+            }
+            return {
+                key: (item.key ?? index) as V,
+                name: item.name ?? String(item.key ?? index),
+                description: item.description ?? '',
+                condition: item.condition,
+            };
+        });
+    }
+
+    /** 转换参数值的类型 */
+    toArg<V extends ArgumentValue>(value: VmValue, definition: Parameter): V {
+        switch (definition.type as LiteralUnion<keyof ParameterMap, string>) {
+            case 'real':
+            case 'integer':
+                return to_number(value) as V;
+            case 'file':
+            case 'text':
+            case 'code':
+            case 'pinLike':
+            case 'cssColor':
+            case 'cssBackground':
+            case 'resourceId':
+                return to_string(value) as V;
+
+            case 'choice':
+            case 'logical':
+                return value as V;
+
+            case 'multiSelect':
+            case 'table': {
+                if (isVmArray(value)) {
+                    return value as V;
+                }
+                return (value != null ? [value] : []) as ArgumentValue as V;
+            }
+            case 'grouped':
+            case 'record':
+            default:
+                return value as V;
+        }
+    }
+
+    /** 求参数值 */
+    evaluateArg<V extends ArgumentValue>(
+        expression: ExpressionOrValue<V> | undefined,
+        scope: Scope | undefined,
+        definition: Parameter,
+    ): V {
+        const result =
+            this.evaluate<V>(expression ?? (definition.value as ExpressionOrValue<V>), scope) ??
+            (definition.value as V);
+        return this.toArg<V>(result, definition);
+    }
+    /** 求参数表的所有参数值 */
+    evaluateArgs<T extends Record<string, ArgumentValue>>(
+        args: ArgumentMap<T> | undefined,
+        scope: Scope | undefined,
+        definition: ReadonlyArray<Pick<ParameterGroup, 'items'>>,
+    ): T {
+        const a = this.defaultArgs(definition, args);
+        const ret: Record<string, ArgumentValue> = {};
+        for (const group of definition) {
+            for (const param of group.items) {
+                const { key } = param;
+                if (!key) continue;
+                const arg = a[key];
+                ret[key] = this.evaluateArg(arg, scope, param);
+            }
+        }
+        return ret as T;
+    }
+    /** 获取参数默认值，修复现有的参数，并填充缺失的参数 */
+    defaultArgs<T extends Record<string, ArgumentValue>>(
+        definition: ReadonlyArray<Pick<ParameterGroup, 'items'>> | undefined,
+        args: ArgumentMap<T> = {} as ArgumentMap<T>,
+    ): ArgumentMap<T> {
+        if (definition == null || !isArray(definition as unknown[])) {
+            return args;
+        }
+        /** 参数键的类型 */
+        type K = keyof T & string;
+        /** 参数值的类型 */
+        type V = NonNullable<T[K]>;
+        const keys = new Set(Object.keys(args) as K[]);
+
+        // 根据定义填充或修复参数
+        for (const group of definition) {
+            for (const param of group.items) {
+                const key = param.key as K;
+                if (!key) continue;
+                const currentValue = keys.has(key) ? args[key] : undefined;
+                if (currentValue == null) {
+                    // 使用默认值填充
+                    const defaultValue = param.value;
+                    if (isExpression(defaultValue)) {
+                        args[key] = { [ExpressionTag]: '', source: defaultValue.source } as Expression<V>;
+                    } else {
+                        const value =
+                            defaultValue != null && typeof defaultValue == 'object'
+                                ? klona(defaultValue)
+                                : defaultValue;
+                        args[key] = this.toArg<V>(value, param);
+                    }
+                } else {
+                    // 已存在的参数值
+                    if (isExpression(currentValue)) {
+                        // 保留表达式
+                    } else {
+                        // 修复现有的参数值
+                        const castedValue = this.toArg<V>(currentValue, param);
+                        if (castedValue != null && castedValue !== currentValue) {
+                            args[key] = castedValue;
+                        }
+                    }
+                }
+                keys.delete(key);
+            }
+        }
+
+        // 删除多余的参数
+        for (const key of keys) {
+            // 保留特殊参数和私有字段
+            if (key.startsWith('_') || key.startsWith('$') || key.startsWith('@')) continue;
+            delete args[key];
+        }
+        return args;
+    }
+
+    /** 解析表达式 */
+    validate<T extends VmValue>(expression: Expression<T>): void {
+        if (!isExpression(expression) || !expression.source) {
+            throw new Error(`${expression.source || String(expression)} is not a valid expression`);
+        }
+        const tag = expression[ExpressionTag];
+        if (tag) TypeInfo.parse(tag);
+        parse(this.context, expression.source, true);
+    }
+
+    /** 分析表达式 */
+    analyze<T extends VmValue>(expression: Expression<T>): string[][] {
+        if (!isExpression(expression) || !expression.source) {
+            throw new Error(`${expression.source || String(expression)} is not a valid expression`);
+        }
+        const exp = parse(this.context, expression.source, true);
+        return analyze(this.context, exp);
+    }
+}

package/src/migrate.ts

@@ -0,0 +1,25 @@
+import type { VmContext, VmValue } from '@mirascript/mirascript';
+import { BaseState } from './migrator/state.js';
+import type { ExpressionSource } from './expression.js';
+
+/** MathJs 表达式转为 MiraScript 表达式 */
+export function migrateMathJs<const T extends VmValue>(
+    expr: ExpressionSource<T>,
+    condition: boolean,
+    context?: VmContext,
+): ExpressionSource<T> {
+    // 检查输入
+    if (!expr) return '' as ExpressionSource<T>;
+    expr = expr.trim() as ExpressionSource<T>;
+    if (!expr || expr === 'undefined') return '' as ExpressionSource<T>;
+    if (expr === 'null') return 'nil' as ExpressionSource<T>;
+    if (expr === 'true') return 'true' as ExpressionSource<T>;
+    if (expr === 'false') return 'false' as ExpressionSource<T>;
+    if (/^[-+]?(\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)$/.test(expr)) {
+        return expr;
+    }
+
+    const state = new BaseState(expr, condition, context);
+    state.migrate();
+    return state.result() as ExpressionSource<T>;
+}

package/src/migrator/access.ts

@@ -0,0 +1,201 @@
+import {
+    type ConstantNode,
+    isConstantNode,
+    isRangeNode,
+    type AccessorNode,
+    type MathNode,
+    isFunctionNode,
+    isSymbolNode,
+    isAccessorNode,
+    isAssignmentNode,
+    type AssignmentNode,
+} from 'mathjs';
+import type { Result } from './interface.js';
+import { migrateAtomic, migrateExpr } from './node.js';
+import type { State } from './state.js';
+import { unsupportedNode } from './utils.js';
+import { serialize, serializePropName } from '@mirascript/mirascript/subtle';
+
+/** 常量访问 */
+function constIndexing(node: ConstantNode): Result {
+    const { value } = node as ConstantNode<string | number>;
+    if (typeof value == 'string') {
+        return { type: 'string', literal: value, code: serialize(value) };
+    } else if (typeof value == 'number' && Number.isInteger(value) && value > 0) {
+        return { type: 'number', literal: value - 1, code: serialize(value - 1) };
+    } else {
+        return { code: serialize(value) };
+    }
+}
+
+/** 字符串转为数组 */
+function stringToArray(state: State, ret: Result): Result {
+    if (ret.type === 'string') {
+        return {
+            type: 'array',
+            code: `chars(${ret.code})`,
+        };
+    }
+    if (ret.type === 'array') {
+        return ret;
+    }
+    state.helper(`fn @@maybe_chars(x) { if type(x) == 'string' { chars(x) } else { x } }`);
+    return {
+        type: 'array',
+        code: `@@maybe_chars(${ret.code})`,
+    };
+}
+
+/** 访问节点 */
+function accessChain(
+    state: State,
+    object: MathNode,
+    index: ReadonlyArray<string | number>,
+    assignment: boolean,
+): Result {
+    const obj = migrateExpr(state, object);
+    const chain = index.map((i) => {
+        if (typeof i == 'number') return `[${i}]`;
+        const s = serializePropName(i);
+        if (s !== i) return `[${s}]`;
+        return `.${s}`;
+    });
+    if (!assignment && typeof index.at(-1) == 'number') {
+        const prev = chain.slice(0, -1).join('');
+        return {
+            code: `${
+                stringToArray(state, {
+                    code: `${obj.code}${prev}`,
+                }).code
+            }${chain.at(-1)}`,
+        };
+    }
+    return {
+        code: `${migrateExpr(state, object).code}${chain.join('')}`,
+    };
+}
+
+/** 访问节点 */
+function access(
+    state: State,
+    node: MathNode,
+    assignment: boolean,
+): Result | [object: MathNode, index: Array<string | number>] {
+    if (!isAccessorNode(node) && !isAssignmentNode(node)) {
+        return [node, []];
+    }
+    const { object, index } = node;
+    if (!index || index.dimensions.length !== 1 || !index.dimensions[0]) {
+        return unsupportedNode(state, node);
+    }
+    const dim0 = index.dimensions[0];
+
+    if (isRangeNode(dim0)) {
+        const obj = migrateExpr(state, object);
+        if (obj.type === 'array' && !dim0.step && isConstantNode(dim0.start) && isConstantNode(dim0.end)) {
+            const start = constIndexing(dim0.start);
+            const end = constIndexing(dim0.end);
+            if (start.type === 'number' && end.type === 'number') {
+                return {
+                    type: 'array',
+                    code: `${obj.code}[${start.code}..${end.code}]`,
+                };
+            }
+        }
+        const d = unsupportedNode(state, dim0);
+        return {
+            code: `${obj.code}[${d.code}]`,
+        };
+    }
+    if (index.dotNotation) {
+        if (!isConstantNode(dim0)) return unsupportedNode(state, node);
+        const { value } = dim0 as ConstantNode<string | number>;
+        if (typeof value != 'string') return unsupportedNode(state, node);
+        if (!assignment && value === 'length') {
+            const obj = migrateExpr(state, object);
+            if (obj.type === 'string')
+                return {
+                    type: 'number',
+                    code: `len(chars(${obj.code}))`,
+                };
+            if (obj.type === 'array')
+                return {
+                    type: 'number',
+                    code: `len(${obj.code})`,
+                };
+            state.helper(
+                `fn @@length(x) { if type(x) == 'string' { len(chars(x)) } else if type(x) == 'array' { len(x) } } else { x.length } }`,
+            );
+            return {
+                code: `@@length(${obj.code})`,
+            };
+        }
+        const obj = access(state, object, assignment);
+        if (Array.isArray(obj)) {
+            return [obj[0], [...obj[1], value]];
+        }
+        return {
+            code: `${obj.code}.${value}`,
+        };
+    }
+    if (isConstantNode(dim0)) {
+        const index = constIndexing(dim0);
+        if (index.type === 'string') {
+            const obj = access(state, object, assignment);
+            if (Array.isArray(obj)) {
+                return [obj[0], [...obj[1], index.literal as string]];
+            }
+            return { code: `${obj.code}[${index.code}]` };
+        } else if (index.type === 'number') {
+            if (
+                !assignment &&
+                index.literal === 0 &&
+                isFunctionNode(object) &&
+                isSymbolNode(object.fn) &&
+                !state.locals.has('size') &&
+                !('size' in state.globals) &&
+                object.fn.name === 'size' &&
+                object.args.length === 1
+            ) {
+                const el = stringToArray(state, migrateAtomic(state, object.args[0]!));
+                return {
+                    type: 'number',
+                    code: `len(${el.code})`,
+                };
+            }
+            const obj = access(state, object, assignment);
+            if (Array.isArray(obj)) {
+                return [obj[0], [...obj[1], index.literal as number]];
+            }
+            return { code: `${stringToArray(state, obj).code}[${index.code}]` };
+        } else {
+            const obj = migrateExpr(state, object);
+            state.err(`不支持的索引: ${node.toString()}`);
+            return { code: `${obj.code}[${index.code}]` };
+        }
+    }
+    const d0 = migrateAtomic(state, dim0);
+    const obj = migrateExpr(state, object);
+    if (obj.literal && obj.type === 'record') {
+        return {
+            code: `${obj.code}[${d0.code}]`,
+        };
+    }
+    if (obj.literal && obj.type === 'array') {
+        return {
+            code: `${obj.code}[${d0.code} - 1]`,
+        };
+    }
+    state.helper(`fn @@index(index) { if type(index) == 'number' { index - 1 } else { index } }`);
+    return { code: `${obj.code}[@@index(${d0.code})]` };
+}
+
+/** 访问节点 */
+export function migrateAccess(state: State, node: AccessorNode | AssignmentNode): Result {
+    const assignment = isAssignmentNode(node);
+    const ret = access(state, node, assignment);
+    if (Array.isArray(ret)) {
+        return accessChain(state, ret[0], ret[1], assignment);
+    }
+    return ret;
+}