SystemSh0cker/monaco-editor
1
0
Fork 0
mirror of https://github.com/microsoft/monaco-editor.git synced 2025-12-22 03:30:10 +01:00
Code Issues Projects Releases Packages Activity

repairs esm and amd build (#4950)

Browse source
This commit is contained in:
Henning Dieterichs 2025-08-28 13:35:17 +02:00 • committed by GitHub
parent f420968fc9
commit e56ad4b588
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
43 changed files with 2302 additions and 856 deletions
Download patch file Download diff file Expand all files Collapse all files

4
.azure-pipelines/publish-nightly.yml
View file

@ -57,7 +57,7 @@ extends:
- script: npm ci
displayName: Install NPM dependencies
- script: yarn ts-node ./scripts/ci/monaco-editor-core-prepare nightly
- script: yarn ts-node ./scripts/ci/build-monaco-editor-core-pkg nightly
env:
VSCODE_REF: ${{ parameters.vscodeRef }}
PRERELEASE_VERSION: ${{ parameters.prereleaseVersion }}
@ -78,7 +78,7 @@ extends:
- script: npm ci
displayName: Install NPM dependencies
- script: yarn ts-node ./scripts/ci/monaco-editor-prepare nightly
- script: yarn ts-node ./scripts/ci/build-monaco-editor-pkg nightly
env:
VSCODE_REF: ${{ parameters.vscodeRef }}
PRERELEASE_VERSION: ${{ parameters.prereleaseVersion }}

4
.azure-pipelines/publish-stable.yml
View file

@ -45,7 +45,7 @@ extends:
- script: npm ci
displayName: Install NPM dependencies
- script: yarn ts-node ./scripts/ci/monaco-editor-core-prepare stable
- script: yarn ts-node ./scripts/ci/build-monaco-editor-core-pkg stable
displayName: Setup, Build & Test monaco-editor-core
tag: latest
@ -62,7 +62,7 @@ extends:
- script: npm ci
displayName: Install NPM dependencies
- script: yarn ts-node ./scripts/ci/monaco-editor-prepare stable
- script: yarn ts-node ./scripts/ci/build-monaco-editor-pkg stable
displayName: Setup, Build & Test monaco-editor
tag: latest

67
.github/workflows/ci.yml vendored
View file

@ -5,13 +5,15 @@ on: [push, pull_request]
jobs:
build:
name: CI
runs-on: ubuntu-22.04
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@1f8c6b94b26d0feae1e387ca63ccbdc44d27b561 # pin@v2
with:
node-version: 20
persist-credentials: false
- uses: actions/setup-node@v4
with:
node-version-file: .nvmrc
- name: Cache node modules
id: cacheNodeModules
@ -21,25 +23,48 @@ jobs:
key: ${{ runner.os }}-cacheNodeModules2-${{ hashFiles('**/package-lock.json', '**/package.json') }}
restore-keys: ${{ runner.os }}-cacheNodeModules2-
- name: Install build tools
if: steps.cache-node-modules.outputs.cache-hit != 'true'
run: |
sudo apt update -y
sudo apt install -y build-essential pkg-config libx11-dev libx11-xcb-dev libxkbfile-dev libnotify-bin libkrb5-dev
- name: execute `npm ci` (1)
if: ${{ steps.cacheNodeModules.outputs.cache-hit != 'true' }}
run: npm ci
env:
PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: 1
ELECTRON_SKIP_BINARY_DOWNLOAD: 1
run: |
npm ci
- name: Download Playwright
run: npx playwright install --with-deps
- name: execute `npm ci` (2)
if: ${{ steps.cacheNodeModules.outputs.cache-hit != 'true' }}
run: npm ci --prefix webpack-plugin
- name: Install Playwright
run: npm run playwright-install
# <building-from-source>
- name: Setup, Build & Test monaco-editor-core
run: yarn ts-node ./scripts/ci/build-monaco-editor-core-pkg nightly
env:
VSCODE_REF: 'main'
PRERELEASE_VERSION: 'dev-${today}'
- name: Install OS Dependencies for Playwright
run: sudo npm run playwright-install-deps
- name: Link monaco-editor-core
run: npm link
working-directory: ./dependencies/vscode/out-monaco-editor-core
- name: Check prettier
run: npm run prettier-check
- name: Link monaco-editor-core
run: npm link monaco-editor-core
# </building-from-source>
# TODO: prettier formatting
# - name: Check prettier
# run: npm run prettier-check
- name: Build
run: npm run build-monaco-editor
run: npm run build
- name: Run unit tests
run: npm test
@ -63,14 +88,14 @@ jobs:
- name: Run smoke test
run: npm run smoketest
- name: Install website node modules
working-directory: website
run: yarn install --frozen-lockfile
# - name: Install website node modules
# working-directory: website
# run: yarn install --frozen-lockfile
- name: Build website
working-directory: website
run: yarn run build
# - name: Build website
# working-directory: website
# run: yarn run build
- name: Test website
working-directory: website
run: yarn test
# - name: Test website
# working-directory: website
# run: yarn test

2
.nvmrc
View file

@ -1 +1 @@
20.14.0
22.17.0

4
CHANGELOG.md
View file

@ -1,5 +1,9 @@
# Monaco Editor Changelog
## [0.60.0]
- Deprecated `AMD` build.
## [0.52.0]
- Comment added inside of `IModelContentChangedEvent`

10
README.md
View file

@ -24,12 +24,9 @@ The playground is the best way to learn about how to use the editor, which featu
You will get:
- inside `/esm`: ESM version of the editor (compatible with e.g. webpack)
- inside `/dev`: AMD bundled, not minified
- inside `/min`: AMD bundled, and minified
- inside `/min-maps`: source maps for `min`
- `monaco.d.ts`: this specifies the API of the editor (this is what is actually versioned, everything else is considered private and might break with any release).
It is recommended to develop against the `dev` version, and in production to use the `min` version.
The monaco editor also ships an `AMD` build for backwards-compatibility reasons, but the `AMD` support is deprecated and will be removed in future versions.
## Concepts
@ -60,7 +57,6 @@ Many Monaco related objects often implement the `.dispose()` method. This method
## Documentation
- Learn how to integrate the editor with these [complete samples](./samples/).
- [Integrate the AMD version](./docs/integrate-amd.md).
- [Integrate the ESM version](./docs/integrate-esm.md)
- Learn how to use the editor API and try out your own customizations in the [playground](https://microsoft.github.io/monaco-editor/playground.html).
- Explore the [API docs](https://microsoft.github.io/monaco-editor/docs.html) or read them straight from [`monaco.d.ts`](https://github.com/microsoft/monaco-editor/blob/gh-pages/node_modules/monaco-editor/monaco.d.ts).
@ -92,10 +88,6 @@ No.
Language services create web workers to compute heavy stuff outside of the UI thread. They cost hardly anything in terms of resource overhead and you shouldn't worry too much about them, as long as you get them to work (see above the cross-domain case).
❓ **What is this `loader.js`? Can I use `require.js`?**
It is an AMD loader that we use in VS Code. Yes.
❓ **I see the warning "Could not create web worker". What should I do?**
HTML5 does not allow pages loaded on `file://` to create web workers. Please load the editor with a web server on `http://` or `https://` schemes.

7
build/amd/build.script.ts Normal file
View file

@ -0,0 +1,7 @@
import { run } from '../../scripts/lib/index';
export async function buildAmdMinDev() {
const rootPath = __dirname;
await run('npx vite build --mode development', { cwd: rootPath });
await run('npx vite build', { cwd: rootPath });
}

44
build/amd/src/editor.main.js Normal file
View file

@ -0,0 +1,44 @@
self.MonacoEnvironment = {
getWorker: function (_moduleId, label) {
if (label === 'json') {
return new Worker(new URL('../../../src/language/json/json.worker.ts', import.meta.url), {
type: 'module'
});
}
if (label === 'css' || label === 'scss' || label === 'less') {
return new Worker(new URL('../../../src/language/css/css.worker.ts', import.meta.url), {
type: 'module'
});
}
if (label === 'html' || label === 'handlebars' || label === 'razor') {
return new Worker(new URL('../../../src/language/html/html.worker.ts', import.meta.url), {
type: 'module'
});
}
if (label === 'typescript' || label === 'javascript') {
return new Worker(new URL('../../../src/language/typescript/ts.worker.ts', import.meta.url), {
type: 'module'
});
}
return new Worker(new URL('../../../src/editor/editor.worker.ts', import.meta.url), {
type: 'module'
});
}
};
import 'vs/nls.messages-loader!';
import '../../../src/basic-languages/monaco.contribution';
import '../../../src/language/css/monaco.contribution';
import '../../../src/language/html/monaco.contribution';
import '../../../src/language/json/monaco.contribution';
import '../../../src/language/typescript/monaco.contribution';
import * as require_ from 'require';
const styleSheetUrl = require_.toUrl('vs/style.css');
const link = document.createElement('link');
link.rel = 'stylesheet';
link.href = styleSheetUrl;
document.head.appendChild(link);
export * as m from 'monaco-editor-core';

1368
build/amd/src/loader.js Normal file
View file

File diff suppressed because it is too large Load diff

10
build/amd/src/nls.messages-loader.js Normal file
View file

@ -0,0 +1,10 @@
export function load(name, req, load, config) {
const requestedLanguage = config['vs/nls']?.availableLanguages?.['*'];
if (!requestedLanguage || requestedLanguage === 'en') {
load({});
} else {
req([`vs/nls.messages.${requestedLanguage}`], () => {
load({});
});
}
}

79
build/amd/vite.config.js Normal file
View file

@ -0,0 +1,79 @@
import { readFileSync } from 'node:fs';
import { glob } from 'node:fs/promises';
import { basename, dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import { defineConfig } from 'vite';
const __dirname = dirname(fileURLToPath(import.meta.url));
export default defineConfig(async (args) => {
const monacoEditorCoreDir = join(
dirname(require.resolve('monaco-editor-core/package.json')),
'esm'
);
const nlsEntries = {};
for await (const path of glob(`${monacoEditorCoreDir}/nls.messages.*.js`)) {
const entryName = basename(path).replace('.js', '');
nlsEntries[entryName] = path;
}
return {
base: './',
define: {
AMD: false
},
build: {
lib: {
entry: {
...nlsEntries,
'nls.messages-loader': resolve(__dirname, 'src/nls.messages-loader.js'),
'editor/editor.main': resolve(__dirname, 'src/editor.main.js'),
'language/css/monaco.contribution': resolve(
__dirname,
'../../src/language/css/monaco.contribution.ts'
),
'language/html/monaco.contribution': resolve(
__dirname,
'../../src/language/html/monaco.contribution.ts'
),
'language/json/monaco.contribution': resolve(
__dirname,
'../../src/language/json/monaco.contribution.ts'
),
'language/typescript/monaco.contribution': resolve(
__dirname,
'../../src/language/typescript/monaco.contribution.ts'
)
},
name: 'monaco-editor',
fileName: (_format, entryName) => entryName + '.js',
formats: ['amd']
},
outDir: resolve(
__dirname,
'../../out/monaco-editor/',
args.mode === 'development' ? 'dev' : 'min',
'vs'
),
rollupOptions: {
external: ['require', 'vs/nls.messages-loader!'],
output: {}
},
minify: args.mode !== 'development',
emptyOutDir: true
},
plugins: [
{
name: 'copy-loader',
apply: 'build',
generateBundle() {
this.emitFile({
type: 'asset',
fileName: 'loader.js',
source: readFileSync(resolve(__dirname, './src/loader.js'), 'utf-8')
});
}
}
]
};
});

97
build/build-languages.ts
View file

@ -4,8 +4,8 @@
*--------------------------------------------------------------------------------------------*/
import glob from 'glob';
import { runTsc, massageAndCopyDts, buildESM, buildAMD } from './utils';
import { copyFile, removeDir } from './fs';
import { runTsc, massageAndCopyDts, buildESM } from './utils';
import { removeDir } from './fs';
removeDir(`out/languages`);
@ -14,22 +14,22 @@ runTsc(`src/tsconfig.json`);
//#region Type Defintion
massageAndCopyDts(
`out/languages/amd-tsc/language/css/monaco.contribution.d.ts`,
`out/languages/tsc/language/css/monaco.contribution.d.ts`,
`out/languages/bundled/css.d.ts`,
'monaco.languages.css'
);
massageAndCopyDts(
`out/languages/amd-tsc/language/html/monaco.contribution.d.ts`,
`out/languages/tsc/language/html/monaco.contribution.d.ts`,
`out/languages/bundled/html.d.ts`,
'monaco.languages.html'
);
massageAndCopyDts(
`out/languages/amd-tsc/language/json/monaco.contribution.d.ts`,
`out/languages/tsc/language/json/monaco.contribution.d.ts`,
`out/languages/bundled/json.d.ts`,
'monaco.languages.json'
);
massageAndCopyDts(
`out/languages/amd-tsc/language/typescript/monaco.contribution.d.ts`,
`out/languages/tsc/language/typescript/monaco.contribution.d.ts`,
`out/languages/bundled/typescript.d.ts`,
'monaco.languages.typescript'
);
@ -47,23 +47,6 @@ buildESM({
],
external: ['monaco-editor-core', '*/cssMode', '*/monaco.contribution']
});
buildAMD({
base: 'language/css',
entryPoint: 'src/language/css/monaco.contribution.ts',
amdModuleId: 'vs/language/css/monaco.contribution',
amdDependencies: ['vs/editor/editor.api']
});
buildAMD({
base: 'language/css',
entryPoint: 'src/language/css/cssMode.ts',
amdModuleId: 'vs/language/css/cssMode',
external: ['*/monaco.contribution']
});
buildAMD({
base: 'language/css',
entryPoint: 'src/language/css/cssWorker.ts',
amdModuleId: 'vs/language/css/cssWorker'
});
//#endregion
@ -78,23 +61,6 @@ buildESM({
],
external: ['monaco-editor-core', '*/htmlMode', '*/monaco.contribution']
});
buildAMD({
base: 'language/html',
entryPoint: 'src/language/html/monaco.contribution.ts',
amdModuleId: 'vs/language/html/monaco.contribution',
amdDependencies: ['vs/editor/editor.api']
});
buildAMD({
base: 'language/html',
entryPoint: 'src/language/html/htmlMode.ts',
amdModuleId: 'vs/language/html/htmlMode',
external: ['*/monaco.contribution']
});
buildAMD({
base: 'language/html',
entryPoint: 'src/language/html/htmlWorker.ts',
amdModuleId: 'vs/language/html/htmlWorker'
});
//#endregion
@ -109,23 +75,6 @@ buildESM({
],
external: ['monaco-editor-core', '*/jsonMode', '*/monaco.contribution']
});
buildAMD({
base: 'language/json',
entryPoint: 'src/language/json/monaco.contribution.ts',
amdModuleId: 'vs/language/json/monaco.contribution',
amdDependencies: ['vs/editor/editor.api']
});
buildAMD({
base: 'language/json',
entryPoint: 'src/language/json/jsonMode.ts',
amdModuleId: 'vs/language/json/jsonMode',
external: ['*/monaco.contribution']
});
buildAMD({
base: 'language/json',
entryPoint: 'src/language/json/jsonWorker.ts',
amdModuleId: 'vs/language/json/jsonWorker'
});
//#endregion
@ -140,23 +89,6 @@ buildESM({
],
external: ['monaco-editor-core', '*/tsMode', '*/monaco.contribution']
});
buildAMD({
base: 'language/typescript',
entryPoint: 'src/language/typescript/monaco.contribution.ts',
amdModuleId: 'vs/language/typescript/monaco.contribution',
amdDependencies: ['vs/editor/editor.api']
});
buildAMD({
base: 'language/typescript',
entryPoint: 'src/language/typescript/tsMode.ts',
amdModuleId: 'vs/language/typescript/tsMode',
external: ['*/monaco.contribution']
});
buildAMD({
base: 'language/typescript',
entryPoint: 'src/language/typescript/tsWorker.ts',
amdModuleId: 'vs/language/typescript/tsWorker'
});
//#endregion
@ -190,23 +122,6 @@ glob('../src/basic-languages/*/*.contribution.ts', { cwd: __dirname }, function
external
});
}
// AMD
{
buildAMD({
base: 'basic-languages',
entryPoint: 'src/basic-languages/monaco.contribution.ts',
amdModuleId: 'vs/basic-languages/monaco.contribution',
amdDependencies: ['vs/editor/editor.api']
});
for (const language of languages) {
buildAMD({
base: 'basic-languages',
entryPoint: `src/basic-languages/${language}/${language}.ts`,
amdModuleId: `vs/basic-languages/${language}/${language}`
});
}
}
});
//#endregion

