@cloudpss/template 0.6.14 → 0.6.16

package/src/compiler.ts

@@ -0,0 +1,121 @@
+import { unwrapFromVmValue } from '@mirascript/mirascript';
+import { buildError } from './builder.js';
+import type { TemplateFunction, TemplateOptions } from './index.js';
+import { parseTemplate } from './parser.js';
+import {
+    hasOwn,
+    isError,
+    isArrayBuffer,
+    copyArrayBuffer,
+    stringify,
+    toString,
+    isArrayBufferView,
+    isArray,
+} from './utils.js';
+
+/** 模板序列号 */
+let seq = 0;
+
+const $init = [unwrapFromVmValue] as const;
+const $unwrapFromVmValue = 0;
+
+/** 创建模板 */
+export class TemplateCompiler {
+    constructor(
+        readonly template: unknown,
+        readonly options: Required<TemplateOptions>,
+    ) {}
+    private readonly $: unknown[] = [...$init];
+    /** 放入 $，返回索引 */
+    private use(value: unknown): number {
+        this.$.push(value);
+        return this.$.length - 1;
+    }
+    /** 构建数组 */
+    private buildArray(arr: unknown[]): string {
+        let result = '[';
+        for (let i = 0, len = arr.length; i < len; i++) {
+            result += this.buildValue(arr[i]);
+            result += ',\n';
+        }
+        result += ']';
+        return result;
+    }
+    /** 构建 ArrayBuffer */
+    private buildArrayBuffer(buffer: ArrayBuffer | SharedArrayBuffer): string {
+        const copy = copyArrayBuffer(buffer, 0);
+        return `$[${this.use(copy)}].slice(0)`;
+    }
+    /** 构建 ArrayBufferView */
+    private buildArrayBufferView(view: ArrayBufferView): string {
+        const copy = copyArrayBuffer(view.buffer, view.byteOffset, view.byteLength);
+        return `new ${view.constructor.name}($[${this.use(copy)}].slice(0))`;
+    }
+    /** 构建可能为模板的字符串 */
+    private buildTemplate(value: string): string {
+        const template = parseTemplate(value);
+        if (typeof template == 'string') {
+            return stringify(template);
+        } else {
+            return `$[${$unwrapFromVmValue}]($[${this.use(template.value)}](context))`;
+        }
+    }
+    /** 构建对象 */
+    private buildObject(obj: Record<string, unknown>): string {
+        let result = '{';
+        for (const key in obj) {
+            if (!hasOwn(obj, key)) continue;
+            result += '[';
+            if (this.options.objectKeyMode === 'ignore') {
+                result += stringify(key);
+            } else {
+                result += this.buildTemplate(key);
+            }
+            result += ']:';
+            const value = obj[key];
+            result += this.buildValue(value);
+            result += ',\n';
+        }
+        result += '}';
+        return result;
+    }
+    /** 构建值 */
+    private buildValue(value: unknown): string {
+        if (value === null) return 'null';
+        if (value === undefined) return 'undefined';
+        if (value === true) return 'true';
+        if (value === false) return 'false';
+        if (typeof value == 'function') return 'undefined';
+        if (typeof value == 'symbol') return 'undefined';
+        if (typeof value == 'bigint') return `${value}n`;
+        if (typeof value == 'number') return String(value);
+        if (typeof value == 'string') return this.buildTemplate(value);
+        /* c8 ignore next */
+        if (typeof value != 'object') throw new Error(`Unsupported value: ${toString(value)}`);
+        if (value instanceof Date) return `new Date(${value.getTime()})`;
+        if (value instanceof RegExp) return value.toString();
+        if (isError(value)) return buildError(value);
+        if (isArray(value)) return this.buildArray(value);
+        if (isArrayBuffer(value)) return this.buildArrayBuffer(value);
+        if (isArrayBufferView(value)) return this.buildArrayBufferView(value);
+        return this.buildObject(value as Record<string, unknown>);
+    }
+    /** 构建模板 */
+    build(): TemplateFunction {
+        const source = this.buildValue(this.template);
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-implied-eval, @typescript-eslint/no-unsafe-call
+            const result = new Function(
+                '$',
+                [
+                    `//# sourceURL=cloudpss-template[${seq++}]`, // sourceURL 用于调试
+                    `return (context) => (${source});`,
+                ].join('\n'),
+            )(this.$) as TemplateFunction;
+            return result;
+            /* c8 ignore next 3 */
+        } catch (e) {
+            throw new Error(`Failed to compile template: ${source}\n${(e as Error).message}`, { cause: e });
+        }
+    }
+}

