@harmoniclabs/monaco-editor 0.52.0

package/samples/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "monaco-editor-samples",
+	"version": "0.0.1",
+	"private": true,
+	"description": "Samples for using the Monaco Editor",
+	"main": "index.js",
+	"scripts": {
+		"simpleserver": "yaserver --root ./ --port 8888"
+	},
+	"author": "Microsoft Corporation",
+	"license": "MIT",
+	"devDependencies": {
+		"css-loader": "^5.2.7",
+		"electron": "^22.3.25",
+		"file-loader": "^6.2.0",
+		"glob": "^7.2.0",
+		"html-webpack-plugin": "^5.5.0",
+		"monaco-editor-webpack-plugin": "^7.0.1",
+		"monaco-editor": "^0.32.1",
+		"style-loader": "^3.3.1",
+		"terser-webpack-plugin": "^5.3.1",
+		"ts-loader": "^9.2.6",
+		"typescript": "^5.4.5",
+		"webpack-cli": "^4.9.2",
+		"webpack-dev-server": "^4.7.4",
+		"webpack": "^5.76.0",
+		"yaserver": "^0.4.0"
+	},
+	"overrides": {
+		"@electron/get": "2.0.0"
+	}
+}

package/scripts/ci/env.ts

@@ -0,0 +1,15 @@
+interface Env {
+	VSCODE_REF: string;
+	PRERELEASE_VERSION: string;
+}
+
+export function getNightlyEnv(): Env {
+	const env: Env = process.env as any;
+	if (!env.PRERELEASE_VERSION) {
+		throw new Error(`Missing PRERELEASE_VERSION in process.env`);
+	}
+	if (!env.VSCODE_REF) {
+		throw new Error(`Missing VSCODE_REF in process.env`);
+	}
+	return env;
+}

package/scripts/ci/monaco-editor-core-prepare.ts

