@mirascript/monaco 0.1.0

package/src/lsp/utils.ts

@@ -0,0 +1,322 @@
+import { DiagnosticCode } from '@mirascript/wasm';
+import { type editor, Range, type IPosition, type IRange } from '../monaco-api.js';
+import {
+    getVmFunctionInfo,
+    isVmArray,
+    isVmExtern,
+    isVmFunction,
+    isVmModule,
+    isVmPrimitive,
+    isVmRecord,
+    serialize,
+    type VmAny,
+    type VmFunctionInfo,
+    type VmValue,
+} from '@mirascript/mirascript';
+import { operations, serializePropName, serializeString } from '@mirascript/mirascript/subtle';
+import type { LocalDefinition } from './compile-result.js';
+
+/** 参数签名 */
+export type ParamSignature = [name: string, sig: string, doc: string];
+
+/** 生成参数签名 */
+function globalParamsSignature(info: VmFunctionInfo | undefined): ParamSignature[] {
+    if (info == null || (!info.params && !info.paramsType)) return [['..', '..', '']];
+    const paramItems: ParamSignature[] = [];
+    const params = Object.keys(info.paramsType ?? {});
+    for (const key of Object.keys(info.params ?? {})) {
+        if (params.includes(key)) continue;
+        params.push(key);
+    }
+    for (const key of params) {
+        const type = info.paramsType?.[key] ?? '';
+        const doc = info.params?.[key] ?? '';
+        paramItems.push([key, type ? `${key}: ${type}` : key, doc ? `\`${key}\`: ${doc}` : '']);
+    }
+    return paramItems;
+}
+const SIG_WIDTH = 60;
+/** 生成函数签名 */
+export function fnSignature(
+    id: string | undefined,
+    info: VmFunctionInfo,
+): {
+    params: ParamSignature[];
+    returns: string;
+    /** @inheritdoc */
+    toString(): string;
+} {
+    const prefix = id ? `fn ${id}` : 'fn';
+    const params = globalParamsSignature(info);
+    const returns = info.returnsType ? ` -> ${info.returnsType}` : '';
+    return {
+        params,
+        returns,
+        toString() {
+            let p;
+            if (
+                this.params.length >= 1 &&
+                (prefix.length + this.returns.length > SIG_WIDTH ||
+                    prefix.length + this.returns.length + params.reduce((a, b) => a + b[1].length, 0) > SIG_WIDTH)
+            ) {
+                p = `(\n${params.map((item) => `  ${item[1]},`).join('\n')}\n)`;
+            } else {
+                p = `(${params.map((item) => item[1]).join(', ')})`;
+            }
+            return `${prefix}${p}${this.returns}`;
+        },
+    };
+}
+/** 生成函数参数 */
+export function localParamSignature(
+    model: editor.ITextModel,
+    info: NonNullable<LocalDefinition['fn']>,
+): ParamSignature[] {
+    const {
+        args,
+        scope: { params },
+    } = info;
+    if (params[0]?.code === DiagnosticCode.ParameterIt) {
+        return params[0].references.length ? [['it', 'it', '']] : [];
+    }
+    return params.map((a, i) => {
+        const rest =
+            a.code === DiagnosticCode.ParameterRestPattern ||
+            a.code === DiagnosticCode.ParameterMutableRest ||
+            a.code === DiagnosticCode.ParameterImmutableRest;
+        const argsInParam = args.filter((arg) => Range.containsRange(a.range, arg.definition.range));
+        const argName =
+            argsInParam.length === 0
+                ? `arg_${i}`
+                : argsInParam.map((arg) => model.getValueInRange(arg.definition.range)).join('_');
+        if (rest) return [`..${argName}`, `..${argName}`, ''];
+        return [argName, argName, ''];
+    });
+}
+
+/** 生成函数参数列表 */
+export function paramsList(model: editor.ITextModel, info: VmFunctionInfo | LocalDefinition['fn'] | undefined): string {
+    if (!info) return '(..)';
+    if ('scope' in info) {
+        return `(${localParamSignature(model, info)
+            .map((p) => p[1])
+            .join(', ')})`;
+    } else {
+        if (!info.params) return '(..)';
+        const paramItems = Object.keys(info.params).join(', ');
+        return `(${paramItems})`;
+    }
+}
+
+/** 生成函数文档 */
+export function globalFnDoc(info: VmFunctionInfo): string[] {
+    const doc = [];
+    if (info.summary) {
+        doc.push(info.summary);
+    }
+    const paramDoc = [];
+    if (info.params) {
+        for (const [key, value] of Object.entries(info.params)) {
+            if (!value) continue;
+            paramDoc.push(`- \`${key}\`: ${value}`);
+        }
+    }
+    if (info.returns) {
+        paramDoc.push(`- **返回值**: ${info.returns}`);
+    }
+    if (paramDoc.length) {
+        doc.push(paramDoc.join('\n'));
+    }
+    if (info.examples?.length) {
+        let exp = `### 示例`;
+        for (const example of info.examples) {
+            exp += codeblock(example);
+        }
+        doc.push(exp);
+    }
+    return doc;
+}
+
+/** 获取代码块格式化字符串 */
+export function codeblock(value: string): string {
+    const includeFences = /`{3,}/.exec(value);
+    const CODEBLOCK_FENCE = includeFences ? '`'.repeat(includeFences[0].length + 1) : '```';
+    return `\n${CODEBLOCK_FENCE}mirascript\n${value}\n${CODEBLOCK_FENCE}\n`;
+}
+
+/** 检查位置是否在范围内，且范围非空 */
+export function strictContainsPosition(range: IRange, position: IPosition): boolean {
+    return !Range.isEmpty(range) && Range.containsPosition(range, position);
+}
+
+/** 获取单词 */
+export function wordAt(model: editor.ITextModel, position: IPosition): { word: string; range: Range } | undefined {
+    const word = model.getWordAtPosition(position);
+    if (!word) return undefined;
+    const range = new Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
+    return { word: word.word, range };
+}
+
+/** 将值序列化为便于展示的字符串 */
+function serializeForDisplayInner(value: VmValue, maxWidth: number): string {
+    if (maxWidth < 10) maxWidth = 10;
+    if (typeof value === 'string') {
+        if (value.length < maxWidth) {
+            return serializeString(value);
+        }
+        return `${serializeString(value.slice(0, maxWidth))}..`;
+    }
+    if (isVmPrimitive(value)) {
+        return serialize(value);
+    }
+    if (isVmArray(value)) {
+        const len = value.length;
+        if (!len) return '[]';
+        return `[../* x${len} */]`;
+    }
+    if (isVmRecord(value)) {
+        const len = Object.keys(value).length;
+        if (!len) return '()';
+        return `(../* x${len} */)`;
+    }
+    return `/* ${operations.$ToString(value)} */`;
+}
+
+/** 将值序列化为便于展示的字符串 */
+export function serializeForDisplay(value: VmValue, maxEntries = 100, maxWidth = 40): string {
+    if (isVmPrimitive(value) || isVmFunction(value)) {
+        return serializeForDisplayInner(value, maxWidth);
+    }
+    let begin, end;
+    const entries = [];
+    let resultLength = 0;
+    if (isVmArray(value)) {
+        begin = '[';
+        end = ']';
+        for (const v of value) {
+            if (entries.length > maxEntries) {
+                entries.push(`../* x${value.length - entries.length} */`);
+                break;
+            }
+            const entry = serializeForDisplayInner(v ?? null, maxWidth - 2);
+            entries.push(entry);
+            resultLength += entry.length;
+        }
+    } else if (isVmRecord(value)) {
+        begin = '(';
+        end = ')';
+        const e = Object.entries(value);
+        for (const [key, value] of e) {
+            if (entries.length > maxEntries) {
+                entries.push(`../* x${e.length - entries.length} */`);
+                break;
+            }
+            const sk = serializePropName(key);
+            const entry = `${sk}: ${serializeForDisplayInner(value ?? null, maxWidth - sk.length - 4)}`;
+            entries.push(entry);
+            resultLength += entry.length;
+        }
+    } else {
+        const hint = serializeForDisplayInner(value, 100);
+        const isArray = isVmExtern(value) && Array.isArray(value.value);
+        begin = `${hint} ${isArray ? '[' : '('}`;
+        end = isArray ? ']' : ')';
+        const keys = value.keys();
+        for (const [index, key] of keys.entries()) {
+            if (entries.length > maxEntries) {
+                entries.push(`../* x${keys.length - entries.length} */`);
+                break;
+            }
+            let entry;
+            if (isArray && String(index) === key) {
+                // 数组索引
+                entry = serializeForDisplayInner(value.get(key) ?? null, maxWidth - 2);
+            } else {
+                const sk = serializePropName(key);
+                entry = `${sk}: ${serializeForDisplayInner(value.get(key) ?? null, maxWidth - sk.length - 4)}`;
+            }
+            entries.push(entry);
+            resultLength += entry.length;
+        }
+    }
+    if (resultLength >= maxWidth) {
+        return `${begin}\n  ${entries.join(',\n  ')}\n${end}`;
+    }
+    return `${begin}${entries.join(', ')}${end}`;
+}
+
+/** 获取变量文档 */
+export function valueDoc(
+    name: string,
+    value: VmAny,
+    type: 'field' | 'declare' | 'hint',
+): { script: string; doc: string[] } {
+    const info = getVmFunctionInfo(value);
+    if (info) {
+        return {
+            script: fnSignature(name, info).toString() + (type === 'declare' ? ';' : ''),
+            doc: globalFnDoc(info),
+        };
+    }
+    let prefix;
+    let suffix = '';
+    if (type === 'hint') {
+        prefix = `${name} = `;
+    } else if (type === 'declare') {
+        if (name.startsWith('@')) {
+            prefix = `const ${name} = `;
+        } else {
+            prefix = `let ${name} = `;
+        }
+        suffix = ';';
+    } else if (/^\d/.test(name)) {
+        prefix = `[${name}]: `;
+    } else {
+        prefix = `${name}: `;
+    }
+    if (isVmModule(value)) {
+        const doc = `模块 \`${value.name}\``;
+        let script;
+        if (type === 'declare') {
+            const exports = value.keys();
+            script = '\n';
+            for (const k of exports) {
+                const v = value.get(k);
+                const vDoc = valueDoc(k, v, isVmModule(v) ? 'field' : 'declare');
+                const code = [
+                    `/**`,
+                    ...vDoc.doc.flatMap((sec) => sec.split('\n')).map((line) => ` * ${line}`),
+                    ` */`,
+                    'export ' + vDoc.script,
+                    '',
+                    '',
+                ];
+                script += code.join('\n');
+            }
+            script = script.trimEnd();
+        } else {
+            script = `(module) ${value.name}`;
+            if (value.name !== name) {
+                script = `${prefix}${script}`;
+            }
+        }
+        return { script, doc: doc ? [doc] : [] };
+    }
+    let valueStr;
+    if (value === undefined) {
+        valueStr = '/* ... */';
+    } else {
+        valueStr = serializeForDisplay(value, type === 'declare' ? 1000 : 100, type === 'declare' ? 80 : 40);
+    }
+    return { script: `${prefix}${valueStr}${suffix}`, doc: [] };
+}
+
+/** 获取深层属性 */
+export function getDeep(value: VmAny, path: readonly string[]): VmValue {
+    let current: VmAny = value;
+    for (const key of path) {
+        if (current == null) return null;
+        current = operations.$Get(current, key);
+    }
+    return current ?? null;
+}

