Ship ESM; Adopt latest deps

.npmignore

@@ -1,8 +1,10 @@
 /.vscode/
-/lib/
 /out/
+/scripts/
 /src/
 /test/
-/release/dev/
-/gulpfile.js
+/.gitignore
 /.npmignore
+/package-lock.json
+/webpack.dev.config.js
+/webpack.min.config.js

package.json

@@ -3,9 +3,9 @@
   "version": "1.3.3",
   "description": "CSS, LESS and SCSS plugin for the Monaco Editor",
   "scripts": {
-    "compile": "gulp compile",
-    "watch": "gulp watch",
-    "prepublish": "gulp release",
+    "compile": "node ./scripts/rmdir ./out && tsc -p ./src",
+    "watch": "tsc -p ./src --watch",
+    "prepublish": "node ./scripts/rmdir ./release && npm run compile && node ./scripts/release.js && webpack --config webpack.dev.config.js && webpack --config webpack.min.config.js && node ./scripts/copy ./src/monaco.d.ts ./release/monaco.d.ts",
     "install-service-next": "npm install vscode-css-languageservice@next -f -D && npm install vscode-languageserver-types@next -f -D",
     "install-service-local": "npm install ../vscode-css-languageservice -f -D && npm install ../vscode-languageserver-node/types -f -D"
   },
@@ -19,18 +19,12 @@
     "url": "https://github.com/Microsoft/monaco-css/issues"
   },
   "devDependencies": {
-    "event-stream": "^3.3.2",
-    "gulp": "^3.9.1",
-    "gulp-requirejs": "0.1.3",
-    "gulp-tsb": "^2.0.0",
-    "gulp-uglify": "1.5.3",
-    "merge-stream": "1.0.0",
-    "monaco-editor-core": "0.10.0",
+    "monaco-editor-core": "0.11.1",
     "monaco-languages": "0.9.0",
-    "object-assign": "4.1.0",
-    "rimraf": "2.5.2",
-    "typescript": "2.3.4",
-    "vscode-css-languageservice": "2.1.1",
-    "vscode-languageserver-types": "3.3.0"
+    "typescript": "2.7.2",
+    "vscode-css-languageservice": "3.0.8",
+    "vscode-languageserver-types": "3.6.1",
+    "webpack": "^4.1.1",
+    "webpack-cli": "^2.0.10"
   }
 }

scripts/copy.js

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const fs = require('fs');
+const path = require('path');
+
+const source = path.join(process.cwd(), process.argv[2]);
+const destination = path.join(process.cwd(), process.argv[3]);
+
+// ensure target dir
+(function () {
+	let dirs = [];
+	let dirname = path.dirname(destination);
+	while (dirname !== process.cwd()) {
+		dirs.push(dirname);
+		dirname = path.dirname(dirname);
+	}
+
+	dirs.reverse();
+
+	dirs.forEach((dir) => {
+		try { fs.mkdirSync(dir); } catch (err) { }
+	})
+})();
+
+fs.writeFileSync(destination, fs.readFileSync(source));
+
+console.log(`Copied ${process.argv[2]} to ${process.argv[3]}`);

scripts/release.js

