@codingame/monaco-vscode-api 15.0.3 → 16.0.0

package/vscode/src/vs/base/common/observableInternal/logging/debugger/devToolsLogger.d.ts

@@ -0,0 +1,41 @@
+import { AutorunObserver } from "../../autorun.js";
+import { IObservable, TransactionImpl } from "../../base.js";
+import { Derived } from "../../derived.js";
+import { IChangeInformation, IObservableLogger } from "../logging.js";
+export declare class DevToolsLogger implements IObservableLogger {
+    private static _instance;
+    static getInstance(): DevToolsLogger;
+    private _declarationId;
+    private _instanceId;
+    private readonly _declarations;
+    private readonly _instanceInfos;
+    private readonly _aliveInstances;
+    private readonly _activeTransactions;
+    private readonly _channel;
+    private getTransactionState;
+    private _getObservableInfo;
+    private _getAutorunInfo;
+    private _getInfo;
+    private _formatObservable;
+    private _formatObserver;
+    private constructor();
+    private _pendingChanges;
+    private readonly _changeThrottler;
+    private readonly _fullState;
+    private _handleChange;
+    private readonly _flushUpdates;
+    private _getDeclarationId;
+    handleObservableCreated(observable: IObservable<any>): void;
+    handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
+    handleObservableUpdated(observable: IObservable<any>, changeInfo: IChangeInformation): void;
+    handleAutorunCreated(autorun: AutorunObserver): void;
+    handleAutorunDisposed(autorun: AutorunObserver): void;
+    handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
+    handleAutorunStarted(autorun: AutorunObserver): void;
+    handleAutorunFinished(autorun: AutorunObserver): void;
+    handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void;
+    _handleDerivedRecomputed(observable: Derived<any>, changeInfo: IChangeInformation): void;
+    handleDerivedCleared(observable: Derived<any>): void;
+    handleBeginTransaction(transaction: TransactionImpl): void;
+    handleEndTransaction(transaction: TransactionImpl): void;
+}

package/vscode/src/vs/base/common/observableInternal/logging/debugger/devToolsLogger.js