package/src/index.ts

@@ -1,4 +1,60 @@
-export { parseTemplate, parseInterpolation } from './parser.js';
-export type { Template, FormulaTemplate, InterpolationTemplate } from './parser.js';
-export { template } from './template/index.js';
-export type { TemplateFunction, TemplateOptions } from './template/index.js';
+import type { VmContext } from '@mirascript/mirascript';
+import { TemplateCompiler } from './compiler.js';
+
+export {
+    type VmContext,
+    VmError,
+    VmExtern,
+    VmModule,
+    VmFunction,
+    type VmAny,
+    type VmArray,
+    type VmConst,
+    type VmImmutable,
+    type VmPrimitive,
+    type VmScript,
+    type VmRecord,
+    type VmUninitialized,
+    type VmValue,
+    createVmContext,
+    isVmContext,
+    isVmExtern,
+    isVmModule,
+    isVmFunction,
+    isVmValue,
+    isVmAny,
+    isVmArray,
+    isVmCallable,
+    isVmConst,
+    isVmImmutable,
+    isVmPrimitive,
+    isVmRecord,
+    isVmScript,
+    isVmWrapper,
+    wrapToVmValue,
+    unwrapFromVmValue,
+    configCheckpoint,
+} from '@mirascript/mirascript';
+
+/** 模板选项 */
+export interface TemplateOptions {
+    /**
+     * 对 object key 的处理方式
+     * - `template` 使用模板进行插值
+     * - `ignore` 原样输出
+     * @default 'template'
+     */
+    objectKeyMode?: 'template' | 'ignore';
+}
+
+/** 已编译的模板函数 */
+export type TemplateFunction<T = unknown> = (context?: VmContext) => T;
+
+/** 创建模板 */
+export function template<T = unknown>(template: T, options: TemplateOptions = {}): TemplateFunction<T> {
+    const opt: Required<TemplateOptions> = {
+        objectKeyMode: 'template',
+        ...options,
+    };
+    return new TemplateCompiler(template, opt).build() as TemplateFunction<T>;
+}

package/src/parser.ts

@@ -1,173 +1,41 @@
-/** 公式模板 */
-export type FormulaTemplate = {
-    type: 'formula';
-    value: string;
-};
-
-/** 字符串插值模板 */
-export type InterpolationTemplate = {
-    type: 'interpolation';
-    templates: string[];
-    values: string[];
-};
+import { compileSync, type VmScript } from '@mirascript/mirascript';
+import { LRUCache } from 'lru-cache';
 
 /** 字符串模板 */
-export type Template = string | FormulaTemplate | InterpolationTemplate;
+export type Template =
+    | string
+    | {
+          type: TemplateType;
+          value: VmScript;
+      };
 
 /** 字符串模板类型 */
