@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/override/vs/workbench/contrib/files/browser/views/openEditorsView.js

@@ -0,0 +1,2 @@
+class OpenEditorsView {}
+export { OpenEditorsView };

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

@@ -1,10 +1,13 @@
 import { FilterPattern } from '@rollup/pluginutils';
-import { Plugin } from 'rollup';
+import { Plugin, InputPluginOption } from 'rollup';
 
 interface Options {
     include?: FilterPattern;
     exclude?: FilterPattern;
+    isDefaultExtension?: boolean;
+    withCode?: (extensionPath: string) => boolean;
+    rollupPlugins: InputPluginOption[];
 }
-declare function plugin(options: Options): Plugin;
+declare function plugin({ include, exclude, isDefaultExtension, withCode, rollupPlugins }: Options): Plugin;
 
 export { plugin as default };

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

@@ -1,11 +1,19 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
-import { e as extractPathsFromExtensionManifest, p as parseJson, l as localizeManifest } from './extension-tools-b68a64de.js';
+import { p as parseJson, l as localizeManifest, b as buildExtensionCode, i as isBinaryFileSync_1, c as compressResource, e as extractResourcesFromExtensionManifest, m as mimeTypes } from './extension-tools-d0cfdea1.js';
 import * as path from 'path';
 import * as fsPromise from 'fs/promises';
-import * as fs from 'fs';
+import * as require$$0$1 from 'fs';
+import 'util';
+import 'node:path';
+import 'node:process';
+import 'node:perf_hooks';
+import 'node:crypto';
+import 'node:fs/promises';
+import 'node:events';
+import 'tty';
 
