Spaces:
Running
Running
File size: 6,232 Bytes
c592d77 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
dispatchAppRouterAction: null,
dispatchGestureState: null,
refreshOnInstantNavigationUnlock: null,
useActionQueue: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
dispatchAppRouterAction: function() {
return dispatchAppRouterAction;
},
dispatchGestureState: function() {
return dispatchGestureState;
},
refreshOnInstantNavigationUnlock: function() {
return refreshOnInstantNavigationUnlock;
},
useActionQueue: function() {
return useActionQueue;
}
});
const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
const _isthenable = require("../../shared/lib/is-thenable");
const _routerreducertypes = require("./router-reducer/router-reducer-types");
// The app router state lives outside of React, so we can import the dispatch
// method directly wherever we need it, rather than passing it around via props
// or context.
let dispatch = null;
function refreshOnInstantNavigationUnlock() {
if (process.env.__NEXT_EXPOSE_TESTING_API) {
if (dispatch !== null) {
dispatch({
type: _routerreducertypes.ACTION_REFRESH,
bypassCacheInvalidation: true
});
} else {
window.location.reload();
}
}
}
function dispatchAppRouterAction(action) {
if (dispatch === null) {
throw Object.defineProperty(new Error('Internal Next.js error: Router action dispatched before initialization.'), "__NEXT_ERROR_CODE", {
value: "E668",
enumerable: false,
configurable: true
});
}
dispatch(action);
}
// Optimistic state setter for experimental_gesturePush. Only should be used
// during a gesture transition.
let setGestureRouterState = null;
function dispatchGestureState(state) {
if (setGestureRouterState === null) {
throw Object.defineProperty(new Error('Internal Next.js error: Router action dispatched before initialization.'), "__NEXT_ERROR_CODE", {
value: "E668",
enumerable: false,
configurable: true
});
}
setGestureRouterState(state);
}
const __DEV__ = process.env.NODE_ENV !== 'production';
const promisesWithDebugInfo = __DEV__ ? new WeakMap() : null;
function useActionQueue(actionQueue) {
const [canonicalState, setState] = _react.default.useState(actionQueue.state);
// Wrap the canonical state in useOptimistic to support
// experimental_gesturePush. During a gesture transition, this returns a fork
// of the router state that represents the eventual target if/when the gesture
// completes. Otherwise it returns the canonical state.
const [state, setGesture] = (0, _react.useOptimistic)(canonicalState);
if (typeof window !== 'undefined') {
setGestureRouterState = setGesture;
}
// Because of a known issue that requires to decode Flight streams inside the
// render phase, we have to be a bit clever and assign the dispatch method to
// a module-level variable upon initialization. The useState hook in this
// module only exists to synchronize state that lives outside of React.
// Ideally, what we'd do instead is pass the state as a prop to root.render;
// this is conceptually how we're modeling the app router state, despite the
// weird implementation details.
let nextDispatch;
if (process.env.NODE_ENV !== 'production') {
const { useAppDevRenderingIndicator } = require('../../next-devtools/userspace/use-app-dev-rendering-indicator');
// eslint-disable-next-line react-hooks/rules-of-hooks
const appDevRenderingIndicator = useAppDevRenderingIndicator();
nextDispatch = (action)=>{
appDevRenderingIndicator(()=>{
actionQueue.dispatch(action, setState);
});
};
} else {
nextDispatch = (action)=>actionQueue.dispatch(action, setState);
}
if (typeof window !== 'undefined') {
dispatch = nextDispatch;
}
// When navigating to a non-prefetched route, then App Router state will be
// blocked until the server responds. We need to transfer the `_debugInfo`
// from the underlying Flight response onto the top-level promise that is
// passed to React (via `use`) so that the latency is accurately represented
// in the React DevTools.
const stateWithDebugInfo = (0, _react.useMemo)(()=>{
if (!__DEV__) {
return state;
}
if ((0, _isthenable.isThenable)(state)) {
// useMemo can't be used to cache a Promise since the memoized value is thrown
// away when we suspend. So we use a WeakMap to cache the Promise with debug info.
let promiseWithDebugInfo = promisesWithDebugInfo.get(state);
if (promiseWithDebugInfo === undefined) {
const debugInfo = [];
promiseWithDebugInfo = Promise.resolve(state).then((asyncState)=>{
if (asyncState.debugInfo !== null) {
debugInfo.push(...asyncState.debugInfo);
}
return asyncState;
});
promiseWithDebugInfo._debugInfo = debugInfo;
promisesWithDebugInfo.set(state, promiseWithDebugInfo);
}
return promiseWithDebugInfo;
}
return state;
}, [
state
]);
return (0, _isthenable.isThenable)(stateWithDebugInfo) ? (0, _react.use)(stateWithDebugInfo) : stateWithDebugInfo;
}
if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
Object.defineProperty(exports.default, '__esModule', { value: true });
Object.assign(exports.default, exports);
module.exports = exports.default;
}
//# sourceMappingURL=use-action-queue.js.map |