@codingame/monaco-vscode-api 27.0.0 → 28.0.0

package/vscode/src/vs/workbench/contrib/speech/common/speechService.js

@@ -5,15 +5,15 @@ import { language } from '../../../../base/common/platform.js';
 
 const HasSpeechProvider = ( new RawContextKey("hasSpeechProvider", false, {
     type: "boolean",
-    description: ( localize(12347, "A speech provider is registered to the speech service."))
+    description: ( localize(12543, "A speech provider is registered to the speech service."))
 }));
 const SpeechToTextInProgress = ( new RawContextKey("speechToTextInProgress", false, {
     type: "boolean",
-    description: ( localize(12348, "A speech-to-text session is in progress."))
+    description: ( localize(12544, "A speech-to-text session is in progress."))
 }));
 const TextToSpeechInProgress = ( new RawContextKey("textToSpeechInProgress", false, {
     type: "boolean",
-    description: ( localize(12349, "A text-to-speech session is in progress."))
+    description: ( localize(12545, "A text-to-speech session is in progress."))
 }));
 var SpeechToTextStatus;
 (function(SpeechToTextStatus) {
@@ -45,82 +45,82 @@ var AccessibilityVoiceSettingId;
 const SPEECH_LANGUAGE_CONFIG = AccessibilityVoiceSettingId.SpeechLanguage;
 const SPEECH_LANGUAGES = {
     ["da-DK"]: {
-        name: ( localize(12350, "Danish (Denmark)"))
+        name: ( localize(12546, "Danish (Denmark)"))
     },
     ["de-DE"]: {
-        name: ( localize(12351, "German (Germany)"))
+        name: ( localize(12547, "German (Germany)"))
     },
     ["en-AU"]: {
-        name: ( localize(12352, "English (Australia)"))
+        name: ( localize(12548, "English (Australia)"))
     },
     ["en-CA"]: {
-        name: ( localize(12353, "English (Canada)"))
+        name: ( localize(12549, "English (Canada)"))
     },
     ["en-GB"]: {
-        name: ( localize(12354, "English (United Kingdom)"))
+        name: ( localize(12550, "English (United Kingdom)"))
     },
     ["en-IE"]: {
-        name: ( localize(12355, "English (Ireland)"))
+        name: ( localize(12551, "English (Ireland)"))
     },
     ["en-IN"]: {
-        name: ( localize(12356, "English (India)"))
+        name: ( localize(12552, "English (India)"))
     },
     ["en-NZ"]: {
-        name: ( localize(12357, "English (New Zealand)"))
+        name: ( localize(12553, "English (New Zealand)"))
     },
     ["en-US"]: {
-        name: ( localize(12358, "English (United States)"))
+        name: ( localize(12554, "English (United States)"))
     },
     ["es-ES"]: {
-        name: ( localize(12359, "Spanish (Spain)"))
+        name: ( localize(12555, "Spanish (Spain)"))
     },
     ["es-MX"]: {
-        name: ( localize(12360, "Spanish (Mexico)"))
+        name: ( localize(12556, "Spanish (Mexico)"))
     },
     ["fr-CA"]: {
-        name: ( localize(12361, "French (Canada)"))
+        name: ( localize(12557, "French (Canada)"))
     },
     ["fr-FR"]: {
-        name: ( localize(12362, "French (France)"))
+        name: ( localize(12558, "French (France)"))
     },
     ["hi-IN"]: {
-        name: ( localize(12363, "Hindi (India)"))
+        name: ( localize(12559, "Hindi (India)"))
     },
     ["it-IT"]: {
-        name: ( localize(12364, "Italian (Italy)"))
+        name: ( localize(12560, "Italian (Italy)"))
     },
     ["ja-JP"]: {
-        name: ( localize(12365, "Japanese (Japan)"))
+        name: ( localize(12561, "Japanese (Japan)"))
     },
     ["ko-KR"]: {
-        name: ( localize(12366, "Korean (South Korea)"))
+        name: ( localize(12562, "Korean (South Korea)"))
     },
     ["nl-NL"]: {
-        name: ( localize(12367, "Dutch (Netherlands)"))
+        name: ( localize(12563, "Dutch (Netherlands)"))
     },
     ["pt-PT"]: {
-        name: ( localize(12368, "Portuguese (Portugal)"))
+        name: ( localize(12564, "Portuguese (Portugal)"))
     },
     ["pt-BR"]: {
-        name: ( localize(12369, "Portuguese (Brazil)"))
+        name: ( localize(12565, "Portuguese (Brazil)"))
     },
     ["ru-RU"]: {
-        name: ( localize(12370, "Russian (Russia)"))
+        name: ( localize(12566, "Russian (Russia)"))
     },
     ["sv-SE"]: {
-        name: ( localize(12371, "Swedish (Sweden)"))
+        name: ( localize(12567, "Swedish (Sweden)"))
     },
     ["tr-TR"]: {
-        name: ( localize(12372, "Turkish (Türkiye)"))
+        name: ( localize(12568, "Turkish (Türkiye)"))
     },
     ["zh-CN"]: {
-        name: ( localize(12373, "Chinese (Simplified, China)"))
+        name: ( localize(12569, "Chinese (Simplified, China)"))
     },
     ["zh-HK"]: {
-        name: ( localize(12374, "Chinese (Traditional, Hong Kong)"))
+        name: ( localize(12570, "Chinese (Traditional, Hong Kong)"))
     },
     ["zh-TW"]: {
-        name: ( localize(12375, "Chinese (Traditional, Taiwan)"))
+        name: ( localize(12571, "Chinese (Traditional, Taiwan)"))
     }
 };
 function speechLanguageConfigToLanguage(config, lang = language) {

package/vscode/src/vs/workbench/contrib/tasks/common/constants.js

@@ -3,7 +3,7 @@ import { Codicon } from '../../../../base/common/codicons.js';
 import { localize } from '../../../../nls.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 
-const rerunTaskIcon = registerIcon("rerun-task", Codicon.refresh, ( localize(12589, "View icon of the rerun task.")));
+const rerunTaskIcon = registerIcon("rerun-task", Codicon.refresh, ( localize(12785, "View icon of the rerun task.")));
 const RerunForActiveTerminalCommandId = "workbench.action.tasks.rerunForActiveTerminal";
 const RerunAllRunningTasksCommandId = "workbench.action.tasks.rerunAllRunningTasks";
 

package/vscode/src/vs/workbench/contrib/tasks/common/problemMatcher.d.ts

@@ -0,0 +1,433 @@
+import * as Types from "../../../../base/common/types.js";
+import Severity from "../../../../base/common/severity.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IJSONSchema } from "../../../../base/common/jsonSchema.js";
+import { ValidationStatus, IProblemReporter, Parser } from "../../../../base/common/parsers.js";
+import { IMarkerData } from "../../../../platform/markers/common/markers.js";
+import { ExtensionMessageCollector } from "../../../services/extensions/common/extensionsRegistry.js";
+import { Event } from "../../../../base/common/event.js";
+import { IFileService } from "../../../../platform/files/common/files.service.js";
+import { ILogService } from "../../../../platform/log/common/log.service.js";
+export declare enum FileLocationKind {
+    Default = 0,
+    Relative = 1,
+    Absolute = 2,
+    AutoDetect = 3,
+    Search = 4
+}
+export declare namespace FileLocationKind {
+    function fromString(value: string): FileLocationKind | undefined;
+}
+export declare enum ProblemLocationKind {
+    File = 0,
+    Location = 1
+}
+export declare namespace ProblemLocationKind {
+    function fromString(value: string): ProblemLocationKind | undefined;
+}
+export interface IProblemPattern {
+    regexp: RegExp;
+    kind?: ProblemLocationKind;
+    file?: number;
+    message?: number;
+    location?: number;
+    line?: number;
+    character?: number;
+    endLine?: number;
+    endCharacter?: number;
+    code?: number;
+    severity?: number;
+    loop?: boolean;
+}
+export interface INamedProblemPattern extends IProblemPattern {
+    name: string;
+}
+export type MultiLineProblemPattern = IProblemPattern[];
+export interface IWatchingPattern {
+    regexp: RegExp;
+    file?: number;
+}
+export interface IWatchingMatcher {
+    activeOnStart: boolean;
+    beginsPattern: IWatchingPattern;
+    endsPattern: IWatchingPattern;
+}
+export declare enum ApplyToKind {
+    allDocuments = 0,
+    openDocuments = 1,
+    closedDocuments = 2
+}
+export declare namespace ApplyToKind {
+    function fromString(value: string): ApplyToKind | undefined;
+}
+export interface ProblemMatcher {
+    owner: string;
+    source?: string;
+    applyTo: ApplyToKind;
+    fileLocation: FileLocationKind;
+    filePrefix?: string | Config.SearchFileLocationArgs;
+    pattern: Types.SingleOrMany<IProblemPattern>;
+    severity?: Severity;
+    watching?: IWatchingMatcher;
+    uriProvider?: (path: string) => URI;
+}
+export interface INamedProblemMatcher extends ProblemMatcher {
+    name: string;
+    label: string;
+    deprecated?: boolean;
+}
+export interface INamedMultiLineProblemPattern {
+    name: string;
+    label: string;
+    patterns: MultiLineProblemPattern;
+}
+export declare function isNamedProblemMatcher(value: ProblemMatcher | undefined): value is INamedProblemMatcher;
+export interface IProblemMatch {
+    resource: Promise<URI>;
+    marker: IMarkerData;
+    description: ProblemMatcher;
+}
+export interface IHandleResult {
+    match: IProblemMatch | null;
+    continue: boolean;
+}
+export declare function getResource(filename: string, matcher: ProblemMatcher, fileService?: IFileService): Promise<URI>;
+export interface ILineMatcher {
+    matchLength: number;
+    next(line: string): IProblemMatch | null;
+    handle(lines: string[], start?: number): IHandleResult;
+}
+export declare function createLineMatcher(matcher: ProblemMatcher, fileService?: IFileService, logService?: ILogService): ILineMatcher;
+export declare namespace Config {
+    interface IProblemPattern {
+        /**
+        * The regular expression to find a problem in the console output of an
+        * executed task.
+        */
+        regexp?: string;
+        /**
+        * Whether the pattern matches a whole file, or a location (file/line)
+        *
+        * The default is to match for a location. Only valid on the
+        * first problem pattern in a multi line problem matcher.
+        */
+        kind?: string;
+        /**
+        * The match group index of the filename.
+        * If omitted 1 is used.
+        */
+        file?: number;
+        /**
+        * The match group index of the problem's location. Valid location
+        * patterns are: (line), (line,column) and (startLine,startColumn,endLine,endColumn).
+        * If omitted the line and column properties are used.
+        */
+        location?: number;
+        /**
+        * The match group index of the problem's line in the source file.
+        *
+        * Defaults to 2.
+        */
+        line?: number;
+        /**
+        * The match group index of the problem's column in the source file.
+        *
+        * Defaults to 3.
+        */
+        column?: number;
+        /**
+        * The match group index of the problem's end line in the source file.
+        *
+        * Defaults to undefined. No end line is captured.
+        */
+        endLine?: number;
+        /**
+        * The match group index of the problem's end column in the source file.
+        *
+        * Defaults to undefined. No end column is captured.
+        */
+        endColumn?: number;
+        /**
+        * The match group index of the problem's severity.
+        *
+        * Defaults to undefined. In this case the problem matcher's severity
+        * is used.
+        */
+        severity?: number;
+        /**
+        * The match group index of the problem's code.
+        *
+        * Defaults to undefined. No code is captured.
+        */
+        code?: number;
+        /**
+        * The match group index of the message. If omitted it defaults
+        * to 4 if location is specified. Otherwise it defaults to 5.
+        */
+        message?: number;
+        /**
+        * Specifies if the last pattern in a multi line problem matcher should
+        * loop as long as it does match a line consequently. Only valid on the
+        * last problem pattern in a multi line problem matcher.
+        */
+        loop?: boolean;
+    }
+    interface ICheckedProblemPattern extends IProblemPattern {
+        /**
+        * The regular expression to find a problem in the console output of an
+        * executed task.
+        */
+        regexp: string;
+    }
+    namespace CheckedProblemPattern {
+        function is(value: unknown): value is ICheckedProblemPattern;
+    }
+    interface INamedProblemPattern extends IProblemPattern {
+        /**
+         * The name of the problem pattern.
+         */
+        name: string;
+        /**
+         * A human readable label
+         */
+        label?: string;
+    }
+    namespace NamedProblemPattern {
+        function is(value: unknown): value is INamedProblemPattern;
+    }
+    interface INamedCheckedProblemPattern extends INamedProblemPattern {
+        /**
+        * The regular expression to find a problem in the console output of an
+        * executed task.
+        */
+        regexp: string;
+    }
+    namespace NamedCheckedProblemPattern {
+        function is(value: unknown): value is INamedCheckedProblemPattern;
+    }
+    type MultiLineProblemPattern = IProblemPattern[];
+    namespace MultiLineProblemPattern {
+        function is(value: unknown): value is MultiLineProblemPattern;
+    }
+    type MultiLineCheckedProblemPattern = ICheckedProblemPattern[];
+    namespace MultiLineCheckedProblemPattern {
+        function is(value: unknown): value is MultiLineCheckedProblemPattern;
+    }
+    interface INamedMultiLineCheckedProblemPattern {
+        /**
+         * The name of the problem pattern.
+         */
+        name: string;
+        /**
+         * A human readable label
+         */
+        label?: string;
+        /**
+         * The actual patterns
+         */
+        patterns: MultiLineCheckedProblemPattern;
+    }
+    namespace NamedMultiLineCheckedProblemPattern {
+        function is(value: unknown): value is INamedMultiLineCheckedProblemPattern;
+    }
+    type NamedProblemPatterns = (Config.INamedProblemPattern | Config.INamedMultiLineCheckedProblemPattern)[];
+    /**
+    * A watching pattern
+    */
+    interface IWatchingPattern {
+        /**
+        * The actual regular expression
+        */
+        regexp?: string;
+        /**
+        * The match group index of the filename. If provided the expression
+        * is matched for that file only.
+        */
+        file?: number;
+    }
+    /**
+    * A description to track the start and end of a watching task.
+    */
+    interface IBackgroundMonitor {
+        /**
+        * If set to true the watcher starts in active mode. This is the
+        * same as outputting a line that matches beginsPattern when the
+        * task starts.
+        */
+        activeOnStart?: boolean;
+        /**
+        * If matched in the output the start of a watching task is signaled.
+        */
+        beginsPattern?: string | IWatchingPattern;
+        /**
+        * If matched in the output the end of a watching task is signaled.
+        */
+        endsPattern?: string | IWatchingPattern;
+    }
+    /**
+    * A description of a problem matcher that detects problems
+    * in build output.
+    */
+    interface ProblemMatcher {
+        /**
+         * The name of a base problem matcher to use. If specified the
+         * base problem matcher will be used as a template and properties
+         * specified here will replace properties of the base problem
+         * matcher
+         */
+        base?: string;
+        /**
+         * The owner of the produced VSCode problem. This is typically
+         * the identifier of a VSCode language service if the problems are
+         * to be merged with the one produced by the language service
+         * or a generated internal id. Defaults to the generated internal id.
+         */
+        owner?: string;
+        /**
+         * A human-readable string describing the source of this problem.
+         * E.g. 'typescript' or 'super lint'.
+         */
+        source?: string;
+        /**
+        * Specifies to which kind of documents the problems found by this
+        * matcher are applied. Valid values are:
+        *
+        *   "allDocuments": problems found in all documents are applied.
+        *   "openDocuments": problems found in documents that are open
+        *   are applied.
+        *   "closedDocuments": problems found in closed documents are
+        *   applied.
+        */
+        applyTo?: string;
+        /**
+        * The severity of the VSCode problem produced by this problem matcher.
+        *
+        * Valid values are:
+        *   "error": to produce errors.
+        *   "warning": to produce warnings.
+        *   "info": to produce infos.
+        *
+        * The value is used if a pattern doesn't specify a severity match group.
+        * Defaults to "error" if omitted.
+        */
+        severity?: string;
+        /**
+        * Defines how filename reported in a problem pattern
+        * should be read. Valid values are:
+        *  - "absolute": the filename is always treated absolute.
+        *  - "relative": the filename is always treated relative to
+        *    the current working directory. This is the default.
+        *  - ["relative", "path value"]: the filename is always
+        *    treated relative to the given path value.
+        *  - "autodetect": the filename is treated relative to
+        *    the current workspace directory, and if the file
+        *    does not exist, it is treated as absolute.
+        *  - ["autodetect", "path value"]: the filename is treated
+        *    relative to the given path value, and if it does not
+        *    exist, it is treated as absolute.
+        *  - ["search", { include?: "" | []; exclude?: "" | [] }]: The filename
+        *    needs to be searched under the directories named by the "include"
+        *    property and their nested subdirectories. With "exclude" property
+        *    present, the directories should be removed from the search. When
+        *    `include` is not unprovided, the current workspace directory should
+        *    be used as the default.
+        */
+        fileLocation?: Types.SingleOrMany<string> | [
+            "search",
+            SearchFileLocationArgs
+        ];
+        /**
+        * The name of a predefined problem pattern, the inline definition
+        * of a problem pattern or an array of problem patterns to match
+        * problems spread over multiple lines.
+        */
+        pattern?: string | Types.SingleOrMany<IProblemPattern>;
+        /**
+        * A regular expression signaling that a watched tasks begins executing
+        * triggered through file watching.
+        */
+        watchedTaskBeginsRegExp?: string;
+        /**
+        * A regular expression signaling that a watched tasks ends executing.
+        */
+        watchedTaskEndsRegExp?: string;
+        /**
+         * @deprecated Use background instead.
+         */
+        watching?: IBackgroundMonitor;
+        background?: IBackgroundMonitor;
+    }
+    type SearchFileLocationArgs = {
+        include?: Types.SingleOrMany<string>;
+        exclude?: Types.SingleOrMany<string>;
+    };
+    type ProblemMatcherType = string | ProblemMatcher | Array<string | ProblemMatcher>;
+    interface INamedProblemMatcher extends ProblemMatcher {
+        /**
+        * This name can be used to refer to the
+        * problem matcher from within a task.
+        */
+        name: string;
+        /**
+         * A human readable label.
+         */
+        label?: string;
+    }
+    function isNamedProblemMatcher(value: ProblemMatcher): value is INamedProblemMatcher;
+}
+export declare class ProblemPatternParser extends Parser {
+    constructor(logger: IProblemReporter);
+    parse(value: Config.IProblemPattern): IProblemPattern;
+    parse(value: Config.MultiLineProblemPattern): MultiLineProblemPattern;
+    parse(value: Config.INamedProblemPattern): INamedProblemPattern;
+    parse(value: Config.INamedMultiLineCheckedProblemPattern): INamedMultiLineProblemPattern;
+    private createSingleProblemPattern;
+    private createNamedMultiLineProblemPattern;
+    private createMultiLineProblemPattern;
+    private doCreateSingleProblemPattern;
+    private validateProblemPattern;
+    private createRegularExpression;
+}
+export declare class ExtensionRegistryReporter implements IProblemReporter {
+    private _collector;
+    private _validationStatus;
+    constructor(_collector: ExtensionMessageCollector, _validationStatus?: ValidationStatus);
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    fatal(message: string): void;
+    get status(): ValidationStatus;
+}
+export declare namespace Schemas {
+    const ProblemPattern: IJSONSchema;
+    const NamedProblemPattern: IJSONSchema;
+    const MultiLineProblemPattern: IJSONSchema;
+    const NamedMultiLineProblemPattern: IJSONSchema;
+    const WatchingPattern: IJSONSchema;
+    const PatternType: IJSONSchema;
+    const ProblemMatcher: IJSONSchema;
+    const LegacyProblemMatcher: IJSONSchema;
+    const NamedProblemMatcher: IJSONSchema;
+}
+export interface IProblemPatternRegistry {
+    onReady(): Promise<void>;
+    get(key: string): IProblemPattern | MultiLineProblemPattern;
+}
+export declare const ProblemPatternRegistry: IProblemPatternRegistry;
+export declare class ProblemMatcherParser extends Parser {
+    constructor(logger: IProblemReporter);
+    parse(json: Config.ProblemMatcher): ProblemMatcher | undefined;
+    private checkProblemMatcherValid;
+    private createProblemMatcher;
+    private createProblemPattern;
+    private addWatchingMatcher;
+    private createWatchingPattern;
+    private createRegularExpression;
+}
+export interface IProblemMatcherRegistry {
+    onReady(): Promise<void>;
+    get(name: string): INamedProblemMatcher;
+    keys(): string[];
+    readonly onMatcherChanged: Event<void>;
+}
+export declare const ProblemMatcherRegistry: IProblemMatcherRegistry;