@typespec/playground 0.3.0-dev.9 → 0.4.0-dev.0

package/dist/state-storage-CObxFEXn.js

@@ -1,657 +0,0 @@
-import { resolvePath, createSourceFile, getSourceFileKindFromExt, TypeSpecLanguageConfiguration } from '@typespec/compiler';
-import * as monaco from 'monaco-editor';
-import * as lsp from 'vscode-languageserver';
-import { DiagnosticSeverity, FormattingOptions, DocumentHighlightKind } from 'vscode-languageserver';
-import { TextDocument } from 'vscode-languageserver-textdocument';
-import lzutf8 from 'lzutf8';
-
-async function importTypeSpecCompiler(config) {
-    return (await importLibrary("@typespec/compiler", config));
-}
-/**
- * @param name Import name.
- * @returns Promise with the loaded module.
- */
-async function importLibrary(name, config) {
-    return config.useShim
-        ? importShim(name)
-        : import(/* @vite-ignore */ /* webpackIgnore: true */ name);
-}
-/**
- * Loading external import map doesn't work yet
- *
- * https://github.com/WICG/import-maps/issues/235
- *
- * A polyfill for importmap is loaded but required calling importShim instead of the native import https://github.com/guybedford/es-module-shims
- * @param name Import name.
- * @returns Promise with the loaded module.
- */
-async function importShim(name) {
-    return window.importShim(name);
-}
-
-function resolveVirtualPath(path, ...paths) {
-    return resolvePath("/test", path, ...paths);
-}
-/**
- * Create the browser host from the list of libraries.
- * @param libsToLoad List of libraries to load. Those must be set in the webpage importmap.
- * @param importOptions Import configuration.
- * @returns
- */
-async function createBrowserHost(libsToLoad, importOptions = {}) {
-    const virtualFs = new Map();
-    const jsImports = new Map();
-    const libraries = {};
-    for (const libName of libsToLoad) {
-        const { _TypeSpecLibrary_, $lib, $linter } = (await importLibrary(libName, importOptions));
-        libraries[libName] = {
-            name: libName,
-            isEmitter: $lib?.emitter,
-            definition: $lib,
-            packageJson: JSON.parse(_TypeSpecLibrary_.typespecSourceFiles["package.json"]),
-            linter: $linter,
-        };
-        for (const [key, value] of Object.entries(_TypeSpecLibrary_.typespecSourceFiles)) {
-            virtualFs.set(`/test/node_modules/${libName}/${key}`, value);
-        }
-        for (const [key, value] of Object.entries(_TypeSpecLibrary_.jsSourceFiles)) {
-            addJsImport(`/test/node_modules/${libName}/${key}`, value);
-        }
-        virtualFs.set(`/test/package.json`, JSON.stringify({
-            name: "playground-pkg",
-            dependencies: Object.fromEntries(Object.values(libraries).map((x) => [x.name, x.packageJson.version])),
-        }));
-    }
-    function addJsImport(path, value) {
-        virtualFs.set(path, "");
-        jsImports.set(path, value);
-    }
-    return {
-        compiler: await importTypeSpecCompiler(importOptions),
-        libraries,
-        async readUrl(url) {
-            const contents = virtualFs.get(url);
-            if (contents === undefined) {
-                const e = new Error(`File ${url} not found.`);
-                e.code = "ENOENT";
-                throw e;
-            }
-            return createSourceFile(contents, url);
-        },
-        async readFile(path) {
-            path = resolveVirtualPath(path);
-            const contents = virtualFs.get(path);
-            if (contents === undefined) {
-                const e = new Error(`File ${path} not found.`);
-                e.code = "ENOENT";
-                throw e;
-            }
-            return createSourceFile(contents, path);
-        },
-        async writeFile(path, content) {
-            path = resolveVirtualPath(path);
-            virtualFs.set(path, content);
-        },
-        async readDir(path) {
-            path = resolveVirtualPath(path);
-            const fileFolder = [...virtualFs.keys()]
-                .filter((x) => x.startsWith(`${path}/`))
-                .map((x) => x.replace(`${path}/`, ""))
-                .map((x) => {
-                const index = x.indexOf("/");
-                return index !== -1 ? x.substring(0, index) : x;
-            });
-            return [...new Set(fileFolder)];
-        },
-        async rm(path) {
-            path = resolveVirtualPath(path);
-            for (const key of virtualFs.keys()) {
-                if (key === path || key.startsWith(`${path}/`)) {
-                    virtualFs.delete(key);
-                }
-            }
-        },
-        getLibDirs() {
-            if (virtualFs.has(resolveVirtualPath("/test/node_modules/@typespec/compiler/lib/std/main.tsp"))) {
-                return [resolveVirtualPath("/test/node_modules/@typespec/compiler/lib/std")];
-            }
-            else {
-                // To load older version of the compiler < 0.55.0
-                return [resolveVirtualPath("/test/node_modules/@typespec/compiler/lib")];
-            }
-        },
-        getExecutionRoot() {
-            return resolveVirtualPath("/test/node_modules/@typespec/compiler");
-        },
-        async getJsImport(path) {
-            path = resolveVirtualPath(path);
-            const module = await jsImports.get(path);
-            if (module === undefined) {
-                const e = new Error(`Module ${path} not found`);
-                e.code = "MODULE_NOT_FOUND";
-                throw e;
-            }
-            return module;
-        },
-        async stat(path) {
-            path = resolveVirtualPath(path);
-            if (virtualFs.has(path)) {
-                return {
-                    isDirectory() {
-                        return false;
-                    },
-                    isFile() {
-                        return true;
-                    },
-                };
-            }
-            for (const fsPath of virtualFs.keys()) {
-                if (fsPath.startsWith(path) && fsPath !== path) {
-                    return {
-                        isDirectory() {
-                            return true;
-                        },
-                        isFile() {
-                            return false;
-                        },
-                    };
-                }
-            }
-            const e = new Error(`File ${path} not found.`);
-            e.code = "ENOENT";
-            throw e;
-        },
-        // symlinks not supported in test-host
-        async realpath(path) {
-            return path;
-        },
-        getSourceFileKind: getSourceFileKindFromExt,
-        logSink: console,
-        mkdirp: async (path) => path,
-        fileURLToPath(path) {
-            return path.replace("inmemory:/", "");
-        },
-        pathToFileURL(path) {
-            return "inmemory:/" + resolveVirtualPath(path);
-        },
-    };
-}
-
-function range(range) {
-    return {
-        startColumn: range.start.character + 1,
-        startLineNumber: range.start.line + 1,
-        endColumn: range.end.character + 1,
-        endLineNumber: range.end.line + 1,
-    };
-}
-function foldingRange(range) {
-    return {
-        start: range.startLine + 1,
-        end: range.endLine + 1,
-        kind: range.kind ? new monaco.languages.FoldingRangeKind(range.kind) : undefined,
-    };
-}
-function textEdits(edit) {
-    return edit.map(textEdit);
-}
-function textEdit(edit) {
-    return {
-        range: range(edit.range),
-        text: edit.newText,
-    };
-}
-function signatureHelp(help) {
-    return {
-        signatures: help?.signatures.map((x) => ({
-            ...x,
-            parameters: x.parameters ?? [],
-        })) ?? [],
-        activeSignature: help?.activeSignature ?? 0,
-        activeParameter: help?.activeParameter ?? 0,
-    };
-}
-function command(command) {
-    return {
-        id: command.command,
-        title: command.title,
-        arguments: command.arguments,
-    };
-}
-function severity(severity) {
-    switch (severity) {
-        case DiagnosticSeverity.Error:
-            return monaco.MarkerSeverity.Error;
-        case DiagnosticSeverity.Warning:
-            return monaco.MarkerSeverity.Warning;
-        case DiagnosticSeverity.Hint:
-            return monaco.MarkerSeverity.Hint;
-        case DiagnosticSeverity.Information:
-            return monaco.MarkerSeverity.Info;
-    }
-}
-function diagnostic(diagnostic) {
-    return {
-        severity: diagnostic.severity ? severity(diagnostic.severity) : monaco.MarkerSeverity.Error,
-        message: diagnostic.message,
-        code: diagnostic.code?.toString(),
-        source: diagnostic.source,
-        startLineNumber: diagnostic.range.start.line + 1,
-        startColumn: diagnostic.range.start.character + 1,
-        endLineNumber: diagnostic.range.end.line + 1,
-        endColumn: diagnostic.range.end.character + 1,
-    };
-}
-function codeAction(action) {
-    return {
-        title: action.title,
-        kind: action.kind,
-        diagnostics: action.diagnostics?.map(diagnostic),
-        command: action.command && command(action.command),
-    };
-}
-const LspToMonaco = {
-    range,
-    foldingRange,
-    textEdits,
-    textEdit,
-    signatureHelp,
-    codeAction,
-    command,
-};
-
-function getIndentAction(value) {
-    switch (value) {
-        case "none":
-            return monaco.languages.IndentAction.None;
-        case "indent":
-            return monaco.languages.IndentAction.Indent;
-        case "indentOutdent":
-            return monaco.languages.IndentAction.IndentOutdent;
-        case "outdent":
-            return monaco.languages.IndentAction.Outdent;
-    }
-}
-function getTypeSpecLanguageConfiguration() {
-    return {
-        ...TypeSpecLanguageConfiguration,
-        onEnterRules: TypeSpecLanguageConfiguration.onEnterRules.map((rule) => {
-            return {
-                beforeText: new RegExp(rule.beforeText.pattern),
-                previousLineText: "previousLineText" in rule ? new RegExp(rule.previousLineText.pattern) : undefined,
-                action: {
-                    indentAction: getIndentAction(rule.action.indent),
-                    appendText: "appendText" in rule.action ? rule.action.appendText : undefined,
-                    removeText: "removeText" in rule.action ? rule.action.removeText : undefined,
-                },
-            };
-        }),
-    };
-}
-async function registerMonacoLanguage(host) {
-    monaco.languages.register({ id: "typespec", extensions: [".tsp"] });
-    monaco.languages.setLanguageConfiguration("typespec", getTypeSpecLanguageConfiguration());
-    const serverHost = {
-        compilerHost: host,
-        getOpenDocumentByURL(url) {
-            const model = monaco.editor.getModel(monaco.Uri.parse(url));
-            return model ? textDocumentForModel(model) : undefined;
-        },
-        sendDiagnostics() { },
-        // eslint-disable-next-line no-console
-        log: console.log,
-        applyEdit(param) {
-            return Promise.resolve({ applied: false });
-        },
-    };
-    const { createServer } = host.compiler;
-    const serverLib = createServer(serverHost);
-    const lsConfig = await serverLib.initialize({
-        capabilities: {},
-        processId: 1,
-        workspaceFolders: [],
-        rootUri: "inmemory://",
-    });
-    serverLib.initialized({});
-    function textDocumentForModel(model) {
-        return TextDocument.create(model.uri.toString(), "typespec", model.getVersionId(), model.getValue());
-    }
-    function lspDocumentArgs(model) {
-        return {
-            textDocument: textDocumentForModel(model),
-        };
-    }
-    function lspArgs(model, pos) {
-        return {
-            ...lspDocumentArgs(model),
-            position: lspPosition(pos),
-        };
-    }
-    function lspPosition(pos) {
-        return {
-            line: pos.lineNumber - 1,
-            character: pos.column - 1,
-        };
-    }
-    function lspFormattingOptions(options) {
-        return FormattingOptions.create(options.tabSize, options.insertSpaces);
-    }
-    function monacoLocation(loc) {
-        return {
-            uri: monaco.Uri.parse(loc.uri),
-            range: LspToMonaco.range(loc.range),
-        };
-    }
-    function monacoDocumentHighlight(highlight) {
-        return {
-            range: LspToMonaco.range(highlight.range),
-            kind: monacoDocumentHighlightKind(highlight.kind),
-        };
-    }
-    function monacoDocumentHighlightKind(kind) {
-        switch (kind) {
-            case DocumentHighlightKind.Text:
-                return monaco.languages.DocumentHighlightKind.Text;
-            case DocumentHighlightKind.Read:
-                return monaco.languages.DocumentHighlightKind.Read;
-            case DocumentHighlightKind.Write:
-                return monaco.languages.DocumentHighlightKind.Write;
-            default:
-                return undefined;
-        }
-    }
-    function monacoHoverContents(contents) {
-        return [{ value: contents.value }];
-    }
-    function monacoHover(hover) {
-        // eslint-disable-next-line deprecation/deprecation
-        if (Array.isArray(hover.contents) || lsp.MarkedString.is(hover.contents)) {
-            throw new Error("MarkedString (deprecated) not supported.");
-        }
-        return {
-            contents: monacoHoverContents(hover.contents),
-            range: hover.range ? LspToMonaco.range(hover.range) : undefined,
-        };
-    }
-    function monacoWorkspaceEdit(edit) {
-        const edits = [];
-        for (const [uri, changes] of Object.entries(edit.changes ?? {})) {
-            const resource = monaco.Uri.parse(uri);
-            for (const change of changes) {
-                edits.push({ resource, textEdit: LspToMonaco.textEdit(change), versionId: undefined });
-            }
-        }
-        return { edits };
-    }
-    monaco.languages.registerDefinitionProvider("typespec", {
-        async provideDefinition(model, position) {
-            const results = await serverLib.gotoDefinition(lspArgs(model, position));
-            return results.map(monacoLocation);
-        },
-    });
-    monaco.languages.registerReferenceProvider("typespec", {
-        async provideReferences(model, position, context) {
-            const results = await serverLib.findReferences({ ...lspArgs(model, position), context });
-            return results.map(monacoLocation);
-        },
-    });
-    monaco.languages.registerRenameProvider("typespec", {
-        async resolveRenameLocation(model, position) {
-            const result = await serverLib.prepareRename(lspArgs(model, position));
-            if (!result) {
-                throw new Error("This element can't be renamed.");
-            }
-            const text = model.getWordAtPosition(position)?.word;
-            if (!text) {
-                throw new Error("Failed to obtain word at position.");
-            }
-            return { text, range: LspToMonaco.range(result) };
-        },
-        async provideRenameEdits(model, position, newName) {
-            const result = await serverLib.rename({ ...lspArgs(model, position), newName });
-            return monacoWorkspaceEdit(result);
-        },
-    });
-    monaco.languages.registerFoldingRangeProvider("typespec", {
-        async provideFoldingRanges(model) {
-            const ranges = await serverLib.getFoldingRanges(lspDocumentArgs(model));
-            const output = ranges.map(LspToMonaco.foldingRange);
-            return output;
-        },
-    });
-    monaco.languages.registerHoverProvider("typespec", {
-        async provideHover(model, position) {
-            const hover = await serverLib.getHover(lspArgs(model, position));
-            return monacoHover(hover);
-        },
-    });
-    monaco.languages.registerSignatureHelpProvider("typespec", {
-        signatureHelpTriggerCharacters: ["(", ",", "<"],
-        signatureHelpRetriggerCharacters: [")"],
-        async provideSignatureHelp(model, position) {
-            const help = await serverLib.getSignatureHelp(lspArgs(model, position));
-            return { value: LspToMonaco.signatureHelp(help), dispose: () => { } };
-        },
-    });
-    monaco.languages.registerDocumentFormattingEditProvider("typespec", {
-        async provideDocumentFormattingEdits(model, options, token) {
-            const edits = await serverLib.formatDocument({
-                ...lspDocumentArgs(model),
-                options: lspFormattingOptions(options),
-            });
-            return LspToMonaco.textEdits(edits);
-        },
-    });
-    monaco.languages.registerDocumentHighlightProvider("typespec", {
-        async provideDocumentHighlights(model, position) {
-            const highlights = await serverLib.findDocumentHighlight(lspArgs(model, position));
-            return highlights.map(monacoDocumentHighlight);
-        },
-    });
-    monaco.languages.registerCompletionItemProvider("typespec", {
-        triggerCharacters: lsConfig.capabilities.completionProvider.triggerCharacters,
-        async provideCompletionItems(model, position) {
-            const result = await serverLib.complete(lspArgs(model, position));
-            const word = model.getWordUntilPosition(position);
-            const range = {
-                startLineNumber: position.lineNumber,
-                endLineNumber: position.lineNumber,
-                startColumn: word.startColumn,
-                endColumn: word.endColumn,
-            };
-            const suggestions = [];
-            for (const item of result.items) {
-                let itemRange = range;
-                let insertText = item.insertText ?? item.label;
-                if (item.textEdit && "range" in item.textEdit) {
-                    itemRange = LspToMonaco.range(item.textEdit.range);
-                    insertText = item.textEdit.newText;
-                }
-                suggestions.push({
-                    label: item.label,
-                    kind: item.kind,
-                    documentation: item.documentation,
-                    insertText,
-                    range: itemRange,
-                    commitCharacters: item.commitCharacters ?? lsConfig.capabilities.completionProvider.allCommitCharacters,
-                    tags: item.tags,
-                });
-            }
-            return { suggestions };
-        },
-    });
-    // This doesn't actually work because the lsp is not aware of the diagnostics here as we make our own compilation in the playground.
-    // monaco.languages.registerCodeActionProvider("typespec", {
-    //   async provideCodeActions(model, range, context, token) {
-    //     const result = await serverLib.getCodeActions({
-    //       range: MonacoToLsp.range(range),
-    //       context: MonacoToLsp.codeActionContext(context),
-    //       textDocument: textDocumentForModel(model),
-    //     });
-    //     return { actions: result.map(LspToMonaco.codeAction), dispose: () => {} };
-    //   },
-    // });
-    monaco.editor.defineTheme("typespec", {
-        base: "vs",
-        inherit: true,
-        colors: {},
-        rules: [
-            { token: "macro", foreground: "#800000" },
-            { token: "function", foreground: "#795E26" },
-        ],
-    });
-    monaco.editor.defineTheme("typespec-dark", {
-        base: "vs-dark",
-        inherit: true,
-        colors: {},
-        rules: [
-            { token: "macro", foreground: "#E06C75" },
-            { token: "function", foreground: "#E06C75" },
-        ],
-    });
-    monaco.editor.setTheme("typespec");
-    monaco.languages.registerDocumentSemanticTokensProvider("typespec", {
-        getLegend() {
-            const legend = lsConfig.capabilities.semanticTokensProvider.legend;
-            return {
-                tokenModifiers: legend.tokenModifiers,
-                tokenTypes: legend.tokenTypes.map((entry) => {
-                    switch (entry) {
-                        case "namespace":
-                        case "class":
-                        case "enum":
-                        case "typeParameter":
-                        case "struct":
-                        case "interface":
-                            return "type";
-                        case "property":
-                        case "enumMember":
-                            return "variable";
-                        case "docCommentTag":
-                            return "keyword";
-                        default:
-                            return entry;
-                    }
-                }),
-            };
-        },
-        async provideDocumentSemanticTokens(model) {
-            const result = await serverLib.buildSemanticTokens(lspDocumentArgs(model));
-            return {
-                resultId: result.resultId,
-                data: new Uint32Array(result.data),
-            };
-        },
-        releaseDocumentSemanticTokens() { },
-    });
-}
-function getMonacoRange(typespecCompiler, target) {
-    const loc = typespecCompiler.getSourceLocation(target);
-    if (loc === undefined || loc.file.path !== "/test/main.tsp") {
-        return {
-            startLineNumber: 1,
-            startColumn: 1,
-            endLineNumber: 1,
-            endColumn: 1,
-        };
-    }
-    const start = loc.file.getLineAndCharacterOfPosition(loc.pos);
-    const end = loc.file.getLineAndCharacterOfPosition(loc.end);
-    return {
-        startLineNumber: start.line + 1,
-        startColumn: start.character + 1,
-        endLineNumber: end.line + 1,
-        endColumn: end.character + 1,
-    };
-}
-
-/**
- * Generic storage mechanism for data in the playground.
- * @param schema Schema of the data to be serialized in the query
- * @returns
- */
-function createUrlStateStorage(schema) {
-    return { load, save, resolveSearchParams };
-    function load() {
-        const result = {};
-        const parsed = new URLSearchParams(window.location.search);
-        for (const [key, item] of Object.entries(schema)) {
-            const value = parsed.get(item.queryParam);
-            const decompressed = value && decompress(item, value);
-            const deserialized = decompressed && deserialize(item, decompressed);
-            if (deserialized) {
-                result[key] = deserialized;
-            }
-        }
-        return result;
-    }
-    function decompress(item, value) {
-        if (item.compress) {
-            try {
-                return lzutf8.decompress(value, { inputEncoding: "Base64" });
-            }
-            catch (e) {
-                // eslint-disable-next-line no-console
-                console.error(`Error decompressing query parameter ${item.queryParam} with content:`, value);
-                return undefined;
-            }
-        }
-        else {
-            return value;
-        }
-    }
-    function deserialize(item, value) {
-        if (item.type === "object") {
-            try {
-                return JSON.parse(value);
-            }
-            catch (e) {
-                // eslint-disable-next-line no-console
-                console.error(`Error decompressing query parameter ${item.queryParam} with content:`, value);
-                return undefined;
-            }
-        }
-        else {
-            return value;
-        }
-    }
-    function save(data) {
-        const params = resolveSearchParams(data, true);
-        history.pushState(null, "", window.location.pathname + "?" + params.toString());
-    }
-    function resolveSearchParams(data, mergeWithExisting = false) {
-        const params = new URLSearchParams(mergeWithExisting ? location.search : undefined);
-        for (const [key, item] of Object.entries(schema)) {
-            const value = data[key];
-            if (value) {
-                const serialized = serialize(item, value);
-                const compressed = compress(item, serialized);
-                params.set(item.queryParam, compressed);
-            }
-            else {
-                params.delete(item.queryParam);
-            }
-        }
-        return params;
-    }
-    function compress(item, value) {
-        if (item.compress) {
-            return lzutf8.compress(value, { outputEncoding: "Base64" });
-        }
-        else {
-            return value;
-        }
-    }
-    function serialize(item, value) {
-        if (item.type === "object") {
-            return JSON.stringify(value);
-        }
-        else {
-            return value;
-        }
-    }
-}
-
-export { createUrlStateStorage as a, createBrowserHost as c, getMonacoRange as g, registerMonacoLanguage as r };
-//# sourceMappingURL=state-storage-CObxFEXn.js.map