package/src/lsp/worker-helper.ts

@@ -0,0 +1,119 @@
+import type { editor } from '../monaco-api.js';
+import type { Ready, CacheKey, Req, Res, ResOk } from './worker.js';
+import { CompileResult } from './compile-result.js';
+import { setMarkers } from './diagnostics.js';
+
+/** 缓存 */
+type CacheValue = {
+    readonly version: number;
+    readonly result: Promise<CompileResult>;
+    lastAccess: number;
+};
+/** 编译结果缓存，避免重复编译 */
+const cache = new Map<CacheKey, CacheValue>();
+let worker: Promise<Worker> | undefined = undefined;
+
+// 清理缓存
+const CACHE_MAX_AGE = 30000;
+setInterval(() => {
+    const now = Date.now();
+    for (const [key, { lastAccess }] of cache) {
+        if (now - lastAccess > CACHE_MAX_AGE) {
+            cache.delete(key);
+        }
+    }
+}, CACHE_MAX_AGE);
+
+/** 使用 worker 进行编译 */
+async function compileWorker(req: Req): Promise<CompileResult> {
+    if (!worker) {
+        const w = new Worker(new URL('#lsp/worker', import.meta.url), {
+            type: 'module',
+            name: '@mirascript/lsp-server',
+        });
+        worker = new Promise((resolve, reject) => {
+            const onError = (e: ErrorEvent) => {
+                cleanUp();
+                reject(new Error(`Worker failed to start: ${e.message}`));
+            };
+            const onMessage = (e: MessageEvent<Ready | Error>) => {
+                if (e.data === 'mirascript lsp ready') {
+                    cleanUp();
+                    resolve(w);
+                } else if (e.data instanceof Error) {
+                    cleanUp();
+                    reject(e.data);
+                }
+            };
+            w.addEventListener('error', onError);
+            w.addEventListener('message', onMessage);
+            const cleanUp = () => {
+                w.removeEventListener('error', onError);
+                w.removeEventListener('message', onMessage);
+            };
+            setTimeout(() => {
+                onError(new ErrorEvent('error', { message: 'Worker did not respond in time' }));
+            }, 30000);
+        });
+    }
+
+    const instance = await worker;
+    instance.postMessage(req);
+    const [key, version, source] = req;
+    const [_key, _version, result] = await new Promise<ResOk>((resolve, reject) => {
+        const onMessage = (e: MessageEvent<Res>) => {
+            if (e.data[0] === key && e.data[1] === version) {
+                instance.removeEventListener('message', onMessage);
+                if (e.data[2] instanceof Error) {
+                    reject(e.data[2]);
+                } else {
+                    resolve(e.data as ResOk);
+                }
+            }
+        };
+        instance.addEventListener('message', onMessage);
+    });
+    return new CompileResult(key, version, source, result);
+}
+
+/** 使用当前线程编译 */
+async function compileSync(req: Req): Promise<CompileResult> {
+    const [key, version, script, mode] = req;
+    const { compile } = await import('./worker.js');
+    const result = compile(script, mode);
+    return new CompileResult(key, version, script, result);
+}
+
+const USE_WORKER = typeof Worker === 'function';
+/** 注册 worker */
+export async function compile(model: editor.ITextModel): Promise<CompileResult> {
+    const uri = model.uri.toString();
+    const version = model.getVersionId();
+    const mode = model.getLanguageId() === 'mirascript-template' ? 'Template' : 'Script';
+    const cacheKey = `${model.id}\0${uri}\0${mode}` as const;
+    const cached = cache.get(cacheKey);
+    if (cached?.version === version) {
+        cached.lastAccess = Date.now();
+        return cached.result;
+    }
+
+    const value = model.getValue();
+    const req: Req = [cacheKey, version, value, mode];
+    const res = USE_WORKER ? compileWorker(req) : compileSync(req);
+    void res.then((result) => {
+        setMarkers(model, result);
+    });
+    const item: CacheValue = {
+        version,
+        lastAccess: Date.now(),
+        result: res,
+    };
+    cache.set(cacheKey, item);
+    res.catch(() => {
+        const current = cache.get(cacheKey);
+        if (current === item) {
+            cache.delete(cacheKey);
+        }
+    });
+    return res;
+}

