@tyroneross/navgator 0.9.0 → 0.10.0

package/web/runtime/packages/next/dist/server/app-render/rsc/taint.js

@@ -0,0 +1,79 @@
+/*
+
+Files in the rsc directory are meant to be packaged as part of the RSC graph using next-app-loader.
+
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    taintObjectReference: null,
+    taintUniqueValue: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    taintObjectReference: function() {
+        return taintObjectReference;
+    },
+    taintUniqueValue: function() {
+        return taintUniqueValue;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function notImplemented() {
+    throw Object.defineProperty(new Error('Taint can only be used with the taint flag.'), "__NEXT_ERROR_CODE", {
+        value: "E354",
+        enumerable: false,
+        configurable: true
+    });
+}
+const taintObjectReference = process.env.__NEXT_EXPERIMENTAL_REACT ? _react.experimental_taintObjectReference : notImplemented;
+const taintUniqueValue = process.env.__NEXT_EXPERIMENTAL_REACT ? _react.experimental_taintUniqueValue : notImplemented;
+
+//# sourceMappingURL=taint.js.map

package/web/runtime/packages/next/dist/server/app-render/segment-explorer-path.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    BOUNDARY_PREFIX: null,
+    BOUNDARY_SUFFIX: null,
+    BUILTIN_PREFIX: null,
+    getBoundaryOriginFileType: null,
+    getConventionPathByType: null,
+    isBoundaryFile: null,
+    isBuiltinBoundaryFile: null,
+    isNextjsBuiltinFilePath: null,
+    normalizeBoundaryFilename: null,
+    normalizeConventionFilePath: null,
+    normalizeFilePath: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    BOUNDARY_PREFIX: function() {
+        return BOUNDARY_PREFIX;
+    },
+    BOUNDARY_SUFFIX: function() {
+        return BOUNDARY_SUFFIX;
+    },
+    BUILTIN_PREFIX: function() {
+        return BUILTIN_PREFIX;
+    },
+    getBoundaryOriginFileType: function() {
+        return getBoundaryOriginFileType;
+    },
+    getConventionPathByType: function() {
+        return getConventionPathByType;
+    },
+    isBoundaryFile: function() {
+        return isBoundaryFile;
+    },
+    isBuiltinBoundaryFile: function() {
+        return isBuiltinBoundaryFile;
+    },
+    isNextjsBuiltinFilePath: function() {
+        return isNextjsBuiltinFilePath;
+    },
+    normalizeBoundaryFilename: function() {
+        return normalizeBoundaryFilename;
+    },
+    normalizeConventionFilePath: function() {
+        return normalizeConventionFilePath;
+    },
+    normalizeFilePath: function() {
+        return normalizeFilePath;
+    }
+});
+const BUILTIN_PREFIX = '__next_builtin__';
+const nextInternalPrefixRegex = /^(.*[\\/])?next[\\/]dist[\\/]client[\\/]components[\\/]builtin[\\/]/;
+function normalizeFilePath(projectDir, filePath) {
+    // Turbopack project path is formed as: "<project root>/<cwd>".
+    // When project root is not the working directory, we can extract the relative project root path.
+    // This is mostly used for running Next.js inside a monorepo.
+    const cwd = process.env.NEXT_RUNTIME === 'edge' ? '' : process.cwd();
+    const relativeProjectRoot = projectDir.replace(cwd, '').replace(/^[\\/]/, '');
+    let relativePath = (filePath || '')// remove turbopack [project] prefix
+    .replace(/^\[project\][\\/]?/, '')// remove the project root from the path (absolute)
+    .replace(projectDir, '')// remove cwd prefix (absolute)
+    .replace(cwd, '')// normalize path separators and remove leading slash
+    .replace(/\\/g, '/').replace(/^\//, '');
+    // remove relative project path prefix (e.g., "test/e2e/app-dir/actions/")
+    if (relativeProjectRoot && relativePath.startsWith(relativeProjectRoot)) {
+        relativePath = relativePath.slice(relativeProjectRoot.length).replace(/^\//, '');
+    }
+    // Handle case where filename is relative to a parent of projectDir
+    // (e.g., in tests where filename is "test/tmp/next-test-XXX/app/page.js"
+    // but projectDir is the test temp directory)
+    if (relativePath.includes('/')) {
+        const projectDirName = projectDir.split(/[\\/]/).pop() || '';
+        if (projectDirName) {
+            const projectDirWithSlash = projectDirName + '/';
+            const idx = relativePath.indexOf(projectDirWithSlash);
+            if (idx >= 0) {
+                relativePath = relativePath.slice(idx + projectDirWithSlash.length);
+            }
+        }
+    }
+    return relativePath;
+}
+function normalizeConventionFilePath(projectDir, conventionPath) {
+    let relativePath = normalizeFilePath(projectDir, conventionPath)// remove /(src/)?app/ dir prefix
+    .replace(/^(src\/)?app\//, '');
+    // If it's internal file only keep the filename, strip nextjs internal prefix
+    if (nextInternalPrefixRegex.test(relativePath)) {
+        relativePath = relativePath.replace(nextInternalPrefixRegex, '');
+        // Add a special prefix to let segment explorer know it's a built-in component
+        relativePath = `${BUILTIN_PREFIX}${relativePath}`;
+    }
+    return relativePath;
+}
+const isNextjsBuiltinFilePath = (filePath)=>{
+    return nextInternalPrefixRegex.test(filePath);
+};
+const BOUNDARY_SUFFIX = '@boundary';
+function normalizeBoundaryFilename(filename) {
+    return filename.replace(new RegExp(`^${BUILTIN_PREFIX}`), '').replace(new RegExp(`${BOUNDARY_SUFFIX}$`), '');
+}
+const BOUNDARY_PREFIX = 'boundary:';
+function isBoundaryFile(fileType) {
+    return fileType.startsWith(BOUNDARY_PREFIX);
+}
+function isBuiltinBoundaryFile(fileType) {
+    return fileType.startsWith(BUILTIN_PREFIX);
+}
+function getBoundaryOriginFileType(fileType) {
+    return fileType.replace(BOUNDARY_PREFIX, '');
+}
+function getConventionPathByType(tree, dir, conventionType) {
+    const modules = tree[2];
+    const conventionPath = modules[conventionType] ? modules[conventionType][1] : undefined;
+    if (conventionPath) {
+        return normalizeConventionFilePath(dir, conventionPath);
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=segment-explorer-path.js.map

package/web/runtime/packages/next/dist/server/app-render/server-inserted-html.js

@@ -0,0 +1,77 @@
+/* eslint-disable @next/internal/no-ambiguous-jsx -- whole module is used in React Client */ // Provider for the `useServerInsertedHTML` API to register callbacks to insert
+// elements into the HTML stream.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createServerInsertedHTML", {
+    enumerable: true,
+    get: function() {
+        return createServerInsertedHTML;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _serverinsertedhtmlsharedruntime = require("../../shared/lib/server-inserted-html.shared-runtime");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function createServerInsertedHTML() {
+    const serverInsertedHTMLCallbacks = [];
+    const addInsertedHtml = (handler)=>{
+        serverInsertedHTMLCallbacks.push(handler);
+    };
+    return {
+        ServerInsertedHTMLProvider ({ children }) {
+            return /*#__PURE__*/ (0, _jsxruntime.jsx)(_serverinsertedhtmlsharedruntime.ServerInsertedHTMLContext.Provider, {
+                value: addInsertedHtml,
+                children: children
+            });
+        },
+        renderServerInsertedHTML () {
+            return serverInsertedHTMLCallbacks.map((callback, index)=>/*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Fragment, {
+                    children: callback()
+                }, '__next_server_inserted__' + index));
+        }
+    };
+}
+
+//# sourceMappingURL=server-inserted-html.js.map

package/web/runtime/packages/next/dist/server/app-render/staged-rendering.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    RenderStage: null,
+    StagedRenderingController: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    RenderStage: function() {
+        return RenderStage;
+    },
+    StagedRenderingController: function() {
+        return StagedRenderingController;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
+var RenderStage = /*#__PURE__*/ function(RenderStage) {
+    RenderStage[RenderStage["Before"] = 1] = "Before";
+    RenderStage[RenderStage["EarlyStatic"] = 2] = "EarlyStatic";
+    RenderStage[RenderStage["Static"] = 3] = "Static";
+    RenderStage[RenderStage["EarlyRuntime"] = 4] = "EarlyRuntime";
+    RenderStage[RenderStage["Runtime"] = 5] = "Runtime";
+    RenderStage[RenderStage["Dynamic"] = 6] = "Dynamic";
+    RenderStage[RenderStage["Abandoned"] = 7] = "Abandoned";
+    return RenderStage;
+}({});
+class StagedRenderingController {
+    constructor(abortSignal, abandonController, shouldTrackSyncIO){
+        this.abortSignal = abortSignal;
+        this.abandonController = abandonController;
+        this.shouldTrackSyncIO = shouldTrackSyncIO;
+        this.currentStage = 1;
+        this.syncInterruptReason = null;
+        this.staticStageEndTime = Infinity;
+        this.runtimeStageEndTime = Infinity;
+        this.staticStageListeners = [];
+        this.earlyRuntimeStageListeners = [];
+        this.runtimeStageListeners = [];
+        this.dynamicStageListeners = [];
+        this.staticStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.earlyRuntimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        if (abortSignal) {
+            abortSignal.addEventListener('abort', ()=>{
+                // Reject all stage promises that haven't already been resolved.
+                // If a promise was already resolved via advanceStage, the reject
+                // is a no-op. The ignoreReject handler suppresses unhandled
+                // rejection warnings for promises that no one is awaiting.
+                const { reason } = abortSignal;
+                this.staticStagePromise.promise.catch(ignoreReject);
+                this.staticStagePromise.reject(reason);
+                this.earlyRuntimeStagePromise.promise.catch(ignoreReject);
+                this.earlyRuntimeStagePromise.reject(reason);
+                this.runtimeStagePromise.promise.catch(ignoreReject);
+                this.runtimeStagePromise.reject(reason);
+                this.dynamicStagePromise.promise.catch(ignoreReject);
+                this.dynamicStagePromise.reject(reason);
+            }, {
+                once: true
+            });
+        }
+        if (abandonController) {
+            abandonController.signal.addEventListener('abort', ()=>{
+                this.abandonRender();
+            }, {
+                once: true
+            });
+        }
+    }
+    onStage(stage, callback) {
+        if (this.currentStage >= stage) {
+            callback();
+        } else if (stage === 3) {
+            this.staticStageListeners.push(callback);
+        } else if (stage === 4) {
+            this.earlyRuntimeStageListeners.push(callback);
+        } else if (stage === 5) {
+            this.runtimeStageListeners.push(callback);
+        } else if (stage === 6) {
+            this.dynamicStageListeners.push(callback);
+        } else {
+            // This should never happen
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+                value: "E881",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    shouldTrackSyncInterrupt() {
+        if (!this.shouldTrackSyncIO) {
+            return false;
+        }
+        switch(this.currentStage){
+            case 1:
+                // If we haven't started the render yet, it can't be interrupted.
+                return false;
+            case 2:
+            case 3:
+                return true;
+            case 4:
+                // EarlyRuntime is for runtime-prefetchable segments. Sync IO
+                // should error because it would abort a runtime prefetch.
+                return true;
+            case 5:
+                // Runtime is for non-prefetchable segments. Sync IO is fine there
+                // because in practice this segment will never be runtime prefetched
+                return false;
+            case 6:
+            case 7:
+                return false;
+            default:
+                return false;
+        }
+    }
+    syncInterruptCurrentStageWithReason(reason) {
+        if (this.currentStage === 1) {
+            return;
+        }
+        // If the render has already been abandoned, there's nothing to interrupt.
+        if (this.currentStage === 7) {
+            return;
+        }
+        // If Sync IO occurs during an abandonable render, we trigger the abandon.
+        // The abandon listener will call abandonRender which advances through
+        // stages to let caches fill before marking as Abandoned.
+        if (this.abandonController) {
+            this.abandonController.abort();
+            return;
+        }
+        if (this.abortSignal) {
+            // If this is an abortable render, we capture the interruption reason and stop advancing.
+            // We don't release any more promises.
+            // The caller is expected to abort the signal.
+            this.syncInterruptReason = reason;
+            this.currentStage = 7;
+            return;
+        }
+        // If we're in a non-abandonable & non-abortable render,
+        // we need to advance to the Dynamic stage and capture the interruption reason.
+        // (in dev, this will be the restarted render)
+        switch(this.currentStage){
+            case 2:
+            case 3:
+            case 4:
+                {
+                    // EarlyRuntime is for runtime-prefetchable segments. Sync IO here
+                    // means the prefetch would be aborted too early.
+                    this.syncInterruptReason = reason;
+                    this.advanceStage(6);
+                    return;
+                }
+            case 5:
+                {
+                    // canSyncInterrupt returns false for Runtime, so we should
+                    // never get here. Defensive no-op.
+                    return;
+                }
+            case 6:
+            default:
+        }
+    }
+    getSyncInterruptReason() {
+        return this.syncInterruptReason;
+    }
+    getStaticStageEndTime() {
+        return this.staticStageEndTime;
+    }
+    getRuntimeStageEndTime() {
+        return this.runtimeStageEndTime;
+    }
+    abandonRender() {
+        // In staged rendering, only the initial render is abandonable.
+        // We can abandon the initial render if
+        //   1. We notice a cache miss, and need to wait for caches to fill
+        //   2. A sync IO error occurs, and the render should be interrupted
+        //      (this might be a lazy intitialization of a module,
+        //       so we still want to restart in this case and see if it still occurs)
+        // In either case, we'll be doing another render after this one,
+        // so we only want to unblock the next stage, not Dynamic, because
+        // unblocking the dynamic stage would likely lead to wasted (uncached) IO.
+        const { currentStage } = this;
+        switch(currentStage){
+            case 2:
+                {
+                    this.resolveStaticStage();
+                }
+            // intentional fallthrough
+            case 3:
+                {
+                    this.resolveEarlyRuntimeStage();
+                }
+            // intentional fallthrough
+            case 4:
+                {
+                    this.resolveRuntimeStage();
+                }
+            // intentional fallthrough
+            case 5:
+                {
+                    this.currentStage = 7;
+                    return;
+                }
+            case 6:
+            case 1:
+            case 7:
+                break;
+            default:
+                {
+                    currentStage;
+                }
+        }
+    }
+    advanceStage(stage) {
+        // If we're already at the target stage or beyond, do nothing.
+        // (this can happen e.g. if sync IO advanced us to the dynamic stage)
+        if (stage <= this.currentStage) {
+            return;
+        }
+        let currentStage = this.currentStage;
+        this.currentStage = stage;
+        if (currentStage < 3 && stage >= 3) {
+            this.resolveStaticStage();
+        }
+        if (currentStage < 4 && stage >= 4) {
+            this.resolveEarlyRuntimeStage();
+        }
+        if (currentStage < 5 && stage >= 5) {
+            this.staticStageEndTime = performance.now() + performance.timeOrigin;
+            this.resolveRuntimeStage();
+        }
+        if (currentStage < 6 && stage >= 6) {
+            this.runtimeStageEndTime = performance.now() + performance.timeOrigin;
+            this.resolveDynamicStage();
+            return;
+        }
+    }
+    /** Fire the `onStage` listeners for the static stage and unblock any promises waiting for it. */ resolveStaticStage() {
+        const staticListeners = this.staticStageListeners;
+        for(let i = 0; i < staticListeners.length; i++){
+            staticListeners[i]();
+        }
+        staticListeners.length = 0;
+        this.staticStagePromise.resolve();
+    }
+    /** Fire the `onStage` listeners for the early runtime stage and unblock any promises waiting for it. */ resolveEarlyRuntimeStage() {
+        const earlyRuntimeListeners = this.earlyRuntimeStageListeners;
+        for(let i = 0; i < earlyRuntimeListeners.length; i++){
+            earlyRuntimeListeners[i]();
+        }
+        earlyRuntimeListeners.length = 0;
+        this.earlyRuntimeStagePromise.resolve();
+    }
+    /** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */ resolveRuntimeStage() {
+        const runtimeListeners = this.runtimeStageListeners;
+        for(let i = 0; i < runtimeListeners.length; i++){
+            runtimeListeners[i]();
+        }
+        runtimeListeners.length = 0;
+        this.runtimeStagePromise.resolve();
+    }
+    /** Fire the `onStage` listeners for the dynamic stage and unblock any promises waiting for it. */ resolveDynamicStage() {
+        const dynamicListeners = this.dynamicStageListeners;
+        for(let i = 0; i < dynamicListeners.length; i++){
+            dynamicListeners[i]();
+        }
+        dynamicListeners.length = 0;
+        this.dynamicStagePromise.resolve();
+    }
+    getStagePromise(stage) {
+        switch(stage){
+            case 3:
+                {
+                    return this.staticStagePromise.promise;
+                }
+            case 4:
+                {
+                    return this.earlyRuntimeStagePromise.promise;
+                }
+            case 5:
+                {
+                    return this.runtimeStagePromise.promise;
+                }
+            case 6:
+                {
+                    return this.dynamicStagePromise.promise;
+                }
+            default:
+                {
+                    stage;
+                    throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+                        value: "E881",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+        }
+    }
+    waitForStage(stage) {
+        return this.getStagePromise(stage);
+    }
+    delayUntilStage(stage, displayName, resolvedValue) {
+        const ioTriggerPromise = this.getStagePromise(stage);
+        const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue);
+        // Analogously to `makeHangingPromise`, we might reject this promise if the signal is invoked.
+        // (e.g. in the case where we don't want want the render to proceed to the dynamic stage and abort it).
+        // We shouldn't consider this an unhandled rejection, so we attach a noop catch handler here to suppress this warning.
+        if (this.abortSignal) {
+            promise.catch(ignoreReject);
+        }
+        return promise;
+    }
+}
+function ignoreReject() {}
+// TODO(restart-on-cache-miss): the layering of `delayUntilStage`,
+// `makeDevtoolsIOPromiseFromIOTrigger` and and `makeDevtoolsIOAwarePromise`
+// is confusing, we should clean it up.
+function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValue) {
+    // If we create a `new Promise` and give it a displayName
+    // (with no userspace code above us in the stack)
+    // React Devtools will use it as the IO cause when determining "suspended by".
+    // In particular, it should shadow any inner IO that resolved/rejected the promise
+    // (in case of staged rendering, this will be the `setTimeout` that triggers the relevant stage)
+    const promise = new Promise((resolve, reject)=>{
+        ioTrigger.then(resolve.bind(null, resolvedValue), reject);
+    });
+    if (displayName !== undefined) {
+        // @ts-expect-error
+        promise.displayName = displayName;
+    }
+    return promise;
+}
+
+//# sourceMappingURL=staged-rendering.js.map