/opt/canhelp/node_modules/next/dist/client
Edit: /opt/canhelp/node_modules/next/dist/client/router.js (6716B)
/* global window */ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
Router: null,
createRouter: null,
default: null,
makePublicRouterInstance: null,
useRouter: null,
withRouter: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
Router: function() {
return _router.default;
},
createRouter: function() {
return createRouter;
},
// Export the singletonRouter and this is the public API.
default: function() {
return _default;
},
makePublicRouterInstance: function() {
return makePublicRouterInstance;
},
useRouter: function() {
return useRouter;
},
withRouter: function() {
return _withrouter.default;
}
});
const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
const _router = /*#__PURE__*/ _interop_require_default._(require("../shared/lib/router/router"));
const _routercontextsharedruntime = require("../shared/lib/router-context.shared-runtime");
const _iserror = /*#__PURE__*/ _interop_require_default._(require("../lib/is-error"));
const _withrouter = /*#__PURE__*/ _interop_require_default._(require("./with-router"));
const singletonRouter = {
router: null,
readyCallbacks: [],
ready (callback) {
if (this.router) return callback();
if (typeof window !== 'undefined') {
this.readyCallbacks.push(callback);
}
}
};
// Create public properties and methods of the router in the singletonRouter
const urlPropertyFields = [
'pathname',
'route',
'query',
'asPath',
'components',
'isFallback',
'basePath',
'locale',
'locales',
'defaultLocale',
'isReady',
'isPreview',
'isLocaleDomain',
'domainLocales'
];
const routerEvents = [
'routeChangeStart',
'beforeHistoryChange',
'routeChangeComplete',
'routeChangeError',
'hashChangeStart',
'hashChangeComplete'
];
const coreMethodFields = [
'push',
'replace',
'reload',
'back',
'prefetch',
'beforePopState'
];
// Events is a static property on the router, the router doesn't have to be initialized to use it
Object.defineProperty(singletonRouter, 'events', {
get () {
return _router.default.events;
}
});
function getRouter() {
if (!singletonRouter.router) {
const message = 'No router instance found.\n' + 'You should only use "next/router" on the client side of your app.\n';
throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
value: "E394",
enumerable: false,
configurable: true
});
}
return singletonRouter.router;
}
urlPropertyFields.forEach((field)=>{
// Here we need to use Object.defineProperty because we need to return
// the property assigned to the actual router
// The value might get changed as we change routes and this is the
// proper way to access it
Object.defineProperty(singletonRouter, field, {
get () {
const router = getRouter();
return router[field];
}
});
});
coreMethodFields.forEach((field)=>{
// We don't really know the types here, so we add them later instead
;
singletonRouter[field] = function() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
const router = getRouter();
return router[field](...args);
};
});
routerEvents.forEach((event)=>{
singletonRouter.ready(()=>{
_router.default.events.on(event, function() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
const eventField = "on" + event.charAt(0).toUpperCase() + event.substring(1);
const _singletonRouter = singletonRouter;
if (_singletonRouter[eventField]) {
try {
_singletonRouter[eventField](...args);
} catch (err) {
console.error("Error when running the Router event: " + eventField);
console.error((0, _iserror.default)(err) ? err.message + "\n" + err.stack : err + '');
}
}
});
});
});
const _default = singletonRouter;
function useRouter() {
const router = _react.default.useContext(_routercontextsharedruntime.RouterContext);
if (!router) {
throw Object.defineProperty(new Error('NextRouter was not mounted. https://nextjs.org/docs/messages/next-router-not-mounted'), "__NEXT_ERROR_CODE", {
value: "E509",
enumerable: false,
configurable: true
});
}
return router;
}
function createRouter() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
singletonRouter.router = new _router.default(...args);
singletonRouter.readyCallbacks.forEach((cb)=>cb());
singletonRouter.readyCallbacks = [];
return singletonRouter.router;
}
function makePublicRouterInstance(router) {
const scopedRouter = router;
const instance = {};
for (const property of urlPropertyFields){
if (typeof scopedRouter[property] === 'object') {
instance[property] = Object.assign(Array.isArray(scopedRouter[property]) ? [] : {}, scopedRouter[property]) // makes sure query is not stateful
;
continue;
}
instance[property] = scopedRouter[property];
}
// Events is a static property on the router, the router doesn't have to be initialized to use it
instance.events = _router.default.events;
coreMethodFields.forEach((field)=>{
instance[field] = function() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
return scopedRouter[field](...args);
};
});
return instance;
}
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=router.js.map