@isopodlabs/vscode_utils 0.0.2 → 0.1.1

package/dist/debug.d.ts

@@ -0,0 +1,130 @@
+import * as vscode from 'vscode';
+import * as fs from './fs';
+import { DebugProtocol } from '@vscode/debugprotocol';
+type Response<T extends DebugProtocol.Response> = Promise<T['body']>;
+export declare function request(session: vscode.DebugSession, command: 'cancel', args: DebugProtocol.CancelArguments): Response<DebugProtocol.CancelResponse>;
+export declare function request(session: vscode.DebugSession, command: 'runInTerminal', args: DebugProtocol.RunInTerminalRequestArguments): Response<DebugProtocol.RunInTerminalResponse>;
+export declare function request(session: vscode.DebugSession, command: 'startDebugging', args: DebugProtocol.StartDebuggingRequestArguments): Response<DebugProtocol.StartDebuggingResponse>;
+export declare function request(session: vscode.DebugSession, command: 'initialize', args: DebugProtocol.InitializeRequestArguments): Response<DebugProtocol.InitializeResponse>;
+export declare function request(session: vscode.DebugSession, command: 'configurationDone', args: DebugProtocol.ConfigurationDoneArguments): Response<DebugProtocol.ConfigurationDoneResponse>;
+export declare function request(session: vscode.DebugSession, command: 'launch', args: DebugProtocol.LaunchRequestArguments): Response<DebugProtocol.LaunchResponse>;
+export declare function request(session: vscode.DebugSession, command: 'attach', args: DebugProtocol.AttachRequestArguments): Response<DebugProtocol.AttachResponse>;
+export declare function request(session: vscode.DebugSession, command: 'restart', args: DebugProtocol.RestartArguments): Response<DebugProtocol.RestartResponse>;
+export declare function request(session: vscode.DebugSession, command: 'disconnect', args: DebugProtocol.DisconnectArguments): Response<DebugProtocol.DisconnectResponse>;
+export declare function request(session: vscode.DebugSession, command: 'terminate', args: DebugProtocol.TerminateArguments): Response<DebugProtocol.TerminateResponse>;
+export declare function request(session: vscode.DebugSession, command: 'breakpointLocations', args: DebugProtocol.BreakpointLocationsArguments): Response<DebugProtocol.BreakpointLocationsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'setBreakpoints', args: DebugProtocol.SetBreakpointsArguments): Response<DebugProtocol.SetBreakpointsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'setFunctionBreakpoints', args: DebugProtocol.SetFunctionBreakpointsArguments): Response<DebugProtocol.SetFunctionBreakpointsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'setExceptionBreakpoints', args: DebugProtocol.SetExceptionBreakpointsArguments): Response<DebugProtocol.SetExceptionBreakpointsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'dataBreakpointInfo', args: DebugProtocol.DataBreakpointInfoArguments): Response<DebugProtocol.DataBreakpointInfoResponse>;
+export declare function request(session: vscode.DebugSession, command: 'setDataBreakpoints', args: DebugProtocol.SetDataBreakpointsArguments): Response<DebugProtocol.SetDataBreakpointsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'setInstructionBreakpoints', args: DebugProtocol.SetInstructionBreakpointsArguments): Response<DebugProtocol.SetInstructionBreakpointsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'continue', args: DebugProtocol.ContinueArguments): Response<DebugProtocol.ContinueResponse>;
+export declare function request(session: vscode.DebugSession, command: 'next', args: DebugProtocol.NextArguments): Response<DebugProtocol.NextResponse>;
+export declare function request(session: vscode.DebugSession, command: 'stepIn', args: DebugProtocol.StepInArguments): Response<DebugProtocol.StepInResponse>;
+export declare function request(session: vscode.DebugSession, command: 'stepOut', args: DebugProtocol.StepOutArguments): Response<DebugProtocol.StepOutResponse>;
+export declare function request(session: vscode.DebugSession, command: 'stepBack', args: DebugProtocol.StepBackArguments): Response<DebugProtocol.StepBackResponse>;
+export declare function request(session: vscode.DebugSession, command: 'reverseContinue', args: DebugProtocol.ReverseContinueArguments): Response<DebugProtocol.ReverseContinueResponse>;
+export declare function request(session: vscode.DebugSession, command: 'restartFrame', args: DebugProtocol.RestartFrameArguments): Response<DebugProtocol.RestartFrameResponse>;
+export declare function request(session: vscode.DebugSession, command: 'goto', args: DebugProtocol.GotoArguments): Response<DebugProtocol.GotoResponse>;
+export declare function request(session: vscode.DebugSession, command: 'pause', args: DebugProtocol.PauseArguments): Response<DebugProtocol.PauseResponse>;
+export declare function request(session: vscode.DebugSession, command: 'stackTrace', args: DebugProtocol.StackTraceArguments): Response<DebugProtocol.StackTraceResponse>;
+export declare function request(session: vscode.DebugSession, command: 'scopes', args: DebugProtocol.ScopesArguments): Response<DebugProtocol.ScopesResponse>;
+export declare function request(session: vscode.DebugSession, command: 'variables', args: DebugProtocol.VariablesArguments): Response<DebugProtocol.VariablesResponse>;
+export declare function request(session: vscode.DebugSession, command: 'setVariable', args: DebugProtocol.SetVariableArguments): Response<DebugProtocol.SetVariableResponse>;
+export declare function request(session: vscode.DebugSession, command: 'source', args: DebugProtocol.SourceArguments): Response<DebugProtocol.SourceResponse>;
+export declare function request(session: vscode.DebugSession, command: 'threads'): Response<DebugProtocol.ThreadsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'terminateThreads', args: DebugProtocol.TerminateThreadsArguments): Response<DebugProtocol.TerminateThreadsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'modules', args: DebugProtocol.ModulesArguments): Response<DebugProtocol.ModulesResponse>;
+export declare function request(session: vscode.DebugSession, command: 'loadedSources', args: DebugProtocol.LoadedSourcesArguments): Response<DebugProtocol.LoadedSourcesResponse>;
+export declare function request(session: vscode.DebugSession, command: 'evaluate', args: DebugProtocol.EvaluateArguments): Response<DebugProtocol.EvaluateResponse>;
+export declare function request(session: vscode.DebugSession, command: 'setExpression', args: DebugProtocol.SetExpressionArguments): Response<DebugProtocol.SetExpressionResponse>;
+export declare function request(session: vscode.DebugSession, command: 'stepInTargets', args: DebugProtocol.StepInTargetsArguments): Response<DebugProtocol.StepInTargetsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'gotoTargets', args: DebugProtocol.GotoTargetsArguments): Response<DebugProtocol.GotoTargetsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'completions', args: DebugProtocol.CompletionsArguments): Response<DebugProtocol.CompletionsResponse>;
+export declare function request(session: vscode.DebugSession, command: 'exceptionInfo', args: DebugProtocol.ExceptionInfoArguments): Response<DebugProtocol.ExceptionInfoResponse>;
+export declare function request(session: vscode.DebugSession, command: 'readMemory', args: DebugProtocol.ReadMemoryArguments): Response<DebugProtocol.ReadMemoryResponse>;
+export declare function request(session: vscode.DebugSession, command: 'writeMemory', args: DebugProtocol.WriteMemoryArguments): Response<DebugProtocol.WriteMemoryResponse>;
+export declare function request(session: vscode.DebugSession, command: 'disassemble', args: DebugProtocol.DisassembleArguments): Response<DebugProtocol.DisassembleResponse>;
+export declare function request(session: vscode.DebugSession, command: 'locations', args: DebugProtocol.LocationsArguments): Response<DebugProtocol.LocationsResponse>;
+export declare const enum State {
+    Inactive = 0,
+    Initializing = 1,
+    Stopped = 2,
+    Running = 3
+}
+export declare class Session implements vscode.DebugAdapterTracker {
+    session: vscode.DebugSession;
+    static sessions: Record<string, Session>;
+    private static _onCreate;
+    private static bpchange;
+    static get onCreate(): vscode.Event<Session>;
+    static get_wrapper(id: string): Session;
+    static get(id: string): vscode.DebugSession;
+    static get_caps(id: string): DebugProtocol.Capabilities | undefined;
+    private _onMessage;
+    private _onDidChangeState;
+    private _onDidInvalidateMemory;
+    _state: number;
+    threadId?: number;
+    frameId?: Promise<number>;
+    capabilities?: DebugProtocol.Capabilities;
+    static register(context: vscode.ExtensionContext): void;
+    constructor(session: vscode.DebugSession);
+    set state(value: number);
+    get onMessage(): vscode.Event<any>;
+    get onDidChangeState(): vscode.Event<number>;
+    get onDidInvalidateMemory(): vscode.Event<DebugProtocol.MemoryEvent>;
+    onExit(_code: number | undefined, _signal: string | undefined): void;
+    onWillStartSession(): void;
+    onWillStopSession?(): void;
+    onDidSendMessage(message: DebugProtocol.ProtocolMessage): void;
+}
+export declare function getTopStackFrameId(session: vscode.DebugSession): Promise<number> | undefined;
+declare class MemoryFile implements fs.File {
+    session: vscode.DebugSession;
+    memoryReference: string;
+    constructor(session: vscode.DebugSession, memoryReference: string);
+    dispose(): void;
+    read(pos: number, length: number): Promise<Uint8Array>;
+    write(pos: number, data: Uint8Array): Promise<number>;
+}
+export declare class MemoryFileSystem extends fs.BaseFileSystem {
+    static SCHEME: string;
+    static makeUri(session: vscode.DebugSession, memoryReference: string, range?: fs.FileRange, displayName?: string): vscode.Uri;
+    static parseUri(uri: vscode.Uri): {
+        session: Session;
+        offset: {
+            fromOffset: number;
+            toOffset: number;
+        } | undefined;
+        readOnly: boolean | undefined;
+        memoryReference: string;
+    };
+    constructor(context: vscode.ExtensionContext);
+    openFile(uri: vscode.Uri): MemoryFile;
+    watch(uri: vscode.Uri, options: {
+        readonly recursive: boolean;
+        readonly excludes: readonly string[];
+    }): vscode.Disposable;
+    stat(uri: vscode.Uri): Promise<{
+        type: vscode.FileType;
+        mtime: number;
+        ctime: number;
+        size: number;
+        permissions: vscode.FilePermission | undefined;
+    }>;
+    readFile(uri: vscode.Uri): Promise<Uint8Array<ArrayBufferLike>>;
+    writeFile(uri: vscode.Uri, content: Uint8Array): Promise<void>;
+}
+export declare class MemorySchema {
+    static SCHEME: string;
+    static makeUri(session: vscode.DebugSession, memoryReference: string, range?: fs.FileRange, displayName?: string): vscode.Uri;
+}
+export declare class SourceProvider implements vscode.TextDocumentContentProvider {
+    static SCHEME: string;
+    static makeUri(session: vscode.DebugSession, sourceReference: number, displayName?: string): vscode.Uri;
+    constructor(context: vscode.ExtensionContext);
+    provideTextDocumentContent(uri: vscode.Uri): Promise<string>;
+}
+export {};

