@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/extensions.d2.ts

@@ -0,0 +1,457 @@
+import { U as URI } from './uri.js';
+import { C as ContextKeyExpression } from './contextkey.js';
+import { T as ThemeIcon } from './themables.js';
+import { S as ServiceIdentifier } from './instantiation.js';
+
+declare enum Severity {
+    Ignore = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3
+}
+declare namespace Severity {
+    /**
+     * Parses 'error', 'warning', 'warn', 'info' in call casings
+     * and falls back to ignore.
+     */
+    function fromValue(value: string): Severity;
+    function toString(severity: Severity): string;
+}
+
+declare const Categories: Readonly<{
+    View: {
+        value: string;
+        original: string;
+    };
+    Help: {
+        value: string;
+        original: string;
+    };
+    Test: {
+        value: string;
+        original: string;
+    };
+    File: {
+        value: string;
+        original: string;
+    };
+    Preferences: {
+        value: string;
+        original: string;
+    };
+    Developer: {
+        value: string;
+        original: string;
+    };
+}>;
+
+interface ILocalizedString {
+    /**
+     * The localized value of the string.
+     */
+    value: string;
+    /**
+     * The original (non localized value of the string)
+     */
+    original: string;
+}
+interface ICommandActionTitle extends ILocalizedString {
+    /**
+     * The title with a mnemonic designation. && precedes the mnemonic.
+     */
+    mnemonicTitle?: string;
+}
+type Icon = {
+    dark?: URI;
+    light?: URI;
+} | ThemeIcon;
+interface ICommandActionToggleInfo {
+    /**
+     * The condition that marks the action as toggled.
+     */
+    condition: ContextKeyExpression;
+    icon?: Icon;
+    tooltip?: string;
+    /**
+     * The title that goes well with a a check mark, e.g "(check) Line Numbers" vs "Toggle Line Numbers"
+     */
+    title?: string;
+    /**
+     * Like title but with a mnemonic designation.
+     */
+    mnemonicTitle?: string;
+}
+interface ICommandActionSource {
+    readonly id: string;
+    readonly title: string;
+}
+interface ICommandAction {
+    id: string;
+    title: string | ICommandActionTitle;
+    shortTitle?: string | ICommandActionTitle;
+    category?: keyof typeof Categories | ILocalizedString | string;
+    tooltip?: string | ILocalizedString;
+    icon?: Icon;
+    source?: ICommandActionSource;
+    precondition?: ContextKeyExpression;
+    /**
+     * The action is a toggle action. Define the context key expression that reflects its toggle-state
+     * or define toggle-info including an icon and a title that goes well with a checkmark.
+     */
+    toggled?: ContextKeyExpression | ICommandActionToggleInfo;
+}
+
+interface IDebugParams {
+    port: number | null;
+    break: boolean;
+}
+interface IExtensionHostDebugParams extends IDebugParams {
+    debugId?: string;
+    env?: Record<string, string>;
+}
+/**
+ * Type of extension.
+ *
+ * **NOTE**: This is defined in `platform/environment` because it can appear as a CLI argument.
+ */
+type ExtensionKind = 'ui' | 'workspace' | 'web';
+
+declare const IEnvironmentService: ServiceIdentifier<IEnvironmentService>;
+/**
+ * A basic environment service that can be used in various processes,
+ * such as main, renderer and shared process. Use subclasses of this
+ * service for specific environment.
+ */
+interface IEnvironmentService {
+    readonly _serviceBrand: undefined;
+    stateResource: URI;
+    userRoamingDataHome: URI;
+    keyboardLayoutResource: URI;
+    argvResource: URI;
+    untitledWorkspacesHome: URI;
+    workspaceStorageHome: URI;
+    localHistoryHome: URI;
+    cacheHome: URI;
+    userDataSyncHome: URI;
+    sync: 'on' | 'off' | undefined;
+    continueOn?: string;
+    editSessionId?: string;
+    debugExtensionHost: IExtensionHostDebugParams;
+    isExtensionDevelopment: boolean;
+    disableExtensions: boolean | string[];
+    enableExtensions?: readonly string[];
+    extensionDevelopmentLocationURI?: URI[];
+    extensionDevelopmentKind?: ExtensionKind[];
+    extensionTestsLocationURI?: URI;
+    logsHome: URI;
+    logLevel?: string;
+    extensionLogLevel?: [string, string][];
+    verbose: boolean;
+    isBuilt: boolean;
+    disableTelemetry: boolean;
+    serviceMachineIdResource: URI;
+    policyFile?: URI;
+}
+
+interface ICommand {
+    command: string;
+    title: string | ILocalizedString;
+    category?: string | ILocalizedString;
+}
+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 icon?: 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;
+}
+type LimitedWorkspaceSupportType = 'limited';
+type ExtensionUntrustedWorkspaceSupport = {
+    supported: true;
+} | {
+    supported: false;
+    description: string;
+} | {
+    supported: LimitedWorkspaceSupportType;
+    description: string;
+    restrictedConfigurations?: string[];
+};
+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;
+    preview?: boolean;
+    l10n?: 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;
+}
+type IExtensionManifest = Readonly<IRelaxedExtensionManifest>;
+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;
+}
+type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
+
+export { ExtensionIdentifier as E, IExtensionDescription as I, Severity as S, IExtensionManifest as a, IExtensionContributions as b, ICommandAction as c, ICommandActionTitle as d, Icon as e, ILocalizedString as f, IEnvironmentService as g, ExtensionKind as h };