@@ -0,0 +1,436 @@
+
+import { AutorunObserver, AutorunState } from '../../autorun.js';
+import { ObservableValue } from '../../base.js';
+import { Derived, DerivedState } from '../../derived.js';
+import { formatValue } from '../consoleObservableLogger.js';
+import { registerDebugChannel } from './debuggerRpc.js';
+import { Throttler, deepAssignDeleteNulls, deepAssign, getFirstStackFrameOutsideOf } from './utils.js';
+import { isDefined } from '../../../types.js';
+import { FromEventObservable } from '../../utils.js';
+import { onUnexpectedError, BugIndicatingError } from '../../../errors.js';
+
+class DevToolsLogger {
+    static { this._instance = undefined; }
+    static getInstance() {
+        if (DevToolsLogger._instance === undefined) {
+            DevToolsLogger._instance = ( new DevToolsLogger());
+        }
+        return DevToolsLogger._instance;
+    }
+    getTransactionState() {
+        const affected = [];
+        const txs = [...this._activeTransactions];
+        if (txs.length === 0) {
+            return undefined;
+        }
+        const observerQueue = ( txs.flatMap(t => t.debugGetUpdatingObservers() ?? []).map(o => o.observer));
+        const processedObservers = ( new Set());
+        while (observerQueue.length > 0) {
+            const observer = observerQueue.shift();
+            if (( processedObservers.has(observer))) {
+                continue;
+            }
+            processedObservers.add(observer);
+            const state = this._getInfo(observer, d => {
+                if (!( processedObservers.has(d))) {
+                    observerQueue.push(d);
+                }
+            });
+            if (state) {
+                affected.push(state);
+            }
+        }
+        return { names: ( txs.map(t => t.getDebugName() ?? 'tx')), affected };
+    }
+    _getObservableInfo(observable) {
+        const info = this._instanceInfos.get(observable);
+        if (!info) {
+            onUnexpectedError(( new BugIndicatingError('No info found')));
+            return undefined;
+        }
+        return info;
+    }
+    _getAutorunInfo(autorun) {
+        const info = this._instanceInfos.get(autorun);
+        if (!info) {
+            onUnexpectedError(( new BugIndicatingError('No info found')));
+            return undefined;
+        }
+        return info;
+    }
+    _getInfo(observer, queue) {
+        if (observer instanceof Derived) {
+            const observersToUpdate = [...observer.debugGetObservers()];
+            for (const o of observersToUpdate) {
+                queue(o);
+            }
+            const info = this._getObservableInfo(observer);
+            if (!info) {
+                return;
+            }
+            const observerState = observer.debugGetState();
+            const base = { name: observer.debugName, instanceId: info.instanceId, updateCount: observerState.updateCount };
+            const changedDependencies = ( [...info.changedObservables].map(o => this._instanceInfos.get(o)?.instanceId)).filter(isDefined);
+            if (observerState.isComputing) {
+                return { ...base, type: 'observable/derived', state: 'updating', changedDependencies, initialComputation: false };
+            }
+            switch (observerState.state) {
+                case DerivedState.initial:
+                    return { ...base, type: 'observable/derived', state: 'noValue' };
+                case DerivedState.upToDate:
+                    return { ...base, type: 'observable/derived', state: 'upToDate' };
+                case DerivedState.stale:
+                    return { ...base, type: 'observable/derived', state: 'stale', changedDependencies };
+                case DerivedState.dependenciesMightHaveChanged:
+                    return { ...base, type: 'observable/derived', state: 'possiblyStale' };
+            }
+        }
+        else if (observer instanceof AutorunObserver) {
+            const info = this._getAutorunInfo(observer);
+            if (!info) {
+                return undefined;
+            }
+            const base = { name: observer.debugName, instanceId: info.instanceId, updateCount: info.updateCount };
+            const changedDependencies = ( [...info.changedObservables].map(o => this._instanceInfos.get(o).instanceId));
+            if (observer.debugGetState().isRunning) {
+                return { ...base, type: 'autorun', state: 'updating', changedDependencies };
+            }
+            switch (observer.debugGetState().state) {
+                case AutorunState.upToDate:
+                    return { ...base, type: 'autorun', state: 'upToDate' };
+                case AutorunState.stale:
+                    return { ...base, type: 'autorun', state: 'stale', changedDependencies };
+                case AutorunState.dependenciesMightHaveChanged:
+                    return { ...base, type: 'autorun', state: 'possiblyStale' };
+            }
+        }
+        return undefined;
+    }
+    _formatObservable(obs) {
+        const info = this._getObservableInfo(obs);
+        if (!info) {
+            return undefined;
+        }
+        return { name: obs.debugName, instanceId: info.instanceId };
+    }
+    _formatObserver(obs) {
+        if (obs instanceof Derived) {
+            return { name: ( obs.toString()), instanceId: this._getObservableInfo(obs)?.instanceId };
+        }
+        const autorunInfo = this._getAutorunInfo(obs);
+        if (autorunInfo) {
+            return { name: ( obs.toString()), instanceId: autorunInfo.instanceId };
+        }
+        return undefined;
+    }
+    constructor() {
+        this._declarationId = 0;
+        this._instanceId = 0;
+        this._declarations = ( new Map());
+        this._instanceInfos = ( new WeakMap());
+        this._aliveInstances = ( new Map());
+        this._activeTransactions = ( new Set());
+        this._channel = registerDebugChannel('observableDevTools', () => {
+            return {
+                notifications: {
+                    setDeclarationIdFilter: declarationIds => {
+                    },
+                    logObservableValue: (observableId) => {
+                        console.log('logObservableValue', observableId);
+                    },
+                    flushUpdates: () => {
+                        this._flushUpdates();
+                    },
+                    resetUpdates: () => {
+                        this._pendingChanges = null;
+                        this._channel.api.notifications.handleChange(this._fullState, true);
+                    },
+                },
+                requests: {
+                    getDeclarations: () => {
+                        const result = {};
+                        for (const decl of ( this._declarations.values())) {
+                            result[decl.id] = decl;
+                        }
+                        return { decls: result };
+                    },
+                    getSummarizedInstances: () => {
+                        return null;
+                    },
+                    getObservableValueInfo: instanceId => {
+                        const obs = this._aliveInstances.get(instanceId);
+                        return {
+                            observers: ( [...obs.debugGetObservers()].map(d => this._formatObserver(d))).filter(isDefined),
+                        };
+                    },
+                    getDerivedInfo: instanceId => {
+                        const d = this._aliveInstances.get(instanceId);
+                        return {
+                            dependencies: ( [...d.debugGetState().dependencies].map(d => this._formatObservable(d))).filter(isDefined),
+                            observers: ( [...d.debugGetObservers()].map(d => this._formatObserver(d))).filter(isDefined),
+                        };
+                    },
+                    getAutorunInfo: instanceId => {
+                        const obs = this._aliveInstances.get(instanceId);
+                        return {
+                            dependencies: ( [...obs.debugGetState().dependencies].map(d => this._formatObservable(d))).filter(isDefined),
+                        };
+                    },
+                    getTransactionState: () => {
+                        return this.getTransactionState();
+                    },
+                    setValue: (instanceId, jsonValue) => {
+                        const obs = this._aliveInstances.get(instanceId);
+                        if (obs instanceof Derived) {
+                            obs.debugSetValue(jsonValue);
+                        }
+                        else if (obs instanceof ObservableValue) {
+                            obs.debugSetValue(jsonValue);
+                        }
+                        else if (obs instanceof FromEventObservable) {
+                            obs.debugSetValue(jsonValue);
+                        }
+                        else {
+                            throw ( new BugIndicatingError('Observable is not supported'));
+                        }
+                        const observers = [...obs.debugGetObservers()];
+                        for (const d of observers) {
+                            d.beginUpdate(obs);
+                        }
+                        for (const d of observers) {
+                            d.handleChange(obs, undefined);
+                        }
+                        for (const d of observers) {
+                            d.endUpdate(obs);
+                        }
+                    },
+                    getValue: instanceId => {
+                        const obs = this._aliveInstances.get(instanceId);
+                        if (obs instanceof Derived) {
+                            return formatValue(obs.debugGetState().value, 200);
+                        }
+                        else if (obs instanceof ObservableValue) {
+                            return formatValue(obs.debugGetState().value, 200);
+                        }
+                        return undefined;
+                    }
+                }
+            };
+        });
+        this._pendingChanges = null;
+        this._changeThrottler = ( new Throttler());
+        this._fullState = {};
+        this._flushUpdates = () => {
+            if (this._pendingChanges !== null) {
+                this._channel.api.notifications.handleChange(this._pendingChanges, false);
+                this._pendingChanges = null;
+            }
+        };
+    }
+    _handleChange(update) {
+        deepAssignDeleteNulls(this._fullState, update);
+        if (this._pendingChanges === null) {
+            this._pendingChanges = update;
+        }
+        else {
+            deepAssign(this._pendingChanges, update);
+        }
+        this._changeThrottler.throttle(this._flushUpdates, 10);
+    }
+    _getDeclarationId(type) {
+        let shallow = true;
+        let loc;
+        const Err = Error;
+        while (true) {
+            const l = Err.stackTraceLimit;
+            Err.stackTraceLimit = shallow ? 6 : 20;
+            const stack = ( new Error()).stack;
+            Err.stackTraceLimit = l;
+            let result = getFirstStackFrameOutsideOf(stack, /[/\\]observableInternal[/\\]|\.observe|[/\\]util(s)?\./);
+            if (!shallow && !result) {
+                result = getFirstStackFrameOutsideOf(stack, /[/\\]observableInternal[/\\]|\.observe/);
+            }
+            if (result) {
+                loc = result;
+                break;
+            }
+            if (!shallow) {
+                console.error('Could not find location for declaration', ( new Error()).stack);
+                loc = { fileName: 'unknown', line: 0, column: 0, id: 'unknown' };
+                break;
+            }
+            shallow = false;
+        }
+        let decInfo = this._declarations.get(loc.id);
+        if (decInfo === undefined) {
+            decInfo = {
+                id: this._declarationId++,
+                type,
+                url: loc.fileName,
+                line: loc.line,
+                column: loc.column,
+            };
+            this._declarations.set(loc.id, decInfo);
+            this._handleChange({ decls: { [decInfo.id]: decInfo } });
+        }
+        return decInfo.id;
+    }
+    handleObservableCreated(observable) {
+        const declarationId = this._getDeclarationId('observable/value');
+        const info = {
+            declarationId,
+            instanceId: this._instanceId++,
+            listenerCount: 0,
+            lastValue: undefined,
+            updateCount: 0,
+            changedObservables: ( new Set()),
+        };
+        this._instanceInfos.set(observable, info);
+    }
+    handleOnListenerCountChanged(observable, newCount) {
+        const info = this._getObservableInfo(observable);
+        if (!info) {
+            return;
+        }
+        if (info.listenerCount === 0 && newCount > 0) {
+            const type = observable instanceof Derived ? 'observable/derived' : 'observable/value';
+            this._aliveInstances.set(info.instanceId, observable);
+            this._handleChange({
+                instances: {
+                    [info.instanceId]: {
+                        instanceId: info.instanceId,
+                        declarationId: info.declarationId,
+                        formattedValue: info.lastValue,
+                        type,
+                        name: observable.debugName,
+                    }
+                }
+            });
+        }
+        else if (info.listenerCount > 0 && newCount === 0) {
+            this._handleChange({
+                instances: { [info.instanceId]: null }
+            });
+            this._aliveInstances.delete(info.instanceId);
+        }
+        info.listenerCount = newCount;
+    }
+    handleObservableUpdated(observable, changeInfo) {
+        if (observable instanceof Derived) {
+            this._handleDerivedRecomputed(observable, changeInfo);
+            return;
+        }
+        const info = this._getObservableInfo(observable);
+        if (info) {
+            if (changeInfo.didChange) {
+                info.lastValue = formatValue(changeInfo.newValue, 30);
+                if (info.listenerCount > 0) {
+                    this._handleChange({
+                        instances: { [info.instanceId]: { formattedValue: info.lastValue } }
+                    });
+                }
+            }
+        }
+    }
+    handleAutorunCreated(autorun) {
+        const declarationId = this._getDeclarationId('autorun');
+        const info = {
+            declarationId,
+            instanceId: this._instanceId++,
+            updateCount: 0,
+            changedObservables: ( new Set()),
+        };
+        this._instanceInfos.set(autorun, info);
+        this._aliveInstances.set(info.instanceId, autorun);
+        if (info) {
+            this._handleChange({
+                instances: {
+                    [info.instanceId]: {
+                        instanceId: info.instanceId,
+                        declarationId: info.declarationId,
+                        runCount: 0,
+                        type: 'autorun',
+                        name: autorun.debugName,
+                    }
+                }
+            });
+        }
+    }
+    handleAutorunDisposed(autorun) {
+        const info = this._getAutorunInfo(autorun);
+        if (!info) {
+            return;
+        }
+        this._handleChange({
+            instances: { [info.instanceId]: null }
+        });
+        this._instanceInfos.delete(autorun);
+        this._aliveInstances.delete(info.instanceId);
+    }
+    handleAutorunDependencyChanged(autorun, observable, change) {
+        const info = this._getAutorunInfo(autorun);
+        if (!info) {
+            return;
+        }
+        info.changedObservables.add(observable);
+    }
+    handleAutorunStarted(autorun) {
+    }
+    handleAutorunFinished(autorun) {
+        const info = this._getAutorunInfo(autorun);
+        if (!info) {
+            return;
+        }
+        info.changedObservables.clear();
+        info.updateCount++;
+        this._handleChange({
+            instances: { [info.instanceId]: { runCount: info.updateCount } }
+        });
+    }
+    handleDerivedDependencyChanged(derived, observable, change) {
+        const info = this._getObservableInfo(derived);
+        if (info) {
+            info.changedObservables.add(observable);
+        }
+    }
+    _handleDerivedRecomputed(observable, changeInfo) {
+        const info = this._getObservableInfo(observable);
+        if (!info) {
+            return;
+        }
+        const formattedValue = formatValue(changeInfo.newValue, 30);
+        info.updateCount++;
+        info.changedObservables.clear();
+        info.lastValue = formattedValue;
+        if (info.listenerCount > 0) {
+            this._handleChange({
+                instances: { [info.instanceId]: { formattedValue: formattedValue, recomputationCount: info.updateCount } }
+            });
+        }
+    }
+    handleDerivedCleared(observable) {
+        const info = this._getObservableInfo(observable);
+        if (!info) {
+            return;
+        }
+        info.lastValue = undefined;
+        info.changedObservables.clear();
+        if (info.listenerCount > 0) {
+            this._handleChange({
+                instances: {
+                    [info.instanceId]: {
+                        formattedValue: undefined,
+                    }
+                }
+            });
+        }
+    }
+    handleBeginTransaction(transaction) {
+        this._activeTransactions.add(transaction);
+    }
+    handleEndTransaction(transaction) {
+        this._activeTransactions.delete(transaction);
+    }
+}
+
+export { DevToolsLogger };

