@mirascript/mirascript 0.1.92 → 0.1.93

package/src/helpers/serialize.ts

@@ -1,397 +0,0 @@
-import { REG_IDENTIFIER_FULL, REG_ORDINAL_FULL } from '@mirascript/constants';
-import type { VmArray, VmExtern, VmFunction, VmModule, VmAny, VmRecord } from '../vm/index.js';
-import { entries, hasOwn } from '../helpers/utils.js';
-import {
-    getVmFunctionInfo,
-    isVmArray,
-    isVmArrayLikeRecordByEntries,
-    isVmExtern,
-    isVmFunction,
-    isVmModule,
-    isVmRecord,
-} from './types/index.js';
-import { numberToString } from './convert/string.js';
-
-/** 序列化 nil 值 */
-export function serializeNil(): string {
-    return 'nil';
-}
-
-/** 序列化布尔值 */
-export function serializeBoolean(value: boolean): string {
-    return value ? 'true' : 'false';
-}
-
-/** 序列化数字 */
-export function serializeNumber(value: number): string {
-    return numberToString(value, true);
-}
-
-/**
- * 将 MiraScript 转义字符串序列化为 MiraScript 字面量。
- */
-function serializeStringEscaped(escaped: string, options: Readonly<SerializeOptions>): string {
-    return options.serializeStringEscape('\\' + escaped, options);
-}
-
-/**
- * 将 MiraScript 普通字符串序列化为 MiraScript 字面量。
- */
-function serializeStringContent(value: string, options: Readonly<SerializeOptions>): string {
-    return options.serializeStringContent(value, options);
-}
-
-const STRING_QUOTE = `'`;
-const STRING_REG = new RegExp(String.raw`[${STRING_QUOTE}\\\$\p{C}\u2028\u2029]`, 'gu');
-const STRING_MARK = /^[\p{M}]$/u;
-
-/**
- * 序列化为特殊字符
- */
-function serializeSpecialChar(char: string, options: Readonly<SerializeOptions>): string {
-    if (char === STRING_QUOTE) {
-        return serializeStringEscaped(STRING_QUOTE, options);
-    } else if (char === '\0') {
-        return serializeStringEscaped(`0`, options);
-    } else if (char === '\n') {
-        return serializeStringEscaped(`n`, options);
-    } else if (char === '\r') {
-        return serializeStringEscaped(`r`, options);
-    } else if (char === '\t') {
-        return serializeStringEscaped(`t`, options);
-    } else if (char === '\b') {
-        return serializeStringEscaped(`b`, options);
-    } else if (char === '\f') {
-        return serializeStringEscaped(`f`, options);
-    } else if (char === '\v') {
-        return serializeStringEscaped(`v`, options);
-    } else if (char === '\\') {
-        return serializeStringEscaped(`\\`, options);
-    } else if (char === '$') {
-        return serializeStringEscaped(`$`, options);
-    } else {
-        const code = char.codePointAt(0)!;
-        if (code <= 0x7f) {
-            return serializeStringEscaped(`x${code.toString(16).padStart(2, '0')}`, options);
-        } else if (code >= 0xd800 && code <= 0xdfff) {
-            // 无效的代理对
-            return serializeStringContent('�', options);
-        } else {
-            return serializeStringEscaped(`u{${code.toString(16)}}`, options);
-        }
-    }
-}
-
-/**
- * 将 MiraScript 字符串序列化为 MiraScript 字面量。
- */
-function serializeStringImpl(value: string, options: Readonly<SerializeOptions>): string {
-    const oq = options.serializeStringQuote(STRING_QUOTE, true, options);
-    const cq = options.serializeStringQuote(STRING_QUOTE, false, options);
-    if (value.length === 0) {
-        return oq + cq;
-    }
-
-    let ret = oq;
-    let lastIndex = 0;
-
-    // 当开头字符是 \p{M} 时，使用转义序列化
-    while (value.length > lastIndex) {
-        const cp = value.codePointAt(lastIndex)!;
-        const ch = String.fromCodePoint(cp);
-        if (!STRING_MARK.test(ch)) break;
-        ret += serializeStringEscaped(`u{${cp.toString(16)}}`, options);
-        lastIndex += ch.length;
-    }
-
-    // 序列化字符串内容，遇到特殊字符时使用转义序列化
-    STRING_REG.lastIndex = lastIndex;
-    let match: RegExpExecArray | null;
-    while ((match = STRING_REG.exec(value)) !== null) {
-        ret += serializeStringContent(value.slice(lastIndex, match.index), options);
-        lastIndex = STRING_REG.lastIndex;
-        ret += serializeSpecialChar(match[0], options);
-    }
-    ret += serializeStringContent(value.slice(lastIndex), options);
-    ret += cq;
-    return ret;
-}
-
-/**
- * 将 MiraScript 字符串序列化为 MiraScript 字面量。
- */
-export function serializeString(value: string, options?: Partial<SerializeOptions>): string {
-    return serializeStringImpl(value, getSerializeOptions(options));
-}
-
-/** 使用默认选项序列化属性名 */
-function serializeRecordKeyDefault(key: string): string {
-    if (REG_ORDINAL_FULL.test(key) || REG_IDENTIFIER_FULL.test(key)) {
-        return key;
-    }
-    return serializeStringImpl(key, DEFAULT_OPTIONS);
-}
-
-/** 序列化属性名 */
-function serializeRecordKeyOpt(value: string, options: Readonly<SerializeOptions>): string {
-    if (isDefaultOptions(options)) {
-        return serializeRecordKeyDefault(value);
-    }
-    if (REG_ORDINAL_FULL.test(value)) {
-        // 合法的数字属性名
-        return options.serializePropName(Number(value), options);
-    }
-    if (REG_IDENTIFIER_FULL.test(value)) {
-        // 合法的标识符
-        return options.serializePropName(value, options);
-    }
-    // 否则，序列化为字符串
-    return options.serializeString(value, options);
-}
-
-/** 序列化属性名 */
-export function serializeRecordKey(key: string, options?: Partial<SerializeOptions>): string {
-    if (isDefaultOptions(options)) {
-        return serializeRecordKeyDefault(key);
-    }
-    return serializeRecordKeyOpt(key, getSerializeOptions(options));
-}
-
-/** 序列化数组 */
-export function serializeArray(value: VmArray, depth: number, options: Readonly<SerializeOptions>): string {
-    if (depth > options.maxDepth) return `[]`;
-    if (value.length === 0) return '[]';
-    let result = '[';
-    for (let i = 0; i < value.length; i++) {
-        if (i > 0) result += ', ';
-        result += serializeImpl(value[i], depth, options);
-    }
-    result += ']';
-    return result;
-}
-
-// eslint-disable-next-line @typescript-eslint/unbound-method
-const { valueOf } = Object.prototype;
-/**
- * 如果值有自定义的 valueOf 方法，调用它并返回结果，否则返回 undefined。
- */
-function customValueOf(value: VmRecord): VmAny | undefined {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const thisValueOf = value.valueOf;
-    if (typeof thisValueOf !== 'function' || thisValueOf === valueOf) {
-        return undefined;
-    }
-    const customValue = thisValueOf.call(value) as VmAny | undefined;
-    if (customValue === value) return undefined;
-    return customValue;
-}
-
-/** 序列化记录 */
-export function serializeRecord(value: VmRecord, depth: number, options: Readonly<SerializeOptions>): string {
-    const customValue = customValueOf(value);
-    if (customValue !== undefined) {
-        return serializeImpl(customValue, depth - 1, options);
-    }
-    if (depth > options.maxDepth) return `()`;
-    const e = entries(value);
-    if (e.length === 0) return '()';
-    if (e.length === 1) {
-        const [k, v] = e[0]!;
-        if (k === '0') {
-            return `(${serializeImpl(v, depth, options)},)`; // 单个元素数组
-        }
-        return `(${serializeRecordKeyOpt(k, options)}: ${serializeImpl(v, depth, options)})`;
-    }
-
-    const omitKey = isVmArrayLikeRecordByEntries(e);
-    let result = '(';
-    for (const [key, val] of e) {
-        if (result.length > 1) result += ', ';
-        if (omitKey) {
-            result += serializeImpl(val, depth, options);
-        } else {
-            result += `${serializeRecordKeyOpt(key, options)}: ${serializeImpl(val, depth, options)}`;
-        }
-    }
-    result += ')';
-    return result;
-}
-
-/** 序列化 */
-function serializeImpl(value: VmAny | undefined, depth: number, options: Readonly<SerializeOptions>): string {
-    if (value == null) {
-        return options.serializeNil(options);
-    }
-    if (typeof value == 'boolean') {
-        return options.serializeBoolean(value, options);
-    }
-    if (typeof value == 'number') {
-        return options.serializeNumber(value, options);
-    }
-    if (typeof value == 'string') {
-        return options.serializeString(value, options);
-    }
-    if (isVmFunction(value)) {
-        return options.serializeFunction(value, options);
-    }
-    if (isVmModule(value)) {
-        return options.serializeModule(value, depth + 1, options);
-    }
-    if (isVmExtern(value)) {
-        return options.serializeExtern(value, depth + 1, options);
-    }
-    if (isVmArray(value)) {
-        return options.serializeArray(value, depth + 1, options);
-    }
-    if (isVmRecord(value)) {
-        return options.serializeRecord(value, depth + 1, options);
-    }
-    // 不支持序列化的值
-    value satisfies never;
-    return options.serializeNil(options);
-}
-
-/**
- * 将 MiraScript 值序列化为 MiraScript 字面量字符串，非常量值默认转换为 `nil`。
- */
-export function serialize(value: VmAny, options?: Partial<SerializeOptions>): string {
-    return serializeImpl(value, 0, getSerializeOptions(options));
-}
-
-/** 将 MiraScript 函数转化为 MiraScript 字符串 */
-export function displayFunction(value: VmFunction): string {
-    try {
-        const name = getVmFunctionInfo(value)?.fullName;
-        return name ? `<function ${name}>` : `<function>`;
-        /* c8 ignore next 3 */
-    } catch {
-        return `<function>`;
-    }
-}
-
-/** 将 MiraScript 模块转化为 MiraScript 字符串 */
-export function displayModule(value: VmModule): string {
-    try {
-        return value.toString(true);
-        /* c8 ignore next 3 */
-    } catch {
-        return `<module>`;
-    }
-}
-
-/** 将 MiraScript 外部值转化为 MiraScript 字符串 */
-export function displayExtern(value: VmExtern): string {
-    try {
-        const tag = `<extern ${value.tag}>`;
-        const rep = value.toString(true);
-        if (rep === tag || rep.length > 50) {
-            return tag;
-        }
-        return `${tag} ${rep}`;
-        /* c8 ignore next 3 */
-    } catch {
-        return `<extern>`;
-    }
-}
-
-/**
- * 将 MiraScript 值转化为 MiraScript 字符串。
- */
-export function display(value: VmAny, options?: Partial<SerializeOptions>): string {
-    const opt = mergeOptions(DISPLAY_OPTIONS, options);
-    return serializeImpl(value, 0, opt);
-}
-
-/** 序列化设置 */
-export interface SerializeOptions {
-    /** 最大递归深度，超过该深度的值将被序列化为 `nil`，默认值为 128 */
-    maxDepth: number;
-    /** 序列化 nil 值 */
-    serializeNil: (options: SerializeOptions) => string;
-    /** 序列化布尔值 */
-    serializeBoolean: (value: boolean, options: SerializeOptions) => string;
-    /** 序列化数字 */
-    serializeNumber: (value: number, options: SerializeOptions) => string;
-    /** 序列化字符串 */
-    serializeString: (value: string, options: SerializeOptions) => string;
-    /** 序列化字符串引号 */
-    serializeStringQuote: (value: string, open: boolean, options: SerializeOptions) => string;
-    /** 序列化字符串转义序列 */
-    serializeStringEscape: (value: string, options: SerializeOptions) => string;
-    /** 序列化字符串常规内容 */
-    serializeStringContent: (value: string, options: SerializeOptions) => string;
-    /** 序列化数组 */
-    serializeArray: (value: VmArray, depth: number, options: SerializeOptions) => string;
-    /** 序列化记录 */
-    serializeRecord: (value: VmRecord, depth: number, options: SerializeOptions) => string;
-    /** 序列化属性名 */
-    serializePropName: (value: number | string, options: SerializeOptions) => string;
-    /** 序列化函数 */
-    serializeFunction: (value: VmFunction, options: SerializeOptions) => string;
-    /** 序列化模块 */
-    serializeModule: (value: VmModule, depth: number, options: SerializeOptions) => string;
-    /** 序列化外部值 */
-    serializeExtern: (value: VmExtern, depth: number, options: SerializeOptions) => string;
-}
-
-/** 是否为默认选项 */
-function isDefaultOptions(options: Partial<SerializeOptions> | undefined): boolean {
-    return options == null || options === DEFAULT_OPTIONS;
-}
-
-/** 合并选项 */
-function mergeOptions(
-    base: Readonly<SerializeOptions>,
-    options: Partial<SerializeOptions> | null | undefined,
-): Readonly<SerializeOptions> {
-    if (options == null) return base;
-    let opt: SerializeOptions | null = null;
-    for (const key in options) {
-        if (!hasOwn(options, key) || !hasOwn(base, key)) continue;
-        const el = options[key as keyof SerializeOptions];
-        if (el == null) continue;
-        opt ??= { ...base };
-        opt[key as keyof SerializeOptions] = el as never;
-    }
-    return opt ? Object.freeze(opt) : base;
-}
-
-/** 获取选项 */
-function getSerializeOptions(options: Partial<SerializeOptions> | undefined): Readonly<SerializeOptions> {
-    if (isDefaultOptions(options)) return DEFAULT_OPTIONS;
-    return mergeOptions(DEFAULT_OPTIONS, options);
-}
-
-const DEFAULT_OPTIONS = Object.freeze({
-    maxDepth: 128,
-    serializeNil,
-    serializeBoolean,
-    serializeNumber,
-    serializeString: serializeStringImpl,
-    serializeStringQuote: (value) => value,
-    serializeStringEscape: (value) => value,
-    serializeStringContent: (value) => value,
-    serializeArray,
-    serializeRecord,
-    serializePropName: String,
-    serializeFunction: serializeNil,
-    serializeModule: serializeNil,
-    serializeExtern: serializeNil,
-} satisfies SerializeOptions);
-
-const DISPLAY_OPTIONS = Object.freeze({
-    maxDepth: 3,
-    serializeNil,
-    serializeBoolean,
-    serializeNumber,
-    serializeString: serializeStringImpl,
-    serializeStringQuote: (value) => value,
-    serializeStringEscape: (value) => value,
-    serializeStringContent: (value) => value,
-    serializeArray,
-    serializeRecord,
-    serializePropName: String,
-    serializeFunction: displayFunction,
-    serializeModule: displayModule,
-    serializeExtern: displayExtern,
-} satisfies SerializeOptions);