@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/utils.js

@@ -1,345 +0,0 @@
-import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-let _derived;
-function _setDerived(derived) {
-    _derived = derived;
-}
-class ConvenientObservable {
-    get TChange() { return null; }
-    read(reader) {
-        reader.subscribeTo(this);
-        return this.get();
-    }
-    map(fn) {
-        return _derived(() => {
-            const name = getFunctionName(fn);
-            return name !== undefined ? name : `${this.debugName} (mapped)`;
-        }, (reader) => fn(this.read(reader)));
-    }
-}
-class BaseObservable extends ConvenientObservable {
-    constructor() {
-        super(...arguments);
-        this.observers = ( new Set());
-    }
-    addObserver(observer) {
-        const len = this.observers.size;
-        this.observers.add(observer);
-        if (len === 0) {
-            this.onFirstObserverAdded();
-        }
-    }
-    removeObserver(observer) {
-        const deleted = this.observers.delete(observer);
-        if (deleted && this.observers.size === 0) {
-            this.onLastObserverRemoved();
-        }
-    }
-    onFirstObserverAdded() { }
-    onLastObserverRemoved() { }
-}
-function transaction(fn, getDebugName) {
-    const tx = ( new TransactionImpl(fn, getDebugName));
-    try {
-        fn(tx);
-    }
-    finally {
-        tx.finish();
-    }
-}
-function getFunctionName(fn) {
-    const fnSrc = ( fn.toString());
-    const regexp = /\/\*\*\s*@description\s*([^*]*)\*\//;
-    const match = regexp.exec(fnSrc);
-    const result = match ? match[1] : undefined;
-    return result?.trim();
-}
-class TransactionImpl {
-    constructor(fn, _getDebugName) {
-        this.fn = fn;
-        this._getDebugName = _getDebugName;
-        this.updatingObservers = [];
-    }
-    getDebugName() {
-        if (this._getDebugName) {
-            return this._getDebugName();
-        }
-        return getFunctionName(this.fn);
-    }
-    updateObserver(observer, observable) {
-        this.updatingObservers.push({ observer, observable });
-        observer.beginUpdate(observable);
-    }
-    finish() {
-        const updatingObservers = this.updatingObservers;
-        this.updatingObservers = null;
-        for (const { observer, observable } of updatingObservers) {
-            observer.endUpdate(observable);
-        }
-    }
-}
-function observableValue(name, initialValue) {
-    return ( new ObservableValue(name, initialValue));
-}
-class ObservableValue extends BaseObservable {
-    constructor(debugName, initialValue) {
-        super();
-        this.debugName = debugName;
-        this.value = initialValue;
-    }
-    get() {
-        return this.value;
-    }
-    set(value, tx, change) {
-        if (this.value === value) {
-            return;
-        }
-        if (!tx) {
-            transaction((tx) => {
-                this.set(value, tx, change);
-            }, () => `Setting ${this.debugName}`);
-            return;
-        }
-        this.value = value;
-        for (const observer of this.observers) {
-            tx.updateObserver(observer, this);
-            observer.handleChange(this, change);
-        }
-    }
-    toString() {
-        return `${this.debugName}: ${this.value}`;
-    }
-}
-function autorun(debugName, fn) {
-    return ( new AutorunObserver(debugName, fn, undefined));
-}
-function autorunWithStore(fn, debugName) {
-    const store = ( new DisposableStore());
-    const disposable = autorun(debugName, reader => {
-        store.clear();
-        fn(reader, store);
-    });
-    return toDisposable(() => {
-        disposable.dispose();
-        store.dispose();
-    });
-}
-class AutorunObserver {
-    get dependencies() {
-        return this._dependencies;
-    }
-    constructor(debugName, runFn, _handleChange) {
-        this.debugName = debugName;
-        this.runFn = runFn;
-        this._handleChange = _handleChange;
-        this.needsToRun = true;
-        this.updateCount = 0;
-        this.disposed = false;
-        this._dependencies = ( new Set());
-        this.staleDependencies = ( new Set());
-        this.runIfNeeded();
-    }
-    subscribeTo(observable) {
-        if (this.disposed) {
-            return;
-        }
-        this._dependencies.add(observable);
-        if (!this.staleDependencies.delete(observable)) {
-            observable.addObserver(this);
-        }
-    }
-    handleChange(observable, change) {
-        const shouldReact = this._handleChange ? this._handleChange({
-            changedObservable: observable,
-            change,
-            didChange: o => o === observable,
-        }) : true;
-        this.needsToRun = this.needsToRun || shouldReact;
-        if (this.updateCount === 0) {
-            this.runIfNeeded();
-        }
-    }
-    beginUpdate() {
-        this.updateCount++;
-    }
-    endUpdate() {
-        this.updateCount--;
-        if (this.updateCount === 0) {
-            this.runIfNeeded();
-        }
-    }
-    runIfNeeded() {
-        if (!this.needsToRun) {
-            return;
-        }
-        const emptySet = this.staleDependencies;
-        this.staleDependencies = this._dependencies;
-        this._dependencies = emptySet;
-        this.needsToRun = false;
-        try {
-            this.runFn(this);
-        }
-        finally {
-            for (const o of this.staleDependencies) {
-                o.removeObserver(this);
-            }
-            this.staleDependencies.clear();
-        }
-    }
-    dispose() {
-        this.disposed = true;
-        for (const o of this._dependencies) {
-            o.removeObserver(this);
-        }
-        this._dependencies.clear();
-    }
-    toString() {
-        return `Autorun<${this.debugName}>`;
-    }
-}
-( (function(autorun) {
-    autorun.Observer = AutorunObserver;
-})(autorun || (autorun = {})));
-function autorunDelta(name, observable, handler) {
-    let _lastValue;
-    return autorun(name, (reader) => {
-        const newValue = observable.read(reader);
-        const lastValue = _lastValue;
-        _lastValue = newValue;
-        handler({ lastValue, newValue });
-    });
-}
-function constObservable(value) {
-    return ( new ConstObservable(value));
-}
-class ConstObservable extends ConvenientObservable {
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-    get debugName() {
-        return ( this.toString());
-    }
-    get() {
-        return this.value;
-    }
-    addObserver(observer) {
-    }
-    removeObserver(observer) {
-    }
-    toString() {
-        return `Const: ${this.value}`;
-    }
-}
-function observableFromPromise(promise) {
-    const observable = observableValue('promiseValue', {});
-    promise.then((value) => {
-        observable.set({ value }, undefined);
-    });
-    return observable;
-}
-function observableFromEvent(event, getValue) {
-    return ( new FromEventObservable(event, getValue));
-}
-class FromEventObservable extends BaseObservable {
-    constructor(event, getValue) {
-        super();
-        this.event = event;
-        this.getValue = getValue;
-        this.hasValue = false;
-        this.handleEvent = (args) => {
-            const newValue = this.getValue(args);
-            const didChange = !this.hasValue || this.value !== newValue;
-            if (didChange) {
-                this.value = newValue;
-                if (this.hasValue) {
-                    transaction((tx) => {
-                        for (const o of this.observers) {
-                            tx.updateObserver(o, this);
-                            o.handleChange(this, undefined);
-                        }
-                    }, () => {
-                        const name = this.getDebugName();
-                        return 'Event fired' + (name ? `: ${name}` : '');
-                    });
-                }
-                this.hasValue = true;
-            }
-        };
-    }
-    getDebugName() {
-        return getFunctionName(this.getValue);
-    }
-    get debugName() {
-        const name = this.getDebugName();
-        return 'From Event' + (name ? `: ${name}` : '');
-    }
-    onFirstObserverAdded() {
-        this.subscription = this.event(this.handleEvent);
-    }
-    onLastObserverRemoved() {
-        this.subscription.dispose();
-        this.subscription = undefined;
-        this.hasValue = false;
-        this.value = undefined;
-    }
-    get() {
-        if (this.subscription) {
-            if (!this.hasValue) {
-                this.handleEvent(undefined);
-            }
-            return this.value;
-        }
-        else {
-            return this.getValue(undefined);
-        }
-    }
-}
-( (function(observableFromEvent) {
-    observableFromEvent.Observer = FromEventObservable;
-})(observableFromEvent || (observableFromEvent = {})));
-function debouncedObservable(observable, debounceMs, disposableStore) {
-    const debouncedObservable = observableValue('debounced', undefined);
-    let timeout = undefined;
-    disposableStore.add(autorun('debounce', reader => {
-        const value = observable.read(reader);
-        if (timeout) {
-            clearTimeout(timeout);
-        }
-        timeout = setTimeout(() => {
-            transaction(tx => {
-                debouncedObservable.set(value, tx);
-            });
-        }, debounceMs);
-    }));
-    return debouncedObservable;
-}
-function wasEventTriggeredRecently(event, timeoutMs, disposableStore) {
-    const observable = observableValue('triggeredRecently', false);
-    let timeout = undefined;
-    disposableStore.add(event(() => {
-        observable.set(true, undefined);
-        if (timeout) {
-            clearTimeout(timeout);
-        }
-        timeout = setTimeout(() => {
-            observable.set(false, undefined);
-        }, timeoutMs);
-    }));
-    return observable;
-}
-function keepAlive(observable) {
-    const o = ( new KeepAliveObserver());
-    observable.addObserver(o);
-    return toDisposable(() => {
-        observable.removeObserver(o);
-    });
-}
-class KeepAliveObserver {
-    beginUpdate(observable) {
-    }
-    handleChange(observable, change) {
-    }
-    endUpdate(observable) {
-    }
-}
-export { BaseObservable, _setDerived, autorun, autorunDelta, autorunWithStore, constObservable, debouncedObservable, keepAlive, observableFromEvent, observableFromPromise, wasEventTriggeredRecently };