-function plugin(options) {
-    const filter = createFilter(options.include, options.exclude);
+function plugin({ include, exclude, isDefaultExtension = false, withCode = () => true, rollupPlugins }) {
+    const filter = createFilter(include, exclude);
     return {
         name: 'default-extensions-loader',
         resolveId(source) {
@@ -19,47 +27,15 @@ function plugin(options) {
             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;
-            }
+            // Load extension resources
             const basename = path.basename(id);
             if (basename === 'package.json') {
-                let parsed = parseJson(id, code);
+                const content = await fsPromise.readFile(id);
+                let parsed = parseJson(id, content.toString('utf-8'));
                 const nlsFile = path.resolve(path.dirname(id), 'package.nls.json');
-                if (fs.existsSync(nlsFile)) {
+                if (require$$0$1.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,
@@ -68,13 +44,65 @@ registerFile('${filePath}', async () => await import('${path.resolve(id, filePat
                     })
                 };
             }
-            else {
-                // transform extension files to strings
-                return {
-                    code: `export default ${JSON.stringify(code)};`,
-                    map: { mappings: '' }
-                };
+            const extensionResourceMatch = /^(.*)\.extensionResource$/.exec(id);
+            if (extensionResourceMatch != null) {
+                const resourcePath = extensionResourceMatch[1];
+                if (resourcePath.endsWith('.js')) {
+                    const code = await buildExtensionCode(resourcePath, rollupPlugins);
+                    return {
+                        code: `export default ${JSON.stringify(code)};`,
+                        map: { mappings: '' }
+                    };
+                }
+                const content = await fsPromise.readFile(resourcePath);
+                if (isBinaryFileSync_1(content)) {
+                    return {
+                        code: `export default Uint8Array.from(window.atob(${JSON.stringify(content.toString('base64'))}), v => v.charCodeAt(0));`,
+                        map: { mappings: '' }
+                    };
+                }
+                else {
+                    return {
+                        code: `export default ${JSON.stringify(compressResource(id, content.toString('utf-8')))};`,
+                        map: { mappings: '' }
+                    };
+                }
+            }
+            // load extension directory as a module that loads the extension
+            const stat = await fsPromise.stat(id);
+            if (stat.isDirectory()) {
+                // Load the extension directory as a module importing the required files and registering the extension
+                const manifestPath = path.resolve(id, 'package.json');
+                const manifest = JSON.parse((await fsPromise.readFile(manifestPath)).toString('utf8'));
+                try {
+                    const extensionResources = await extractResourcesFromExtensionManifest(manifest, async (resourcePath) => {
+                        return (await fsPromise.readFile(path.join(id, resourcePath)));
+                    });
+                    const syncPaths = extensionResources.filter(resource => resource.sync).map(r => r.path);
+                    const asyncPaths = extensionResources.filter(resource => !resource.sync).map(r => r.path);
+                    return `
+import manifest from '${manifestPath}'
+import { registerExtension, onExtHostInitialized } from '${isDefaultExtension ? '../src/extensions' : 'vscode/extensions'}'
+${syncPaths.map((resourcePath, index) => (`
+import resource_${index} from '${path.resolve(id, resourcePath)}.extensionResource'`)).join('\n')}
+
+onExtHostInitialized(() => {
+  const { registerFile, registerSyncFile, runCode } = registerExtension(manifest)
+${asyncPaths.map(resourcePath => (`
+  registerFile('${resourcePath}', async () => await import('${path.resolve(id, resourcePath)}.extensionResource'))`)).join('\n')}
+${syncPaths.map((resourcePath, index) => (`
+  registerSyncFile('${resourcePath}', resource_${index}, '${mimeTypes.lookup(resourcePath)}')`)).join('\n')}
+
+  ${withCode(id) ? '  runCode()' : ''}
+})
+        `;
+                }
+                catch (err) {
+                    console.error(err, err.stack);
+                    throw err;
+                }
             }
+            return undefined;
         }
     };
 }

package/dist/rollup-vsix-plugin.d.ts

@@ -1,10 +1,12 @@
 import { FilterPattern } from '@rollup/pluginutils';
-import { Plugin } from 'rollup';
+import { Plugin, InputPluginOption } from 'rollup';
 
 interface Options {
     include?: FilterPattern;
     exclude?: FilterPattern;
+    withCode?: (extensionPath: string) => boolean;
+    rollupPlugins: InputPluginOption[];
 }
-declare function plugin(options?: Options): Plugin;
+declare function plugin({ include, exclude, rollupPlugins, withCode }: Options): Plugin;
 
 export { plugin as default };

package/dist/rollup-vsix-plugin.js

@@ -1,7 +1,16 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
 import * as yauzl from 'yauzl';
-import { p as parseJson, l as localizeManifest, e as extractPathsFromExtensionManifest } from './extension-tools-b68a64de.js';
+import { b as buildExtensionCode, i as isBinaryFileSync_1, c as compressResource, p as parseJson, l as localizeManifest, e as extractResourcesFromExtensionManifest, m as mimeTypes } from './extension-tools-d0cfdea1.js';
 import * as path from 'path';
+import 'fs';
+import 'util';
+import 'node:path';
+import 'node:process';
+import 'node:perf_hooks';
+import 'node:crypto';
+import 'node:fs/promises';
+import 'node:events';
+import 'tty';
 
 function read(stream) {
     const bufs = [];
@@ -42,11 +51,11 @@ async function readVsix(file) {
         });
     });
 }