package/vscode/src/vs/base/common/observableInternal/logging/debugger/rpc.d.ts

@@ -0,0 +1,41 @@
+export type ChannelFactory = (handler: IChannelHandler) => IChannel;
+export interface IChannel {
+    sendNotification(data: unknown): void;
+    sendRequest(data: unknown): Promise<RpcRequestResult>;
+}
+export interface IChannelHandler {
+    handleNotification(notificationData: unknown): void;
+    handleRequest(requestData: unknown): Promise<RpcRequestResult> | RpcRequestResult;
+}
+export type RpcRequestResult = {
+    type: "result";
+    value: unknown;
+} | {
+    type: "error";
+    value: unknown;
+};
+export type API = {
+    host: Side;
+    client: Side;
+};
+export type Side = {
+    notifications: Record<string, (...args: any[]) => void>;
+    requests: Record<string, (...args: any[]) => Promise<unknown> | unknown>;
+};
+type MakeAsyncIfNot<TFn> = TFn extends (...args: infer TArgs) => infer TResult ? TResult extends Promise<unknown> ? TFn : (...args: TArgs) => Promise<TResult> : never;
+export type MakeSideAsync<T extends Side> = {
+    notifications: T["notifications"];
+    requests: {
+        [K in keyof T["requests"]]: MakeAsyncIfNot<T["requests"][K]>;
+    };
+};
+export declare class SimpleTypedRpcConnection<T extends Side> {
+    private readonly _channelFactory;
+    private readonly _getHandler;
+    static createHost<T extends API>(channelFactory: ChannelFactory, getHandler: () => T["host"]): SimpleTypedRpcConnection<MakeSideAsync<T["client"]>>;
+    static createClient<T extends API>(channelFactory: ChannelFactory, getHandler: () => T["client"]): SimpleTypedRpcConnection<MakeSideAsync<T["host"]>>;
+    readonly api: T;
+    private readonly _channel;
+    private constructor();
+}
+export {};

