@codingame/monaco-vscode-api 1.78.4-next.0 → 1.78.4-next.1

package/dist/monaco.d.ts

@@ -1,6 +1,17 @@
 import * as monaco from 'monaco-editor';
 import * as vscode from 'vscode';
 
+interface ServicesAccessor {
+    get<T>(id: ServiceIdentifier<T>): T;
+}
+/**
+ * Identifies a service of type `T`.
+ */
+interface ServiceIdentifier<T> {
+    (...args: any[]): void;
+    type: T;
+}
+
 /**
  * An object that performs a cleanup operation when `.dispose()` is called.
  *
@@ -537,17 +548,6 @@ declare namespace Event {
     function fromObservable<T>(obs: IObservable<T, any>, store?: DisposableStore): Event<T>;
 }
 
-interface ServicesAccessor {
-    get<T>(id: ServiceIdentifier<T>): T;
-}
-/**
- * Identifies a service of type `T`.
- */
-interface ServiceIdentifier<T> {
-    (...args: any[]): void;
-    type: T;
-}
-
 declare const enum ContextKeyExprType {
     False = 0,
     True = 1,

package/dist/rollup-extension-directory-plugin.d.ts

@@ -0,0 +1,10 @@
+import { FilterPattern } from '@rollup/pluginutils';
+import { Plugin } from 'rollup';
+
+interface Options {
+    include?: FilterPattern;
+    exclude?: FilterPattern;
+}
+declare function plugin(options: Options): Plugin;
+
+export { plugin as default };

package/dist/rollup-extension-directory-plugin.js

@@ -0,0 +1,82 @@
+import { createFilter, dataToEsm } from '@rollup/pluginutils';
+import { e as extractPathsFromExtensionManifest, p as parseJson, l as localizeManifest } from './extension-tools-b2d018a3.js';
+import * as path from 'path';
+import * as fsPromise from 'fs/promises';
+import * as fs from 'fs';
+
+function plugin(options) {
+    const filter = createFilter(options.include, options.exclude);
+    return {
+        name: 'default-extensions-loader',
+        resolveId(source) {
+            if (filter(source)) {
+                return source;
+            }
+            return undefined;
+        },
+        async load(id) {
+            // load extension directory as a module that loads the extension
+            if (!filter(id)) {
+                return;
+            }
+            // load extension directory as a module that loads the extension
+            const stat = await fsPromise.stat(id);
+            if (!stat.isDirectory()) {
+                return;
+            }
+            const manifestPath = path.resolve(id, 'package.json');
+            const manifest = JSON.parse((await fsPromise.readFile(manifestPath)).toString('utf8'));
+            try {
+                const filePaths = extractPathsFromExtensionManifest(manifest);
+                return `
+import manifest from '${manifestPath}'
+import { registerExtension } from '../src/extensions'
+import { onExtHostInitialized } from '../src/vscode-services/extHost'
+onExtHostInitialized(() => {
+const { registerFile } = registerExtension(manifest)
+${filePaths.map(filePath => (`
+registerFile('${filePath}', async () => await import('${path.resolve(id, filePath)}'))`))}
+})
+      `;
+            }
+            catch (err) {
+                console.error(err, err.stack);
+                throw err;
+            }
+        },
+        async transform(code, id) {
+            if (!filter(id)) {
+                return code;
+            }
+            const stat = await fsPromise.stat(id);
+            if (stat.isDirectory()) {
+                return code;
+            }
+            const basename = path.basename(id);
+            if (basename === 'package.json') {
+                let parsed = parseJson(id, code);
+                const nlsFile = path.resolve(path.dirname(id), 'package.nls.json');
+                if (fs.existsSync(nlsFile)) {
+                    parsed = localizeManifest(parsed, parseJson(id, (await fsPromise.readFile(nlsFile)).toString()));
+                }
+                // Load extension package.json and package.nls.json as a json
+                return {
+                    code: dataToEsm(parsed, {
+                        compact: true,
+                        namedExports: false,
+                        preferConst: false
+                    })
+                };
+            }
+            else {
+                // transform extension files to strings
+                return {
+                    code: `export default ${JSON.stringify(code)};`,
+                    map: { mappings: '' }
+                };
+            }
+        }
+    };
+}
+
+export { plugin as default };