@sifxprime/krouter 0.5.166 → 0.5.167

package/app/node_modules/next/dist/server/dev/debug-channel.js

@@ -50,12 +50,8 @@ function connectReactDebugChannel(requestId, debugChannel, sendToClient) {
     };
     const onError = (err)=>{
         if (!finished) {
-            console.error(Object.defineProperty(new Error('React debug channel stream error', {
+            console.error(new Error('React debug channel stream error', {
                 cause: err
-            }), "__NEXT_ERROR_CODE", {
-                value: "E810",
-                enumerable: false,
-                configurable: true
             }));
         }
         stop();

package/app/node_modules/next/dist/server/dev/dev-validation-worker-pool.js

@@ -177,6 +177,7 @@ function installDevValidationWorker(options) {
                 httpAgentOptions: nextConfig.httpAgentOptions,
                 cacheLifeProfiles: nextConfig.cacheLife,
                 useCacheTimeout: nextConfig.experimental.useCacheTimeout,
+                durableUseCacheEntries: Boolean(nextConfig.experimental.durableUseCacheEntries),
                 staticPageGenerationTimeout: nextConfig.staticPageGenerationTimeout
             }
         };

package/app/node_modules/next/dist/server/dev/get-source-map-from-file.js

@@ -38,12 +38,8 @@ async function getSourceMapFromFile(filename) {
     try {
         fileContents = await _promises.default.readFile(filename, 'utf-8');
     } catch (error) {
-        throw Object.defineProperty(new Error(`Failed to read file contents of ${filename}.`, {
+        throw new Error(`Failed to read file contents of ${filename}.`, {
             cause: error
-        }), "__NEXT_ERROR_CODE", {
-            value: "E466",
-            enumerable: false,
-            configurable: true
         });
     }
     const sourceUrl = getSourceMapUrl(fileContents);
@@ -55,30 +51,18 @@ async function getSourceMapFromFile(filename) {
         try {
             buffer = (0, _datauritobuffer.default)(sourceUrl);
         } catch (error) {
-            throw Object.defineProperty(new Error(`Failed to parse source map URL for ${filename}.`, {
+            throw new Error(`Failed to parse source map URL for ${filename}.`, {
                 cause: error
-            }), "__NEXT_ERROR_CODE", {
-                value: "E199",
-                enumerable: false,
-                configurable: true
             });
         }
         if (buffer.type !== 'application/json') {
-            throw Object.defineProperty(new Error(`Unknown source map type for ${filename}: ${buffer.typeFull}.`), "__NEXT_ERROR_CODE", {
-                value: "E113",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Unknown source map type for ${filename}: ${buffer.typeFull}.`);
         }
         try {
             return JSON.parse(buffer.toString());
         } catch (error) {
-            throw Object.defineProperty(new Error(`Failed to parse source map for ${filename}.`, {
+            throw new Error(`Failed to parse source map for ${filename}.`, {
                 cause: error
-            }), "__NEXT_ERROR_CODE", {
-                value: "E318",
-                enumerable: false,
-                configurable: true
             });
         }
     }
@@ -87,12 +71,8 @@ async function getSourceMapFromFile(filename) {
         const sourceMapContents = await _promises.default.readFile(sourceMapFilename, 'utf-8');
         return JSON.parse(sourceMapContents.toString());
     } catch (error) {
-        throw Object.defineProperty(new Error(`Failed to parse source map ${sourceMapFilename}.`, {
+        throw new Error(`Failed to parse source map ${sourceMapFilename}.`, {
             cause: error
-        }), "__NEXT_ERROR_CODE", {
-            value: "E220",
-            enumerable: false,
-            configurable: true
         });
     }
 }

package/app/node_modules/next/dist/server/dev/hot-middleware.js

@@ -62,17 +62,19 @@ function getStatsForSyncEvent(clientStats, serverStats) {
     return serverStats.ts > clientStats.ts ? serverStats.stats : clientStats.stats;
 }
 class WebpackHotMiddleware {
-    constructor(compilers, versionInfo, devtoolsFrontendUrl, config, devToolsConfig){
+    constructor(compilers, versionInfo, devtoolsFrontendUrl, config, devToolsConfig, hasVulnerabilityInsight){
         this.versionInfo = versionInfo;
         this.devtoolsFrontendUrl = devtoolsFrontendUrl;
         this.config = config;
         this.devToolsConfig = devToolsConfig;
         this.clientsWithoutHtmlRequestId = new Set();
         this.clientsByHtmlRequestId = new Map();
+        this.runtimeErrorStates = this.config.experimental.exposeRuntimeErrorsToHMR || Boolean(process.env.__NEXT_EXPOSE_RUNTIME_ERRORS_TO_HMR) ? new Map() : null;
         this.closed = false;
         this.clientLatestStats = null;
         this.middlewareLatestStats = null;
         this.serverLatestStats = null;
+        this.hasVulnerabilityInsight = false;
         this.onClientInvalid = ()=>{
             var _this_serverLatestStats;
             if (this.closed || ((_this_serverLatestStats = this.serverLatestStats) == null ? void 0 : _this_serverLatestStats.stats.hasErrors())) return;
@@ -148,6 +150,11 @@ class WebpackHotMiddleware {
                     this.clientsWithoutHtmlRequestId.delete(client);
                 }
             });
+            if (this.runtimeErrorStates) {
+                for (const message of this.runtimeErrorStates.values()){
+                    this.publishToClient(client, message);
+                }
+            }
             const syncStats = getStatsForSyncEvent(this.clientLatestStats, this.serverLatestStats);
             if (syncStats) {
                 var _this_middlewareLatestStats;
@@ -168,6 +175,7 @@ class WebpackHotMiddleware {
                         ...middlewareStats.warnings || []
                     ],
                     versionInfo: this.versionInfo,
+                    hasVulnerabilityInsight: this.hasVulnerabilityInsight,
                     debug: {
                         devtoolsFrontendUrl: this.devtoolsFrontendUrl
                     },
@@ -206,6 +214,13 @@ class WebpackHotMiddleware {
             if (this.closed) {
                 return;
             }
+            if (this.runtimeErrorStates && message.type === _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.RUNTIME_ERRORS) {
+                if (message.errors.length === 0) {
+                    this.runtimeErrorStates.delete(message.clientId);
+                } else {
+                    this.runtimeErrorStates.set(message.clientId, message);
+                }
+            }
             for (const wsClient of [
                 ...this.clientsWithoutHtmlRequestId,
                 ...this.clientsByHtmlRequestId.values()
@@ -232,6 +247,7 @@ class WebpackHotMiddleware {
             }
         };
         this.close = ()=>{
+            var _this_runtimeErrorStates;
             if (this.closed) {
                 return;
             }
@@ -247,6 +263,7 @@ class WebpackHotMiddleware {
             }
             this.clientsWithoutHtmlRequestId.clear();
             this.clientsByHtmlRequestId.clear();
+            (_this_runtimeErrorStates = this.runtimeErrorStates) == null ? void 0 : _this_runtimeErrorStates.clear();
         };
         this.deleteClient = (client, htmlRequestId)=>{
             if (htmlRequestId) {
@@ -261,6 +278,15 @@ class WebpackHotMiddleware {
         this.getClientCount = ()=>{
             return this.clientsWithoutHtmlRequestId.size + this.clientsByHtmlRequestId.size;
         };
+        hasVulnerabilityInsight.then((enabled)=>{
+            if (enabled) {
+                this.hasVulnerabilityInsight = true;
+                this.publish({
+                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.VULNERABILITY_INSIGHT,
+                    hasVulnerabilityInsight: true
+                });
+            }
+        });
         compilers[0].hooks.invalid.tap('webpack-hot-middleware', this.onClientInvalid);
         compilers[0].hooks.done.tap('webpack-hot-middleware', this.onClientDone);
         compilers[1].hooks.invalid.tap('webpack-hot-middleware', this.onServerInvalid);