monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/webWorker.js

@@ -0,0 +1,396 @@
+import { onUnexpectedError, transformErrorForSerialization } from '../errors.js';
+import { Emitter } from '../event.js';
+import { Disposable } from '../lifecycle.js';
+import { isWeb } from '../platform.js';
+import { isUpperAsciiLetter } from '../strings.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const DEFAULT_CHANNEL = 'default';
+const INITIALIZE = '$initialize';
+let webWorkerWarningLogged = false;
+function logOnceWebWorkerWarning(err) {
+    if (!isWeb) {
+        // running tests
+        return;
+    }
+    if (!webWorkerWarningLogged) {
+        webWorkerWarningLogged = true;
+        console.warn('Could not create web worker(s). Falling back to loading web worker code in main thread, which might cause UI freezes. Please see https://github.com/microsoft/monaco-editor#faq');
+    }
+    console.warn(err.message);
+}
+class RequestMessage {
+    constructor(vsWorker, req, channel, method, args) {
+        this.vsWorker = vsWorker;
+        this.req = req;
+        this.channel = channel;
+        this.method = method;
+        this.args = args;
+        this.type = 0 /* MessageType.Request */;
+    }
+}
+class ReplyMessage {
+    constructor(vsWorker, seq, res, err) {
+        this.vsWorker = vsWorker;
+        this.seq = seq;
+        this.res = res;
+        this.err = err;
+        this.type = 1 /* MessageType.Reply */;
+    }
+}
+class SubscribeEventMessage {
+    constructor(vsWorker, req, channel, eventName, arg) {
+        this.vsWorker = vsWorker;
+        this.req = req;
+        this.channel = channel;
+        this.eventName = eventName;
+        this.arg = arg;
+        this.type = 2 /* MessageType.SubscribeEvent */;
+    }
+}
+class EventMessage {
+    constructor(vsWorker, req, event) {
+        this.vsWorker = vsWorker;
+        this.req = req;
+        this.event = event;
+        this.type = 3 /* MessageType.Event */;
+    }
+}
+class UnsubscribeEventMessage {
+    constructor(vsWorker, req) {
+        this.vsWorker = vsWorker;
+        this.req = req;
+        this.type = 4 /* MessageType.UnsubscribeEvent */;
+    }
+}
+class WebWorkerProtocol {
+    constructor(handler) {
+        this._workerId = -1;
+        this._handler = handler;
+        this._lastSentReq = 0;
+        this._pendingReplies = Object.create(null);
+        this._pendingEmitters = new Map();
+        this._pendingEvents = new Map();
+    }
+    setWorkerId(workerId) {
+        this._workerId = workerId;
+    }
+    async sendMessage(channel, method, args) {
+        const req = String(++this._lastSentReq);
+        return new Promise((resolve, reject) => {
+            this._pendingReplies[req] = {
+                resolve: resolve,
+                reject: reject
+            };
+            this._send(new RequestMessage(this._workerId, req, channel, method, args));
+        });
+    }
+    listen(channel, eventName, arg) {
+        let req = null;
+        const emitter = new Emitter({
+            onWillAddFirstListener: () => {
+                req = String(++this._lastSentReq);
+                this._pendingEmitters.set(req, emitter);
+                this._send(new SubscribeEventMessage(this._workerId, req, channel, eventName, arg));
+            },
+            onDidRemoveLastListener: () => {
+                this._pendingEmitters.delete(req);
+                this._send(new UnsubscribeEventMessage(this._workerId, req));
+                req = null;
+            }
+        });
+        return emitter.event;
+    }
+    handleMessage(message) {
+        if (!message || !message.vsWorker) {
+            return;
+        }
+        if (this._workerId !== -1 && message.vsWorker !== this._workerId) {
+            return;
+        }
+        this._handleMessage(message);
+    }
+    createProxyToRemoteChannel(channel, sendMessageBarrier) {
+        const handler = {
+            get: (target, name) => {
+                if (typeof name === 'string' && !target[name]) {
+                    if (propertyIsDynamicEvent(name)) { // onDynamic...
+                        target[name] = (arg) => {
+                            return this.listen(channel, name, arg);
+                        };
+                    }
+                    else if (propertyIsEvent(name)) { // on...
+                        target[name] = this.listen(channel, name, undefined);
+                    }
+                    else if (name.charCodeAt(0) === 36 /* CharCode.DollarSign */) { // $...
+                        target[name] = async (...myArgs) => {
+                            await sendMessageBarrier?.();
+                            return this.sendMessage(channel, name, myArgs);
+                        };
+                    }
+                }
+                return target[name];
+            }
+        };
+        return new Proxy(Object.create(null), handler);
+    }
+    _handleMessage(msg) {
+        switch (msg.type) {
+            case 1 /* MessageType.Reply */:
+                return this._handleReplyMessage(msg);
+            case 0 /* MessageType.Request */:
+                return this._handleRequestMessage(msg);
+            case 2 /* MessageType.SubscribeEvent */:
+                return this._handleSubscribeEventMessage(msg);
+            case 3 /* MessageType.Event */:
+                return this._handleEventMessage(msg);
+            case 4 /* MessageType.UnsubscribeEvent */:
+                return this._handleUnsubscribeEventMessage(msg);
+        }
+    }
+    _handleReplyMessage(replyMessage) {
+        if (!this._pendingReplies[replyMessage.seq]) {
+            console.warn('Got reply to unknown seq');
+            return;
+        }
+        const reply = this._pendingReplies[replyMessage.seq];
+        delete this._pendingReplies[replyMessage.seq];
+        if (replyMessage.err) {
+            let err = replyMessage.err;
+            if (replyMessage.err.$isError) {
+                const newErr = new Error();
+                newErr.name = replyMessage.err.name;
+                newErr.message = replyMessage.err.message;
+                newErr.stack = replyMessage.err.stack;
+                err = newErr;
+            }
+            reply.reject(err);
+            return;
+        }
+        reply.resolve(replyMessage.res);
+    }
+    _handleRequestMessage(requestMessage) {
+        const req = requestMessage.req;
+        const result = this._handler.handleMessage(requestMessage.channel, requestMessage.method, requestMessage.args);
+        result.then((r) => {
+            this._send(new ReplyMessage(this._workerId, req, r, undefined));
+        }, (e) => {
+            if (e.detail instanceof Error) {
+                // Loading errors have a detail property that points to the actual error
+                e.detail = transformErrorForSerialization(e.detail);
+            }
+            this._send(new ReplyMessage(this._workerId, req, undefined, transformErrorForSerialization(e)));
+        });
+    }
+    _handleSubscribeEventMessage(msg) {
+        const req = msg.req;
+        const disposable = this._handler.handleEvent(msg.channel, msg.eventName, msg.arg)((event) => {
+            this._send(new EventMessage(this._workerId, req, event));
+        });
+        this._pendingEvents.set(req, disposable);
+    }
+    _handleEventMessage(msg) {
+        if (!this._pendingEmitters.has(msg.req)) {
+            console.warn('Got event for unknown req');
+            return;
+        }
+        this._pendingEmitters.get(msg.req).fire(msg.event);
+    }
+    _handleUnsubscribeEventMessage(msg) {
+        if (!this._pendingEvents.has(msg.req)) {
+            console.warn('Got unsubscribe for unknown req');
+            return;
+        }
+        this._pendingEvents.get(msg.req).dispose();
+        this._pendingEvents.delete(msg.req);
+    }
+    _send(msg) {
+        const transfer = [];
+        if (msg.type === 0 /* MessageType.Request */) {
+            for (let i = 0; i < msg.args.length; i++) {
+                const arg = msg.args[i];
+                if (arg instanceof ArrayBuffer) {
+                    transfer.push(arg);
+                }
+            }
+        }
+        else if (msg.type === 1 /* MessageType.Reply */) {
+            if (msg.res instanceof ArrayBuffer) {
+                transfer.push(msg.res);
+            }
+        }
+        this._handler.sendMessage(msg, transfer);
+    }
+}
+/**
+ * Main thread side
+ */
+class WebWorkerClient extends Disposable {
+    constructor(worker) {
+        super();
+        this._localChannels = new Map();
+        this._worker = this._register(worker);
+        this._register(this._worker.onMessage((msg) => {
+            this._protocol.handleMessage(msg);
+        }));
+        this._register(this._worker.onError((err) => {
+            logOnceWebWorkerWarning(err);
+            onUnexpectedError(err);
+        }));
+        this._protocol = new WebWorkerProtocol({
+            sendMessage: (msg, transfer) => {
+                this._worker.postMessage(msg, transfer);
+            },
+            handleMessage: (channel, method, args) => {
+                return this._handleMessage(channel, method, args);
+            },
+            handleEvent: (channel, eventName, arg) => {
+                return this._handleEvent(channel, eventName, arg);
+            }
+        });
+        this._protocol.setWorkerId(this._worker.getId());
+        // Send initialize message
+        this._onModuleLoaded = this._protocol.sendMessage(DEFAULT_CHANNEL, INITIALIZE, [
+            this._worker.getId(),
+        ]).then(() => { });
+        this.proxy = this._protocol.createProxyToRemoteChannel(DEFAULT_CHANNEL, async () => { await this._onModuleLoaded; });
+        this._onModuleLoaded.catch((e) => {
+            this._onError('Worker failed to load ', e);
+        });
+    }
+    _handleMessage(channelName, method, args) {
+        const channel = this._localChannels.get(channelName);
+        if (!channel) {
+            return Promise.reject(new Error(`Missing channel ${channelName} on main thread`));
+        }
+        const fn = channel[method];
+        if (typeof fn !== 'function') {
+            return Promise.reject(new Error(`Missing method ${method} on main thread channel ${channelName}`));
+        }
+        try {
+            return Promise.resolve(fn.apply(channel, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+    _handleEvent(channelName, eventName, arg) {
+        const channel = this._localChannels.get(channelName);
+        if (!channel) {
+            throw new Error(`Missing channel ${channelName} on main thread`);
+        }
+        if (propertyIsDynamicEvent(eventName)) {
+            const fn = channel[eventName];
+            if (typeof fn !== 'function') {
+                throw new Error(`Missing dynamic event ${eventName} on main thread channel ${channelName}.`);
+            }
+            const event = fn.call(channel, arg);
+            if (typeof event !== 'function') {
+                throw new Error(`Missing dynamic event ${eventName} on main thread channel ${channelName}.`);
+            }
+            return event;
+        }
+        if (propertyIsEvent(eventName)) {
+            const event = channel[eventName];
+            if (typeof event !== 'function') {
+                throw new Error(`Missing event ${eventName} on main thread channel ${channelName}.`);
+            }
+            return event;
+        }
+        throw new Error(`Malformed event name ${eventName}`);
+    }
+    setChannel(channel, handler) {
+        this._localChannels.set(channel, handler);
+    }
+    _onError(message, error) {
+        console.error(message);
+        console.info(error);
+    }
+}
+function propertyIsEvent(name) {
+    // Assume a property is an event if it has a form of "onSomething"
+    return name[0] === 'o' && name[1] === 'n' && isUpperAsciiLetter(name.charCodeAt(2));
+}
+function propertyIsDynamicEvent(name) {
+    // Assume a property is a dynamic event (a method that returns an event) if it has a form of "onDynamicSomething"
+    return /^onDynamic/.test(name) && isUpperAsciiLetter(name.charCodeAt(9));
+}
+/**
+ * Worker side
+ */
+class WebWorkerServer {
+    constructor(postMessage, requestHandlerFactory) {
+        this._localChannels = new Map();
+        this._remoteChannels = new Map();
+        this._protocol = new WebWorkerProtocol({
+            sendMessage: (msg, transfer) => {
+                postMessage(msg, transfer);
+            },
+            handleMessage: (channel, method, args) => this._handleMessage(channel, method, args),
+            handleEvent: (channel, eventName, arg) => this._handleEvent(channel, eventName, arg)
+        });
+        this.requestHandler = requestHandlerFactory(this);
+    }
+    onmessage(msg) {
+        this._protocol.handleMessage(msg);
+    }
+    _handleMessage(channel, method, args) {
+        if (channel === DEFAULT_CHANNEL && method === INITIALIZE) {
+            return this.initialize(args[0]);
+        }
+        const requestHandler = (channel === DEFAULT_CHANNEL ? this.requestHandler : this._localChannels.get(channel));
+        if (!requestHandler) {
+            return Promise.reject(new Error(`Missing channel ${channel} on worker thread`));
+        }
+        const fn = requestHandler[method];
+        if (typeof fn !== 'function') {
+            return Promise.reject(new Error(`Missing method ${method} on worker thread channel ${channel}`));
+        }
+        try {
+            return Promise.resolve(fn.apply(requestHandler, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+    _handleEvent(channel, eventName, arg) {
+        const requestHandler = (channel === DEFAULT_CHANNEL ? this.requestHandler : this._localChannels.get(channel));
+        if (!requestHandler) {
+            throw new Error(`Missing channel ${channel} on worker thread`);
+        }
+        if (propertyIsDynamicEvent(eventName)) {
+            const fn = requestHandler[eventName];
+            if (typeof fn !== 'function') {
+                throw new Error(`Missing dynamic event ${eventName} on request handler.`);
+            }
+            const event = fn.call(requestHandler, arg);
+            if (typeof event !== 'function') {
+                throw new Error(`Missing dynamic event ${eventName} on request handler.`);
+            }
+            return event;
+        }
+        if (propertyIsEvent(eventName)) {
+            const event = requestHandler[eventName];
+            if (typeof event !== 'function') {
+                throw new Error(`Missing event ${eventName} on request handler.`);
+            }
+            return event;
+        }
+        throw new Error(`Malformed event name ${eventName}`);
+    }
+    getChannel(channel) {
+        if (!this._remoteChannels.has(channel)) {
+            const inst = this._protocol.createProxyToRemoteChannel(channel);
+            this._remoteChannels.set(channel, inst);
+        }
+        return this._remoteChannels.get(channel);
+    }
+    async initialize(workerId) {
+        this._protocol.setWorkerId(workerId);
+    }
+}
+
+export { WebWorkerClient, WebWorkerServer, logOnceWebWorkerWarning };

package/dist/workers/webWorkerBootstrap.js

@@ -0,0 +1,20 @@
+import { WebWorkerServer } from './webWorker.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+let initialized = false;
+function initialize(factory) {
+    if (initialized) {
+        throw new Error('WebWorker already initialized!');
+    }
+    initialized = true;
+    const webWorkerServer = new WebWorkerServer(msg => globalThis.postMessage(msg), (workerServer) => factory(workerServer));
+    globalThis.onmessage = (e) => {
+        webWorkerServer.onmessage(e.data);
+    };
+    return webWorkerServer;
+}
+
+export { initialize };

package/dist/workers/webWorkerFactory.js

@@ -0,0 +1,171 @@
+import { createTrustedTypesPolicy } from './trustedTypes.js';
+import { onUnexpectedError } from '../common/errors.js';
+import { COI } from '../common/network.js';
+import { URI } from '../common/uri.js';
+import { WebWorkerClient } from '../common/worker/webWorker.js';
+import { Disposable, toDisposable } from '../common/lifecycle.js';
+import { coalesce } from '../common/arrays.js';
+import '../../nls.js';
+import { Emitter } from '../common/event.js';
+import { getMonacoEnvironment } from './browser.js';
+import { getNLSMessages, getNLSLanguage } from '../../nls.messages.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Reuse the trusted types policy defined from worker bootstrap
+// when available.
+// Refs https://github.com/microsoft/vscode/issues/222193
+let ttPolicy;
+// eslint-disable-next-line local/code-no-any-casts
+if (typeof self === 'object' && self.constructor && self.constructor.name === 'DedicatedWorkerGlobalScope' && globalThis.workerttPolicy !== undefined) {
+    // eslint-disable-next-line local/code-no-any-casts
+    ttPolicy = globalThis.workerttPolicy;
+}
+else {
+    ttPolicy = createTrustedTypesPolicy('defaultWorkerFactory', { createScriptURL: value => value });
+}
+function getWorker(descriptor, id) {
+    const label = descriptor.label || 'anonymous' + id;
+    // Option for hosts to overwrite the worker script (used in the standalone editor)
+    const monacoEnvironment = getMonacoEnvironment();
+    if (monacoEnvironment) {
+        if (typeof monacoEnvironment.getWorker === 'function') {
+            return monacoEnvironment.getWorker('workerMain.js', label);
+        }
+        if (typeof monacoEnvironment.getWorkerUrl === 'function') {
+            const workerUrl = monacoEnvironment.getWorkerUrl('workerMain.js', label);
+            return new Worker(ttPolicy ? ttPolicy.createScriptURL(workerUrl) : workerUrl, { name: label, type: 'module' });
+        }
+    }
+    const esmWorkerLocation = descriptor.esmModuleLocation;
+    if (esmWorkerLocation) {
+        const workerUrl = getWorkerBootstrapUrl(label, esmWorkerLocation.toString(true));
+        const worker = new Worker(ttPolicy ? ttPolicy.createScriptURL(workerUrl) : workerUrl, { name: label, type: 'module' });
+        return whenESMWorkerReady(worker);
+    }
+    throw new Error(`You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker`);
+}
+function getWorkerBootstrapUrl(label, workerScriptUrl) {
+    if (/^((http:)|(https:)|(file:))/.test(workerScriptUrl) && workerScriptUrl.substring(0, globalThis.origin.length) !== globalThis.origin) ;
+    else {
+        const start = workerScriptUrl.lastIndexOf('?');
+        const end = workerScriptUrl.lastIndexOf('#', start);
+        const params = start > 0
+            ? new URLSearchParams(workerScriptUrl.substring(start + 1, ~end ? end : undefined))
+            : new URLSearchParams();
+        COI.addSearchParam(params, true, true);
+        const search = params.toString();
+        if (!search) {
+            workerScriptUrl = `${workerScriptUrl}#${label}`;
+        }
+        else {
+            workerScriptUrl = `${workerScriptUrl}?${params.toString()}#${label}`;
+        }
+    }
+    // In below blob code, we are using JSON.stringify to ensure the passed
+    // in values are not breaking our script. The values may contain string
+    // terminating characters (such as ' or ").
+    const blob = new Blob([coalesce([
+            `/*${label}*/`,
+            `globalThis._VSCODE_NLS_MESSAGES = ${JSON.stringify(getNLSMessages())};`,
+            `globalThis._VSCODE_NLS_LANGUAGE = ${JSON.stringify(getNLSLanguage())};`,
+            `globalThis._VSCODE_FILE_ROOT = ${JSON.stringify(globalThis._VSCODE_FILE_ROOT)};`,
+            `const ttPolicy = globalThis.trustedTypes?.createPolicy('defaultWorkerFactory', { createScriptURL: value => value });`,
+            `globalThis.workerttPolicy = ttPolicy;`,
+            `await import(ttPolicy?.createScriptURL(${JSON.stringify(workerScriptUrl)}) ?? ${JSON.stringify(workerScriptUrl)});`,
+            `globalThis.postMessage({ type: 'vscode-worker-ready' });`,
+            `/*${label}*/`
+        ]).join('')], { type: 'application/javascript' });
+    return URL.createObjectURL(blob);
+}
+function whenESMWorkerReady(worker) {
+    return new Promise((resolve, reject) => {
+        worker.onmessage = function (e) {
+            if (e.data.type === 'vscode-worker-ready') {
+                worker.onmessage = null;
+                resolve(worker);
+            }
+        };
+        worker.onerror = reject;
+    });
+}
+function isPromiseLike(obj) {
+    return !!obj && typeof obj.then === 'function';
+}
+/**
+ * A worker that uses HTML5 web workers so that is has
+ * its own global scope and its own thread.
+ */
+class WebWorker extends Disposable {
+    static { this.LAST_WORKER_ID = 0; }
+    constructor(descriptorOrWorker) {
+        super();
+        this._onMessage = this._register(new Emitter());
+        this.onMessage = this._onMessage.event;
+        this._onError = this._register(new Emitter());
+        this.onError = this._onError.event;
+        this.id = ++WebWorker.LAST_WORKER_ID;
+        const workerOrPromise = (descriptorOrWorker instanceof Worker
+            ? descriptorOrWorker :
+            'then' in descriptorOrWorker ? descriptorOrWorker
+                : getWorker(descriptorOrWorker, this.id));
+        if (isPromiseLike(workerOrPromise)) {
+            this.worker = workerOrPromise;
+        }
+        else {
+            this.worker = Promise.resolve(workerOrPromise);
+        }
+        this.postMessage('-please-ignore-', []); // TODO: Eliminate this extra message
+        const errorHandler = (ev) => {
+            this._onError.fire(ev);
+        };
+        this.worker.then((w) => {
+            w.onmessage = (ev) => {
+                this._onMessage.fire(ev.data);
+            };
+            w.onmessageerror = (ev) => {
+                this._onError.fire(ev);
+            };
+            if (typeof w.addEventListener === 'function') {
+                w.addEventListener('error', errorHandler);
+            }
+        });
+        this._register(toDisposable(() => {
+            this.worker?.then(w => {
+                w.onmessage = null;
+                w.onmessageerror = null;
+                w.removeEventListener('error', errorHandler);
+                w.terminate();
+            });
+            this.worker = null;
+        }));
+    }
+    getId() {
+        return this.id;
+    }
+    postMessage(message, transfer) {
+        this.worker?.then(w => {
+            try {
+                w.postMessage(message, transfer);
+            }
+            catch (err) {
+                onUnexpectedError(err);
+                onUnexpectedError(new Error(`FAILED to post message to worker`, { cause: err }));
+            }
+        });
+    }
+}
+class WebWorkerDescriptor {
+    constructor(esmModuleLocation, label) {
+        this.esmModuleLocation = esmModuleLocation;
+        this.label = label;
+    }
+}
+function createWebWorker(arg0, arg1) {
+    const workerDescriptorOrWorker = (URI.isUri(arg0) ? new WebWorkerDescriptor(arg0, arg1) : arg0);
+    return new WebWorkerClient(new WebWorker(workerDescriptorOrWorker));
+}
+
+export { WebWorkerDescriptor, createWebWorker };

package/dist/workers/wgsl.contribution.js

@@ -0,0 +1,8 @@
+import { registerLanguage } from '../_.contribution.js';
+
+registerLanguage({
+  id: "wgsl",
+  extensions: [".wgsl"],
+  aliases: ["WebGPU Shading Language", "WGSL", "wgsl"],
+  loader: () => import('./wgsl.js')
+});