crelte 0.4.8 → 0.5.0-alpha.2

package/dist/routing/Router.d.ts

@@ -1,12 +1,8 @@
-import Route from './Route.js';
-import Site, { SiteFromGraphQl } from './Site.js';
-import { LoadFn } from './PageLoader.js';
 import { Readable } from 'crelte-std/stores';
-import Request, { RequestOptions } from './Request.js';
-export type RouterOptions = {
-    preloadOnMouseOver?: boolean;
-    debugTiming?: boolean;
-};
+import BaseRouter from './BaseRouter.js';
+import { Request, RequestOptions, Route, Site } from './index.js';
+import { Entry } from '../entry/index.js';
+import CrelteRequest from '../CrelteRequest.js';
 /**
  * Allows to easely modify a Request
  *
@@ -18,72 +14,52 @@ export type RouterOptions = {
  * ```
  */
 export type UpdateRequest = (req: Request) => boolean | null | undefined | void;
-/**
- * internal only
- */
-type Internal = {
-    onLoaded: (success: boolean, req: Request, ready: () => any) => void;
-    onNothingLoaded: (req: Request, ready: () => void) => void;
-    onLoad: LoadFn;
-    domReady: (req: Request) => void;
-    initClient: () => void;
-    initServer: (url: string, acceptLang?: string) => Promise<ServerInited>;
-};
-type ServerInited = {
-    success: boolean;
-    redirect: boolean;
-    req: Request;
-    props: any;
-};
 export default class Router {
+    private inner;
+    private _request;
+    constructor(inner: BaseRouter);
     /**
-     * The current route
+     * returns a store with the current route
      *
      * ## Note
-     * Will always contain a route expect in the first loadData call
+     * Will always contain a route except in the first loadData call this
+     * is intentional since you will get the wrong route in a loadData call.
+     * In a loadData you should always use the `CrelteRequest` provided
+     * in each loadData call.
      */
-    private _route;
+    get route(): Readable<Route | null>;
     /**
-     * The current site
+     * returns a store with the current site
      *
      * ## Note
-     * Will always contain a site expect in the first loadData call
-     */
-    private _site;
-    private _request;
-    /**
-     * The loading flag, specifies if a page is currently
-     * getting loaded
-     */
-    private _loading;
-    /**
-     * The loading progress, the value is between 0 and 1
+     * Will always contain a site except in the first loadData call this
+     * is intentional since you might get the wrong site if a site switch
+     * is happening and you call this in loadData. If possible use the CrelteRequest
+     * provided in each loadData call.
+     *
+     * Else use `router.site.get() ?? router.req.site`
      */
-    private _loadingProgress;
-    private _onRequest;
-    /** @hidden */
-    _internal: Internal;
-    private inner;
-    private pageLoader;
-    constructor(sites: SiteFromGraphQl[], opts?: RouterOptions);
+    get site(): Readable<Site | null>;
     /**
-     * returns a store with the current route
+     * returns a store with the current entry
      *
      * ## Note
-     * Will always contain a route expect in the first loadData call
-     *
-     * Consider to use CrelteRequest instead
+     * Will always contain an entry except in the first loadData call this
+     * is intentional since you might get the wrong entry if a request is happening
+     * and you call this in loadData. If possible use the CrelteRequest
+     * provided in each loadData call.
      */
-    get route(): Readable<Route | null>;
+    get entry(): Readable<Entry | null>;
     /**
-     * returns a store with the current site
+     * returns the latest request in progress otherwise returns null.
      *
-     * ## Note
-     * Will always contain a site expect in the first loadData call
-     *
-     * Consider to use CrelteRequest instead
+     * ## Important !!
+     * If at all possible prefer using the `CrelteRequest` provided in each
+     * loadData call. For example in a preload request this will return null.
+     * Or a user has clicked multiple times on different links you might get
+     * the url of the newer request.
      */
-    get site(): Readable<Site | null>;
+    get req(): Request | null;
     /**
      * The sites which are available
      */
@@ -117,7 +93,7 @@ export default class Router {
      * // the following page will be opened https://example.com/de/foo/bar
      * ```
      */
-    open(target: string | URL | Route | Request | UpdateRequest, opts?: RequestOptions): void;
+    open(target: string | URL | Route | Request | UpdateRequest, opts?: RequestOptions): Promise<Route | void>;
     /**
      * This pushes the new route without triggering a new pageload
      *
@@ -151,7 +127,7 @@ export default class Router {
      * router.push(route);
      * ```
      */
-    push(route: Route | Request | UpdateRequest, opts?: RequestOptions): void;
+    push(route: Route | Request | UpdateRequest, opts?: RequestOptions): Promise<void | Route>;
     /**
      * @deprecated use push instead
      */
@@ -188,17 +164,21 @@ export default class Router {
      * router.replace(route);
      * ```
      */
-    replace(route: Route | Request | UpdateRequest, opts?: RequestOptions): void;
+    replace(route: Route | Request | UpdateRequest, opts?: RequestOptions): Promise<void | Route>;
     /**
      * @deprecated use replace instead
      */
     replaceState(route: Route | Request): void;
     /**
      * Checks if there are previous routes which would allow it to go back
+     *
+     * On the server this will always return false
      */
     canGoBack(): boolean;
     /**
      * Go back in the history
+     *
+     * On the server this throw an error
      */
     back(): void;
     /**
@@ -210,7 +190,7 @@ export default class Router {
      *
      * This will trigger every time a new route is set
      * and is equivalent to router.route.subscribe(fn)
-     * expect that it will not trigger instantly
+     * except that it will not trigger instantly
      *
      * @returns a function to remove the listener
      */
@@ -222,7 +202,7 @@ export default class Router {
      *
      * @returns a function to remove the listener
      */
-    onRequest(fn: (req: Request) => void): () => void;
+    onRequest(fn: (req: CrelteRequest) => void): () => void;
     /**
      * Resolve a url or Route and convert it to a Request
      *
@@ -231,21 +211,17 @@ export default class Router {
      * @return Returns null if the url does not match our host (the protocol get's ignored)
      */
     targetToRequest(target: string | URL | Route | Request, opts?: RequestOptions): Request;
-    private setNewRoute;
-    private _initClient;
-    private _initServer;
-    private _onRoute;
-    private destroyRequest;
-    private _onPreload;
-    private _onLoaded;
-    private _onNothingLoaded;
-    private _onProgress;
     /**
      * Transforms a target to a request
      *
      * returns null if the request was canceled by the update request
      */
     private targetOrUpdateToRequest;
+    /**
+     * @hidden
+     * call this after creating a CrelteRequest
+     */
+    _toRequest(req: Request): Router;
+    _requestCompleted(): void;
 }
-export {};
 //# sourceMappingURL=Router.d.ts.map

package/dist/routing/Router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Router.d.ts","sourceRoot":"","sources":["../../src/routing/Router.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Router.d.ts","sourceRoot":"","sources":["../../src/routing/Router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,UAAU,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,aAAa,MAAM,qBAAqB,CAAC;AAEhD;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC;AAIhF,MAAM,CAAC,OAAO,OAAO,MAAM;IAC1B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,QAAQ,CAAiB;gBAErB,KAAK,EAAE,UAAU;IAK7B;;;;;;;;OAQG;IACH,IAAI,KAAK,IAAI,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,CAElC;IAED;;;;;;;;;;OAUG;IACH,IAAI,IAAI,IAAI,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC,CAEhC;IAED;;;;;;;;OAQG;IACH,IAAI,KAAK,IAAI,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,CAElC;IAED;;;;;;;;OAQG;IACH,IAAI,GAAG,IAAI,OAAO,GAAG,IAAI,CAMxB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,IAAI,EAAE,CAElB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,QAAQ,CAAC,OAAO,CAAC,CAE/B;IAED;;OAEG;IACH,IAAI,eAAe,IAAI,QAAQ,CAAC,MAAM,CAAC,CAEtC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,IAAI,CACT,MAAM,EAAE,MAAM,GAAG,GAAG,GAAG,KAAK,GAAG,OAAO,GAAG,aAAa,EACtD,IAAI,GAAE,cAAmB,GACvB,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAOxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,IAAI,CACT,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,aAAa,EACtC,IAAI,GAAE,cAAmB;IAQ1B;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAKhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,OAAO,CACZ,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,aAAa,EACtC,IAAI,GAAE,cAAmB;IAU1B;;OAEG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAKnC;;;;OAIG;IACH,SAAS,IAAI,OAAO;IAIpB;;;;OAIG;IACH,IAAI;IAIJ;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,GAAG,KAAK;IAIpC;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IAI/C;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,IAAI,GAAG,MAAM,IAAI;IAIvD;;;;;;OAMG;IACH,eAAe,CACd,MAAM,EAAE,MAAM,GAAG,GAAG,GAAG,KAAK,GAAG,OAAO,EACtC,IAAI,GAAE,cAAmB,GACvB,OAAO;IAIV;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;;OAGG;IACH,UAAU,CAAC,GAAG,EAAE,OAAO;IAMvB,iBAAiB;CAGjB"}

package/dist/routing/Router.js

@@ -1,96 +1,65 @@
-import InnerRouter from './InnerRouter.js';
-import PageLoader from './PageLoader.js';
-import { Writable } from 'crelte-std/stores';
-import { Listeners } from 'crelte-std/sync';
-import Request from './Request.js';
-const defaultRouterOpts = {
-    preloadOnMouseOver: false,
-    debugTiming: false,
-};
-// Make sure route and nextRoute are not the same object as _inner.route
+// Todo this router should be stateful like globals
+// allow to reference the correct route or request
 export default class Router {
-    /**
-     * The current route
-     *
-     * ## Note
-     * Will always contain a route expect in the first loadData call
-     */
-    _route;
-    /**
-     * The current site
-     *
-     * ## Note
-     * Will always contain a site expect in the first loadData call
-     */
-    _site;
-    // the next request, just here to destroy it
-    _request;
-    /**
-     * The loading flag, specifies if a page is currently
-     * getting loaded
-     */
-    _loading;
-    /**
-     * The loading progress, the value is between 0 and 1
-     */
-    _loadingProgress;
-    _onRequest;
-    /** @hidden */
-    _internal;
     inner;
-    pageLoader;
-    constructor(sites, opts = {}) {
-        opts = { ...defaultRouterOpts, ...opts };
-        this.inner = new InnerRouter(sites, {
-            preloadOnMouseOver: opts.preloadOnMouseOver,
-        });
-        this.pageLoader = new PageLoader({
-            debugTiming: opts.debugTiming,
-        });
-        // in the first onRoute call we will update this value
-        this._route = new Writable(null);
-        this._site = new Writable(null);
+    _request;
+    constructor(inner) {
+        this.inner = inner;
         this._request = null;
-        this._loading = new Writable(false);
-        this._loadingProgress = new Writable(0);
-        this._onRequest = new Listeners();
-        // these functions are exposed to the init "module"
-        // but should not be used by anybody else
-        this._internal = {
-            onLoaded: () => { },
-            onNothingLoaded: () => { },
-            onLoad: () => { },
-            domReady: req => this.inner.domReady(req),
-            initClient: () => this._initClient(),
-            initServer: (url, acceptLang) => this._initServer(url, acceptLang),
-        };
-        this.inner.onRoute = (route, changeHistory) => this._onRoute(route, changeHistory);
-        this.inner.onPreload = route => this._onPreload(route);
-        this.pageLoader.onLoaded = (resp, req, more) => this._onLoaded(resp, req, more);
-        this.pageLoader.loadFn = (req, opts) => this._internal.onLoad(req, opts);
-        this.pageLoader.onProgress = (loading, progress) => this._onProgress(loading, progress);
     }
     /**
      * returns a store with the current route
      *
      * ## Note
-     * Will always contain a route expect in the first loadData call
-     *
-     * Consider to use CrelteRequest instead
+     * Will always contain a route except in the first loadData call this
+     * is intentional since you will get the wrong route in a loadData call.
+     * In a loadData you should always use the `CrelteRequest` provided
+     * in each loadData call.
      */
     get route() {
-        return this._route.readclone();
+        return this.inner.route.readclone();
     }
     /**
      * returns a store with the current site
      *
      * ## Note
-     * Will always contain a site expect in the first loadData call
+     * Will always contain a site except in the first loadData call this
+     * is intentional since you might get the wrong site if a site switch
+     * is happening and you call this in loadData. If possible use the CrelteRequest
+     * provided in each loadData call.
      *
-     * Consider to use CrelteRequest instead
+     * Else use `router.site.get() ?? router.req.site`
      */
     get site() {
-        return this._site.readonly();
+        return this.inner.site.readonly();
+    }
+    /**
+     * returns a store with the current entry
+     *
+     * ## Note
+     * Will always contain an entry except in the first loadData call this
+     * is intentional since you might get the wrong entry if a request is happening
+     * and you call this in loadData. If possible use the CrelteRequest
+     * provided in each loadData call.
+     */
+    get entry() {
+        return this.inner.entry.readonly();
+    }
+    /**
+     * returns the latest request in progress otherwise returns null.
+     *
+     * ## Important !!
+     * If at all possible prefer using the `CrelteRequest` provided in each
+     * loadData call. For example in a preload request this will return null.
+     * Or a user has clicked multiple times on different links you might get
+     * the url of the newer request.
+     */
+    get req() {
+        // this._request is not used because that could be a weird
+        // behaviour for the user
+        // we will use that however internally
+        // todo maybe reconsider this?
+        return this.inner.request;
     }
     /**
      * The sites which are available
@@ -102,13 +71,13 @@ export default class Router {
      * returns a store which indicates if the a page is loading
      */
     get loading() {
-        return this._loading.readonly();
+        return this.inner.loading.readonly();
     }
     /**
      * returns a store which indicates the loading progress between 0 and 1
      */
     get loadingProgress() {
-        return this._loadingProgress.readonly();
+        return this.inner.loadingProgress.readonly();
     }
     /**
      * Open a new route
@@ -131,17 +100,11 @@ export default class Router {
      * // the following page will be opened https://example.com/de/foo/bar
      * ```
      */
-    open(target, opts = {}) {
-        const req = this.targetOrUpdateToRequest(target, opts, {
-            origin: 'manual',
-        });
+    async open(target, opts = {}) {
+        const req = this.targetOrUpdateToRequest(target, opts);
         if (!req)
             return;
-        if (req === this._request) {
-            throw new Error('Cannot open the same request object twice. Either clone the request ' +
-                'or just pass in the url.');
-        }
-        this.inner.open(req);
+        return await this.inner.open(req);
     }
     /**
      * This pushes the new route without triggering a new pageload
@@ -176,20 +139,11 @@ export default class Router {
      * router.push(route);
      * ```
      */
-    push(route, opts = {}) {
-        // todo not sure if that is what we want?
-        if (import.meta.env.SSR)
-            return this.open(route, opts);
-        // theoretically string and URL also work but we might
-        // change that in the future
-        const req = this.targetOrUpdateToRequest(route, opts, {
-            origin: 'push',
-            scrollY: opts.scrollY ?? undefined,
-            disableLoadData: opts.disableLoadData ?? true,
-        });
+    async push(route, opts = {}) {
+        const req = this.targetOrUpdateToRequest(route, opts);
         if (!req)
             return;
-        this.inner.push(req);
+        return await this.inner.push(req);
     }
     /**
      * @deprecated use push instead
@@ -230,20 +184,13 @@ export default class Router {
      * router.replace(route);
      * ```
      */
-    replace(route, opts = {}) {
-        // todo not sure if that is what we want?
-        if (import.meta.env.SSR)
-            return this.open(route, opts);
-        // theoretically string and URL also work but we might
-        // change that in the future
-        const req = this.targetOrUpdateToRequest(route, opts, {
-            origin: 'replace',
-            scrollY: opts.scrollY ?? undefined,
-            disableLoadData: opts.disableLoadData ?? true,
-        });
+    async replace(route, opts = {}) {
+        const req = this.targetOrUpdateToRequest(route, opts);
         if (!req)
             return;
-        this.inner.replace(req);
+        // we don't force disableLoadData here
+        // because the user might want to reload the data
+        return await this.inner.replace(req);
     }
     /**
      * @deprecated use replace instead
@@ -254,15 +201,19 @@ export default class Router {
     }
     /**
      * Checks if there are previous routes which would allow it to go back
+     *
+     * On the server this will always return false
      */
     canGoBack() {
-        return this.inner.route?.canGoBack() ?? false;
+        return this.inner.canGoBack();
     }
     /**
      * Go back in the history
+     *
+     * On the server this throw an error
      */
     back() {
-        this.inner.history.back();
+        this.inner.back();
     }
     /**
      * Preload a url
@@ -275,13 +226,12 @@ export default class Router {
      *
      * This will trigger every time a new route is set
      * and is equivalent to router.route.subscribe(fn)
-     * expect that it will not trigger instantly
+     * except that it will not trigger instantly
      *
      * @returns a function to remove the listener
      */
     onRoute(fn) {
-        let first = true;
-        return this.route.subscribe(r => (first ? (first = false) : fn(r)));
+        return this.inner.onRouteListeners.add(fn);
     }
     /**
      * Add a listener for the onRequest event
@@ -291,7 +241,7 @@ export default class Router {
      * @returns a function to remove the listener
      */
     onRequest(fn) {
-        return this._onRequest.add(fn);
+        return this.inner.onRequestListeners.add(fn);
     }
     /**
      * Resolve a url or Route and convert it to a Request
@@ -303,155 +253,39 @@ export default class Router {
     targetToRequest(target, opts = {}) {
         return this.inner.targetToRequest(target, opts);
     }
-    setNewRoute(route) {
-        this._route.setSilent(route);
-        const siteChanged = this.site.get()?.id !== route.site.id;
-        this._site.setSilent(route.site);
-        this._route.notify();
-        if (siteChanged)
-            this._site.notify();
-    }
-    async _initClient() {
-        this.inner.initClient();
-    }
-    async _initServer(url, acceptLang) {
-        this.inner.initServer();
-        this._internal.onNothingLoaded = (_req, ready) => {
-            ready();
-        };
-        const prom = new Promise(resolve => {
-            this._internal.onLoaded = (success, req, ready) => {
-                const props = ready();
-                this._internal.onLoaded = () => { };
-                resolve({
-                    success,
-                    redirect: false,
-                    req,
-                    props,
-                });
-            };
-        });
-        const req = this.inner.targetToRequest(url);
-        req.origin = 'init';
-        // let's see if the url matches any route and site
-        // if not let's redirect to the site which matches the acceptLang
-        if (!req.siteMatches()) {
-            const site = this.inner.siteByAcceptLang(acceptLang);
-            return {
-                success: true,
-                redirect: true,
-                req: new Request(site.url, site),
-                props: {},
-            };
-        }
-        this.inner.route = req.toRoute();
-        this.inner.onRoute(req, () => { });
-        const resp = await prom;
-        const hist = this.inner.history;
-        if (hist.url || hist.req) {
-            const nReq = this.inner.targetToRequest(hist.req ?? hist.url);
-            if (!req.eq(nReq)) {
-                return {
-                    success: true,
-                    redirect: true,
-                    req: nReq,
-                    props: {},
-                };
-            }
-        }
-        return resp;
-    }
-    // gets called by the InnerRouter when a new route is requested
-    _onRoute(req, changeHistory) {
-        this.destroyRequest();
-        this._request = req;
-        const barrier = req._renderBarrier;
-        if (barrier.isOpen()) {
-            throw new Error('render barrier is already open');
-        }
-        this._onRequest.trigger(req);
-        // route prepared
-        if (!req.disableLoadData) {
-            this.pageLoader.load(req, { changeHistory });
-        }
-        else {
-            this.pageLoader.discard();
-            this._onNothingLoaded(req, { changeHistory });
-        }
-    }
-    destroyRequest() {
-        if (!this._request)
-            return;
-        this._request._renderBarrier.cancel();
-        this._request = null;
-    }
-    _onPreload(req) {
-        this.pageLoader.preload(req);
-    }
-    // gets called by the pageLoader when teh loadData completes
-    async _onLoaded(resp, req, more) {
-        // check if the render was cancelled
-        if (await req._renderBarrier.ready())
-            return;
-        // when the data is loaded let's update the route of the inner
-        // this will only happen if no other route has been requested
-        // in the meantime
-        more.changeHistory();
-        const route = req.toRoute();
-        // call the client or server saying we are ready for a new render
-        this._internal.onLoaded(resp.success, req, () => {
-            this.setNewRoute(route);
-            return resp.data;
-        });
-    }
-    // this gets called if loadData is not called
-    async _onNothingLoaded(req, more) {
-        // check if the render was cancelled
-        if (await req._renderBarrier.ready())
-            return;
-        // when the data is loaded let's update the route of the inner
-        // this is will only happen if no other route has been requested
-        // in the meantime
-        more.changeHistory();
-        const route = req.toRoute();
-        // call the client or server saying there was an update in the route
-        // but no new data was loaded so no render should happen
-        this._internal.onNothingLoaded(req, () => {
-            this.setNewRoute(route);
-        });
-    }
-    // this is called by the pageLoader if we get a progress update
-    _onProgress(loading, progress) {
-        if (this._loading.get() !== loading)
-            this._loading.set(loading);
-        if (typeof progress === 'number')
-            this._loadingProgress.set(progress);
-    }
     /**
      * Transforms a target to a request
      *
      * returns null if the request was canceled by the update request
      */
-    targetOrUpdateToRequest(target, opts = {}, forcedOpts = {}) {
+    targetOrUpdateToRequest(target, opts = {}) {
         // we have an update request
         if (typeof target === 'function') {
-            const route = this.route.get();
-            if (!route) {
+            const source = this._request ?? this.route.get();
+            if (!source) {
+                // todo should we use the request here?
                 throw new Error('route to update missing in first loadData call. ' +
-                    'Use cr.req.clone() instead');
+                    'Use `cr.router...` or `cr.req.clone()`');
             }
             // first get a req
-            const req = this.inner.targetToRequest(route, opts);
+            const req = this.inner.targetToRequest(source, opts);
             // check if the request was canceled by the update request
             if (target(req) === false)
                 return null;
-            // now we add the forcedOpts
-            req._updateOpts(forcedOpts);
             return req;
         }
-        return this.inner.targetToRequest(target, {
-            ...opts,
-            ...forcedOpts,
-        });
+        return this.inner.targetToRequest(target, opts);
+    }
+    /**
+     * @hidden
+     * call this after creating a CrelteRequest
+     */
+    _toRequest(req) {
+        const nRouter = new Router(this.inner);
+        nRouter._request = req;
+        return nRouter;
+    }
+    _requestCompleted() {
+        this._request = null;
     }
 }