@codingame/monaco-vscode-api 1.68.7 → 1.69.2

package/dist/injection.js

@@ -0,0 +1,15 @@
+import { _util } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+function getInjectedParameters(instantiationService, ctor) {
+    return instantiationService.invokeFunction((accessor) => {
+        return _util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index).map(d => accessor.get(d.id));
+    });
+}
+function createInjectedClass(ctor) {
+    const _ctor = ctor;
+    return class extends _ctor {
+        constructor(...args) {
+            super(...args.slice(1), ...getInjectedParameters(args[0], ctor));
+        }
+    };
+}
+export { createInjectedClass as c };

package/dist/jsonErrorMessages.js

@@ -0,0 +1,17 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+function getParseErrorMessage(errorCode) {
+    switch (errorCode) {
+        case 1 : return ( localize('error.invalidSymbol', 'Invalid symbol'));
+        case 2 : return ( localize('error.invalidNumberFormat', 'Invalid number format'));
+        case 3 : return ( localize('error.propertyNameExpected', 'Property name expected'));
+        case 4 : return ( localize('error.valueExpected', 'Value expected'));
+        case 5 : return ( localize('error.colonExpected', 'Colon expected'));
+        case 6 : return ( localize('error.commaExpected', 'Comma expected'));
+        case 7 : return ( localize('error.closeBraceExpected', 'Closing brace expected'));
+        case 8 : return ( localize('error.closeBracketExpected', 'Closing bracket expected'));
+        case 9 : return ( localize('error.endOfFileExpected', 'End of file expected'));
+        default:
+            return '';
+    }
+}
+export { getParseErrorMessage as g };

package/dist/keybindings.d.ts

