add smaller promise-polyfill for IE11 - #53526

build/gulpfile.hygiene.js

@@ -110,6 +110,7 @@ const copyrightFilter = [
 	'!**/*.opts',
 	'!**/*.disabled',
 	'!**/*.code-workspace',
+	'!**/promise-polyfill/polyfill.js',
 	'!build/**/*.init',
 	'!resources/linux/snap/snapcraft.yaml',
 	'!resources/linux/snap/electron-launch',

src/vs/base/common/worker/simpleWorker.ts

@@ -6,15 +6,6 @@
 import { transformErrorForSerialization } from 'vs/base/common/errors';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { isWeb } from 'vs/base/common/platform';
-import { PolyfillPromise } from 'vs/base/common/winjs.polyfill.promise';
-
-var global: any = self;
-
-// When missing, polyfill the native promise
-// with our winjs-based polyfill
-if (typeof global.Promise === 'undefined') {
-	global.Promise = PolyfillPromise;
-}
 
 const INITIALIZE = '$initialize';
 

src/vs/editor/common/standalone/promise-polyfill/cgmanifest.json

@@ -0,0 +1,17 @@
+{
+	"registrations": [
+		{
+			"component": {
+				"type": "git",
+				"git": {
+					"name": "promise-polyfill",
+					"repositoryUrl": "https://github.com/taylorhakes/promise-polyfill",
+					"commitHash": "efe662be6ea569c439ec92a4f8662c0a7faf0b96"
+				}
+			},
+			"license": "MIT",
+			"version": "8.0.0"
+		}
+	],
+	"version": 1
+}

src/vs/editor/common/standalone/promise-polyfill/polyfill.js

@@ -0,0 +1,291 @@
+/*!
+Copyright (c) 2014 Taylor Hakes
+Copyright (c) 2014 Forbes Lindesay
+ */
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory() :
+		typeof define === 'function' && define.amd ? define(factory) :
+			(factory());
+}(this, (function () {
+	'use strict';
+
+	/**
+	 * @this {Promise}
+	 */
+	function finallyConstructor(callback) {
+		var constructor = this.constructor;
+		return this.then(
+			function (value) {
+				return constructor.resolve(callback()).then(function () {
+					return value;
+				});
+			},
+			function (reason) {
+				return constructor.resolve(callback()).then(function () {
+					return constructor.reject(reason);
+				});
+			}
+		);
+	}
+
+	// Store setTimeout reference so promise-polyfill will be unaffected by
+	// other code modifying setTimeout (like sinon.useFakeTimers())
+	var setTimeoutFunc = setTimeout;
+
+	function noop() { }
+
+	// Polyfill for Function.prototype.bind
+	function bind(fn, thisArg) {
+		return function () {
+			fn.apply(thisArg, arguments);
+		};
+	}
+
+	/**
+	 * @constructor
+	 * @param {Function} fn
+	 */
+	function Promise(fn) {
+		if (!(this instanceof Promise))
+			throw new TypeError('Promises must be constructed via new');
+		if (typeof fn !== 'function') throw new TypeError('not a function');
+		/** @type {!number} */
+		this._state = 0;
+		/** @type {!boolean} */
+		this._handled = false;
+		/** @type {Promise|undefined} */
+		this._value = undefined;
+		/** @type {!Array<!Function>} */
+		this._deferreds = [];
+
+		doResolve(fn, this);
+	}
+
+	function handle(self, deferred) {
+		while (self._state === 3) {
+			self = self._value;
+		}
+		if (self._state === 0) {
+			self._deferreds.push(deferred);
+			return;
+		}
+		self._handled = true;
+		Promise._immediateFn(function () {
+			var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
+			if (cb === null) {
+				(self._state === 1 ? resolve : reject)(deferred.promise, self._value);
+				return;
+			}
+			var ret;
+			try {
+				ret = cb(self._value);
+			} catch (e) {
+				reject(deferred.promise, e);
+				return;
+			}
+			resolve(deferred.promise, ret);
+		});
+	}
+
+	function resolve(self, newValue) {
+		try {
+			// Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+			if (newValue === self)
+				throw new TypeError('A promise cannot be resolved with itself.');
+			if (
+				newValue &&
+				(typeof newValue === 'object' || typeof newValue === 'function')
+			) {
+				var then = newValue.then;
+				if (newValue instanceof Promise) {
+					self._state = 3;
+					self._value = newValue;
+					finale(self);
+					return;
+				} else if (typeof then === 'function') {
+					doResolve(bind(then, newValue), self);
+					return;
+				}
+			}
+			self._state = 1;
+			self._value = newValue;
+			finale(self);
+		} catch (e) {
+			reject(self, e);
+		}
+	}
+
+	function reject(self, newValue) {
+		self._state = 2;
+		self._value = newValue;
+		finale(self);
+	}
+
+	function finale(self) {
+		if (self._state === 2 && self._deferreds.length === 0) {
+			Promise._immediateFn(function () {
+				if (!self._handled) {
+					Promise._unhandledRejectionFn(self._value);
+				}
+			});
+		}
+
+		for (var i = 0, len = self._deferreds.length; i < len; i++) {
+			handle(self, self._deferreds[i]);
+		}
+		self._deferreds = null;
+	}
+
+	/**
+	 * @constructor
+	 */
+	function Handler(onFulfilled, onRejected, promise) {
+		this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+		this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+		this.promise = promise;
+	}
+
+	/**
+	 * Take a potentially misbehaving resolver function and make sure
+	 * onFulfilled and onRejected are only called once.
+	 *
+	 * Makes no guarantees about asynchrony.
+	 */
+	function doResolve(fn, self) {
+		var done = false;
+		try {
+			fn(
+				function (value) {
+					if (done) return;
+					done = true;
+					resolve(self, value);
+				},
+				function (reason) {
+					if (done) return;
+					done = true;
+					reject(self, reason);
+				}
+			);
+		} catch (ex) {
+			if (done) return;
+			done = true;
+			reject(self, ex);
+		}
+	}
+
+	Promise.prototype['catch'] = function (onRejected) {
+		return this.then(null, onRejected);
+	};
+
+	Promise.prototype.then = function (onFulfilled, onRejected) {
+		// @ts-ignore
+		var prom = new this.constructor(noop);
+
+		handle(this, new Handler(onFulfilled, onRejected, prom));
+		return prom;
+	};
+
+	Promise.prototype['finally'] = finallyConstructor;
+
+	Promise.all = function (arr) {
+		return new Promise(function (resolve, reject) {
+			if (!arr || typeof arr.length === 'undefined')
+				throw new TypeError('Promise.all accepts an array');
+			var args = Array.prototype.slice.call(arr);
+			if (args.length === 0) return resolve([]);
+			var remaining = args.length;
+
+			function res(i, val) {
+				try {
+					if (val && (typeof val === 'object' || typeof val === 'function')) {
+						var then = val.then;
+						if (typeof then === 'function') {
+							then.call(
+								val,
+								function (val) {
+									res(i, val);
+								},
+								reject
+							);
+							return;
+						}
+					}
+					args[i] = val;
+					if (--remaining === 0) {
+						resolve(args);
+					}
+				} catch (ex) {
+					reject(ex);
+				}
+			}
+
+			for (var i = 0; i < args.length; i++) {
+				res(i, args[i]);
+			}
+		});
+	};
+
+	Promise.resolve = function (value) {
+		if (value && typeof value === 'object' && value.constructor === Promise) {
+			return value;
+		}
+
+		return new Promise(function (resolve) {
+			resolve(value);
+		});
+	};
+
+	Promise.reject = function (value) {
+		return new Promise(function (resolve, reject) {
+			reject(value);
+		});
+	};
+
+	Promise.race = function (values) {
+		return new Promise(function (resolve, reject) {
+			for (var i = 0, len = values.length; i < len; i++) {
+				values[i].then(resolve, reject);
+			}
+		});
+	};
+
+	// Use polyfill for setImmediate for performance gains
+	Promise._immediateFn =
+		(typeof setImmediate === 'function' &&
+			function (fn) {
+				setImmediate(fn);
+			}) ||
+		function (fn) {
+			setTimeoutFunc(fn, 0);
+		};
+
+	Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
+		if (typeof console !== 'undefined' && console) {
+			console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
+		}
+	};
+
+	/** @suppress {undefinedVars} */
+	var globalNS = (function () {
+		// the only reliable means to get the global object is
+		// `Function('return this')()`
+		// However, this causes CSP violations in Chrome apps.
+		if (typeof self !== 'undefined') {
+			return self;
+		}
+		if (typeof window !== 'undefined') {
+			return window;
+		}
+		if (typeof global !== 'undefined') {
+			return global;
+		}
+		throw new Error('unable to locate global object');
+	})();
+
+	if (!('Promise' in globalNS)) {
+		globalNS['Promise'] = Promise;
+	} else if (!globalNS.Promise.prototype['finally']) {
+		globalNS.Promise.prototype['finally'] = finallyConstructor;
+	}
+
+})));