package/src/lsp/worker.ts

@@ -0,0 +1,83 @@
+import { createConfig, type CompileResult, wasm, ready } from '@mirascript/wasm';
+import type { InputMode } from '@mirascript/mirascript';
+await ready;
+
+/** Monaco 编译结果 */
+export interface MonacoResult extends CompileResult {
+    /** 格式化结果 */
+    formatted?: string;
+}
+
+/** 缓存 Key (id, uri, inputMode) */
+export type CacheKey = `${string}\0${string}\0${InputMode}`;
+/** 请求参数 */
+export type Req = [key: CacheKey, version: number, script: string, mode: InputMode];
+/** 编译结果 */
+export type ResOk = [key: CacheKey, version: number, result: MonacoResult];
+/** 编译结果 */
+export type ResErr = [key: CacheKey, version: number, error: Error];
+/** 编译结果 */
+export type Res = ResOk | ResErr;
+/** Ready */
+export type Ready = 'mirascript lsp ready';
+
+const configTemplate = createConfig({
+    diagnostic_position_encoding: 'Utf16',
+    track_references: true,
+    diagnostic_other: true,
+    trivia: true,
+    input_mode: 'Template',
+});
+const configScript = createConfig({
+    diagnostic_position_encoding: 'Utf16',
+    track_references: true,
+    diagnostic_other: true,
+    trivia: true,
+    input_mode: 'Script',
+});
+
+/** 编译 */
+export function compile(script: string, mode: InputMode): MonacoResult {
+    const config = mode === 'Script' ? configScript : configTemplate;
+    const compiler = new wasm.MonacoCompiler(script, config);
+    try {
+        const parseOk = compiler.parse();
+        if (!parseOk) {
+            return { diagnostics: compiler.diagnostics(), chunk: undefined };
+        }
+        const chunk = compiler.emit();
+        const formatted = compiler.format();
+        return {
+            diagnostics: compiler.diagnostics(),
+            chunk,
+            formatted,
+        };
+    } finally {
+        try {
+            compiler.free();
+        } catch (ex) {
+            /* 忽略错误 */
+            // eslint-disable-next-line no-console
+            console.error(ex);
+        }
+    }
+}
+
+if (typeof Worker == 'function' && typeof addEventListener == 'function' && typeof postMessage == 'function') {
+    addEventListener('message', (event: MessageEvent) => {
+        const data = event.data as Req;
+        if (!Array.isArray(data)) return;
+        const [key, version, script, mode] = data;
+        try {
+            const result = compile(script, mode);
+            const transfer = [];
+            if (result.chunk) transfer.push(result.chunk.buffer);
+            if (result.diagnostics) transfer.push(result.diagnostics.buffer);
+            postMessage([key, version, result] satisfies ResOk, { transfer });
+        } catch (error) {
+            const e = error instanceof Error ? error : new Error(String(error));
+            postMessage([key, version, e] satisfies ResErr);
+        }
+    });
+    postMessage('mirascript lsp ready' satisfies Ready);
+}