-export type TemplateType = (Template & object)['type'];
-
-const PARSER_STATUS_TEXT = 0;
-const PARSER_STATUS_EXPRESSION_SIMPLE = 1;
-const PARSER_STATUS_EXPRESSION_COMPLEX = 2;
-/** 解析状态机 */
-type ParserStatus =
-    | typeof PARSER_STATUS_TEXT
-    | typeof PARSER_STATUS_EXPRESSION_SIMPLE
-    | typeof PARSER_STATUS_EXPRESSION_COMPLEX;
-
-/** 检查字符满足 [a-zA-Z0-9_] */
-function isIdentifierChar(char: string): boolean {
-    // eslint-disable-next-line unicorn/prefer-code-point
-    const charCode = char.charCodeAt(0);
-    return (
-        (charCode >= 97 && charCode <= 122) ||
-        (charCode >= 65 && charCode <= 90) ||
-        (charCode >= 48 && charCode <= 57) ||
-        charCode === 95
-    );
-}
-
-/** 检查字符满足 [a-zA-Z_] */
-function isIdentifierFirstChar(char: string): boolean {
-    // eslint-disable-next-line unicorn/prefer-code-point
-    const charCode = char.charCodeAt(0);
-    return (charCode >= 97 && charCode <= 122) || (charCode >= 65 && charCode <= 90) || charCode === 95;
-}
-
-/** 字符串插值模板标识符 */
-const INTERPOLATION_CHAR = '$';
-/** 字符串插值模板表达式开始标识符 */
-const INTERPOLATION_EXPRESSION_START = ['{', '[', '<', '('];
-/** 字符串插值模板表达式结束标识符 */
-const INTERPOLATION_EXPRESSION_END = ['}', ']', '>', ')'];
-
-/**
- * 解析字符串插值模板
- * @example parseInterpolationImpl("hello $name! I am $age years old. I'll be ${age+1} next year. Give me $$100.")
- * // {
- * //   type: 'interpolation',
- * //   templates: ['hello ', '! I am ', ' years old. I\'ll be ', ' next year. Give me $$100.'],
- * //   values: ['name', 'age', 'age+1']
- * // }
- */
-function parseInterpolationImpl(template: string, start: number, length: number): InterpolationTemplate {
-    const templates: string[] = [];
-    const values: string[] = [];
-    let currentTemplate = '';
-    let currentValue = '';
-    let expressionComplexDepth = 0;
-    let status: ParserStatus = PARSER_STATUS_TEXT;
-    let complexExpressionStartType = -1;
-
-    const end = start + length - 1;
-    for (let i = start; i <= end; i++) {
-        if (status === PARSER_STATUS_TEXT) {
-            const nextInterpolationChar = template.indexOf(INTERPOLATION_CHAR, i);
-            if (nextInterpolationChar < 0 || nextInterpolationChar >= end) {
-                // No more interpolation
-                currentTemplate += template.slice(i, end + 1);
-                break;
-            }
-            currentTemplate += template.slice(i, nextInterpolationChar);
-            i = nextInterpolationChar;
-            const nextChar = template.charAt(nextInterpolationChar + 1);
-
-            complexExpressionStartType = INTERPOLATION_EXPRESSION_START.indexOf(nextChar);
-            if (complexExpressionStartType >= 0) {
-                // Start of complex expression
-                templates.push(currentTemplate);
-                currentTemplate = '';
-                status = PARSER_STATUS_EXPRESSION_COMPLEX;
-                expressionComplexDepth = 1;
-                i++;
-                continue;
-            }
-            if (isIdentifierFirstChar(nextChar)) {
-                // Start of simple expression
-                templates.push(currentTemplate);
-                currentTemplate = '';
-                currentValue = nextChar;
-                status = PARSER_STATUS_EXPRESSION_SIMPLE;
-                i++;
-                continue;
-            }
-            // Not an expression
-            currentTemplate += INTERPOLATION_CHAR;
-            continue;
-        }
-        const char = template.charAt(i);
-        if (status === PARSER_STATUS_EXPRESSION_SIMPLE) {
-            if (isIdentifierChar(char)) {
-                currentValue += char;
-                continue;
-            }
-            // End of expression
-            values.push(currentValue);
-            currentValue = '';
-            status = PARSER_STATUS_TEXT;
-            i--;
-            continue;
-        }
-        if (status === PARSER_STATUS_EXPRESSION_COMPLEX) {
-            if (char === INTERPOLATION_EXPRESSION_START[complexExpressionStartType]) {
-                expressionComplexDepth++;
-            } else if (char === INTERPOLATION_EXPRESSION_END[complexExpressionStartType]) {
-                expressionComplexDepth--;
-                if (expressionComplexDepth === 0) {
-                    // End of expression
-                    values.push(currentValue.trim());
-                    currentValue = '';
-                    status = PARSER_STATUS_TEXT;
-                    continue;
-                }
-            }
-            currentValue += char;
-            continue;
-        }
-    }
-    if (status === PARSER_STATUS_TEXT) {
-        templates.push(currentTemplate);
-    } else if (status === PARSER_STATUS_EXPRESSION_SIMPLE) {
-        values.push(currentValue);
-        templates.push('');
-    } else {
-        throw new Error('Unexpected end of input');
-    }
+export type TemplateType = 'interpolation' | 'formula';
 
-    return {
-        type: 'interpolation',
-        templates,
-        values,
-    };
-}
+const CACHE_SIZE = 100;
 
