@cloudpss/expression 0.6.0-alpha.1 → 0.6.0-alpha.11

package/src/main.ts

@@ -1,116 +1,198 @@
-import type { LiteralUnion, SetFieldType } from 'type-fest';
-import { isVmArray, wrapToVmValue, type VmValue } from '@mirascript/mirascript';
+import { isVmFunction, isVmPrimitive, wrapToVmValue, type VmValue } from '@mirascript/mirascript';
 import { lib } from '@mirascript/mirascript/subtle';
-import { klona } from 'klona';
-import { Context, type Options } from './context.js';
+import { defaultOptions, type Logger, type Options } from './interface.js';
 import { parse } from './parser.js';
-import { analyze } from './analyze.js';
+import { analyze, type AccessChain } from './analyze.js';
 import {
     type CompiledExpression,
     Expression,
+    type ExpressionFunction,
     type ExpressionOrValue,
+    type ExpressionSource,
     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,
+import {
+    enumType,
+    fillArgumentMap,
+    toArgumentValue,
+    type ArgumentMap,
+    type ArgumentValue,
+    type Choice,
+    type ChoiceParameterType,
+    type ConditionExpression,
+    type Parameter,
+    type ParameterGroup,
+    type ParameterMap,
 } from './definitions.js';
 const { isArray } = Array;
-const { to_number, to_string } = lib;
+const { defineProperty } = Object;
+const { to_string } = lib;
+
+/** 选项类型 */
+export type EvaluatedChoices<T extends ChoiceParameterType> = {
+    [K in T]: ParameterMap[K] extends { choices?: infer C } ? (C extends readonly unknown[] ? C : never) : never;
+}[T];
 
 /**
  * 表达式求值
  */
 export class Evaluator {
-    constructor(options?: Partial<Options>) {
-        this.context = new Context(options);
-    }
-    /** 选项 */
-    get options(): Options {
-        return this.context.options;
+    constructor(options?: Partial<Options> | null) {
+        this.options = options ?? defaultOptions;
     }
 
-    /** 上下文 */
-    private readonly context: Context;
+    /** Logger */
+    get logger(): Logger {
+        return this.options.logger ?? console;
+    }
+    /** 选项 */
+    readonly options: Readonly<Partial<Options>>;
 
     /** 默认执行环境 */
-    private readonly scope = new Scope(undefined, false, '<evaluator>');
+    private readonly scope = new Scope(null, true, '<evaluator>');
 
-    /** 导入到执行环境 */
+    private readonly __imported = new Map<string, VmValue>();
+    /** 执行环境 */
+    get imported(): ReadonlyMap<string, VmValue> {
+        return this.__imported;
+    }
+    /**
+     * 导入到执行环境
+     *
+     * 使用 `undefined` 删除已导入的变量
+     */
     import(values: Record<string, unknown>): void {
         for (const [key, value] of Object.entries(values)) {
             if (value === undefined) {
-                this.context.imported.delete(key);
+                this.__imported.delete(key);
             } else {
-                this.context.imported.set(key, wrapToVmValue(value, null));
+                this.__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 value = parse(this, expression.source, throws, false);
         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;
+        const type = tag ? TypeInfo.parse(tag) : '';
+        const compiled: ExpressionFunction<T> = (scope, evaluator) => {
+            const ret = evaluate<T>(evaluator, value, scope);
+            if (ret == null) return null;
+            if (!type) return ret;
+            return TypeInfo.to(ret, type) as T;
+        };
+        defineProperty(compiled, ExpressionTag, { value: type, enumerable: true });
+        defineProperty(compiled, 'source', { value: value.source, enumerable: true });
+        return compiled as CompiledExpression<T>;
     }
 
-    /**
-     * 求值
-     */
-    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,
+    /** 执行 MiraScript 模板 */
+    template(template: string | null | undefined, scope: Scope | undefined): string {
+        if (template == null) return '';
+        const throws = scope?.throws ?? true;
+        const value = parse(this, template, throws, true);
+        const result = evaluate<string>(this, value, scope ?? this.scope) ?? template;
+        if (typeof result == 'string') return result;
+        return to_string(result);
+    }
+
+    /** 求值 */
+    evaluate<T extends VmValue>(
+        expression: ExpressionOrValue<T> | ExpressionFunction<T> | null | undefined,
+        scope?: Scope | null,
+    ): T | null;
+    /** 求值 */
+    evaluate<T extends VmValue, const D = NonNullable<T>>(
+        expression: ExpressionOrValue<T> | ExpressionFunction<T> | null | undefined,
+        scope: Scope | null | undefined,
         defaults: D,
-    ): T | D;
-    /**
-     * 求值
-     */
-    evaluate<T extends VmValue, D = T>(
-        expression: ExpressionOrValue<T> | undefined,
-        scope: Scope | undefined,
-        defaults?: D,
-    ): T | D | undefined {
+    ): NonNullable<T> | D;
+    /** 求值 */
+    evaluate<T>(expression: ExpressionFunction<T> | T | null | undefined, scope?: Scope | null): T | null;
+    /** 求值 */
+    evaluate<T, const D = NonNullable<T>>(
+        expression: ExpressionFunction<T> | T | null | undefined,
+        scope: Scope | null | undefined,
+        defaults: D,
+    ): NonNullable<T> | D;
+
+    /** 求值 */
+    evaluate<T extends VmValue, const D = NonNullable<T>>(
+        expression: ExpressionOrValue<T> | ExpressionFunction<T> | null | undefined,
+        scope: Scope | null | undefined,
+        defaults: D | null = null,
+    ): T | D | null {
         if (expression == null) return defaults;
-        if (!isExpression(expression)) return expression;
-        const throws = scope?.throws ?? true;
+
+        if (typeof expression == 'function' && !isVmFunction(expression)) {
+            try {
+                const ret = expression(scope ?? this.scope, this);
+                if (ret == null) return defaults;
+                return ret;
+            } catch (ex) {
+                if (scope?.throws ?? true) {
+                    throw ex;
+                }
+                return defaults;
+            }
+        }
+
+        if (!isExpression<T>(expression)) {
+            return expression;
+        }
+
+        const result = this.evaluateSource(expression.source, scope);
+        if (result == null) return defaults;
+
         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);
+        if (!tag) return result;
+        return TypeInfo.to(result, tag) as T;
+    }
+
+    /** 求值 */
+    evaluateSource<T extends VmValue>(
+        expression: ExpressionSource<T> | T | null | undefined,
+        scope: Scope | null | undefined,
+    ): T | null;
+    /** 求值 */
+    evaluateSource<T extends VmValue, const D = NonNullable<T>>(
+        expression: ExpressionSource<T> | T | null | undefined,
+        scope: Scope | null | undefined,
+        defaults: D,
+    ): NonNullable<T> | D;
+
+    /** 求值 */
+    evaluateSource<T extends VmValue, const D = NonNullable<T>>(
+        expression: ExpressionSource<T> | T | null | undefined,
+        scope: Scope | null | undefined,
+        defaults: D | null = null,
+    ): NonNullable<T> | D | null {
+        if (expression == null) return defaults;
+        if (typeof expression != 'string') return expression;
+
+        scope ??= this.scope;
+        const { throws } = scope;
+        const value = parse(this, expression, throws, false);
+        const result = evaluate<T>(this, value, scope);
+        if (result == null) return defaults;
+
         return result;
     }
 
     /** 求条件 */
-    evaluateCondition(condition: ConditionExpression | undefined, scope: Scope | undefined, defaults = true): boolean {
+    evaluateCondition(
+        condition: ConditionExpression | null | undefined,
+        scope: Scope | null | 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;
+        condition = to_string(condition).trim() as ConditionExpression & string;
         if (condition === '') return defaults;
         if (condition === 'true') return true;
         if (condition === 'false') return false;
@@ -120,92 +202,83 @@ export class Evaluator {
             if (scope?.throws) {
                 throw ex;
             }
-            this.options.logger.warn(`Invalid condition`, ex);
+            this.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`);
+    evaluateChoices<T extends ChoiceParameterType>(
+        definition: Pick<ParameterMap[T], 'type' | 'choices'>,
+        scope: Scope | null | undefined,
+    ): EvaluatedChoices<T> {
+        const ret: Choice[] = [];
+        const { type, choices } = definition;
+        if (choices != null) {
+            const result = this.evaluate(choices, scope);
+            if (result == null) {
+                // do nothing
+            } else if (!isArray(result as unknown[])) {
+                if (scope?.throws ?? true) {
+                    throw new Error(`Choices is not an array`);
+                }
+            } else {
+                const len = result.length;
+                for (let i = 0; i < len; i++) {
+                    const item = result[i];
+                    if (item == null) {
+                        ret[i] = { key: i, name: String(i), description: '', condition: undefined };
+                    } else if (isVmPrimitive(item)) {
+                        ret[i] = { key: item, name: String(item), description: '', condition: undefined };
+                    } else {
+                        const key = item.key ?? i;
+                        ret[i] = {
+                            key,
+                            name: item.name ?? String(key),
+                            description: item.description ?? '',
+                            condition: item.condition || undefined,
+                        };
+                    }
+                }
             }
-            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;
+        if (type === 'logical') {
+            if (ret.length >= 2) {
+                ret.length = 2;
+            } else {
+                const type = enumType(definition) ?? 'boolean';
+                const keys = type === 'boolean' ? [false, true] : type === 'number' ? [0, 1] : ['0', '1'];
+                while (ret.length < 2) {
+                    ret.push({
+                        key: keys[ret.length]!,
+                        name: '',
+                        description: '',
+                        condition: undefined,
+                    });
                 }
-                return (value != null ? [value] : []) as ArgumentValue as V;
             }
-            case 'grouped':
-            case 'record':
-            default:
-                return value as V;
         }
+        return ret as EvaluatedChoices<T>;
     }
 
     /** 求参数值 */
     evaluateArg<V extends ArgumentValue>(
-        expression: ExpressionOrValue<V> | undefined,
-        scope: Scope | undefined,
+        expression: ExpressionOrValue<V> | null | undefined,
+        scope: Scope | null | 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);
+        // 默认值有可能为表达式，因此需要先填充再求值
+        expression ??= definition.value as ExpressionOrValue<V>;
+        const result = this.evaluate<V>(expression, scope, definition.value as V);
+        return toArgumentValue<V>(result, definition);
     }
     /** 求参数表的所有参数值 */
     evaluateArgs<T extends Record<string, ArgumentValue>>(
-        args: ArgumentMap<T> | undefined,
-        scope: Scope | undefined,
+        args: ArgumentMap<T> | null | undefined,
+        scope: Scope | null | undefined,
         definition: ReadonlyArray<Pick<ParameterGroup, 'items'>>,
     ): T {
-        const a = this.defaultArgs(definition, args);
+        const a = fillArgumentMap(definition, args);
         const ret: Record<string, ArgumentValue> = {};
         for (const group of definition) {
             for (const param of group.items) {
@@ -217,63 +290,6 @@ export class Evaluator {
         }
         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) {
@@ -281,15 +297,18 @@ export class Evaluator {
         }
         const tag = expression[ExpressionTag];
         if (tag) TypeInfo.parse(tag);
-        parse(this.context, expression.source, true);
+        parse(this, expression.source, true, false);
     }
 
     /** 分析表达式 */
-    analyze<T extends VmValue>(expression: Expression<T>): string[][] {
+    analyze<T extends VmValue>(expression: Expression<T>, scope?: Scope | null): readonly AccessChain[] {
         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);
+        scope ??= this.scope;
+        const exp = parse(this, expression.source, scope.throws, false);
+        // 如果 throws=true，则 parse 会抛出错误，此处有 error 一定是 throws=false 的情况
+        if (exp.error) return [];
+        return analyze(exp, this, scope);
     }
 }

package/src/migrate.ts

@@ -1,12 +1,16 @@
-import type { VmContext, VmValue } from '@mirascript/mirascript';
-import { BaseState } from './migrator/state.js';
+import type { VmValue } from '@mirascript/mirascript';
+import type { Scope } from './scope.js';
 import type { ExpressionSource } from './expression.js';
+import { BaseState } from './migrator/state.js';
+import { Evaluator } from './main.js';
+import { DefaultVmContext } from '@mirascript/mirascript/subtle';
 
+const evaluator = new Evaluator();
 /** MathJs 表达式转为 MiraScript 表达式 */
 export function migrateMathJs<const T extends VmValue>(
     expr: ExpressionSource<T>,
     condition: boolean,
-    context?: VmContext,
+    context: Scope | undefined,
 ): ExpressionSource<T> {
     // 检查输入
     if (!expr) return '' as ExpressionSource<T>;
@@ -15,11 +19,31 @@ export function migrateMathJs<const T extends VmValue>(
     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 (condition) {
+        // 兼容旧的 evaluateCondition 的宽容处理
+        if (expr === 'True' || expr === 'TRUE' || expr === '1' || expr === '"1"' || expr === "'1'")
+            return 'true' as ExpressionSource<T>;
+        if (
+            expr === 'False' ||
+            expr === 'FALSE' ||
+            expr === '0' ||
+            expr === '"0"' ||
+            expr === "'0'" ||
+            expr === '""' ||
+            expr === "''"
+        )
+            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>;
+    const dispose = context?.reset(evaluator);
+    try {
+        const state = new BaseState(expr, condition, context ? context.proxy : DefaultVmContext);
+        state.migrate();
+        return state.result() as ExpressionSource<T>;
+    } finally {
+        dispose?.();
+    }
 }