package/src/monaco-api.js

@@ -0,0 +1,66 @@
+let monaco = null;
+export default monaco;
+
+export let CancellationTokenSource,
+    Emitter,
+    KeyCode,
+    KeyMod,
+    MarkerSeverity,
+    MarkerTag,
+    Position,
+    Range,
+    Selection,
+    SelectionDirection,
+    Token,
+    Uri,
+    editor,
+    languages,
+    service,
+    utils;
+
+/**
+ * 注册 MiraScript Monaco API，不实际启用任何功能。
+ * @param {object} monacoApi - Monaco API 对象，必须包含特定方法和属性。
+ */
+export function registerMonacoApi(monacoApi) {
+    if (monaco) {
+        throw new Error('MiraScriptMonacoLoader has already been registered.');
+    }
+    if (
+        !monacoApi ||
+        typeof monacoApi !== 'object' ||
+        // !monaco.languages ||
+        // 'function' != typeof monaco.languages.register ||
+        // 'function' != typeof monaco.languages.onLanguage ||
+        // !monaco.editor ||
+        // 'function' != typeof monaco.editor.create ||
+        // 'function' != typeof monaco.editor.createModel ||
+        // 'function' != typeof monaco.editor.createWebWorker ||
+        'function' != typeof monacoApi.Uri ||
+        'function' != typeof monacoApi.Range ||
+        'function' != typeof monacoApi.Position ||
+        'function' != typeof monacoApi.CancellationTokenSource ||
+        'function' != typeof monacoApi.Emitter
+    ) {
+        throw new TypeError('Invalid Monaco editor instance provided.');
+    }
+    monaco = monacoApi;
+    ({
+        CancellationTokenSource,
+        Emitter,
+        KeyCode,
+        KeyMod,
+        MarkerSeverity,
+        MarkerTag,
+        Position,
+        Range,
+        Selection,
+        SelectionDirection,
+        Token,
+        Uri,
+        editor,
+        languages,
+        service,
+        utils,
+    } = monacoApi);
+}

package/src/monaco-api.ts

@@ -0,0 +1,18 @@
+import type * as monaco from 'monaco-editor';
+
+export * from 'monaco-editor';
+export * as monaco from 'monaco-editor';
+
+/** Monaco Api 属性 */
+export type MonacoApi = {
+    Range: typeof monaco.Range;
+    Position: typeof monaco.Position;
+    Emitter: typeof monaco.Emitter;
+    CancellationTokenSource: typeof monaco.CancellationTokenSource;
+    Uri: typeof monaco.Uri;
+};
+
+/**
+ * 注册 MiraScript Monaco API，不实际启用任何功能。
+ */
+export declare function registerMonacoApi(monacoApi: MonacoApi): void;