@@ -0,0 +1,176 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+exports.__esModule = true;
+var fs = require("fs");
+var ts = require("typescript");
+var path = require("path");
+var REPO_ROOT = path.join(__dirname, '../');
+process({
+    repoRoot: REPO_ROOT,
+    esmSource: 'out',
+    esmDestination: 'release/esm',
+    entryPoints: [
+        'monaco.contribution.js',
+        'cssMode.js',
+        'css.worker.js',
+    ],
+    resolveAlias: {
+        'vscode-nls': path.join(REPO_ROOT, "out/fillers/vscode-nls.js")
+    },
+    resolveSkip: [
+        'monaco-editor-core'
+    ],
+    destinationFolderSimplification: {
+        'node_modules': '_deps',
+        'vscode-languageserver-types/lib/esm': 'vscode-languageserver-types',
+        'vscode-uri/lib/esm': 'vscode-uri',
+        'vscode-css-languageservice/lib/esm': 'vscode-css-languageservice'
+    }
+});
+function process(options) {
+    options.repoRoot = path.normalize(options.repoRoot).replace(/(\/|\\)$/, '');
+    var ESM_SRC = path.join(options.repoRoot, options.esmSource);
+    var ESM_DEST = path.join(options.repoRoot, options.esmDestination);
+    var in_queue = Object.create(null);
+    var queue = [];
+    var enqueue = function (filePath) {
+        if (in_queue[filePath]) {
+            return;
+        }
+        in_queue[filePath] = true;
+        queue.push(filePath);
+    };
+    var seenDir = {};
+    var createDirectoryRecursive = function (dir) {
+        if (seenDir[dir]) {
+            return;
+        }
+        var lastSlash = dir.lastIndexOf('/');
+        if (lastSlash === -1) {
+            lastSlash = dir.lastIndexOf('\\');
+        }
+        if (lastSlash !== -1) {
+            createDirectoryRecursive(dir.substring(0, lastSlash));
+        }
+        seenDir[dir] = true;
+        try {
+            fs.mkdirSync(dir);
+        }
+        catch (err) { }
+    };
+    seenDir[options.repoRoot] = true;
+    var applyDestinationFolderSimplifications = function (filePath) {
+        filePath = filePath.replace(/\\/g, '/');
+        for (var key in options.destinationFolderSimplification) {
+            var test = key.replace(/\\/g, '/');
+            while (filePath.indexOf(test) >= 0) {
+                filePath = filePath.replace(test, options.destinationFolderSimplification[test]);
+            }
+        }
+        return filePath;
+    };
+    var shouldSkipImport = function (importText) {
+        for (var i = 0; i < options.resolveSkip.length; i++) {
+            var skip = options.resolveSkip[i];
+            if (importText.indexOf(skip) === 0) {
+                return true;
+            }
+        }
+        return false;
+    };
+    var computeDestinationFilePath = function (filePath) {
+        if (filePath.indexOf(ESM_SRC) === 0) {
+            // This file is from our sources
+            return path.join(ESM_DEST, path.relative(ESM_SRC, filePath));
+        }
+        else {
+            // This file is from node_modules
+            return path.normalize(applyDestinationFolderSimplifications(path.join(ESM_DEST, path.relative(options.repoRoot, filePath))));
+        }
+    };
+    var write = function (filePath, fileContents) {
+        var finalFilePath = computeDestinationFilePath(filePath);
+        createDirectoryRecursive(path.dirname(finalFilePath));
+        fs.writeFileSync(finalFilePath, fileContents);
+    };
+    options.entryPoints.forEach(function (filePath) {
+        enqueue(path.join(ESM_SRC, filePath));
+    });
+    while (queue.length > 0) {
+        var filePath = queue.shift();
+        var fileContents = fs.readFileSync(filePath).toString();
+        var info = ts.preProcessFile(fileContents);
+        for (var i = info.importedFiles.length - 1; i >= 0; i--) {
+            var importText = info.importedFiles[i].fileName;
+            if (shouldSkipImport(importText)) {
+                continue;
+            }
+            var pos = info.importedFiles[i].pos;
+            var end = info.importedFiles[i].end;
+            if (/(^\.\/)|(^\.\.\/)/.test(importText)) {
+                // Relative import
+                var importedFilename = path.join(path.dirname(filePath), importText) + '.js';
+                enqueue(importedFilename);
+            }
+            else {
+                var importedFilename = void 0;
+                if (options.resolveAlias[importText]) {
+                    importedFilename = options.resolveAlias[importText];
+                }
+                else {
+                    importedFilename = findNodeModuleImport(options.repoRoot, importText, filePath);
+                }
+                var myDestinationPath = computeDestinationFilePath(filePath);
+                var importDestinationPath = computeDestinationFilePath(importedFilename);
+                var relativePath = path.relative(path.dirname(myDestinationPath), importDestinationPath);
+                if (!/(^\.\/)|(^\.\.\/)/.test(relativePath)) {
+                    relativePath = './' + relativePath;
+                }
+                relativePath = relativePath.replace(/\\/g, '/');
+                relativePath = relativePath.replace(/\.js$/, '');
+                fileContents = (fileContents.substring(0, pos + 1)
+                    + relativePath
+                    + fileContents.substring(end + 1));
+                enqueue(importedFilename);
+            }
+        }
+        write(filePath, fileContents);
+    }
+}
+function findNodeModuleImport(repoRoot, module, sourceFilePath) {
+    var modulePath = findNodeModule(repoRoot, module, sourceFilePath);
+    var modulePackagePath = path.join(modulePath, 'package.json');
+    if (!fs.existsSync(modulePackagePath)) {
+        throw new Error("Missing " + modulePackagePath + " in node module " + modulePath);
+    }
+    var modulePackage = JSON.parse(fs.readFileSync(modulePackagePath).toString());
+    if (typeof modulePackage.module !== 'string') {
+        throw new Error("Missing property 'module' package.json at " + modulePackagePath);
+    }
+    var result = path.join(modulePath, modulePackage.module);
+    if (!fs.existsSync(result)) {
+        throw new Error("Missing file " + result);
+    }
+    return result;
+    function findNodeModule(repoRoot, module, sourceFilePath) {
+        var modulePaths = generatePaths(repoRoot, module, sourceFilePath);
+        for (var i = 0; i < modulePaths.length; i++) {
+            if (fs.existsSync(modulePaths[i])) {
+                return modulePaths[i];
+            }
+        }
+        throw new Error("Cannot find module " + module + " requested by " + sourceFilePath);
+    }
+    function generatePaths(repoRoot, module, sourceFilePath) {
+        var sourceDir = path.dirname(sourceFilePath);
+        var result = [];
+        while (sourceDir.length >= repoRoot.length) {
+            result.push(path.join(sourceDir, 'node_modules', module));
+            sourceDir = path.dirname(sourceDir);
+        }
+        return result;
+    }
+}

