Add extract-editor-src with treeshaking task

.gitignore

@@ -6,6 +6,7 @@ node_modules/
 out/
 out-build/
 out-editor/
+out-editor-src/
 out-editor-esm/
 out-editor-min/
 out-monaco-editor-core/

build/gulpfile.editor.js

@@ -75,6 +75,33 @@ function editorLoaderConfig() {
 
 const languages = i18n.defaultLanguages.concat([]);  // i18n.defaultLanguages.concat(process.env.VSCODE_QUALITY !== 'stable' ? i18n.extraLanguages : []);
 
+gulp.task('clean-editor-src', util.rimraf('out-editor-src'));
+gulp.task('extract-editor-src', ['clean-editor-src'], function() {
+	standalone.extractEditor({
+		sourcesRoot: path.join(root, 'src'),
+		entryPoints: [
+			'vs/editor/editor.main',
+			'vs/editor/editor.worker',
+			// 'user',
+			// 'user2',
+		],
+		libs: [
+			`lib.d.ts`,
+			`lib.es2015.collection.d.ts`
+		],
+		redirects: {
+			'vs/base/browser/ui/octiconLabel/octiconLabel': 'vs/base/browser/ui/octiconLabel/octiconLabel.mock',
+		},
+		compilerOptions: {
+			module: 2, // ModuleKind.AMD
+			// moduleResolution: 'classic'
+		},
+		shakeLevel: 1, // 1-InnerFile, 2-ClassMembers
+		importIgnorePattern: /^vs\/css!/,
+		destRoot: path.join(root, 'out-editor-src')
+	});
+});
+
 gulp.task('clean-optimized-editor', util.rimraf('out-editor'));
 gulp.task('optimize-editor', ['clean-optimized-editor', 'compile-client-build'], common.optimizeTask({
 	entryPoints: editorEntryPoints,
@@ -229,7 +256,7 @@ gulp.task('editor-distro', ['clean-editor-distro', 'compile-editor-esm', 'minify
 });
 
 gulp.task('analyze-editor-distro', function () {
-	// @ts-ignore 
+	// @ts-ignore
 	var bundleInfo = require('../out-editor/bundleInfo.json');
 	var graph = bundleInfo.graph;
 	var bundles = bundleInfo.bundles;

build/lib/standalone.js

@@ -7,9 +7,87 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var ts = require("typescript");
 var fs = require("fs");
 var path = require("path");
+var tss = require("./treeshaking");
 var REPO_ROOT = path.join(__dirname, '../../');
 var SRC_DIR = path.join(REPO_ROOT, 'src');
 var OUT_EDITOR = path.join(REPO_ROOT, 'out-editor');
+var dirCache = {};
+function writeFile(filePath, contents) {
+    function ensureDirs(dirPath) {
+        if (dirCache[dirPath]) {
+            return;
+        }
+        dirCache[dirPath] = true;
+        ensureDirs(path.dirname(dirPath));
+        if (fs.existsSync(dirPath)) {
+            return;
+        }
+        fs.mkdirSync(dirPath);
+    }
+    ensureDirs(path.dirname(filePath));
+    fs.writeFileSync(filePath, contents);
+}
+function extractEditor(options) {
+    var result = tss.shake(options);
+    for (var fileName in result) {
+        if (result.hasOwnProperty(fileName)) {
+            writeFile(path.join(options.destRoot, fileName), result[fileName]);
+        }
+    }
+    var copied = {};
+    var copyFile = function (fileName) {
+        if (copied[fileName]) {
+            return;
+        }
+        copied[fileName] = true;
+        var srcPath = path.join(options.sourcesRoot, fileName);
+        var dstPath = path.join(options.destRoot, fileName);
+        fs.writeFileSync(dstPath, fs.readFileSync(srcPath));
+    };
+    var writeOutputFile = function (fileName, contents) {
+        writeFile(path.join(options.destRoot, fileName), contents);
+    };
+    for (var fileName in result) {
+        if (result.hasOwnProperty(fileName)) {
+            var fileContents = result[fileName];
+            var info = ts.preProcessFile(fileContents);
+            for (var i = info.importedFiles.length - 1; i >= 0; i--) {
+                var importedFileName = info.importedFiles[i].fileName;
+                var importedFilePath = void 0;
+                if (/^vs\/css!/.test(importedFileName)) {
+                    importedFilePath = importedFileName.substr('vs/css!'.length) + '.css';
+                }
+                else {
+                    importedFilePath = importedFileName;
+                }
+                if (/(^\.\/)|(^\.\.\/)/.test(importedFilePath)) {
+                    importedFilePath = path.join(path.dirname(fileName), importedFilePath);
+                }
+                if (/\.css$/.test(importedFilePath)) {
+                    transportCSS(importedFilePath, copyFile, writeOutputFile);
+                }
+                else {
+                    if (fs.existsSync(path.join(options.sourcesRoot, importedFilePath + '.js'))) {
+                        copyFile(importedFilePath + '.js');
+                    }
+                }
+            }
+        }
+    }
+    [
+        'tsconfig.json',
+        'vs/css.build.js',
+        'vs/css.d.ts',
+        'vs/css.js',
+        'vs/loader.js',
+        'vs/monaco.d.ts',
+        'vs/nls.build.js',
+        'vs/nls.d.ts',
+        'vs/nls.js',
+        'vs/nls.mock.ts',
+    ].forEach(copyFile);
+}
+exports.extractEditor = extractEditor;
 function createESMSourcesAndResources(options) {
     var OUT_FOLDER = path.join(REPO_ROOT, options.outFolder);
     var OUT_RESOURCES_FOLDER = path.join(REPO_ROOT, options.outResourcesFolder);
@@ -94,7 +172,7 @@ function createESMSourcesAndResources(options) {
     options.entryPoints.forEach(function (entryPoint) { return enqueue(entryPoint); });
     while (queue.length > 0) {
         var module_1 = queue.shift();
-        if (transportCSS(options, module_1, enqueue, write)) {
+        if (transportCSS(module_1, enqueue, write)) {
             continue;
         }
         if (transportResource(options, module_1, enqueue, write)) {
@@ -171,7 +249,7 @@ function createESMSourcesAndResources(options) {
     fs.writeFileSync(path.join(OUT_FOLDER, 'vs/monaco.d.ts'), monacodts);
 }
 exports.createESMSourcesAndResources = createESMSourcesAndResources;
-function transportCSS(options, module, enqueue, write) {
+function transportCSS(module, enqueue, write) {
     if (!/\.css/.test(module)) {
         return false;
     }
@@ -179,10 +257,10 @@ function transportCSS(options, module, enqueue, write) {
     var fileContents = fs.readFileSync(filename).toString();
     var inlineResources = 'base64'; // see https://github.com/Microsoft/monaco-editor/issues/148
     var inlineResourcesLimit = 300000; //3000; // see https://github.com/Microsoft/monaco-editor/issues/336
-    var newContents = _rewriteOrInlineUrls(filename, fileContents, inlineResources === 'base64', inlineResourcesLimit);
+    var newContents = _rewriteOrInlineUrls(fileContents, inlineResources === 'base64', inlineResourcesLimit);
     write(module, newContents);
     return true;
-    function _rewriteOrInlineUrls(originalFileFSPath, contents, forceBase64, inlineByteLimit) {
+    function _rewriteOrInlineUrls(contents, forceBase64, inlineByteLimit) {
         return _replaceURL(contents, function (url) {
             var imagePath = path.join(path.dirname(module), url);
             var fileContents = fs.readFileSync(path.join(SRC_DIR, imagePath));

build/lib/standalone.ts

@@ -6,11 +6,94 @@
 import * as ts from 'typescript';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as tss from './treeshaking';
 
 const REPO_ROOT = path.join(__dirname, '../../');
 const SRC_DIR = path.join(REPO_ROOT, 'src');
 const OUT_EDITOR = path.join(REPO_ROOT, 'out-editor');
 
+let dirCache: { [dir: string]: boolean; } = {};
+
+function writeFile(filePath: string, contents: string): void {
+	function ensureDirs(dirPath: string): void {
+		if (dirCache[dirPath]) {
+			return;
+		}
+		dirCache[dirPath] = true;
+
+		ensureDirs(path.dirname(dirPath));
+		if (fs.existsSync(dirPath)) {
+			return;
+		}
+		fs.mkdirSync(dirPath);
+	}
+	ensureDirs(path.dirname(filePath));
+	fs.writeFileSync(filePath, contents);
+}
+
+export function extractEditor(options: tss.ITreeShakingOptions & { destRoot: string }): void {
+	let result = tss.shake(options);
+	for (let fileName in result) {
+		if (result.hasOwnProperty(fileName)) {
+			writeFile(path.join(options.destRoot, fileName), result[fileName]);
+		}
+	}
+	let copied: { [fileName:string]: boolean; } = {};
+	const copyFile = (fileName: string) => {
+		if (copied[fileName]) {
+			return;
+		}
+		copied[fileName] = true;
+		const srcPath = path.join(options.sourcesRoot, fileName);
+		const dstPath = path.join(options.destRoot, fileName);
+		fs.writeFileSync(dstPath, fs.readFileSync(srcPath));
+	};
+	const writeOutputFile = (fileName: string, contents: string) => {
+		writeFile(path.join(options.destRoot, fileName), contents);
+	};
+	for (let fileName in result) {
+		if (result.hasOwnProperty(fileName)) {
+			const fileContents = result[fileName];
+			const info = ts.preProcessFile(fileContents);
+
+			for (let i = info.importedFiles.length - 1; i >= 0; i--) {
+				const importedFileName = info.importedFiles[i].fileName;
+
+				let importedFilePath: string;
+				if (/^vs\/css!/.test(importedFileName)) {
+					importedFilePath = importedFileName.substr('vs/css!'.length) + '.css';
+				} else {
+					importedFilePath = importedFileName;
+				}
+				if (/(^\.\/)|(^\.\.\/)/.test(importedFilePath)) {
+					importedFilePath = path.join(path.dirname(fileName), importedFilePath);
+				}
+
+				if (/\.css$/.test(importedFilePath)) {
+					transportCSS(importedFilePath, copyFile, writeOutputFile);
+				} else {
+					if (fs.existsSync(path.join(options.sourcesRoot, importedFilePath + '.js'))) {
+						copyFile(importedFilePath + '.js');
+					}
+				}
+			}
+		}
+	}
+
+	[
+		'tsconfig.json',
+		'vs/css.build.js',
+		'vs/css.d.ts',
+		'vs/css.js',
+		'vs/loader.js',
+		'vs/monaco.d.ts',
+		'vs/nls.build.js',
+		'vs/nls.d.ts',
+		'vs/nls.js',
+		'vs/nls.mock.ts',
+	].forEach(copyFile);
+}
+
 export interface IOptions {
 	entryPoints: string[];
 	outFolder: string;
@@ -111,7 +194,7 @@ export function createESMSourcesAndResources(options: IOptions): void {
 
 	while (queue.length > 0) {
 		const module = queue.shift();
-		if (transportCSS(options, module, enqueue, write)) {
+		if (transportCSS(module, enqueue, write)) {
 			continue;
 		}
 		if (transportResource(options, module, enqueue, write)) {
@@ -198,7 +281,7 @@ export function createESMSourcesAndResources(options: IOptions): void {
 
 }
 
-function transportCSS(options: IOptions, module: string, enqueue: (module: string) => void, write: (path: string, contents: string | Buffer) => void): boolean {
+function transportCSS(module: string, enqueue: (module: string) => void, write: (path: string, contents: string | Buffer) => void): boolean {
 
 	if (!/\.css/.test(module)) {
 		return false;
@@ -209,11 +292,11 @@ function transportCSS(options: IOptions, module: string, enqueue: (module: strin
 	const inlineResources = 'base64'; // see https://github.com/Microsoft/monaco-editor/issues/148
 	const inlineResourcesLimit = 300000;//3000; // see https://github.com/Microsoft/monaco-editor/issues/336
 
-	const newContents = _rewriteOrInlineUrls(filename, fileContents, inlineResources === 'base64', inlineResourcesLimit);
+	const newContents = _rewriteOrInlineUrls(fileContents, inlineResources === 'base64', inlineResourcesLimit);
 	write(module, newContents);
 	return true;
 
-	function _rewriteOrInlineUrls(originalFileFSPath: string, contents: string, forceBase64: boolean, inlineByteLimit: number): string {
+	function _rewriteOrInlineUrls(contents: string, forceBase64: boolean, inlineByteLimit: number): string {
 		return _replaceURL(contents, (url) => {
 			let imagePath = path.join(path.dirname(module), url);
 			let fileContents = fs.readFileSync(path.join(SRC_DIR, imagePath));