-/**
- * 解析字符串插值模板
- * @example parseInterpolation("hello $name! I am $age years old. I'll be ${age+1} next year. And $(2*age) after $<age> years.")
- * // {
- * //   type: 'interpolation',
- * //   templates: ['hello ', '! I am ', ' years old. I\'ll be ', ' next year. And ', ' after ', ' years.'],
- * //   values: ['name', 'age', 'age+1', '2*age', 'age']
- * // }
- */
-export function parseInterpolation(template: string, start?: number, length?: number): InterpolationTemplate {
-    start ??= 0;
-    length ??= template.length - start;
-    if (start < 0 || start > template.length) throw new Error('start out of range');
-    if (length < 0 || start + length > template.length) throw new Error('length out of range');
-    return parseInterpolationImpl(template, start, length);
-}
+const formula = new LRUCache<string, Template & { type: 'formula' }>({
+    max: CACHE_SIZE,
+    memoMethod: (template: string) => {
+        const formula = template.slice(1);
+        const value = compileSync(formula, { input_mode: 'Script' });
+        return {
+            type: 'formula',
+            value: value,
+        };
+    },
+});
+const interpolation = new LRUCache<string, Template & { type: 'interpolation' }>({
+    max: CACHE_SIZE,
+    memoMethod: (template: string) => {
+        const expr = template.slice(1);
+        const value = compileSync(expr, { input_mode: 'Template' });
+        return {
+            type: 'interpolation',
+            value: value,
+        };
+    },
+});
 
 /**
  * 解析字符串模板
@@ -177,18 +45,12 @@ export function parseInterpolation(template: string, start?: number, length?: nu
  * - 否则表示是一个普通字符串
  */
 export function parseTemplate(template: string): Template {
-    if (!template) return '';
     if (template.length <= 1) return template;
     if (template.startsWith('=')) {
-        return {
-            type: 'formula',
-            value: template.slice(1),
-        };
+        return formula.memo(template);
     }
     if (template.startsWith('$')) {
-        const result = parseInterpolationImpl(template, 1, template.length - 1);
-        if (result.values.length === 0) return result.templates[0]!;
-        return result;
+        return interpolation.memo(template);
     }
     return template;
 }

package/src/utils.ts