-const defaultOptions = {
-    include: '**/*.vsix'
-};
-function plugin(options = defaultOptions) {
-    const filter = createFilter(options.include, options.exclude);
+function getVsixPath(file) {
+    return path.relative('/', path.resolve('/', file));
+}
+function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () => true }) {
+    const filter = createFilter(include, exclude);
     const vsixFiles = {};
     return {
         name: 'vsix-loader',
@@ -60,12 +69,34 @@ function plugin(options = defaultOptions) {
             return undefined;
         },
         async load(id) {
-            const rawMatch = /vsix:(.*):(.*)\.raw/.exec(id);
+            const rawMatch = /^vsix:(.*):(.*)\.raw$/.exec(id);
             if (rawMatch != null) {
-                const content = vsixFiles[rawMatch[1]][rawMatch[2]].toString('utf8');
-                return `export default ${JSON.stringify(content)};`;
+                const vsixFile = vsixFiles[rawMatch[1]];
+                const resourcePath = rawMatch[2];
+                if (resourcePath.endsWith('.js')) {
+                    const code = await buildExtensionCode(resourcePath, rollupPlugins, async (resourcePath) => {
+                        return vsixFile[getVsixPath(resourcePath)]?.toString('utf-8') ?? 'export default ""';
+                    });
+                    return {
+                        code: `export default ${JSON.stringify(code)};`,
+                        map: { mappings: '' }
+                    };
+                }
+                const content = vsixFile[resourcePath];
+                if (isBinaryFileSync_1(content)) {
+                    return {
+                        code: `export default Uint8Array.from(window.atob(${JSON.stringify(content.toString('base64'))}), v => v.charCodeAt(0));`,
+                        map: { mappings: '' }
+                    };
+                }
+                else {
+                    return {
+                        code: `export default ${JSON.stringify(compressResource(id, content.toString('utf-8')))};`,
+                        map: { mappings: '' }
+                    };
+                }
             }
-            const match = /vsix:(.*):(.*)\.vsjson/.exec(id);
+            const match = /^vsix:(.*):(.*)\.vsjson$/.exec(id);
             if (match != null) {
                 const file = match[2];
                 const vsixFile = vsixFiles[match[1]];
@@ -85,25 +116,32 @@ function plugin(options = defaultOptions) {
                 return null;
             const files = await readVsix(id);
             const manifest = parseJson(id, files['package.json'].toString('utf8'));
-            function getVsixPath(file) {
-                return path.relative('/', path.resolve('/', file));
-            }
-            const usedFiles = extractPathsFromExtensionManifest(manifest).filter(file => getVsixPath(file) in files);
-            const allFiles = ['package.json', 'package.nls.json', ...usedFiles].filter(file => getVsixPath(file) in files);
-            const vsixFile = allFiles.reduce((acc, usedFile) => {
+            const extensionResources = (await extractResourcesFromExtensionManifest(manifest, async (path) => {
+                return files[getVsixPath(path)];
+            })).filter(resource => getVsixPath(resource.path) in files);
+            const vsixFile = Object.keys(files).reduce((acc, usedFile) => {
                 return ({
                     ...acc,
                     [usedFile]: files[getVsixPath(usedFile)]
                 });
             }, {});
             vsixFiles[id] = vsixFile;
+            const syncPaths = extensionResources.filter(resource => resource.sync).map(r => r.path);
+            const asyncPaths = extensionResources.filter(resource => !resource.sync).map(r => r.path);
             return `
 import manifest from 'vsix:${id}:package.json.vsjson'
 import { registerExtension, onExtHostInitialized } from 'vscode/extensions'
+${syncPaths.map((resourcePath, index) => (`
+import resource_${index} from 'vsix:${id}:${resourcePath}.raw'`)).join('\n')}
+
 onExtHostInitialized(() => {
-  const { registerFile } = registerExtension(manifest)
-${usedFiles.map((filePath) => (`
-  registerFile('${filePath}', async () => (await import('vsix:${id}:${filePath}.raw')).default)`))}
+  const { registerFile, registerSyncFile, runCode } = registerExtension(manifest)
+${asyncPaths.map((filePath) => (`
+  registerFile('${filePath}', async () => (await import('vsix:${id}:${filePath}.raw')).default)`)).join('\n')}
+${syncPaths.map((resourcePath, index) => (`
+  registerSyncFile('${resourcePath}', resource_${index}, '${mimeTypes.lookup(resourcePath)}')`)).join('\n')}
+
+${withCode(id) ? '  runCode()' : ''}
 })
 `;
         }

package/dist/service-override/audioCue.d.ts

@@ -1,22 +1,7 @@
-import * as monaco from 'monaco-editor';
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
-
-interface IRawLanguageExtensionPoint {
-    id: string;
-    extensions: string[];
-    filenames: string[];
-    filenamePatterns: string[];
-    firstLine: string;
-    aliases: string[];
-    mimetypes: string[];
-    configuration: string;
-    icon: {
-        light: string;
-        dark: string;
-    };
-}
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import '../instantiation.js';
+import 'monaco-editor';
 
 declare function getServiceOverride(): IEditorOverrideServices;
 
-export { IRawLanguageExtensionPoint, getServiceOverride as default };
+export { getServiceOverride as default };