package/dist/debug.js

@@ -0,0 +1,276 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceProvider = exports.MemorySchema = exports.MemoryFileSystem = exports.Session = void 0;
+exports.request = request;
+exports.getTopStackFrameId = getTopStackFrameId;
+const vscode = __importStar(require("vscode"));
+const fs = __importStar(require("./fs"));
+async function request(session, command, args) {
+    return session.customRequest(command, args);
+}
+class Session {
+    session;
+    static sessions = {};
+    static _onCreate = new vscode.EventEmitter();
+    static bpchange = vscode.debug.onDidChangeBreakpoints(event => {
+        console.log(event);
+    });
+    static get onCreate() { return this._onCreate.event; }
+    static get_wrapper(id) { return this.sessions[id]; }
+    static get(id) { return this.sessions[id]?.session; }
+    static get_caps(id) { return this.sessions[id]?.capabilities; }
+    _onMessage = new vscode.EventEmitter();
+    _onDidChangeState = new vscode.EventEmitter();
+    _onDidInvalidateMemory = new vscode.EventEmitter();
+    _state = 0 /* State.Inactive */;
+    threadId;
+    frameId;
+    capabilities;
+    static register(context) {
+        context.subscriptions.push(vscode.debug.registerDebugAdapterTrackerFactory('*', {
+            createDebugAdapterTracker: (session) => new Session(session)
+        }));
+    }
+    constructor(session) {
+        this.session = session;
+        Session.sessions[session.id] = this;
+        Session._onCreate.fire(this);
+    }
+    set state(value) {
+        //if (this._state !== value)
+        this._onDidChangeState.fire((this._state = value));
+    }
+    get onMessage() { return this._onMessage.event; }
+    get onDidChangeState() { return this._onDidChangeState.event; }
+    get onDidInvalidateMemory() { return this._onDidInvalidateMemory.event; }
+    onExit(_code, _signal) {
+        delete Session.sessions[this.session.id];
+    }
+    onWillStartSession() {
+        this.state = 1 /* State.Initializing */;
+    }
+    onWillStopSession() {
+        this.state = 0 /* State.Inactive */;
+    }
+    //	onWillReceiveMessage?(message: any): void;
+    onDidSendMessage(message) {
+        this._onMessage.fire(message);
+        switch (message.type) {
+            case "response": {
+                const response = message;
+                switch (response.command) {
+                    case "initialize":
+                        this.capabilities = response.body;
+                        break;
+                    //case "stackTrace":
+                    //	this.frameId = ((response as DebugProtocol.StackTraceResponse).body).stackFrames[0].id;
+                    //	break;
+                }
+                break;
+            }
+            case "event": {
+                const event = message;
+                switch (event.event) {
+                    case "initialized":
+                        //this.state = State.Inactive;
+                        break;
+                    case "stopped":
+                        this.threadId = event.body.threadId;
+                        this.frameId = request(this.session, 'stackTrace', { threadId: this.threadId ?? 0 }).then(resp => resp.stackFrames[0].id);
+                        this.state = 2 /* State.Stopped */;
+                        break;
+                    case "continued":
+                        this.state = 3 /* State.Running */;
+                        break;
+                    case "memory":
+                        this._onDidInvalidateMemory.fire(event);
+                        break;
+                }
+                break;
+            }
+        }
+    }
+}
+exports.Session = Session;
+function getTopStackFrameId(session) {
+    return Session.get_wrapper(session.id).frameId;
+    //	const resp = await request(session, 'stackTrace', { threadId: 0 });
+    //	return resp.stackFrames[0].id;
+}
+//-----------------------------------------------------------------------------
+//	FileSystems
+//-----------------------------------------------------------------------------
+class MemoryFile {
+    session;
+    memoryReference;
+    constructor(session, memoryReference) {
+        this.session = session;
+        this.memoryReference = memoryReference;
+    }
+    dispose() { }
+    async read(pos, length) {
+        const resp = await request(this.session, 'readMemory', {
+            memoryReference: this.memoryReference,
+            offset: pos,
+            count: length,
+        });
+        return resp?.data
+            ? new Uint8Array(Buffer.from(resp.data, 'base64'))
+            : new Uint8Array(0);
+    }
+    async write(pos, data) {
+        const resp = await request(this.session, 'writeMemory', {
+            memoryReference: this.memoryReference,
+            offset: pos,
+            data: Buffer.from(data).toString('base64')
+        });
+        return resp?.bytesWritten ?? 0;
+    }
+}
+class MemoryFileSystem extends fs.BaseFileSystem {
+    static SCHEME = 'modules-debug-memory';
+    static makeUri(session, memoryReference, range, displayName = 'memory') {
+        return vscode.Uri.from({
+            scheme: this.SCHEME,
+            authority: session.id,
+            path: `/${encodeURIComponent(memoryReference)}/${encodeURIComponent(displayName)}`,
+            query: range ? `?range=${range.fromOffset}:${range.toOffset}` : undefined,
+        });
+    }
+    static parseUri(uri) {
+        const session = Session.get_wrapper(uri.authority);
+        if (!session)
+            throw 'Debug session not found';
+        const rangeMatch = /range=([0-9]+):([0-9]+)/.exec(uri.query);
+        const offset = rangeMatch ? { fromOffset: Number(rangeMatch[1]), toOffset: Number(rangeMatch[2]) } : undefined;
+        const memoryReference = decodeURIComponent(uri.path.split('/')[1]);
+        return {
+            session,
+            offset,
+            readOnly: Session.get_caps(uri.authority)?.supportsWriteMemoryRequest,
+            memoryReference,
+        };
+    }
+    constructor(context) {
+        super(context, MemoryFileSystem.SCHEME);
+    }
+    openFile(uri) {
+        const { session, memoryReference } = MemoryFileSystem.parseUri(uri);
+        return new MemoryFile(session.session, memoryReference);
+    }
+    watch(uri, options) {
+        if (options.recursive)
+            return new vscode.Disposable(() => { });
+        const { session, memoryReference, offset } = MemoryFileSystem.parseUri(uri);
+        return vscode.Disposable.from(session.onDidChangeState(state => {
+            if (state === 3 /* State.Running */ || state === 0 /* State.Inactive */)
+                this._onDidChangeFile.fire([{ type: vscode.FileChangeType.Deleted, uri }]);
+        }), session.onDidInvalidateMemory(e => {
+            if (e.body.memoryReference === memoryReference && (!offset || (e.body.offset < offset.toOffset && e.body.offset + e.body.count >= offset.fromOffset)))
+                this._onDidChangeFile.fire([{ type: vscode.FileChangeType.Changed, uri }]);
+        }));
+    }
+    stat(uri) {
+        const { readOnly, offset } = MemoryFileSystem.parseUri(uri);
+        return Promise.resolve({
+            type: vscode.FileType.File,
+            mtime: 0,
+            ctime: 0,
+            size: offset ? offset.toOffset - offset.fromOffset : 0x10000,
+            permissions: readOnly ? vscode.FilePermission.Readonly : undefined,
+        });
+    }
+    async readFile(uri) {
+        const { session, memoryReference, offset } = MemoryFileSystem.parseUri(uri);
+        if (!offset)
+            throw `Range must be present to read a file`;
+        const file = new MemoryFile(session.session, memoryReference);
+        try {
+            return await file.read(offset.fromOffset, offset.toOffset - offset.fromOffset);
+        }
+        finally {
+            file.dispose();
+        }
+    }
+    async writeFile(uri, content) {
+        const { session, memoryReference, offset } = MemoryFileSystem.parseUri(uri);
+        if (!offset)
+            throw `Range must be present to read a file`;
+        const file = new MemoryFile(session.session, memoryReference);
+        try {
+            await file.write(offset.fromOffset, content);
+        }
+        finally {
+            file.dispose();
+        }
+    }
+}
+exports.MemoryFileSystem = MemoryFileSystem;
+//-----------------------------------------------------------------------------
+//	uri schema
+//-----------------------------------------------------------------------------
+class MemorySchema {
+    static SCHEME = 'vscode-debug-memory';
+    static makeUri(session, memoryReference, range, displayName = 'memory') {
+        return vscode.Uri.from({
+            scheme: MemorySchema.SCHEME,
+            authority: session.id,
+            path: `/${encodeURIComponent(memoryReference)}/${encodeURIComponent(displayName)}`,
+            query: range ? `?range=${range.fromOffset}:${range.toOffset}` : undefined,
+        });
+    }
+}
+exports.MemorySchema = MemorySchema;
+class SourceProvider {
+    static SCHEME = 'vscode-debug-source';
+    static makeUri(session, sourceReference, displayName = 'memory') {
+        return vscode.Uri.from({
+            scheme: this.SCHEME,
+            authority: session.id,
+            path: `/${sourceReference}/${encodeURIComponent(displayName)}`,
+        });
+    }
+    constructor(context) {
+        context.subscriptions.push(vscode.workspace.registerTextDocumentContentProvider(SourceProvider.SCHEME, this));
+    }
+    async provideTextDocumentContent(uri) {
+        const parts = uri.path.split('/');
+        const sourceReference = +parts[1];
+        const session = Session.get(uri.authority);
+        return session && (await request(session, 'source', { sourceReference })).content;
+    }
+}
+exports.SourceProvider = SourceProvider;

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,57 @@
+/** @jsxImportSource . */
+import * as vscode from 'vscode';
+export declare function jsx(type: any, props: any): any;
+export declare function jsxs(type: any, props: any): any;
+export declare function jsxFrag(props: any): {
+    props: any;
+};
+export declare namespace JSX {
+    interface Element {
+        type: string;
+        props: any;
+    }
+    interface IntrinsicElements {
+        [elemName: string]: any;
+    }
+    function render(element: any): string;
+}
+export declare function id_selector(id: string | number): string;
+export declare const codicons: Record<string, string>;
+type IconType0 = string | vscode.Uri;
+export type IconType = IconType0 | vscode.ThemeIcon | {
+    light: IconType0;
+    dark: IconType0;
+};
+export declare function iconAttribute(icon: IconType0): string;
+export declare function iconAttributes(icon?: IconType): {
+    icon: string;
+    color?: undefined;
+} | {
+    icon: string;
+    color: string;
+} | undefined;
+export declare function Label({ id, display }: {
+    id: string;
+    display: string;
+}): JSX.Element;
+export declare class Hash {
+    algorithm: string;
+    value: string;
+    constructor(algorithm: string, value: string);
+    toString(): string;
+}
+export declare function Nonce(): Hash;
+type Source = Hash | string | "'self'" | "'unsafe-inline'" | "'unsafe-eval'" | "'wasm-unsafe-eval'" | "'unsafe-hashes'" | "'inline-speculation-rules'" | "'strict-dynamic'";
+export declare function CSP({ csp, ...others }: {
+    csp: string;
+    script?: Source;
+    script_elem?: Source;
+    script_attr?: Source;
+    style?: Source;
+    stype_elem?: Source;
+    style_attr?: Source;
+    font?: Source;
+    img?: Source;
+    media?: Source;
+}): JSX.Element;
+export {};