@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common 19.0.0

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common",
+  "version": "19.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package (chat, extensions, notebook, terminal, testing)",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {},
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/platform/terminal/common/capabilities/capabilities.d.ts

@@ -0,0 +1,182 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import type { IPromptInputModel, ISerializedPromptInputModel } from "@codingame/monaco-vscode-f6ab89b2-83b0-5a43-8772-cb0eafa650b5-common/vscode/vs/platform/terminal/common/capabilities/commandDetection/promptInputModel";
+import { ICurrentPartialCommand } from "@codingame/monaco-vscode-f6ab89b2-83b0-5a43-8772-cb0eafa650b5-common/vscode/vs/platform/terminal/common/capabilities/commandDetection/terminalCommand";
+import { ITerminalOutputMatch, ITerminalOutputMatcher } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal";
+import { ReplayEntry } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminalProcess";
+import type { IMarker } from "@xterm/headless";
+export declare enum TerminalCapability {
+    CwdDetection = 0,
+    NaiveCwdDetection = 1,
+    CommandDetection = 2,
+    PartialCommandDetection = 3,
+    BufferMarkDetection = 4,
+    ShellEnvDetection = 5
+}
+export interface ITerminalCapabilityStore {
+    readonly items: IterableIterator<TerminalCapability>;
+    readonly onDidAddCapabilityType: Event<TerminalCapability>;
+    readonly onDidRemoveCapabilityType: Event<TerminalCapability>;
+    readonly onDidAddCapability: Event<TerminalCapabilityChangeEvent<any>>;
+    readonly onDidRemoveCapability: Event<TerminalCapabilityChangeEvent<any>>;
+    has(capability: TerminalCapability): boolean;
+    get<T extends TerminalCapability>(capability: T): ITerminalCapabilityImplMap[T] | undefined;
+}
+export interface TerminalCapabilityChangeEvent<T extends TerminalCapability> {
+    id: T;
+    capability: ITerminalCapabilityImplMap[T];
+}
+export interface ITerminalCapabilityImplMap {
+    [TerminalCapability.CwdDetection]: ICwdDetectionCapability;
+    [TerminalCapability.CommandDetection]: ICommandDetectionCapability;
+    [TerminalCapability.NaiveCwdDetection]: INaiveCwdDetectionCapability;
+    [TerminalCapability.PartialCommandDetection]: IPartialCommandDetectionCapability;
+    [TerminalCapability.BufferMarkDetection]: IBufferMarkCapability;
+    [TerminalCapability.ShellEnvDetection]: IShellEnvDetectionCapability;
+}
+export interface ICwdDetectionCapability {
+    readonly type: TerminalCapability.CwdDetection;
+    readonly onDidChangeCwd: Event<string>;
+    readonly cwds: string[];
+    getCwd(): string;
+    updateCwd(cwd: string): void;
+}
+export interface IShellEnvDetectionCapability {
+    readonly type: TerminalCapability.ShellEnvDetection;
+    readonly onDidChangeEnv: Event<TerminalShellIntegrationEnvironment>;
+    get env(): TerminalShellIntegrationEnvironment;
+    setEnvironment(envs: {
+        [key: string]: string | undefined;
+    } | undefined, isTrusted: boolean): void;
+    startEnvironmentSingleVar(clear: boolean, isTrusted: boolean): void;
+    setEnvironmentSingleVar(key: string, value: string | undefined, isTrusted: boolean): void;
+    deleteEnvironmentSingleVar(key: string, value: string | undefined, isTrusted: boolean): void;
+    endEnvironmentSingleVar(isTrusted: boolean): void;
+}
+export interface TerminalShellIntegrationEnvironment {
+    value: {
+        [key: string]: string | undefined;
+    } | undefined;
+    isTrusted: boolean;
+}
+export interface TerminalShellIntegration {
+    readonly env: TerminalShellIntegrationEnvironment;
+}
+export declare enum CommandInvalidationReason {
+    Windows = "windows",
+    NoProblemsReported = "noProblemsReported"
+}
+export interface ICommandInvalidationRequest {
+    reason: CommandInvalidationReason;
+}
+export interface IBufferMarkCapability {
+    type: TerminalCapability.BufferMarkDetection;
+    markers(): IterableIterator<IMarker>;
+    onMarkAdded: Event<IMarkProperties>;
+    addMark(properties?: IMarkProperties): void;
+    getMark(id: string): IMarker | undefined;
+}
+export interface ICommandDetectionCapability {
+    readonly type: TerminalCapability.CommandDetection;
+    readonly promptInputModel: IPromptInputModel;
+    readonly commands: readonly ITerminalCommand[];
+    readonly executingCommand: string | undefined;
+    readonly executingCommandObject: ITerminalCommand | undefined;
+    readonly executingCommandConfidence: "low" | "medium" | "high" | undefined;
+    readonly cwd: string | undefined;
+    readonly hasRichCommandDetection: boolean;
+    readonly promptType: string | undefined;
+    readonly currentCommand: ICurrentPartialCommand | undefined;
+    readonly onCommandStarted: Event<ITerminalCommand>;
+    readonly onCommandFinished: Event<ITerminalCommand>;
+    readonly onCommandExecuted: Event<ITerminalCommand>;
+    readonly onCommandInvalidated: Event<ITerminalCommand[]>;
+    readonly onCurrentCommandInvalidated: Event<ICommandInvalidationRequest>;
+    readonly onPromptTypeChanged: Event<string | undefined>;
+    readonly onSetRichCommandDetection: Event<boolean>;
+    setContinuationPrompt(value: string): void;
+    setPromptTerminator(value: string, lastPromptLine: string): void;
+    setCwd(value: string): void;
+    setIsWindowsPty(value: boolean): void;
+    setIsCommandStorageDisabled(): void;
+    getCwdForLine(line: number): string | undefined;
+    getCommandForLine(line: number): ITerminalCommand | ICurrentPartialCommand | undefined;
+    handlePromptStart(options?: IHandleCommandOptions): void;
+    handleContinuationStart(): void;
+    handleContinuationEnd(): void;
+    handleRightPromptStart(): void;
+    handleRightPromptEnd(): void;
+    handleCommandStart(options?: IHandleCommandOptions): void;
+    handleCommandExecuted(options?: IHandleCommandOptions): void;
+    handleCommandFinished(exitCode?: number, options?: IHandleCommandOptions): void;
+    setHasRichCommandDetection(value: boolean): void;
+    setPromptType(value: string): void;
+    setCommandLine(commandLine: string, isTrusted: boolean): void;
+    serialize(): ISerializedCommandDetectionCapability;
+    deserialize(serialized: ISerializedCommandDetectionCapability): void;
+}
+export interface IHandleCommandOptions {
+    ignoreCommandLine?: boolean;
+    marker?: IMarker;
+    markProperties?: IMarkProperties;
+}
+export interface INaiveCwdDetectionCapability {
+    readonly type: TerminalCapability.NaiveCwdDetection;
+    readonly onDidChangeCwd: Event<string>;
+    getCwd(): Promise<string>;
+}
+export interface IPartialCommandDetectionCapability {
+    readonly type: TerminalCapability.PartialCommandDetection;
+    readonly commands: readonly IMarker[];
+    readonly onCommandFinished: Event<IMarker>;
+}
+interface IBaseTerminalCommand {
+    command: string;
+    commandLineConfidence: "low" | "medium" | "high";
+    isTrusted: boolean;
+    timestamp: number;
+    duration: number;
+    cwd: string | undefined;
+    exitCode: number | undefined;
+    commandStartLineContent: string | undefined;
+    markProperties: IMarkProperties | undefined;
+    executedX: number | undefined;
+    startX: number | undefined;
+}
+export interface ITerminalCommand extends IBaseTerminalCommand {
+    readonly promptStartMarker?: IMarker;
+    readonly marker?: IMarker;
+    endMarker?: IMarker;
+    readonly executedMarker?: IMarker;
+    readonly aliases?: string[][];
+    readonly wasReplayed?: boolean;
+    extractCommandLine(): string;
+    getOutput(): string | undefined;
+    getOutputMatch(outputMatcher: ITerminalOutputMatcher): ITerminalOutputMatch | undefined;
+    hasOutput(): boolean;
+    getPromptRowCount(): number;
+    getCommandRowCount(): number;
+}
+export interface ISerializedTerminalCommand extends IBaseTerminalCommand {
+    startLine: number | undefined;
+    promptStartLine: number | undefined;
+    endLine: number | undefined;
+    executedLine: number | undefined;
+}
+export interface IMarkProperties {
+    hoverMessage?: string;
+    disableCommandStorage?: boolean;
+    hidden?: boolean;
+    marker?: IMarker;
+    id?: string;
+}
+export interface ISerializedCommandDetectionCapability {
+    isWindowsPty: boolean;
+    hasRichCommandDetection: boolean;
+    commands: ISerializedTerminalCommand[];
+    promptInputModel: ISerializedPromptInputModel | undefined;
+}
+export interface IPtyHostProcessReplayEvent {
+    events: ReplayEntry[];
+    commands: ISerializedCommandDetectionCapability;
+}
+export {};

package/vscode/src/vs/platform/terminal/common/capabilities/capabilities.js

@@ -0,0 +1,18 @@
+
+
+var TerminalCapability;
+(function (TerminalCapability) {
+    TerminalCapability[TerminalCapability["CwdDetection"] = 0] = "CwdDetection";
+    TerminalCapability[TerminalCapability["NaiveCwdDetection"] = 1] = "NaiveCwdDetection";
+    TerminalCapability[TerminalCapability["CommandDetection"] = 2] = "CommandDetection";
+    TerminalCapability[TerminalCapability["PartialCommandDetection"] = 3] = "PartialCommandDetection";
+    TerminalCapability[TerminalCapability["BufferMarkDetection"] = 4] = "BufferMarkDetection";
+    TerminalCapability[TerminalCapability["ShellEnvDetection"] = 5] = "ShellEnvDetection";
+})(TerminalCapability || (TerminalCapability = {}));
+var CommandInvalidationReason;
+(function (CommandInvalidationReason) {
+    CommandInvalidationReason["Windows"] = "windows";
+    CommandInvalidationReason["NoProblemsReported"] = "noProblemsReported";
+})(CommandInvalidationReason || (CommandInvalidationReason = {}));
+
+export { CommandInvalidationReason, TerminalCapability };