scripts/rmdir.js

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const fs = require('fs');
+const path = require('path');
+
+const target = path.join(process.cwd(), process.argv[2]);
+if (fs.existsSync(target)) {
+	rmDir(target);
+}
+console.log(`Deleted ${process.argv[2]}`);
+
+function rmDir(dirPath) {
+	let entries = fs.readdirSync(dirPath);
+	if (entries.length > 0) {
+		for (var i = 0; i < entries.length; i++) {
+			var filePath = path.join(dirPath, entries[i]);
+			if (fs.statSync(filePath).isFile()) {
+				fs.unlinkSync(filePath);
+			} else {
+				rmDir(filePath);
+			}
+		}
+	}
+	fs.rmdirSync(dirPath);
+}

scripts/webpack.js

@@ -0,0 +1,28 @@
+const path = require('path');
+const webpack = require('webpack');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+exports.createWebpackConfig = function (isDev) {
+	let targetFolder = isDev ? './release/dev' : './release/min';
+	let mode = isDev ? 'development' : 'production';
+
+	return {
+		entry: {
+			"monaco.contribution": './release/esm/monaco.contribution',
+			"cssMode": './release/esm/cssMode',
+			"cssWorker": './release/esm/cssWorker'
+		},
+		output: {
+			filename: '[name].js',
+			path: path.resolve(REPO_ROOT, targetFolder),
+			libraryTarget: "amd"
+		},
+		mode: mode,
+		plugins: [
+			new webpack.optimize.LimitChunkCountPlugin({
+				maxChunks: 1,
+			})
+		],
+	};
+};

src/css.worker.ts

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
+import { CSSWorker } from './cssWorker';
+
+self.onmessage = () => {
+	// ignore the first message
+	worker.initialize((ctx, createData) => {
+		return new CSSWorker(ctx, createData)
+	});
+};

src/languageFeatures.ts

@@ -227,14 +227,39 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 	}
 }
 
-function toMarkedStringArray(contents: ls.MarkedString | ls.MarkedString[]): monaco.MarkedString[] {
+
+function isMarkupContent(thing: any): thing is ls.MarkupContent {
+	return thing && typeof thing === 'object' && typeof (<ls.MarkupContent>thing).kind === 'string';
+}
+
+function toMarkdownString(entry: ls.MarkupContent | ls.MarkedString): monaco.IMarkdownString {
+	if (typeof entry === 'string') {
+		return {
+			value: entry
+		};
+	}
+	if (isMarkupContent(entry)) {
+		if (entry.kind === 'plaintext') {
+			return {
+				value: entry.value.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&')
+			};
+		}
+		return {
+			value: entry.value
+		};
+	}
+
+	return { value: '```' + entry.value + '\n' + entry.value + '\n```\n' };
+}
+
+function toMarkedStringArray(contents: ls.MarkupContent | ls.MarkedString | ls.MarkedString[]): monaco.IMarkdownString[] {
 	if (!contents) {
 		return void 0;
 	}
 	if (Array.isArray(contents)) {
-		return (<ls.MarkedString[]>contents);
+		return contents.map(toMarkdownString);
 	}
-	return [<ls.MarkedString>contents];
+	return [toMarkdownString(contents)];
 }
 
 
@@ -353,11 +378,16 @@ function toWorkspaceEdit(edit: ls.WorkspaceEdit): monaco.languages.WorkspaceEdit
 	if (!edit || !edit.changes) {
 		return void 0;
 	}
-	let resourceEdits: monaco.languages.IResourceEdit[] = [];
+	let resourceEdits: monaco.languages.ResourceTextEdit[] = [];
 	for (let uri in edit.changes) {
+		let edits: monaco.languages.TextEdit[] = [];
 		for (let e of edit.changes[uri]) {
-			resourceEdits.push({ resource: Uri.parse(uri), range: toRange(e.range), newText: e.newText });
+			edits.push({
+				range: toRange(e.range),
+				text: e.newText
+			});
 		}
+		resourceEdits.push({ resource: Uri.parse(uri), edits: edits });
 	}
 	return {
 		edits: resourceEdits

src/monaco.contribution.ts

@@ -85,7 +85,7 @@ monaco.languages.css = createAPI();
 // --- Registration to monaco editor ---
 
 function withMode(callback: (module: typeof mode) => void): void {
-	require<typeof mode>(['vs/language/css/cssMode'], callback);
+	require<typeof mode>(['./cssMode'], callback);
 }
 
 monaco.languages.onLanguage('less', () => {

src/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "module": "umd",
+    "module": "es6",
     "moduleResolution": "node",
     "outDir": "../out",
     "target": "es5"

webpack.dev.config.js

@@ -0,0 +1 @@
+module.exports = require('./scripts/webpack').createWebpackConfig(true);

webpack.min.config.js

@@ -0,0 +1 @@
+module.exports = require('./scripts/webpack').createWebpackConfig(false);