src/vs/editor/common/standalone/promise-polyfill/polyfill.license.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Taylor Hakes
+Copyright (c) 2014 Forbes Lindesay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

src/vs/editor/common/standalone/standaloneBase.ts

@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import 'vs/editor/common/standalone/promise-polyfill/polyfill';
 import { CancellationTokenSource } from 'vs/base/common/cancellation';
 import { Emitter } from 'vs/base/common/event';
 import { KeyChord, KeyMod as ConstKeyMod } from 'vs/base/common/keyCodes';

src/vs/editor/editor.api.ts

@@ -3,7 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { PolyfillPromise } from 'vs/base/common/winjs.polyfill.promise';
 import { EDITOR_DEFAULTS, WrappingIndent } from 'vs/editor/common/config/editorOptions';
 import { createMonacoBaseAPI } from 'vs/editor/common/standalone/standaloneBase';
 import { createMonacoEditorAPI } from 'vs/editor/standalone/browser/standaloneEditor';
@@ -11,12 +10,6 @@ import { createMonacoLanguagesAPI } from 'vs/editor/standalone/browser/standalon
 
 var global: any = self;
 
-// When missing, polyfill the native promise
-// with our winjs-based polyfill
-if (typeof global.Promise === 'undefined') {
-	global.Promise = PolyfillPromise;
-}
-
 // Set defaults for standalone editor
 (<any>EDITOR_DEFAULTS).wrappingIndent = WrappingIndent.None;
 (<any>EDITOR_DEFAULTS.viewInfo).glyphMargin = false;