@@ -0,0 +1,50 @@
+/** 是否为 ArrayBuffer */
+export let isArrayBuffer: (value: object) => value is ArrayBuffer | SharedArrayBuffer;
+
+/** 是否为 Error */
+export let isError: (value: unknown) => value is Error;
+
+declare global {
+    /** @inheritdoc */
+    interface ErrorConstructor {
+        /** @inheritdoc */
+        isError?(this: void, value: unknown): value is Error;
+    }
+}
+
+if (typeof Error.isError == 'function') {
+    isError = Error.isError;
+}
+
+if (typeof process == 'object' && typeof process.getBuiltinModule == 'function') {
+    const typeUtils = process.getBuiltinModule('node:util/types');
+    isArrayBuffer = typeUtils.isAnyArrayBuffer;
+    isError = typeUtils.isNativeError;
+}
+
+isError ??= (value: unknown): value is Error => {
+    return value instanceof Error;
+};
+
+isArrayBuffer ??= (value: object): value is ArrayBuffer | SharedArrayBuffer => {
+    const tag = toString(value);
+    return tag === '[object ArrayBuffer]' || tag === '[object SharedArrayBuffer]';
+};
+
+/**
+ * Object.prototype.toString.call 的快捷方式
+ */
+// eslint-disable-next-line @typescript-eslint/unbound-method
+export const toString = Function.call.bind(Object.prototype.toString) as (value: unknown) => string;
+export const { hasOwn } = Object;
+export const { isArray } = Array;
+export const isArrayBufferView = ArrayBuffer.isView.bind(ArrayBuffer);
+export const { stringify } = JSON;
+/**
+ * 获取 ArrayBuffer 的拷贝
+ */
+export function copyArrayBuffer(buffer: ArrayBuffer | SharedArrayBuffer, start: number, length?: number): ArrayBuffer {
+    const copy = new ArrayBuffer(length ?? buffer.byteLength - start);
+    new Uint8Array(copy).set(new Uint8Array(buffer, start, length));
+    return copy;
+}

package/tests/template.ts

@@ -1,6 +1,5 @@
 import { randomBytes, randomFillSync } from 'node:crypto';