package/vscode/src/vs/base/common/observableInternal/logging/debugger/rpc.js

@@ -0,0 +1,57 @@
+
+
+class SimpleTypedRpcConnection {
+    static createHost(channelFactory, getHandler) {
+        return ( new SimpleTypedRpcConnection(channelFactory, getHandler));
+    }
+    static createClient(channelFactory, getHandler) {
+        return ( new SimpleTypedRpcConnection(channelFactory, getHandler));
+    }
+    constructor(_channelFactory, _getHandler) {
+        this._channelFactory = _channelFactory;
+        this._getHandler = _getHandler;
+        this._channel = this._channelFactory({
+            handleNotification: (notificationData) => {
+                const m = notificationData;
+                const fn = this._getHandler().notifications[m[0]];
+                if (!fn) {
+                    throw ( new Error(`Unknown notification "${m[0]}"!`));
+                }
+                fn(...m[1]);
+            },
+            handleRequest: (requestData) => {
+                const m = requestData;
+                try {
+                    const result = this._getHandler().requests[m[0]](...m[1]);
+                    return { type: 'result', value: result };
+                }
+                catch (e) {
+                    return { type: 'error', value: e };
+                }
+            },
+        });
+        const requests = ( new Proxy({}, {
+            get: (target, key) => {
+                return async (...args) => {
+                    const result = await this._channel.sendRequest([key, args]);
+                    if (result.type === 'error') {
+                        throw result.value;
+                    }
+                    else {
+                        return result.value;
+                    }
+                };
+            }
+        }));
+        const notifications = ( new Proxy({}, {
+            get: (target, key) => {
+                return (...args) => {
+                    this._channel.sendNotification([key, args]);
+                };
+            }
+        }));
+        this.api = { notifications: notifications, requests: requests };
+    }
+}
+
+export { SimpleTypedRpcConnection };