package/dist/webpack-loader.cjs

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.raw = void 0;
-const path_1 = require("path");
-const monacoPolyfillLoader = function (source) {
-    if (this.resourcePath.endsWith(`monaco-editor${path_1.sep}esm${path_1.sep}vs${path_1.sep}editor${path_1.sep}contrib${path_1.sep}suggest${path_1.sep}browser${path_1.sep}suggest.js`)) {
-        return `${source.toString()}
-export function setSnippetSuggestSupport(support) {
-  const old = _snippetSuggestSupport;
-  _snippetSuggestSupport = support;
-  return old;
-}
-`;
-    }
-    return source;
-};
-exports.default = monacoPolyfillLoader;
-exports.raw = true; // for TTFs, see https://stackoverflow.com/questions/48824081/webpack-image-loader-encoding-breaks

package/dist/webpack-loader.d.ts

@@ -1,4 +0,0 @@
-import type { RawLoaderDefinitionFunction } from 'webpack';
-declare const monacoPolyfillLoader: RawLoaderDefinitionFunction;
-export default monacoPolyfillLoader;
-export declare const raw = true;

package/dist/{unboundCommands.js → vscode/vs/workbench/services/keybinding/browser/unboundCommands.js}

@@ -1,7 +1,7 @@
-import { MenuRegistry, MenuId, isIMenuItem } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { MenuRegistry, MenuId, isIMenuItem } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 function getAllUnboundCommands(boundCommands) {
     const unboundCommands = [];
     const seenMap = ( new Map());