Initial boiler plate project

node_modules/next/dist/client/router.js

@@ -0,0 +1,189 @@
+/* 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 new Error(message);
+    }
+    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)=>{
+    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 new Error("NextRouter was not mounted. https://nextjs.org/docs/messages/next-router-not-mounted");
+    }
+    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