@@ -0,0 +1,81 @@
+import { mkdir, rm } from 'fs/promises';
+import { join, resolve } 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');
+
+async function prepareMonacoEditorCoreReleaseStableOrNightly() {
+	const monacoEditorPackageJson = require(monacoEditorPackageJsonPath) as {
+		version: string;
+		vscodeRef: string;
+	};
+	let version: string;
+	let ref: string;
+
+	const arg = process.argv[2];
+	if (arg === 'stable') {
+		version = monacoEditorPackageJson.version;
+		ref = monacoEditorPackageJson.vscodeRef;
+	} else if (arg === 'nightly') {
+		version = getNightlyVersion(
+			monacoEditorPackageJson.version,
+			getNightlyEnv().PRERELEASE_VERSION
+		);
+		ref = getNightlyEnv().VSCODE_REF;
+	} else {
+		throw new Error('Invalid argument');
+	}
+
+	await prepareMonacoEditorCoreRelease(version, ref);
+
+	// npm package is now in dependencies/vscode/out-monaco-editor-core, ready to be published
+}
+
+async function prepareMonacoEditorCoreRelease(version: string, vscodeRef: string) {
+	await mkdir(vscodePath, { recursive: true });
+
+	await rm(dependenciesPath, { force: true, recursive: true });
+
+	let vscodeCommitId: string;
+
+	await group('Checkout vscode', async () => {
+		const result = await gitShallowClone(
+			vscodePath,
+			'https://github.com/microsoft/vscode.git',
+			vscodeRef
+		);
+		vscodeCommitId = result.commitId;
+	});
+
+	await group('Checkout vscode-loc', async () => {
+		await gitShallowClone(
+			// Must be a sibling to the vscode repository
+			'dependencies/vscode-loc',
+			'https://github.com/microsoft/vscode-loc.git',
+			'main'
+		);
+	});
+
+	await group('Set Version', async () => {
+		const monacoEditorCorePackageJsonSourcePath = resolve(
+			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
+		packageJson.vscodeCommitId = vscodeCommitId;
+		await writeJsonFile(monacoEditorCorePackageJsonSourcePath, packageJson);
+	});
+
+	await group('Building & Testing', async () => {
+		await run(resolve(selfPath, './monaco-editor-core.sh'), { cwd: vscodePath });
+	});
+}
+
+prepareMonacoEditorCoreReleaseStableOrNightly();

package/scripts/ci/monaco-editor-core.sh

@@ -0,0 +1,34 @@
+#!/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

package/scripts/ci/monaco-editor-prepare.ts

@@ -0,0 +1,75 @@
+import { readFile } from 'fs/promises';
+import { join, resolve } from 'path';
+import { PackageJson, getNightlyVersion, group, run, writeJsonFile, gitCommitId } from '../lib';
+import { getNightlyEnv } from './env';
+
+const selfPath = __dirname;
+const rootPath = join(selfPath, '..', '..');
+const monacoEditorPackageJsonPath = resolve(rootPath, 'package.json');
+const monacoEditorCorePackageJsonPath = resolve(
+	rootPath,
+	'node_modules',
+	'monaco-editor-core',
+	'package.json'
+);
+
+async function prepareMonacoEditorReleaseStableOrNightly() {
+	const monacoEditorPackageJson = JSON.parse(
+		await readFile(monacoEditorPackageJsonPath, { encoding: 'utf-8' })
+	) as PackageJson;
+
+	let version: string;
+
+	const arg = process.argv[2];
+	if (arg === 'stable') {
+		version = monacoEditorPackageJson.version;
+	} else if (arg === 'nightly') {
+		version = getNightlyVersion(
+			monacoEditorPackageJson.version,
+			getNightlyEnv().PRERELEASE_VERSION
+		);
+	} else {
+		throw new Error('Invalid argument');
+	}
+
+	await prepareMonacoEditorRelease(version);
+
+	// npm package is now in ./out/monaco-editor, ready to be published
+}
+
+async function prepareMonacoEditorRelease(monacoEditorCoreVersion: string) {
+	await group('npm ci', async () => {
+		await run('npm ci', { cwd: resolve(rootPath, 'webpack-plugin') });
+	});
+
+	await group('Set Version & Update monaco-editor-core Version', async () => {
+		const packageJson = JSON.parse(
+			await readFile(monacoEditorPackageJsonPath, { encoding: 'utf-8' })
+		) as PackageJson;
+		packageJson.version = monacoEditorCoreVersion;
+		packageJson.devDependencies['monaco-editor-core'] = monacoEditorCoreVersion;
+		await writeJsonFile(monacoEditorPackageJsonPath, packageJson);
+	});
+
+	await group('npm install to pick up monaco-editor-core', async () => {
+		await run('npm install', { cwd: rootPath });
+	});
+
+	await group('Setting vscode commitId from monaco-editor-core', async () => {
+		const monacoEditorCorePackageJson = JSON.parse(
+			await readFile(monacoEditorCorePackageJsonPath, { encoding: 'utf-8' })
+		) as PackageJson;
+		const packageJson = JSON.parse(
+			await readFile(monacoEditorPackageJsonPath, { encoding: 'utf-8' })
+		) as PackageJson;
+		packageJson.vscodeCommitId = monacoEditorCorePackageJson.vscodeCommitId;
+		packageJson.monacoCommitId = await gitCommitId(rootPath);
+		await writeJsonFile(monacoEditorPackageJsonPath, packageJson);
+	});
+
+	await group('Building & Testing', async () => {
+		await run(resolve(selfPath, './monaco-editor.sh'), { cwd: rootPath });
+	});
+}
+
+prepareMonacoEditorReleaseStableOrNightly();

package/scripts/ci/monaco-editor.sh

@@ -0,0 +1,29 @@
+#!/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

package/scripts/lib/index.ts

@@ -0,0 +1,95 @@
+import { spawn } from 'child_process';
+import { mkdir, writeFile } from 'fs/promises';
+
+export interface RunOptions {
+	cwd: string;
+}
+
+export async function run(command: string, options: RunOptions) {
+	console.log(`Running ${command} in ${options.cwd}`);
+	const process = spawn(command, { shell: true, cwd: options.cwd, stdio: 'inherit' });
+	return new Promise<void>((resolve, reject) => {
+		process.on('exit', (code) => {
+			if (code !== 0) {
+				reject(new Error(`Command ${command} exited with code ${code}`));
+			} else {
+				resolve();
+			}
+		});
+	});
+}
+
+export async function runGetOutput(command: string, options: RunOptions): Promise<string> {
+	console.log(`Running ${command} in ${options.cwd}`);
+	return new Promise<string>((resolve, reject) => {
+		const process = spawn(command, { shell: true, cwd: options.cwd, stdio: 'pipe' });
+		let output = '';
+		process.stdout.on('data', (data) => {
+			output += data;
+		});
+		process.on('exit', (code) => {
+			if (code !== 0) {
+				reject(new Error(`Command ${command} exited with code ${code}`));
+			} else {
+				resolve(output);
+			}
+		});
+	});
+}
+
+export async function gitCommitId(repositoryPath: string): Promise<string> {
+	const commitId = (await runGetOutput('git rev-parse HEAD', { cwd: repositoryPath })).trim();
+	return commitId;
+}
+
+export async function gitShallowClone(
+	targetPath: string,
+	repositoryUrl: string,
+	ref: string
+): Promise<{ commitId: string }> {
+	await mkdir(targetPath, { recursive: true });
+	const options: RunOptions = { cwd: targetPath };
+	await run('git init', options);
+	await run(`git remote add origin ${repositoryUrl}`, options);
+	await run(`git fetch --depth 1 origin ${ref}`, options);
+	await run(`git checkout ${ref}`, options);
+	const commitId = await gitCommitId(targetPath);
+	return { commitId };
+}
+
+export async function group(name: string, body: () => Promise<void>): Promise<void> {
+	console.log(`##[group]${name}`);
+	try {
+		await body();
+	} catch (e) {
+		console.error(e);
+		throw e;
+	} finally {
+		console.log('##[endgroup]');
+	}
+}
+
+export async function writeJsonFile(filePath: string, jsonData: unknown): Promise<void> {
+	await writeFile(filePath, JSON.stringify(jsonData, null, '\t') + '\n');
+}
+
+export function getNightlyVersion(version: string, prerelease: string): string {
+	const pieces = version.split('.');
+	const minor = parseInt(pieces[1], 10);
+	const date = new Date();
+	const yyyy = date.getUTCFullYear();
+	const mm = String(date.getUTCMonth() + 1).padStart(2, '0');
+	const dd = String(date.getUTCDate()).padStart(2, '0');
+
+	prerelease = prerelease.replace('${today}', `${yyyy}${mm}${dd}`);
+
+	return `0.${minor + 1}.0-${prerelease}`;
+}
+
+export interface PackageJson {
+	version: string;
+	vscodeRef?: string;
+	vscodeCommitId?: string;
+	monacoCommitId?: string;
+	devDependencies: Record<string, string>;
+}

package/src/basic-languages/_.contribution.ts

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { languages, editor } from '../fillers/monaco-editor-core';
+
+interface ILang extends languages.ILanguageExtensionPoint {
+	loader: () => Promise<ILangImpl>;
+}
+
+interface ILangImpl {
+	conf: languages.LanguageConfiguration;
+	language: languages.IMonarchLanguage;
+}
+
+const languageDefinitions: { [languageId: string]: ILang } = {};
+const lazyLanguageLoaders: { [languageId: string]: LazyLanguageLoader } = {};
+
+class LazyLanguageLoader {
+	public static getOrCreate(languageId: string): LazyLanguageLoader {
+		if (!lazyLanguageLoaders[languageId]) {
+			lazyLanguageLoaders[languageId] = new LazyLanguageLoader(languageId);
+		}
+		return lazyLanguageLoaders[languageId];
+	}
+
+	private readonly _languageId: string;
+	private _loadingTriggered: boolean;
+	private _lazyLoadPromise: Promise<ILangImpl>;
+	private _lazyLoadPromiseResolve!: (value: ILangImpl) => void;
+	private _lazyLoadPromiseReject!: (err: any) => void;
+
+	constructor(languageId: string) {
+		this._languageId = languageId;
+		this._loadingTriggered = false;
+		this._lazyLoadPromise = new Promise((resolve, reject) => {
+			this._lazyLoadPromiseResolve = resolve;
+			this._lazyLoadPromiseReject = reject;
+		});
+	}
+
+	public load(): Promise<ILangImpl> {
+		if (!this._loadingTriggered) {
+			this._loadingTriggered = true;
+			languageDefinitions[this._languageId].loader().then(
+				(mod) => this._lazyLoadPromiseResolve(mod),
+				(err) => this._lazyLoadPromiseReject(err)
+			);
+		}
+		return this._lazyLoadPromise;
+	}
+}
+
+export async function loadLanguage(languageId: string): Promise<void> {
+	await LazyLanguageLoader.getOrCreate(languageId).load();
+
+	// trigger tokenizer creation by instantiating a model
+	const model = editor.createModel('', languageId);
+	model.dispose();
+}
+
+export function registerLanguage(def: ILang): void {
+	const languageId = def.id;
+
+	languageDefinitions[languageId] = def;
+	languages.register(def);
+
+	const lazyLanguageLoader = LazyLanguageLoader.getOrCreate(languageId);
+	languages.registerTokensProviderFactory(languageId, {
+		create: async (): Promise<languages.IMonarchLanguage> => {
+			const mod = await lazyLanguageLoader.load();
+			return mod.language;
+		}
+	});
+	languages.onLanguageEncountered(languageId, async () => {
+		const mod = await lazyLanguageLoader.load();
+		languages.setLanguageConfiguration(languageId, mod.conf);
+	});
+}

package/src/basic-languages/abap/abap.contribution.ts

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { registerLanguage } from '../_.contribution';
+
+declare var AMD: any;
+declare var require: any;
+
+registerLanguage({
+	id: 'abap',
+	extensions: ['.abap'],
+	aliases: ['abap', 'ABAP'],
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/abap/abap'], resolve, reject);
+			});
+		} else {
+			return import('./abap');
+		}
+	}
+});