218
build/build-monaco-editor.ts
View file

@ -5,18 +5,23 @@
import path = require('path');
import fs = require('fs');
import { REPO_ROOT, readFiles, writeFiles, IFile, readFile } from '../build/utils';
import {
REPO_ROOT,
readFiles,
writeFiles,
IFile,
readFile,
build,
bundledFileHeader
} from '../build/utils';
import { removeDir } from '../build/fs';
import ts = require('typescript');
import { generateMetadata } from './releaseMetadata';
import { buildAmdMinDev } from './amd/build.script';
import ts = require('typescript');
removeDir(`out/monaco-editor`);
// dev folder
AMD_releaseOne('dev');
// min folder
AMD_releaseOne('min');
buildAmdMinDev();
// esm folder
ESM_release();
@ -48,11 +53,6 @@ generateMetadata();
otherFiles = otherFiles.concat(readFiles('README.md', { base: '' }));
otherFiles = otherFiles.concat(readFiles('CHANGELOG.md', { base: '' }));
otherFiles = otherFiles.concat(
readFiles('node_modules/monaco-editor-core/min-maps/**/*', {
base: 'node_modules/monaco-editor-core/'
})
);
otherFiles = otherFiles.concat(
readFiles('node_modules/monaco-editor-core/LICENSE', {
base: 'node_modules/monaco-editor-core/'
@ -62,114 +62,6 @@ generateMetadata();
writeFiles(otherFiles, `out/monaco-editor`);
})();
/**
* Release to `dev` or `min`.
*/
function AMD_releaseOne(type: 'dev' | 'min') {
let coreFiles = readFiles(`node_modules/monaco-editor-core/${type}/**/*`, {
base: `node_modules/monaco-editor-core/${type}`
});
coreFiles = fixNlsFiles(coreFiles);
AMD_addPluginContribs(type, coreFiles);
writeFiles(coreFiles, `out/monaco-editor/${type}`);
const pluginFiles = readFiles(`out/languages/bundled/amd-${type}/**/*`, {
base: `out/languages/bundled/amd-${type}`,
ignore: ['**/monaco.contribution.js']
});
writeFiles(pluginFiles, `out/monaco-editor/${type}`);
}
function fixNlsFiles(files: IFile[]): IFile[] {
return files.map((f) => {
if (!f.path.match(/nls\.messages\.[a-z\-]+\.js/)) {
return f;
}
const dirName = path.dirname(f.path);
const fileName = path.basename(f.path);
const newPath = path.join(dirName, 'vs', fileName);
let contentStr = f.contents.toString('utf-8');
contentStr = `
define([], function () {
${contentStr}
});
`;
const newContents = Buffer.from(contentStr, 'utf-8');
return {
path: newPath,
contents: newContents
};
});
}
/**
* Edit editor.main.js:
* - rename the AMD module 'vs/editor/editor.main' to 'vs/editor/edcore.main'
* - append monaco.contribution modules from plugins
* - append new AMD module 'vs/editor/editor.main' that stiches things together
*/
function AMD_addPluginContribs(type: 'dev' | 'min', files: IFile[]) {
for (const file of files) {
if (!/editor\.main\.js$/.test(file.path)) {
continue;
}
let contents = file.contents.toString();
// Rename the AMD module 'vs/editor/editor.main' to 'vs/editor/edcore.main'
contents = contents.replace(/"vs\/editor\/editor\.main\"/, '"vs/editor/edcore.main"');
// This ensures that old nls-plugin configurations are still respected by the new localization solution.
const contentPrefixSource = readFile('src/nls-fix.js')
.contents.toString('utf-8')
.replace(/\r\n|\n/g, ' ');
// TODO: Instead of adding this source to the header to maintain the source map indices, it should rewrite the sourcemap!
const searchValue = 'https://github.com/microsoft/vscode/blob/main/LICENSE.txt';
contents = contents.replace(searchValue, searchValue + ' */ ' + contentPrefixSource + ' /*');
const pluginFiles = readFiles(`out/languages/bundled/amd-${type}/**/monaco.contribution.js`, {
base: `out/languages/bundled/amd-${type}`
});
const extraContent = pluginFiles.map((file) => {
return file.contents
.toString()
.replace(
/define\((['"][a-z\/\-]+\/fillers\/monaco-editor-core['"]),\[\],/,
"define($1,['vs/editor/editor.api'],"
);
});
const allPluginsModuleIds = pluginFiles.map((file) => {
return file.path.replace(/\.js$/, '');
});
extraContent.push(
`define("vs/editor/editor.main", ["vs/editor/edcore.main","${allPluginsModuleIds.join(
'","'
)}"], function(api) { return api; });`
);
let insertIndex = contents.lastIndexOf('//# sourceMappingURL=');
if (insertIndex === -1) {
insertIndex = contents.length;
}
contents =
contents.substring(0, insertIndex) +
'\n' +
extraContent.join('\n') +
'\n' +
contents.substring(insertIndex);
file.contents = Buffer.from(contents);
}
}
function ESM_release() {
const coreFiles = readFiles(`node_modules/monaco-editor-core/esm/**/*`, {
base: 'node_modules/monaco-editor-core/esm',
@ -181,6 +73,40 @@ function ESM_release() {
writeFiles(coreFiles, `out/monaco-editor/esm`);
ESM_releasePlugins();
build({
entryPoints: ['src/editor/editor.main.ts', 'src/editor/editor.worker.ts'],
bundle: true,
target: 'esnext',
format: 'esm',
drop: ['debugger'],
define: {
AMD: 'false'
},
banner: {
js: bundledFileHeader
},
external: ['./src/basic-languages/*', './edcore.main.js', './editor.worker.start'],
alias: {
'monaco-editor-core/esm/vs/editor/editor.worker.start': './editor.worker.start',
'monaco-editor-core': './edcore.main.js'
},
outbase: `src/`,
outdir: `out/monaco-editor/esm/vs/`,
plugins: [
{
name: 'example',
setup(build) {
build.onResolve({ filter: /\/language\/|\/basic-languages\// }, (args) => {
if (args.path.includes('monaco-editor-core')) {
return undefined;
}
return { external: true };
});
}
}
]
});
}
/**
@ -198,6 +124,7 @@ function ESM_releasePlugins() {
let contents = file.contents.toString();
// WARNING: this only returns the first occurence of each imported file!
const info = ts.preProcessFile(contents);
for (let i = info.importedFiles.length - 1; i >= 0; i--) {
let importText = info.importedFiles[i].fileName;
@ -290,32 +217,6 @@ function ESM_addPluginContribs(files: IFile[]) {
}
file.path = file.path.replace(/editor\.main/, 'edcore.main');
}
const mainFileDestPath = 'vs/editor/editor.main.js';
const mainFileImports = readFiles(`out/languages/bundled/esm/**/monaco.contribution.js`, {
base: `out/languages/bundled/esm`
}).map((file) => {
let relativePath = path
.relative(path.dirname(mainFileDestPath), file.path)
.replace(/\\/g, '/')
.replace(/\.js$/, '');
if (!/(^\.\/)|(^\.\.\/)/.test(relativePath)) {
relativePath = './' + relativePath;
}
return relativePath;
});
const mainFileContents =
mainFileImports.map((name) => `import '${name}';`).join('\n') +
`\n\nexport * from './edcore.main';`;
files.push({
path: mainFileDestPath,
contents: Buffer.from(mainFileContents)
});
}
/**
@ -329,6 +230,31 @@ function releaseDTS() {
let contents = monacodts.contents.toString();
const additionalDtsFiles: Record<string, string> = {
'out/languages/tsc/common/workers.d.ts': 'editor'
};
Object.entries(additionalDtsFiles).forEach(([filePath, namespace]) => {
try {
const dtsFile = readFile(filePath);
let dtsContent = dtsFile.contents.toString();
// Remove imports
dtsContent = dtsContent.replace(/import .*\n/gm, '');
// Wrap in namespace if specified
if (namespace) {
dtsContent = `declare namespace ${namespace} {\n${dtsContent
.split('\n')
.map((line) => (line ? ` ${line}` : line))
.join('\n')}\n}`;
}
contents += '\n' + dtsContent;
} catch (error) {
console.warn(`Could not read d.ts file: ${filePath}`);
}
});
const extraContent = readFiles('out/languages/bundled/*.d.ts', {
base: 'out/languages/bundled/'
}).map((file) => {

60
build/utils.ts
View file

@ -122,66 +122,6 @@ export function buildESM(options: { base: string; entryPoints: string[]; externa
});
}
function buildOneAMD(
type: 'dev' | 'min',
options: {
base: string;
entryPoint: string;
amdModuleId: string;
amdDependencies?: string[];
external?: string[];
}
) {
if (!options.amdDependencies) {
options.amdDependencies = [];
}
options.amdDependencies.unshift('require');
const opts: esbuild.BuildOptions = {
entryPoints: [options.entryPoint],
bundle: true,
target: 'esnext',
format: 'iife',
drop: ['debugger'],
define: {
AMD: 'true'
},
globalName: 'moduleExports',
banner: {
js: `${bundledFileHeader}define("${options.amdModuleId}", [${(options.amdDependencies || [])
.map((dep) => `"${dep}"`)
.join(',')}],(require)=>{`
},
footer: {
js: 'return moduleExports;\n});'
},
outbase: `src/${options.base}`,
outdir: `out/languages/bundled/amd-${type}/vs/${options.base}/`,
plugins: [
alias({
'vscode-nls': path.join(__dirname, '../build/fillers/vscode-nls.ts'),
'monaco-editor-core': path.join(__dirname, '../src/fillers/monaco-editor-core-amd.ts')
})
],
external: ['vs/editor/editor.api', ...(options.external || [])]
};
if (type === 'min') {
opts.minify = true;
}
build(opts);
}
export function buildAMD(options: {
base: string;
entryPoint: string;
amdModuleId: string;
amdDependencies?: string[];
external?: string[];
}) {
buildOneAMD('dev', options);
buildOneAMD('min', options);
}
function getGitVersion() {
const git = path.join(REPO_ROOT, '.git');
const headPath = path.join(git, 'HEAD');

28
docs/integrate-amd.md
View file

@ -1,28 +0,0 @@
## Integrating the AMD version of the Monaco Editor
Here is the most basic HTML page that embeds the editor using AMD.
More self-contained samples are available in the [samples folder](../samples/).
```html
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
</head>
<body>
<div id="container" style="width:800px;height:600px;border:1px solid grey"></div>
<script src="monaco-editor/min/vs/loader.js"></script>
<script>
require.config({ paths: { vs: 'monaco-editor/min/vs' } });
require(['vs/editor/editor.main'], function () {
var editor = monaco.editor.create(document.getElementById('container'), {
value: ['function x() {', '\tconsole.log("Hello world!");', '}'].join('\n'),
language: 'javascript'
});
});
</script>
</body>
</html>
```

621
package-lock.json generated
View file

File diff suppressed because it is too large Load diff

16
package.json
View file

@ -9,8 +9,6 @@
"license": "MIT",
"scripts": {
"import-typescript": "ts-node ./build/importTypescript",
"playwright-install": "node ./node_modules/playwright/install.js",
"playwright-install-deps": "playwright install-deps",
"postinstall": "ts-node ./build/postinstall",
"prettier-check": "prettier --check .",
"prettier": "prettier --write .",
@ -22,13 +20,14 @@
"package-for-smoketest-vite": "ts-node ./test/smoke/package-vite",
"smoketest": "node ./test/smoke/runner.js",
"smoketest-debug": "node ./test/smoke/runner.js --debug-tests",
"test": "mocha test/unit/all.js && ts-node ./build/check-samples",
"test": "ts-node ./build/check-samples",
"deps-all-remove": "ts-node ./build/npm/removeAll",
"deps-all-install": "ts-node ./build/npm/installAll",
"update-actions": "pin-github-action ./.github/workflows/website.yml",
"watch": "tsc -w -p ./src",
"build": "ts-node ./build/build-languages",
"build-monaco-editor": "npm run build && ts-node ./build/build-monaco-editor"
"build-languages": "ts-node ./build/build-languages",
"build-monaco-editor": "ts-node ./build/build-monaco-editor",
"build": "npm run build-languages && npm run build-monaco-editor"
},
"typings": "./esm/vs/editor/editor.api.d.ts",
"module": "./esm/vs/editor/editor.main.js",
@ -37,13 +36,14 @@
"url": "https://github.com/microsoft/monaco-editor"
},
"devDependencies": {
"@playwright/test": "^1.53.2",
"@types/mocha": "^9.1.0",
"@types/shelljs": "^0.8.11",
"@typescript/vfs": "^1.3.5",
"chai": "^4.3.6",
"clean-css": "^5.2.4",
"css-loader": "^6.7.1",
"esbuild": "^0.20.0",
"esbuild": "^0.25.9",
"esbuild-plugin-alias": "^0.2.1",
"file-loader": "^6.2.0",
"glob": "^7.2.0",
@ -55,7 +55,6 @@
"monaco-editor-core": "0.52.0-rc2",
"parcel": "^2.7.0",
"pin-github-action": "^1.8.0",
"playwright": "^1.32.2",
"prettier": "^2.5.1",
"pretty-quick": "^3.1.3",
"requirejs": "^2.3.7",
@ -77,5 +76,8 @@
"alias": {
"process": false,
"buffer": false
},
"dependencies": {
"@types/trusted-types": "^1.0.6"
}
}

56
scripts/ci/monaco-editor-core-prepare.ts → scripts/ci/build-monaco-editor-core-pkg.ts
View file

@ -1,13 +1,13 @@
import { mkdir, rm } from 'fs/promises';
import { join, resolve } from 'path';
import { rm } from 'fs/promises';
import { join } from 'path';
import { PackageJson, group, gitShallowClone, run, writeJsonFile, getNightlyVersion } from '../lib';
import { getNightlyEnv } from './env';
const selfPath = __dirname;
const rootPath = join(selfPath, '..', '..');
const dependenciesPath = join(rootPath, 'dependencies');
const vscodePath = resolve(dependenciesPath, 'vscode');
const monacoEditorPackageJsonPath = resolve(rootPath, 'package.json');
const vscodePath = join(dependenciesPath, 'vscode');
const monacoEditorPackageJsonPath = join(rootPath, 'package.json');
async function prepareMonacoEditorCoreReleaseStableOrNightly() {
const monacoEditorPackageJson = require(monacoEditorPackageJsonPath) as {
@ -37,8 +37,6 @@ async function prepareMonacoEditorCoreReleaseStableOrNightly() {
}
async function prepareMonacoEditorCoreRelease(version: string, vscodeRef: string) {
await mkdir(vscodePath, { recursive: true });
await rm(dependenciesPath, { force: true, recursive: true });
let vscodeCommitId: string;
@ -62,10 +60,7 @@ async function prepareMonacoEditorCoreRelease(version: string, vscodeRef: string
});
await group('Set Version', async () => {
const monacoEditorCorePackageJsonSourcePath = resolve(
vscodePath,
'./build/monaco/package.json'
);
const monacoEditorCorePackageJsonSourcePath = join(vscodePath, './build/monaco/package.json');
const packageJson = require(monacoEditorCorePackageJsonSourcePath) as PackageJson;
packageJson.version = version;
// This ensures we can always figure out which commit monaco-editor-core was built from
@ -74,8 +69,47 @@ async function prepareMonacoEditorCoreRelease(version: string, vscodeRef: string
});
await group('Building & Testing', async () => {
await run(resolve(selfPath, './monaco-editor-core.sh'), { cwd: vscodePath });
// Install dependencies
await buildAndTest();
});
}
async function buildAndTest() {
await run('npm install', { cwd: vscodePath });
await run('npm run playwright-install', { cwd: vscodePath });
// Run checks and compilation
await run('npm run gulp hygiene', { cwd: vscodePath });
await run('npm run valid-layers-check', { cwd: vscodePath });
await run('npm run compile', { cwd: join(vscodePath, 'build') });
await run('npm run eslint', { cwd: vscodePath });
await run('npm run monaco-compile-check', { cwd: vscodePath });
await run('npm run --max_old_space_size=4095 compile', { cwd: vscodePath });
// Build editor distribution
await run('npm run gulp editor-distro', { cwd: vscodePath });
return; // To save CI time.
// Run browser tests
await run('npm run test-browser --browser chromium', { cwd: vscodePath });
// TypeScript typings test
await run('mkdir typings-test', { cwd: vscodePath });
const typingsTestDir = join(vscodePath, 'typings-test');
await run('npm init -yp', { cwd: typingsTestDir });
await run('../node_modules/.bin/tsc --init', { cwd: typingsTestDir });
await run('echo "import \'../out-monaco-editor-core\';" > a.ts', { cwd: typingsTestDir });
await run('../node_modules/.bin/tsc --noEmit', { cwd: typingsTestDir });
// Monaco tests
const testMonacoDir = join(vscodePath, 'test/monaco');
await run('npm run esm-check', { cwd: testMonacoDir });
await run('npm run bundle-webpack', { cwd: testMonacoDir });
await run('npm run compile', { cwd: testMonacoDir });
await run('npm test', { cwd: testMonacoDir });
}
//buildAndTest();
//prepareMonacoEditorCoreRelease('0.99.0', 'main');
prepareMonacoEditorCoreReleaseStableOrNightly();

11
scripts/ci/monaco-editor-prepare.ts → scripts/ci/build-monaco-editor-pkg.ts
View file

@ -68,7 +68,16 @@ async function prepareMonacoEditorRelease(monacoEditorCoreVersion: string) {
});
await group('Building & Testing', async () => {
await run(resolve(selfPath, './monaco-editor.sh'), { cwd: rootPath });
// TODO@hediet: await run('npm run prettier-check', { cwd: rootPath });
await run('npm run build', { cwd: rootPath });
await run('npm test', { cwd: rootPath });
await run('npm run compile', { cwd: resolve(rootPath, 'webpack-plugin') });
await run('npm run package-for-smoketest-webpack', { cwd: rootPath });
await run('npm run package-for-smoketest-esbuild', { cwd: rootPath });
await run('npm run package-for-smoketest-vite', { cwd: rootPath });
await run('npm run smoketest', { cwd: rootPath });
// npm package is now ready to be published in ./out/monaco-editor
});
}

34
scripts/ci/monaco-editor-core.sh
View file

@ -1,34 +0,0 @@
#!/bin/bash
set -e
# cwd must be the vscode repository.
yarn --frozen-lockfile --network-timeout 180000
yarn playwright-install
yarn gulp hygiene
yarn valid-layers-check
yarn --cwd build compile
yarn eslint
yarn monaco-compile-check
yarn --max_old_space_size=4095 compile
yarn test-browser --browser chromium
yarn gulp editor-distro
mkdir typings-test
cd typings-test
yarn init -yp
../node_modules/.bin/tsc --init
echo "import '../out-monaco-editor-core';" > a.ts
../node_modules/.bin/tsc --noEmit
cd ..
cd test/monaco
yarn run esm-check
yarn run bundle-webpack
yarn run compile
yarn test
cd ../..
# npm package is now in dependencies/vscode/out-monaco-editor-core, ready to be published

29
scripts/ci/monaco-editor.sh
View file

@ -1,29 +0,0 @@
#!/bin/bash
set -e
# Install OS Dependencies for Playwright
sudo npm run playwright-install-deps
# Check prettier
npm run prettier-check
# Build
npm run build-monaco-editor
# Run unit tests
npm test
# Compile webpack plugin
npm run compile --prefix webpack-plugin
# Package using webpack plugin
npm run package-for-smoketest-webpack
# Package using esbuild
npm run package-for-smoketest-esbuild
# Package using vite
npm run package-for-smoketest-vite
# Package using parcel
# npm run package-for-smoketest-parcel --prefix test/smoke/parcel
# Disabled for now, as the parcel bundler cannot deal with VS Code process variable
# Run smoke test
npm run smoketest
# npm package is now ready to be published in ./out/monaco-editor

16
src/common/initialize.ts Normal file
View file

@ -0,0 +1,16 @@
import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker.start';
let initialized = false;
export function isWorkerInitialized(): boolean {
return initialized;
}
export function initialize(callback: (ctx: any, createData: any) => any): void {
initialized = true;
self.onmessage = (m) => {
worker.start((ctx) => {
return callback(ctx, m.data);
});
};
}

131
src/common/workers.ts Normal file
View file

@ -0,0 +1,131 @@
import { editor } from '../fillers/monaco-editor-core';
function createTrustedTypesPolicy<Options extends TrustedTypePolicyOptions>(
policyName: string,
policyOptions?: Options
):
| undefined
| Pick<
TrustedTypePolicy<Options>,
'name' | Extract<keyof Options, keyof TrustedTypePolicyOptions>
> {
interface IMonacoEnvironment {
createTrustedTypesPolicy<Options extends TrustedTypePolicyOptions>(
policyName: string,
policyOptions?: Options
):
| undefined
| Pick<
TrustedTypePolicy<Options>,
'name' | Extract<keyof Options, keyof TrustedTypePolicyOptions>
>;
}
const monacoEnvironment: IMonacoEnvironment | undefined = (globalThis as any).MonacoEnvironment;
if (monacoEnvironment?.createTrustedTypesPolicy) {
try {
return monacoEnvironment.createTrustedTypesPolicy(policyName, policyOptions);
} catch (err) {
console.error(err);
return undefined;
}
}
try {
return (globalThis as any).trustedTypes?.createPolicy(policyName, policyOptions);
} catch (err) {
console.error(err);
return undefined;
}
}
let ttPolicy: ReturnType<typeof createTrustedTypesPolicy>;
if (
typeof self === 'object' &&
self.constructor &&
self.constructor.name === 'DedicatedWorkerGlobalScope' &&
(globalThis as any).workerttPolicy !== undefined
) {
ttPolicy = (globalThis as any).workerttPolicy;
} else {
ttPolicy = createTrustedTypesPolicy('defaultWorkerFactory', {
createScriptURL: (value) => value
});
}
function getWorker(descriptor: { label: string; moduleId: string }): Worker | Promise<Worker> {
const label = descriptor.label;
// Option for hosts to overwrite the worker script (used in the standalone editor)
interface IMonacoEnvironment {
getWorker?(moduleId: string, label: string): Worker | Promise<Worker>;
getWorkerUrl?(moduleId: string, label: string): string;
}
const monacoEnvironment: IMonacoEnvironment | undefined = (globalThis as any).MonacoEnvironment;
if (monacoEnvironment) {
if (typeof monacoEnvironment.getWorker === 'function') {
return monacoEnvironment.getWorker('workerMain.js', label);
}
if (typeof monacoEnvironment.getWorkerUrl === 'function') {
const workerUrl = monacoEnvironment.getWorkerUrl('workerMain.js', label);
return new Worker(
ttPolicy ? (ttPolicy.createScriptURL(workerUrl) as unknown as string) : workerUrl,
{ name: label, type: 'module' }
);
}
}
// const esmWorkerLocation = descriptor.esmModuleLocation;
// if (esmWorkerLocation) {
// const workerUrl = getWorkerBootstrapUrl(label, esmWorkerLocation.toString(true));
// const worker = new Worker(ttPolicy ? ttPolicy.createScriptURL(workerUrl) as unknown as string : workerUrl, { name: label, type: 'module' });
// return whenESMWorkerReady(worker);
// }
throw new Error(
`You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker`
);
}
export function createWebWorker<T extends object>(
opts: IWebWorkerOptions
): editor.MonacoWebWorker<T> {
const worker = Promise.resolve(
getWorker({
label: opts.label ?? 'monaco-editor-worker',
moduleId: opts.moduleId
})
).then((w) => {
w.postMessage('ignore');
w.postMessage(opts.createData);
return w;
});
return editor.createWebWorker<T>({
worker,
host: opts.host,
keepIdleModels: opts.keepIdleModels
});
}
export interface IWebWorkerOptions {
/**
* The AMD moduleId to load.
* It should export a function `create` that should return the exported proxy.
*/
moduleId: string;
/**
* The data to send over when calling create on the module.
*/
createData?: any;
/**
* A label to be used to identify the web worker for debugging purposes.
*/
label?: string;
/**
* An object that can be used by the web worker to make calls back to the main thread.
*/
host?: any;
/**
* Keep idle models.
* Defaults to false, which means that idle models will stop syncing after a while.
*/
keepIdleModels?: boolean;
}

16
src/editor/editor.main.ts Normal file
View file

@ -0,0 +1,16 @@
import { createWebWorker } from '../common/workers';
import '../basic-languages/monaco.contribution';
import '../language/css/monaco.contribution';
import '../language/html/monaco.contribution';
import '../language/json/monaco.contribution';
import '../language/typescript/monaco.contribution';
import * as monaco from 'monaco-editor-core';
export * from 'monaco-editor-core';
const existingCreateWebWorker = monaco.editor.createWebWorker;
monaco.editor.createWebWorker = function (options: any) {
if (options.worker === undefined) {
return createWebWorker(options);
}
return existingCreateWebWorker(options);
} as any;

20
src/editor/editor.worker.ts Normal file
View file

@ -0,0 +1,20 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { initialize, isWorkerInitialized } from '../common/initialize';
import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker.start';
// This is to preserve previous behavior.
self.onmessage = () => {
if (!isWorkerInitialized()) {
worker.start(() => {
return {};
});
} else {
// this is handled because the worker is already initialized
}
};
export { initialize };

11
src/fillers/monaco-editor-core-amd.ts
View file

@ -1,11 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Resolves with the global monaco API
/// <reference path="./editor.api.d.ts" />
import * as api from 'vs/editor/editor.api';
export = api;

4
src/language/css/css.worker.ts
View file

@ -3,12 +3,12 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
import { initialize } from '../../common/initialize';
import { CSSWorker } from './cssWorker';
self.onmessage = () => {
// ignore the first message
worker.initialize((ctx, createData) => {
initialize((ctx, createData) => {
return new CSSWorker(ctx, createData);
});
};

3
src/language/css/workerManager.ts
View file

@ -6,6 +6,7 @@
import { LanguageServiceDefaults } from './monaco.contribution';
import type { CSSWorker } from './cssWorker';
import { editor, IDisposable, Uri } from '../../fillers/monaco-editor-core';
import { createWebWorker } from '../../common/workers';
const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min
@ -55,7 +56,7 @@ export class WorkerManager {
this._lastUsedTime = Date.now();
if (!this._client) {
this._worker = editor.createWebWorker<CSSWorker>({
this._worker = createWebWorker<CSSWorker>({
// module that exports the create() method and returns a `CSSWorker` instance
moduleId: 'vs/language/css/cssWorker',

2
src/language/html/html.worker.ts
View file

@ -3,7 +3,7 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
import * as worker from '../../common/initialize';
import { HTMLWorker } from './htmlWorker';
self.onmessage = () => {

3
src/language/html/workerManager.ts
View file

@ -6,6 +6,7 @@
import { LanguageServiceDefaults } from './monaco.contribution';
import type { HTMLWorker } from './htmlWorker';
import { Uri, IDisposable, editor } from '../../fillers/monaco-editor-core';
import { createWebWorker } from '../../common/workers';
const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min
@ -55,7 +56,7 @@ export class WorkerManager {
this._lastUsedTime = Date.now();
if (!this._client) {
this._worker = editor.createWebWorker<HTMLWorker>({
this._worker = createWebWorker<HTMLWorker>({
// module that exports the create() method and returns a `HTMLWorker` instance
moduleId: 'vs/language/html/htmlWorker',

2
src/language/json/json.worker.ts
View file

@ -3,7 +3,7 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
import * as worker from '../../common/initialize';
import { JSONWorker } from './jsonWorker';
self.onmessage = () => {

3
src/language/json/workerManager.ts
View file

@ -6,6 +6,7 @@
import { LanguageServiceDefaults } from './monaco.contribution';
import type { JSONWorker } from './jsonWorker';
import { IDisposable, Uri, editor } from '../../fillers/monaco-editor-core';
import { createWebWorker } from '../../common/workers';
const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min
@ -55,7 +56,7 @@ export class WorkerManager {
this._lastUsedTime = Date.now();
if (!this._client) {
this._worker = editor.createWebWorker<JSONWorker>({
this._worker = createWebWorker<JSONWorker>({
// module that exports the create() method and returns a `JSONWorker` instance
moduleId: 'vs/language/json/jsonWorker',

6
src/language/typescript/lib/editor.worker.d.ts vendored
View file

@ -3,6 +3,8 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
declare module 'monaco-editor-core/esm/vs/editor/editor.worker' {
export function initialize(callback: (ctx: any, createData: any) => any): void;
declare module 'monaco-editor-core/esm/vs/editor/editor.worker.start' {
import type { worker } from 'monaco-editor-core';
export function start<THost extends object, TClient extends object>(createClient: (ctx: worker.IWorkerContext<THost>) => TClient): TClient;
}

2
src/language/typescript/ts.worker.ts
View file

@ -3,7 +3,7 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { initialize } from 'monaco-editor-core/esm/vs/editor/editor.worker';
import { initialize } from '../../common/initialize';
import * as ts from './lib/typescriptServices';
import { ICreateData, TypeScriptWorker, create } from './tsWorker';
import { worker } from '../../fillers/monaco-editor-core';

3
src/language/typescript/workerManager.ts
View file

@ -6,6 +6,7 @@
import { LanguageServiceDefaults } from './monaco.contribution';
import type { TypeScriptWorker } from './tsWorker';
import { editor, Uri, IDisposable } from '../../fillers/monaco-editor-core';
import { createWebWorker } from '../../common/workers';
export class WorkerManager {
private _configChangeListener: IDisposable;
@ -58,7 +59,7 @@ export class WorkerManager {
private _getClient(): Promise<TypeScriptWorker> {
if (!this._client) {
this._client = (async () => {
this._worker = editor.createWebWorker<TypeScriptWorker>({
this._worker = createWebWorker<TypeScriptWorker>({
// module that exports the create() method and returns a `TypeScriptWorker` instance
moduleId: 'vs/language/typescript/tsWorker',

39
src/nls-fix.js
View file

@ -1,39 +0,0 @@
/* This fix ensures that old nls-plugin configurations are still respected by the new localization solution. */
/* We should try to avoid this file and find a different solution. */
/* Warning: This file still has to work when replacing "\n" with " "! */
/**
* @type {typeof define}
*/
const globalDefine = globalThis.define;
globalDefine('vs/nls.messages-loader', [], function (...args) {
return {
load: (name, req, load, config) => {
const requestedLanguage = config['vs/nls']?.availableLanguages?.['*'];
if (!requestedLanguage || requestedLanguage === 'en') {
load({});
} else {
req([`vs/nls.messages.${requestedLanguage}`], () => {
load({});
});
}
}
};
});
globalDefine(
'vs/nls.messages',
['require', 'exports', 'vs/nls.messages-loader!'],
function (require, exports) {
Object.assign(exports, {
getNLSMessages: () => globalThis._VSCODE_NLS_MESSAGES,
getNLSLanguage: () => globalThis._VSCODE_NLS_LANGUAGE
});
}
);
define = function (...args) {
if (args.length > 0 && args[0] === 'vs/nls.messages') {
return;
}
return globalDefine(...args);
};
define.amd = true;

8
src/tsconfig.json
View file

@ -2,9 +2,13 @@
"compilerOptions": {
"declaration": true,
"lib": ["dom", "es5", "es2015.collection", "es2015.promise", "es2015.iterable"],
"module": "amd",
"module": "esnext",
"moduleResolution": "node",
"outDir": "../out/languages/amd-tsc",
"outDir": "../out/languages/tsc",
"paths": {
"@/*": ["./*"]
},
"emitDeclarationOnly": true,
"strict": true,
"target": "es5",
"sourceMap": true,

6
test/manual/index.js
View file

@ -1,7 +1,5 @@
/// <reference path="../../out/monaco-editor/monaco.d.ts" />
define(['require', './samples'], function (require, SAMPLES) {
const domutils = require('vs/base/browser/dom');
let model = monaco.editor.createModel('', 'plaintext');
monaco.languages.typescript.typescriptDefaults.setInlayHintsOptions({
@ -167,7 +165,7 @@ define(['require', './samples'], function (require, SAMPLES) {
editor.setScrollTop(r);
if (speed >= 0) {
domutils.scheduleAtNextAnimationFrame(scroll);
requestAnimationFrame(scroll);
} else {
isRunning = false;
}
@ -179,7 +177,7 @@ define(['require', './samples'], function (require, SAMPLES) {
isRunning = true;
r = editor.getScrollTop();
lastTime = new Date().getTime();
domutils.runAtThisOrScheduleAtNextAnimationFrame(scroll);
requestAnimationFrame(scroll);
}
};
})()

0
test/manual/index.html → test/manual/index2.html
View file

2
test/manual/typescript/custom-worker.js
View file

@ -2,7 +2,7 @@
// which can do work on a bg thread.
// This version of the vfs edits the global scope (in the case of a webworker, this is 'self')
importScripts('https://unpkg.com/@typescript/vfs@1.3.0/dist/vfs.globals.js');
import 'https://unpkg.com/@typescript/vfs@1.3.0/dist/vfs.globals.js';
/** @type { import("@typescript/vfs") } */
const tsvfs = globalThis.tsvfs;

6
test/smoke/runner.js
View file

@ -42,13 +42,13 @@ async function runTests() {
// uncomment to shortcircuit and run a specific combo
// await runTest('webpack', 'chromium'); return;
/** @type {PackagerKind[]} */
const testTypes = ['amd', 'webpack', 'esbuild', 'vite'];
const testTypes = ['webpack', 'esbuild', 'vite'];
// TODO: add parcel! (this currently fails because parcel replaces process with {})
for (const type of testTypes) {
await runTest(type, 'chromium');
await runTest(type, 'firefox');
await runTest(type, 'webkit');
// await runTest(type, 'firefox');
// await runTest(type, 'webkit');
}
}

70
test/unit/all.js
View file

@ -1,70 +0,0 @@
const requirejs = require('requirejs');
const jsdom = require('jsdom');
const glob = require('glob');
const path = require('path');
requirejs.config({
baseUrl: '',
paths: {
'vs/fillers/monaco-editor-core': 'out/languages/amd-tsc/fillers/monaco-editor-core-amd',
'vs/basic-languages': 'out/languages/amd-tsc/basic-languages',
vs: './node_modules/monaco-editor-core/dev/vs'
},
nodeRequire: require
});
const tmp = new jsdom.JSDOM('<!DOCTYPE html><html><body></body></html>');
global.AMD = true;
global.document = tmp.window.document;
global.navigator = tmp.window.navigator;
global.self = global;
global.document.queryCommandSupported = function () {
return false;
};
global.UIEvent = tmp.window.UIEvent;
global.window = {
location: {},
navigator: tmp.window.navigator,
document: {
body: tmp.window.document.body,
addEventListener: (...args) => tmp.window.document.addEventListener(...args)
},
matchMedia: function () {
return {
matches: false,
addEventListener: function () {}
};
},
setInterval: function () {},
setTimeout: function () {}
};
requirejs(
['test/unit/setup'],
function () {
glob(
'out/languages/amd-tsc/basic-languages/*/*.test.js',
{ cwd: path.join(__dirname, '../../') },
function (err, files) {
if (err) {
console.log(err);
return;
}
requirejs(
files.map((f) => f.replace(/^out\/languages\/amd-tsc/, 'vs').replace(/\.js$/, '')),
function () {
run(); // We can launch the tests!
},
function (err) {
console.log(err);
}
);
}
);
},
function (err) {
console.log(err);
process.exit(1);
}
);

34
test/unit/setup.js
View file

@ -1,34 +0,0 @@
define('vs/css', [], {
load: function (name, req, load) {
load({});
}
});
define('vs/nls', [], {
create: function () {
return {
localize: function () {
return 'NO_LOCALIZATION_FOR_YOU';
},
localize2: function () {
return 'NO_LOCALIZATION_FOR_YOU';
},
getConfiguredDefaultLocale: function () {
return undefined;
}
};
},
localize: function () {
return 'NO_LOCALIZATION_FOR_YOU';
},
localize2: function (key, message) {
return { value: 'NO_LOCALIZATION_FOR_YOU', original: message };
},
load: function (name, req, load) {
load({});
}
});
define(['vs/editor/editor.main'], function (api) {
global.monaco = api;
});