package/vscode/src/vs/base/common/observableInternal/logging/debugger/utils.d.ts

@@ -0,0 +1,20 @@
+import { IDisposable } from "../../../lifecycle.js";
+export declare function getFirstStackFrameOutsideOf(stack: string, pattern?: RegExp): ILocation | undefined;
+export interface ILocation {
+    fileName: string;
+    line: number;
+    column: number;
+    id: string;
+}
+export declare class Debouncer implements IDisposable {
+    private _timeout;
+    debounce(fn: () => void, timeoutMs: number): void;
+    dispose(): void;
+}
+export declare class Throttler implements IDisposable {
+    private _timeout;
+    throttle(fn: () => void, timeoutMs: number): void;
+    dispose(): void;
+}
+export declare function deepAssign<T>(target: T, source: T): void;
+export declare function deepAssignDeleteNulls<T>(target: T, source: T): void;

package/vscode/src/vs/base/common/observableInternal/logging/debugger/utils.js

@@ -0,0 +1,79 @@
+
+
+function getFirstStackFrameOutsideOf(stack, pattern) {
+    const lines = stack.split('\n');
+    for (const line of lines.slice(1)) {
+        if (pattern && pattern.test(line)) {
+            continue;
+        }
+        const result = parseLine(line);
+        if (result) {
+            return result;
+        }
+    }
+    return undefined;
+}
+function parseLine(stackLine) {
+    const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
+    if (match) {
+        return {
+            fileName: match[1],
+            line: parseInt(match[2]),
+            column: parseInt(match[3]),
+            id: stackLine,
+        };
+    }
+    const match2 = stackLine.match(/at ([^\(\)]*):(\d+):(\d+)/);
+    if (match2) {
+        return {
+            fileName: match2[1],
+            line: parseInt(match2[2]),
+            column: parseInt(match2[3]),
+            id: stackLine,
+        };
+    }
+    return undefined;
+}
+class Throttler {
+    constructor() {
+        this._timeout = undefined;
+    }
+    throttle(fn, timeoutMs) {
+        if (this._timeout === undefined) {
+            this._timeout = setTimeout(() => {
+                this._timeout = undefined;
+                fn();
+            }, timeoutMs);
+        }
+    }
+    dispose() {
+        if (this._timeout !== undefined) {
+            clearTimeout(this._timeout);
+        }
+    }
+}
+function deepAssign(target, source) {
+    for (const key in source) {
+        if (!!target[key] && typeof target[key] === 'object' && !!source[key] && typeof source[key] === 'object') {
+            deepAssign(target[key], source[key]);
+        }
+        else {
+            target[key] = source[key];
+        }
+    }
+}
+function deepAssignDeleteNulls(target, source) {
+    for (const key in source) {
+        if (source[key] === null) {
+            delete target[key];
+        }
+        else if (!!target[key] && typeof target[key] === 'object' && !!source[key] && typeof source[key] === 'object') {
+            deepAssignDeleteNulls(target[key], source[key]);
+        }
+        else {
+            target[key] = source[key];
+        }
+    }
+}
+
+export { Throttler, deepAssign, deepAssignDeleteNulls, getFirstStackFrameOutsideOf };