Remove all double work for type fetching

Author: CompuIves

packages/app/src/app/vscode/metadata.js

@@ -1,7 +1,7 @@
 const METADATA = {
   CORE: {
     paths: {
-      src: process.env.VSCODE ? '/vscode/out/vs' : '/public/vscode8/vs',
+      src: '/public/vscode8/vs',
       'npm/dev': 'node_modules/monaco-editor-core/dev/vs',
       'npm/min': 'node_modules/monaco-editor-core/min/vs',
       built: '/vscode/out-monaco-editor-core/min/vs',

standalone-packages/monaco-editor/test/samples-all.generated.js

@@ -81,6 +81,8 @@ define(["require", "exports", "./lib/typescriptServices", "./lib/lib", "./fetchD
             this._languageService = ts.createLanguageService(this);
             this.files = new Map();
             this.typesLoaded = false;
+            this.fetchingTypes = false;
+            this.fetchedTypes = [];
             this._ctx = ctx;
             this._compilerOptions = createData.compilerOptions;
             this._extraLibs = createData.extraLibs;
@@ -106,6 +108,10 @@ define(["require", "exports", "./lib/typescriptServices", "./lib/lib", "./fetchD
         }
         TypeScriptWorker.prototype.getTypings = function () {
             var _this = this;
+            if (this.fetchingTypes) {
+                return;
+            }
+            this.fetchingTypes = true;
             var ensureDirectoryExistence = function (filePath, cb) {
                 var dirname = BrowserFS.BFSRequire("path").dirname(filePath);
                 _this.fs.stat(dirname, function (err, exists) {
@@ -124,10 +130,16 @@ define(["require", "exports", "./lib/typescriptServices", "./lib/lib", "./fetchD
                 }
                 var code = data.toString();
                 try {
-                    var p_1 = JSON.parse(code);
-                    var devDependencies_1 = p_1.devDependencies || {};
-                    Promise.join(__spread(Object.keys(p_1.dependencies), Object.keys(devDependencies_1).filter(function (p) { return p.indexOf("@types/") === 0; })).map(function (depName) {
-                        var version = p_1.dependencies[depName] || devDependencies_1[depName];
+                    var p = JSON.parse(code);
+                    var dependencies_1 = p.dependencies || {};
+                    var devDependencies_1 = p.devDependencies || {};
+                    Promise.join(__spread(Object.keys(dependencies_1), Object.keys(devDependencies_1).filter(function (p) { return p.indexOf("@types/") === 0; })).map(function (depName) {
+                        var version = dependencies_1[depName] || devDependencies_1[depName];
+                        var key = depName + "@" + version;
+                        if (_this.fetchedTypes.indexOf(key) > -1) {
+                            return Promise.as(void 0);
+                        }
+                        _this.fetchedTypes.push(key);
                         return fetchTypings
                             .fetchAndAddDependencies(depName, version)
                             .then(function (paths) {
@@ -143,8 +155,7 @@ define(["require", "exports", "./lib/typescriptServices", "./lib/lib", "./fetchD
                                     });
                                 }
                             });
-                        })
-                            .catch(function () { });
+                        }).catch(function () { });
                     })).then(function () {
                         _this._languageService.cleanupSemanticCache();
                         setTimeout(function () {
@@ -155,6 +166,9 @@ define(["require", "exports", "./lib/typescriptServices", "./lib/lib", "./fetchD
                 catch (e) {
                     return;
                 }
+                finally {
+                    _this.fetchingTypes = false;
+                }
             });
         };
         TypeScriptWorker.prototype.syncFile = function (path) {

standalone-packages/monaco-typescript/release/dev/tsWorker.js

@@ -74,6 +74,8 @@ export class TypeScriptWorker implements ts.LanguageServiceHost {
   private fs: any;
   private files: Map<string, string> = new Map();
   private typesLoaded: boolean = false;
+  private fetchingTypes: boolean = false;
+  private fetchedTypes: string[] = [];
 
   constructor(ctx: IWorkerContext, createData: ICreateData) {
     this._ctx = ctx;
@@ -112,6 +114,12 @@ export class TypeScriptWorker implements ts.LanguageServiceHost {
   }
 
   getTypings() {
+    if (this.fetchingTypes) {
+      return;
+    }
+
+    this.fetchingTypes = true;
+
     const ensureDirectoryExistence = (filePath, cb) => {
       const dirname = BrowserFS.BFSRequire("path").dirname(filePath);
       this.fs.stat(dirname, (err, exists) => {
@@ -134,17 +142,24 @@ export class TypeScriptWorker implements ts.LanguageServiceHost {
       const code = data.toString();
       try {
         const p = JSON.parse(code);
-
+        const dependencies = p.dependencies || {};
         const devDependencies = p.devDependencies || {};
 
         Promise.join(
           [
-            ...Object.keys(p.dependencies),
+            ...Object.keys(dependencies),
             ...Object.keys(devDependencies).filter(
               p => p.indexOf("@types/") === 0
             )
           ].map(depName => {
-            const version = p.dependencies[depName] || devDependencies[depName];
+            const version = dependencies[depName] || devDependencies[depName];
+
+            const key = `${depName}@${version}`;
+            if (this.fetchedTypes.indexOf(key) > -1) {
+              return Promise.as(void 0);
+            }
+
+            this.fetchedTypes.push(key);
 
             return fetchTypings
               .fetchAndAddDependencies(depName, version)
@@ -163,8 +178,7 @@ export class TypeScriptWorker implements ts.LanguageServiceHost {
                     });
                   }
                 });
-              })
-              .catch(() => {});
+              }).catch(() => {})
           })
         ).then(() => {
           this._languageService.cleanupSemanticCache();
@@ -174,6 +188,8 @@ export class TypeScriptWorker implements ts.LanguageServiceHost {
         });
       } catch (e) {
         return;
+      } finally {
+        this.fetchingTypes = false;
       }
     });
   }