-import { setTimeout as timeout } from 'node:timers/promises';
-import { template } from '@cloudpss/template';
+import { template, createVmContext } from '@cloudpss/template';
 
 describe('template', () => {
     it('should handle primitives', () => {
@@ -147,7 +146,7 @@ describe('template', () => {
             randomFillSync(new Uint8Array(buffer));
             const result = template(buffer)();
             expect(new Uint8Array(result)).toEqual(new Uint8Array(buffer));
-            expect(result).toBeInstanceOf(SharedArrayBuffer);
+            expect(result).toBeInstanceOf(ArrayBuffer);
             expect(result).not.toBe(buffer);
         });
     });
@@ -199,9 +198,11 @@ describe('template', () => {
     });
     it('should build interpolated strings', () => {
         const t = template({ hello: '$Hello, ${name}!', not: 'Hello $name', array: ['$$name', '$not'] });
-        const result = t({
-            name: 'world',
-        });
+        const result = t(
+            createVmContext({
+                name: 'world',
+            }),
+        );
         expect(result).toEqual({
             hello: 'Hello, world!',
             not: 'Hello $name',
@@ -227,7 +228,7 @@ describe('template', () => {
     describe('should work while objectKeyMode is', () => {
         it('template', () => {
             const obj = { $: 1, _: 2, '=x': 3, $$y: 4 };
-            const result = template(obj, { objectKeyMode: 'template' })({ x: 11n, y: 12 });
+            const result = template(obj, { objectKeyMode: 'template' })(createVmContext({}, { x: 11n, y: 12 }));
             expect(result).toEqual({
                 $: 1,
                 _: 2,
@@ -237,7 +238,7 @@ describe('template', () => {
         });
         it('ignore', () => {
             const obj = { $: 1, _: 2, '=x': 3, $$y: 4 };
-            const result = template(obj, { objectKeyMode: 'ignore' })({ x: 11n, y: 12 });
+            const result = template(obj, { objectKeyMode: 'ignore' })(createVmContext({}, { x: 11n, y: 12 }));
             expect(result).toEqual({
                 $: 1,
                 _: 2,
@@ -247,62 +248,22 @@ describe('template', () => {
         });
     });
 
-    describe('should work with default evaluator', () => {
-        it('with formula', () => {
-            const obj = { a: '=a', b: '=b' };
-            const result = template(obj)({ a: 1 });
-            expect(result).toEqual({ a: 1, b: undefined });
-        });
-        it('with interpolation', () => {
-            const obj = { a: '$$a', b: '$$b' };
-            const result = template(obj)({ a: 1 });
-            expect(result).toEqual({ a: '1', b: '' });
-        });
-    });
-    describe('should work with custom evaluator', () => {
+    describe('should work with evaluator', () => {
         it('with formula', () => {
-            const obj = { a: '=a', b: '=b' };
-            const result = template(obj, {
-                evaluator: {
-                    inject: { a: 'abcd', b: 11n },
-                    compile: (expression) => `evaluator.${expression}`,
-                },
-            })({ a: 1 });
-            expect(result).toEqual({ a: 'abcd', b: 11n });
+            const obj = { a: '=a', b: '=b', complex: '=a + (b ?? 1)' };
+            const result = template(obj)(createVmContext({ a: 1, b: undefined }));
+            expect(result).toEqual({ a: 1, b: null, complex: 2 });
         });
         it('with interpolation', () => {
-            const obj = { a: '$$a', b: '$$b' };
-            const result = template(obj, {
-                evaluator: {
-                    inject: { a: 'abcd', b: 11n },
-                    compile: (expression) => `evaluator.${expression}`,
-                },
-            })({ a: 1 });
-            expect(result).toEqual({ a: 'abcd', b: '11' });
-        });
-    });
-    describe('should work with async evaluator', () => {
-        it('with formula', async () => {
-            const obj = { a: '=a', b: '=b' };
-            const result = template(obj, {
-                evaluator: {
-                    inject: { a: 'abcd', b: 11n, timeout },
-                    async: true,
-                    compile: (expression) => `await evaluator.timeout(100, evaluator.${expression})`,
-                },
-            })({ a: 1 });
-            await expect(result).resolves.toEqual({ a: 'abcd', b: 11n });
+            const obj = { a: '$$a', b: '$$b', complex: '$Value is ${a}-${b}' };
+            const result = template(obj)(createVmContext({ a: 1, b: undefined }));
+            expect(result).toEqual({ a: '1', b: '', complex: 'Value is 1-' });
         });
-        it('with interpolation', async () => {
-            const obj = { a: '$$a', b: '$$b' };
-            const result = template(obj, {
-                evaluator: {
-                    inject: { a: 'abcd', b: 11n, timeout },
-                    async: true,
-                    compile: (expression) => `await evaluator.timeout(100, evaluator.${expression})`,
-                },
-            })({ a: 1 });
-            await expect(result).resolves.toEqual({ a: 'abcd', b: '11' });
+        it('has extern values', () => {
+            const obj = { a: '=ab', b: '$$(ta.length)', t: '=ta' };
+            const externValues = { ab: new ArrayBuffer(8), ta: new Uint8Array(4) };
+            const result = template(obj)(createVmContext({}, externValues));
+            expect(result).toEqual({ a: externValues.ab, b: '4', t: externValues.ta });
         });
     });
 });

package/dist/template/compiler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../../src/template/compiler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAuBpE,WAAW;AACX,qBAAa,gBAAgB;IAErB,QAAQ,CAAC,QAAQ,EAAE,OAAO;IAC1B,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC;gBADlC,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC;IAE/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,WAAW;IACX,OAAO,CAAC,SAAS;IAOjB,YAAY;IACZ,OAAO,CAAC,WAAW;IAgBnB,eAAe;IACf,OAAO,CAAC,UAAU;IAUlB,WAAW;IACX,OAAO,CAAC,UAAU;IAGlB,qBAAqB;IACrB,OAAO,CAAC,gBAAgB;IAIxB,yBAAyB;IACzB,OAAO,CAAC,oBAAoB;IAI5B,WAAW;IACX,OAAO,CAAC,WAAW;IAqBnB,UAAU;IACV,OAAO,CAAC,UAAU;IAoBlB,WAAW;IACX,KAAK,IAAI,gBAAgB;CAwB5B"}