Handle require.ensure errors well.

Introduce a new Promise library which runs on the same eventloop.

lib/dynamic.js

@@ -53,3 +53,89 @@ export function flushChunks () {
   currentChunks = []
   return chunks
 }
+
+export class SameLoopPromise {
+  constructor (cb) {
+    this.onResultCallbacks = []
+    this.onErrorCallbacks = []
+
+    if (cb) {
+      cb(
+        (result) => this.setResult(result),
+        (error) => this.setError(error)
+      )
+    }
+  }
+
+  setResult (result) {
+    this.gotResult = true
+    this.result = result
+    this.onResultCallbacks.forEach((cb) => cb(result))
+    this.onResultCallbacks = []
+  }
+
+  setError (error) {
+    this.gotError = true
+    this.error = error
+    this.onErrorCallbacks.forEach((cb) => cb(error))
+    this.onErrorCallbacks = []
+  }
+
+  then (onResult, onError) {
+    const promise = new SameLoopPromise()
+
+    const handleError = () => {
+      if (onError) {
+        promise.setResult(onError(this.error))
+      } else {
+        promise.setError(this.error)
+      }
+    }
+
+    const handleResult = () => {
+      promise.setResult(onResult(this.result))
+    }
+
+    if (this.gotResult) {
+      handleResult()
+      return promise
+    }
+
+    if (this.gotError) {
+      handleError()
+      return promise
+    }
+
+    this.onResultCallbacks.push(handleResult)
+    this.onErrorCallbacks.push(handleError)
+
+    return promise
+  }
+
+  catch (onError) {
+    const promise = new SameLoopPromise()
+
+    const handleError = () => {
+      promise.setResult(onError(this.error))
+    }
+
+    const handleResult = () => {
+      promise.setResult(this.result)
+    }
+
+    if (this.gotResult) {
+      handleResult()
+      return promise
+    }
+
+    if (this.gotError) {
+      handleError()
+      return promise
+    }
+
+    this.onErrorCallbacks.push(handleError)
+    this.onResultCallbacks.push(handleResult)
+
+    return promise
+  }
+}

server/build/babel/plugins/handle-import.js

@@ -8,35 +8,34 @@ const TYPE_IMPORT = 'Import'
 
 const buildImport = (args) => (template(`
   (
-    typeof window === 'undefined' ? 
-      {
-        then(cb) {
-          eval('require.ensure = function (deps, callback) { callback(require) }')
-          require.ensure([], (require) => {
-            let m = require(SOURCE)
-            m = m.default || m
-            m.__webpackChunkName = '${args.name}.js'
-            cb(m);
-          }, 'chunks/${args.name}.js');
-        },
-        catch() {}
-      } :
-      {
-        then(cb) {
-          const weakId = require.resolveWeak(SOURCE)
-          try {
-            const weakModule = __webpack_require__(weakId)
-            return cb(weakModule.default || weakModule)
-          } catch (err) {}
+    typeof window === 'undefined' ?
+      new (require('next/dynamic').SameLoopPromise)((resolve, reject) => {
+        eval('require.ensure = function (deps, callback) { callback(require) }')
+        require.ensure([], (require) => {
+          let m = require(SOURCE)
+          m = m.default || m
+          m.__webpackChunkName = '${args.name}.js'
+          resolve(m);
+        }, 'chunks/${args.name}.js');
+      })
+      :
+      new (require('next/dynamic').SameLoopPromise)((resolve, reject) => {
+        const weakId = require.resolveWeak(SOURCE)
+        try {
+          const weakModule = __webpack_require__(weakId)
+          return resolve(weakModule.default || weakModule)
+        } catch (err) {}
 
-          require.ensure([], (require) => {
+        require.ensure([], (require) => {
+          try {
             let m = require(SOURCE)
             m = m.default || m
-            cb(m);
-          }, 'chunks/${args.name}.js');
-        },
-        catch () {}
-      }
+            resolve(m)
+          } catch(error) {
+            reject(error)
+          }
+        }, 'chunks/${args.name}.js');
+      })
   )
 `))