@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/server/app-render/app-render-prerender-utils.js

@@ -7,8 +7,6 @@ Object.defineProperty(exports, "__esModule", {
     ReactServerResult: null,
     createReactServerPrerenderResult: null,
     createReactServerPrerenderResultFromRender: null,
-    prerenderAndAbortInSequentialTasks: null,
-    prerenderAndAbortInSequentialTasksWithStages: null,
     processPrelude: null
 });
 function _export(target, all) {
@@ -30,91 +28,11 @@ _export(exports, {
     createReactServerPrerenderResultFromRender: function() {
         return createReactServerPrerenderResultFromRender;
     },
-    prerenderAndAbortInSequentialTasks: function() {
-        return prerenderAndAbortInSequentialTasks;
-    },
-    prerenderAndAbortInSequentialTasksWithStages: function() {
-        return prerenderAndAbortInSequentialTasksWithStages;
-    },
     processPrelude: function() {
         return processPrelude;
     }
 });
 const _invarianterror = require("../../shared/lib/invariant-error");
-const _apprenderscheduling = require("./app-render-scheduling");
-const _fastsetimmediateexternal = require("../node-environment-extensions/fast-set-immediate.external");
-function prerenderAndAbortInSequentialTasks(prerender, abort) {
-    if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('`prerenderAndAbortInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E538",
-            enumerable: false,
-            configurable: true
-        });
-    } else {
-        return new Promise((resolve, reject)=>{
-            const scheduleTimeout = (0, _apprenderscheduling.createAtomicTimerGroup)();
-            let pendingResult;
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
-                    pendingResult = prerender();
-                    pendingResult.catch(()=>{});
-                } catch (err) {
-                    reject(err);
-                }
-            });
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.expectNoPendingImmediates)();
-                    abort();
-                    resolve(pendingResult);
-                } catch (err) {
-                    reject(err);
-                }
-            });
-        });
-    }
-}
-function prerenderAndAbortInSequentialTasksWithStages(prerender, advanceStage, abort) {
-    if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('`prerenderAndAbortInSequentialTasksWithStages` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E778",
-            enumerable: false,
-            configurable: true
-        });
-    } else {
-        return new Promise((resolve, reject)=>{
-            const scheduleTimeout = (0, _apprenderscheduling.createAtomicTimerGroup)();
-            let pendingResult;
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
-                    pendingResult = prerender();
-                    pendingResult.catch(()=>{});
-                } catch (err) {
-                    reject(err);
-                }
-            });
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
-                    advanceStage();
-                } catch (err) {
-                    reject(err);
-                }
-            });
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.expectNoPendingImmediates)();
-                    abort();
-                    resolve(pendingResult);
-                } catch (err) {
-                    reject(err);
-                }
-            });
-        });
-    }
-}
 class ReactServerResult {
     constructor(stream){
         this._stream = stream;

package/standalone/node_modules/next/dist/server/app-render/app-render-render-utils.js

@@ -2,109 +2,73 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-0 && (module.exports = {
-    pipelineInSequentialTasks: null,
-    scheduleInSequentialTasks: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    pipelineInSequentialTasks: function() {
-        return pipelineInSequentialTasks;
-    },
-    scheduleInSequentialTasks: function() {
-        return scheduleInSequentialTasks;
+Object.defineProperty(exports, "runInSequentialTasks", {
+    enumerable: true,
+    get: function() {
+        return runInSequentialTasks;
     }
 });
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _apprenderscheduling = require("./app-render-scheduling");
 const _fastsetimmediateexternal = require("../node-environment-extensions/fast-set-immediate.external");
-function scheduleInSequentialTasks(render, followup) {
+const _isthenable = require("../../shared/lib/is-thenable");
+function noop() {}
+function runInSequentialTasks(first, ...rest) {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('`scheduleInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E591",
+        throw Object.defineProperty(new _invarianterror.InvariantError('`runInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
+            value: "E1054",
             enumerable: false,
             configurable: true
         });
     } else {
         return new Promise((resolve, reject)=>{
             const scheduleTimeout = (0, _apprenderscheduling.createAtomicTimerGroup)();
-            let pendingResult;
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
-                    pendingResult = render();
-                } catch (err) {
-                    reject(err);
-                }
-            });
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.expectNoPendingImmediates)();
-                    followup();
-                    resolve(pendingResult);
-                } catch (err) {
-                    reject(err);
-                }
-            });
-        });
-    }
-}
-function pipelineInSequentialTasks(one, two, three) {
-    if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('`pipelineInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E875",
-            enumerable: false,
-            configurable: true
-        });
-    } else {
-        return new Promise((resolve, reject)=>{
-            const scheduleTimeout = (0, _apprenderscheduling.createAtomicTimerGroup)();
-            let oneResult;
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
-                    oneResult = one();
-                } catch (err) {
-                    clearTimeout(twoId);
-                    clearTimeout(threeId);
-                    clearTimeout(fourId);
-                    reject(err);
-                }
-            });
-            let twoResult;
-            const twoId = scheduleTimeout(()=>{
-                // if `one` threw, then this timeout would've been cleared,
-                // so if we got here, we're guaranteed to have a value.
+            const ids = [];
+            let result;
+            ids.push(scheduleTimeout(()=>{
                 try {
                     (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
-                    twoResult = two(oneResult);
+                    result = first();
+                    // If the first function returns a thenable, suppress unhandled
+                    // rejections. A later task in the sequence (e.g. an abort) may
+                    // cause the promise to reject, and we don't want that to surface
+                    // as an unhandled rejection — the caller will observe the
+                    // rejection when they await the returned promise.
+                    if ((0, _isthenable.isThenable)(result)) {
+                        result.then(noop, noop);
+                    }
                 } catch (err) {
-                    clearTimeout(threeId);
-                    clearTimeout(fourId);
+                    for(let i = 1; i < ids.length; i++){
+                        clearTimeout(ids[i]);
+                    }
                     reject(err);
                 }
-            });
-            let threeResult;
-            const threeId = scheduleTimeout(()=>{
-                // if `two` threw, then this timeout would've been cleared,
-                // so if we got here, we're guaranteed to have a value.
+            }));
+            for(let i = 0; i < rest.length; i++){
+                const fn = rest[i];
+                let index = ids.length;
+                ids.push(scheduleTimeout(()=>{
+                    try {
+                        (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
+                        fn();
+                    } catch (err) {
+                        // clear remaining timeouts
+                        while(++index < ids.length){
+                            clearTimeout(ids[index]);
+                        }
+                        reject(err);
+                    }
+                }));
+            }
+            // We wait a task before resolving
+            ids.push(scheduleTimeout(()=>{
                 try {
                     (0, _fastsetimmediateexternal.expectNoPendingImmediates)();
-                    threeResult = three(twoResult);
+                    resolve(result);
                 } catch (err) {
-                    clearTimeout(fourId);
                     reject(err);
                 }
-            });
-            // We wait a task before resolving/rejecting
-            const fourId = scheduleTimeout(()=>{
-                resolve(threeResult);
-            });
+            }));
         });
     }
 }