@@ -0,0 +1,502 @@
+import * as monaco from 'monaco-editor';
+
+/**
+ * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
+ * This class is a simple parser which creates the basic component parts
+ * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
+ * and encoding.
+ *
+ * ```txt
+ *       foo://example.com:8042/over/there?name=ferret#nose
+ *       \_/   \______________/\_________/ \_________/ \__/
+ *        |           |            |            |        |
+ *     scheme     authority       path        query   fragment
+ *        |   _____________________|__
+ *       / \ /                        \
+ *       urn:example:animal:ferret:nose
+ * ```
+ */
+declare class URI implements UriComponents {
+    static isUri(thing: any): thing is URI;
+    /**
+     * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part before the first colon.
+     */
+    readonly scheme: string;
+    /**
+     * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part between the first double slashes and the next slash.
+     */
+    readonly authority: string;
+    /**
+     * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly path: string;
+    /**
+     * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly query: string;
+    /**
+     * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly fragment: string;
+    /**
+     * @internal
+     */
+    protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
+    /**
+     * @internal
+     */
+    protected constructor(components: UriComponents);
+    /**
+     * Returns a string representing the corresponding file system path of this URI.
+     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
+     * platform specific path separator.
+     *
+     * * Will *not* validate the path for invalid characters and semantics.
+     * * Will *not* look at the scheme of this URI.
+     * * The result shall *not* be used for display purposes but for accessing a file on disk.
+     *
+     *
+     * The *difference* to `URI#path` is the use of the platform specific separator and the handling
+     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
+     *
+     * ```ts
+        const u = URI.parse('file://server/c$/folder/file.txt')
+        u.authority === 'server'
+        u.path === '/shares/c$/file.txt'
+        u.fsPath === '\\server\c$\folder\file.txt'
+    ```
+     *
+     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
+     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
+     * with URIs that represent files on disk (`file` scheme).
+     */
+    get fsPath(): string;
+    with(change: {
+        scheme?: string;
+        authority?: string | null;
+        path?: string | null;
+        query?: string | null;
+        fragment?: string | null;
+    }): URI;
+    /**
+     * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
+     * `file:///usr/home`, or `scheme:with/path`.
+     *
+     * @param value A string which represents an URI (see `URI#toString`).
+     */
+    static parse(value: string, _strict?: boolean): URI;
+    /**
+     * Creates a new URI from a file system path, e.g. `c:\my\files`,
+     * `/usr/home`, or `\\server\share\some\path`.
+     *
+     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
+     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
+     * `URI.parse('file://' + path)` because the path might contain characters that are
+     * interpreted (# and ?). See the following sample:
+     * ```ts
+    const good = URI.file('/coding/c#/project1');
+    good.scheme === 'file';
+    good.path === '/coding/c#/project1';
+    good.fragment === '';
+    const bad = URI.parse('file://' + '/coding/c#/project1');
+    bad.scheme === 'file';
+    bad.path === '/coding/c'; // path is now broken
+    bad.fragment === '/project1';
+    ```
+     *
+     * @param path A file system path (see `URI#fsPath`)
+     */
+    static file(path: string): URI;
+    static from(components: {
+        scheme: string;
+        authority?: string;
+        path?: string;
+        query?: string;
+        fragment?: string;
+    }): URI;
+    /**
+     * Join a URI path with path fragments and normalizes the resulting path.
+     *
+     * @param uri The input URI.
+     * @param pathFragment The path fragment to add to the URI path.
+     * @returns The resulting URI.
+     */
+    static joinPath(uri: URI, ...pathFragment: string[]): URI;
+    /**
+     * Creates a string representation for this URI. It's guaranteed that calling
+     * `URI.parse` with the result of this function creates an URI which is equal
+     * to this URI.
+     *
+     * * The result shall *not* be used for display purposes but for externalization or transport.
+     * * The result will be encoded using the percentage encoding and encoding happens mostly
+     * ignore the scheme-specific encoding rules.
+     *
+     * @param skipEncoding Do not encode the result, default is `false`
+     */
+    toString(skipEncoding?: boolean): string;
+    toJSON(): UriComponents;
+    static revive(data: UriComponents | URI): URI;
+    static revive(data: UriComponents | URI | undefined): URI | undefined;
+    static revive(data: UriComponents | URI | null): URI | null;
+    static revive(data: UriComponents | URI | undefined | null): URI | undefined | null;
+}
+interface UriComponents {
+    scheme: string;
+    authority: string;
+    path: string;
+    query: string;
+    fragment: string;
+}
+
+/**
+ * Type of extension.
+ *
+ * **NOTE**: This is defined in `platform/environment` because it can appear as a CLI argument.
+ */
+declare type ExtensionKind = 'ui' | 'workspace' | 'web';
+
+interface ICommand {
+    command: string;
+    title: string;
+    category?: string;
+}
+interface IConfigurationProperty {
+    description: string;
+    type: string | string[];
+    default?: any;
+}
+interface IConfiguration {
+    id?: string;
+    order?: number;
+    title?: string;
+    properties: {
+        [key: string]: IConfigurationProperty;
+    };
+}
+interface IDebugger {
+    label?: string;
+    type: string;
+    runtime?: string;
+}
+interface IGrammar {
+    language: string;
+}
+interface IJSONValidation {
+    fileMatch: string | string[];
+    url: string;
+}
+interface IKeyBinding {
+    command: string;
+    key: string;
+    when?: string;
+    mac?: string;
+    linux?: string;
+    win?: string;
+}
+interface ILanguage {
+    id: string;
+    extensions: string[];
+    aliases: string[];
+}
+interface IMenu {
+    command: string;
+    alt?: string;
+    when?: string;
+    group?: string;
+}
+interface ISnippet {
+    language: string;
+}
+interface ITheme {
+    label: string;
+}
+interface IViewContainer {
+    id: string;
+    title: string;
+}
+interface IView {
+    id: string;
+    name: string;
+}
+interface IColor {
+    id: string;
+    description: string;
+    defaults: {
+        light: string;
+        dark: string;
+        highContrast: string;
+    };
+}
+interface IWebviewEditor {
+    readonly viewType: string;
+    readonly priority: string;
+    readonly selector: readonly {
+        readonly filenamePattern?: string;
+    }[];
+}
+interface ICodeActionContributionAction {
+    readonly kind: string;
+    readonly title: string;
+    readonly description?: string;
+}
+interface ICodeActionContribution {
+    readonly languages: readonly string[];
+    readonly actions: readonly ICodeActionContributionAction[];
+}
+interface IAuthenticationContribution {
+    readonly id: string;
+    readonly label: string;
+}
+interface IWalkthroughStep {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string | undefined;
+    readonly media: {
+        image: string | {
+            dark: string;
+            light: string;
+            hc: string;
+        };
+        altText: string;
+        markdown?: never;
+        svg?: never;
+    } | {
+        markdown: string;
+        image?: never;
+        svg?: never;
+    } | {
+        svg: string;
+        altText: string;
+        markdown?: never;
+        image?: never;
+    };
+    readonly completionEvents?: string[];
+    /** @deprecated use `completionEvents: 'onCommand:...'` */
+    readonly doneOn?: {
+        command: string;
+    };
+    readonly when?: string;
+}
+interface IWalkthrough {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string;
+    readonly steps: IWalkthroughStep[];
+    readonly featuredFor: string[] | undefined;
+    readonly when?: string;
+}
+interface IStartEntry {
+    readonly title: string;
+    readonly description: string;
+    readonly command: string;
+    readonly when?: string;
+    readonly category: 'file' | 'folder' | 'notebook';
+}
+interface INotebookEntry {
+    readonly type: string;
+    readonly displayName: string;
+}
+interface INotebookRendererContribution {
+    readonly id: string;
+    readonly displayName: string;
+    readonly mimeTypes: string[];
+}
+interface ITranslation {
+    id: string;
+    path: string;
+}
+interface ILocalizationContribution {
+    languageId: string;
+    languageName?: string;
+    localizedLanguageName?: string;
+    translations: ITranslation[];
+    minimalTranslations?: {
+        [key: string]: string;
+    };
+}
+interface IExtensionContributions {
+    commands?: ICommand[];
+    configuration?: IConfiguration | IConfiguration[];
+    debuggers?: IDebugger[];
+    grammars?: IGrammar[];
+    jsonValidation?: IJSONValidation[];
+    keybindings?: IKeyBinding[];
+    languages?: ILanguage[];
+    menus?: {
+        [context: string]: IMenu[];
+    };
+    snippets?: ISnippet[];
+    themes?: ITheme[];
+    iconThemes?: ITheme[];
+    productIconThemes?: ITheme[];
+    viewsContainers?: {
+        [location: string]: IViewContainer[];
+    };
+    views?: {
+        [location: string]: IView[];
+    };
+    colors?: IColor[];
+    localizations?: ILocalizationContribution[];
+    readonly customEditors?: readonly IWebviewEditor[];
+    readonly codeActions?: readonly ICodeActionContribution[];
+    authentication?: IAuthenticationContribution[];
+    walkthroughs?: IWalkthrough[];
+    startEntries?: IStartEntry[];
+    readonly notebooks?: INotebookEntry[];
+    readonly notebookRenderer?: INotebookRendererContribution[];
+}
+interface IExtensionCapabilities {
+    readonly virtualWorkspaces?: ExtensionVirtualWorkspaceSupport;
+    readonly untrustedWorkspaces?: ExtensionUntrustedWorkspaceSupport;
+}
+declare type LimitedWorkspaceSupportType = 'limited';
+declare type ExtensionUntrustedWorkspaceSupport = {
+    supported: true;
+} | {
+    supported: false;
+    description: string;
+} | {
+    supported: LimitedWorkspaceSupportType;
+    description: string;
+    restrictedConfigurations?: string[];
+};
+declare type ExtensionVirtualWorkspaceSupport = boolean | {
+    supported: true;
+} | {
+    supported: false | LimitedWorkspaceSupportType;
+    description: string;
+};
+interface IRelaxedExtensionManifest {
+    name: string;
+    displayName?: string;
+    publisher: string;
+    version: string;
+    engines: {
+        readonly vscode: string;
+    };
+    description?: string;
+    main?: string;
+    browser?: string;
+    icon?: string;
+    categories?: string[];
+    keywords?: string[];
+    activationEvents?: string[];
+    extensionDependencies?: string[];
+    extensionPack?: string[];
+    extensionKind?: ExtensionKind | ExtensionKind[];
+    contributes?: IExtensionContributions;
+    repository?: {
+        url: string;
+    };
+    bugs?: {
+        url: string;
+    };
+    enabledApiProposals?: readonly string[];
+    api?: string;
+    scripts?: {
+        [key: string]: string;
+    };
+    capabilities?: IExtensionCapabilities;
+}
+declare const enum TargetPlatform {
+    WIN32_X64 = "win32-x64",
+    WIN32_IA32 = "win32-ia32",
+    WIN32_ARM64 = "win32-arm64",
+    LINUX_X64 = "linux-x64",
+    LINUX_ARM64 = "linux-arm64",
+    LINUX_ARMHF = "linux-armhf",
+    ALPINE_X64 = "alpine-x64",
+    ALPINE_ARM64 = "alpine-arm64",
+    DARWIN_X64 = "darwin-x64",
+    DARWIN_ARM64 = "darwin-arm64",
+    WEB = "web",
+    UNIVERSAL = "universal",
+    UNKNOWN = "unknown",
+    UNDEFINED = "undefined"
+}
+/**
+ * **!Do not construct directly!**
+ *
+ * **!Only static methods because it gets serialized!**
+ *
+ * This represents the "canonical" version for an extension identifier. Extension ids
+ * have to be case-insensitive (due to the marketplace), but we must ensure case
+ * preservation because the extension API is already public at this time.
+ *
+ * For example, given an extension with the publisher `"Hello"` and the name `"World"`,
+ * its canonical extension identifier is `"Hello.World"`. This extension could be
+ * referenced in some other extension's dependencies using the string `"hello.world"`.
+ *
+ * To make matters more complicated, an extension can optionally have an UUID. When two
+ * extensions have the same UUID, they are considered equal even if their identifier is different.
+ */
+declare class ExtensionIdentifier {
+    readonly value: string;
+    private readonly _lower;
+    constructor(value: string);
+    static equals(a: ExtensionIdentifier | string | null | undefined, b: ExtensionIdentifier | string | null | undefined): boolean;
+    /**
+     * Gives the value by which to index (for equality).
+     */
+    static toKey(id: ExtensionIdentifier | string): string;
+}
+interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest {
+    id?: string;
+    identifier: ExtensionIdentifier;
+    uuid?: string;
+    targetPlatform: TargetPlatform;
+    isBuiltin: boolean;
+    isUserBuiltin: boolean;
+    isUnderDevelopment: boolean;
+    extensionLocation: URI;
+}
+declare type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
+
+interface IUserFriendlyKeybinding {
+    key: string;
+    command: string;
+    args?: any;
+    when?: string;
+}
+
+type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+
+interface ILocalizedString {
+    /**
+     * The localized value of the string.
+     */
+    value: string;
+    /**
+     * The original (non localized value of the string)
+     */
+    original: string;
+}
+
+interface ContributedKeyBinding {
+    command: string;
+    args?: any;
+    key: string;
+    when?: string;
+    mac?: string;
+    linux?: string;
+    win?: string;
+}
+interface IUserFriendlyCommand {
+    command: string;
+    title: string | ILocalizedString;
+    shortTitle?: string | ILocalizedString;
+    enablement?: string;
+    category?: string | ILocalizedString;
+    icon?: string | {
+        light: string;
+        dark: string;
+    };
+}
+declare function setKeybindings(grammars: ContributedKeyBinding | ContributedKeyBinding[], extension?: IExtensionDescription): void;
+declare function setCommands(keybindings: IUserFriendlyCommand | IUserFriendlyCommand[], extension?: IExtensionDescription): void;
+declare function updateUserKeybindings(keybindingsJson: string): void;
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { ContributedKeyBinding, IUserFriendlyKeybinding, getServiceOverride as default, setCommands, setKeybindings, updateUserKeybindings };