package/dist/extensions.js

@@ -11,8 +11,15 @@ import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { localizeManifest } from './vscode/vs/platform/extensionManagement/common/extensionNls.js';
+import { joinPath, originalFSPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ExtensionMode, ExtensionKind } from './vscode/vs/workbench/api/common/extHostTypes.js';
+import { ExtensionGlobalMemento, ExtensionMemento } from './vscode/vs/workbench/api/common/extHostMemento.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import * as api from './api.js';
 import { registerExtensionFile } from './service-override/files.js';
+import create$7 from './vscode-services/l10n.js';
 import create$6 from './vscode-services/languages.js';
 import create$3 from './vscode-services/commands.js';
 import create$5 from './vscode-services/workspace.js';
@@ -20,8 +27,9 @@ import create$4 from './vscode-services/window.js';
 import create$2 from './vscode-services/env.js';
 import create$1 from './vscode-services/debug.js';
 import create from './vscode-services/extensions.js';
-import { initialize as initialize$1 } from './vscode-services/extHost.js';
+import { initialize as initialize$1, getExtHostServices } from './vscode-services/extHost.js';
 export { onExtHostInitialized } from './vscode-services/extHost.js';
+import { unsupported } from './tools.js';
 function consoleExtensionMessageHandler(msg) {
     if (msg.type === Severity.Error) {
         console.error(msg);
@@ -57,7 +65,7 @@ let DEFAULT_EXTENSION = {
     publisher: 'microsoft',
     version: '1.0.0',
     engines: {
-        vscode: "1.78.0"
+        vscode: "1.79.0"
     },
     targetPlatform: "web"
 };
@@ -80,7 +88,8 @@ function createApi(extension) {
         commands: create$3(() => extension),
         window: create$4(() => extension, workspace),
         workspace: create$5(() => extension),
-        languages: create$6(() => extension)
+        languages: create$6(() => extension),
+        l10n: create$7(() => extension)
     };
 }
 const hasOwnProperty = Object.hasOwnProperty;
@@ -118,6 +127,73 @@ function deltaExtensions(toAdd, toRemove) {
         }
     });
 }
+const extensionFileBlobUrls = new Map();
+function registerExtensionFileBlob(extensionLocation, filePath, content, mimeType) {
+    const blob = new Blob([content instanceof Uint8Array ? content : new TextEncoder().encode(content)], {
+        type: mimeType
+    });
+    extensionFileBlobUrls.set(( joinPath(extensionLocation, filePath).toString()), URL.createObjectURL(blob));
+}
+const original = FileAccess.uriToBrowserUri;
+FileAccess.uriToBrowserUri = function (uri) {
+    if (uri.scheme === 'extension') {
+        const extensionFile = extensionFileBlobUrls.get(( uri.toString()));
+        if (extensionFile != null) {
+            return ( URI.parse(extensionFile));
+        }
+    }
+    return original.call(this, uri);
+};
+async function createExtensionContext(extensionDescription) {
+    const { extHostStorage, extHostInitData } = getExtHostServices();
+    const globalState = new ExtensionGlobalMemento(extensionDescription, extHostStorage);
+    const workspaceState = new ExtensionMemento(extensionDescription.identifier.value, false, extHostStorage);
+    await Promise.all([
+        globalState.whenReady,
+        workspaceState.whenReady
+    ]);
+    return {
+        globalState,
+        workspaceState,
+        get secrets() { return unsupported(); },
+        subscriptions: [],
+        get extensionUri() { return extensionDescription.extensionLocation; },
+        get extensionPath() { return extensionDescription.extensionLocation.fsPath; },
+        asAbsolutePath(relativePath) { return path.join(extensionDescription.extensionLocation.fsPath, relativePath); },
+        get storagePath() { return unsupported(); },
+        get globalStoragePath() { return unsupported(); },
+        get logPath() { return path.join(extHostInitData.logsLocation.fsPath, extensionDescription.identifier.value); },
+        get logUri() { return URI.joinPath(extHostInitData.logsLocation, extensionDescription.identifier.value); },
+        get storageUri() { return unsupported(); },
+        get globalStorageUri() { return unsupported(); },
+        extensionMode: ExtensionMode.Production,
+        extension: {
+            activate: unsupported,
+            id: extensionDescription.identifier.value,
+            extensionUri: extensionDescription.extensionLocation,
+            extensionPath: path.normalize(originalFSPath(extensionDescription.extensionLocation)),
+            isActive: true,
+            packageJSON: extensionDescription,
+            extensionKind: ExtensionKind.UI,
+            exports: null
+        },
+        get environmentVariableCollection() { return unsupported(); }
+    };
+}
+function runExtensionCode(api, code) {
+    const initFn = new Function('module', 'exports', 'require', code);
+    const _exports = {};
+    const _module = { exports: _exports };
+    const _require = (request) => {
+        if (request === 'vscode') {
+            return api;
+        }
+        throw new Error(`Cannot load module '${request}'`);
+    };
+    initFn(_module, _exports, _require);
+    const module = (_module.exports !== _exports ? _module.exports : _exports);
+    return module;
+}
 function registerExtension(manifest, defaultNLS) {
     const uuid = generateUuid();
     const location = ( URI.from({ scheme: 'extension', path: `/${uuid}` }));
@@ -137,14 +213,33 @@ function registerExtension(manifest, defaultNLS) {
     };
     const extensionDescription = toExtensionDescription(extension);
     deltaExtensions([extensionDescription], []);
+    const api = createApi(extensionDescription);
     return {
-        api: createApi(extensionDescription),
+        api,
+        async runCode() {
+            if (extension.manifest.browser == null) {
+                return;
+            }
+            let module = joinPath(location, extension.manifest.browser);
+            module = module.with({ path: ensureSuffix(module.path, '.js') });
+            const content = ( (await StandaloneServices.get(IFileService).readFile(module)).value.toString());
+            const extensionModule = runExtensionCode(api, content);
+            const context = await createExtensionContext(extensionDescription);
+            await extensionModule.activate?.(context);
+        },
         registerFile: (path, getContent) => {
             return registerExtensionFile(location, path, getContent);
         },
+        registerSyncFile: (path, content, mimeType) => {
+            registerExtensionFileBlob(location, path, content, mimeType);
+            return registerExtensionFile(location, path, async () => content);
+        },
         dispose() {
             deltaExtensions([], [extensionDescription]);
         }
     };
 }
-export { consoleExtensionMessageHandler, createApi, getDefaultExtension, initialize, registerExtension };
+function ensureSuffix(path, suffix) {
+    return path.endsWith(suffix) ? path : path + suffix;
+}
+export { consoleExtensionMessageHandler, createApi, getDefaultExtension, initialize, registerExtension, runExtensionCode };