crelte 0.4.7 → 0.5.0-alpha.1

package/dist/routing/ClientRouter.js

@@ -0,0 +1,259 @@
+import BaseRouter from './BaseRouter.js';
+export default class ClientRouter extends BaseRouter {
+    scrollDebounceTimeout;
+    preloadOnMouseOver;
+    onError;
+    constructor(sites, opts) {
+        super(sites, opts);
+        this.scrollDebounceTimeout = null;
+        this.preloadOnMouseOver = opts.preloadOnMouseOver;
+        this.onError = () => { };
+    }
+    /**
+     * ## Throws
+     */
+    async init() {
+        this.listen();
+        // let's first try to load from the state
+        const req = this.targetToRequest(window.location.href);
+        req._fillFromState(window.history.state);
+        req.origin = 'init';
+        window.history.scrollRestoration = 'manual';
+        return await this.handleRequest(req, () => { });
+    }
+    /**
+     * Do not call this with origin push or replace
+     */
+    async openRequest(req) {
+        if (['push', 'replace'].includes(req.origin)) {
+            throw new Error('Do not use open with push or replace');
+        }
+        const current = this.route.get();
+        // store scrollY
+        if (current) {
+            // if the scrollY would still be updated we clear the timeout
+            // since we should have the latest scrollY
+            if (this.scrollDebounceTimeout) {
+                clearTimeout(this.scrollDebounceTimeout);
+                this.scrollDebounceTimeout = null;
+            }
+            // store the scroll position
+            const scrollY = window.scrollY;
+            if (typeof scrollY === 'number') {
+                current.scrollY = scrollY;
+                window.history.replaceState(current._toState(), '');
+            }
+        }
+        // if the domain of the current site is different than the domain of the
+        // new site we need to do a window.location.href call
+        if ((current && current.url.origin !== req.url.origin) ||
+            // @ts-ignore
+            import.meta.env.SSR) {
+            window.location.href = req.url.href;
+            return;
+        }
+        req.index = (current?.index ?? 0) + 1;
+        return await this.handleRequestAndError(req, route => {
+            const url = route.url;
+            window.history.pushState(route._toState(), '', url.pathname + url.search + url.hash);
+        });
+    }
+    async pushRequest(req, _opts = {}) {
+        const url = req.url;
+        // todo a push should also store the previous scrollY
+        let nReq = req;
+        if (req.scrollY === null) {
+            // if there is no scrollY stored we store the current scrollY
+            // since a push does not cause a scroll top
+            // todo: probably should refactor something probably
+            // should not be here
+            nReq = req.clone();
+            nReq.scrollY = window.scrollY;
+            // todo this does not work? nReq is never used
+            // why not assign it without a clone?
+        }
+        return await this.handleRequest(req, route => {
+            window.history.pushState(route._toState(), url.pathname + url.search + url.hash);
+        });
+    }
+    async replaceRequest(req, _opts = {}) {
+        const url = req.url;
+        let nReq = req;
+        if (req.scrollY === null) {
+            // if there is no scrollY stored we store the current scrollY
+            // since a replace does not cause a scrollTo and we wan't
+            // history back to work as intended
+            // todo: probably should refactor something probably
+            // should not be here
+            nReq = req.clone();
+            nReq.scrollY = window.scrollY;
+            // todo this does not work? nReq is never used
+            // why not assign it without a clone?
+        }
+        try {
+            return await this.handleRequest(req, () => {
+                window.history.replaceState(req._toState(), url.pathname + url.search + url.hash);
+            });
+        }
+        catch (e) {
+            console.warn('replacing route failed', e);
+            throw e;
+        }
+    }
+    /**
+     * This returns a route if it was handled else if an error occured
+     * or the request was cancelled returns void
+     */
+    async handleRequestAndError(req, updateHistory) {
+        try {
+            return await this.handleRequest(req, updateHistory);
+        }
+        catch (e) {
+            console.error('request failed', e);
+            this.onError(e);
+        }
+    }
+    listen() {
+        window.addEventListener('click', async (e) => {
+            // @ts-ignore
+            const link = e.target.closest('a');
+            const openInNewTab = e.metaKey || e.ctrlKey || e.shiftKey;
+            const saveLink = e.altKey;
+            if (!link || !link.href || openInNewTab || saveLink)
+                return;
+            if (link.target.toLowerCase() === '_blank')
+                return;
+            if (!link.href.startsWith('http'))
+                return;
+            e.preventDefault();
+            const req = this.targetToRequest(link.href, { origin: 'click' });
+            const currRoute = this.route.get();
+            const routeEq = currRoute && currRoute.eqUrl(req) && currRoute.eqSearch(req);
+            // this means the route is the same maybe with a different hash
+            // so it is not necessary to load the data again
+            if (routeEq) {
+                req.disableLoadData = true;
+            }
+            this.openRequest(req);
+        });
+        if (this.preloadOnMouseOver) {
+            let currentMouseOver = null;
+            window.addEventListener('mouseover', e => {
+                // @ts-ignore
+                const link = e.target.closest('a');
+                if (currentMouseOver && link === currentMouseOver)
+                    return;
+                if (link && link.target.toLowerCase() === '_blank')
+                    return;
+                if (link &&
+                    !link.hasAttribute('data-no-preload') &&
+                    link.href) {
+                    this.preload(link.href);
+                }
+                currentMouseOver = link;
+            });
+        }
+        // store the scrollY position every 200ms
+        // we can't do this at the time of the open call since the pop event
+        // has already changed to a new history state so we can't update our
+        // current/previous state
+        // eslint-disable-next-line no-constant-condition
+        if (true) {
+            window.addEventListener('scroll', () => {
+                const current = this.route.get();
+                if (!current)
+                    return;
+                // store the scroll position
+                current.scrollY = window.scrollY;
+                if (this.scrollDebounceTimeout)
+                    return;
+                // this might cause `Attempt to use history.replaceState() more than
+                // 100 times per 30 seconds` in safari
+                // since we wait a moment we should almost ever be fine
+                this.scrollDebounceTimeout = setTimeout(() => {
+                    const routerRoute = this.route.get();
+                    if (!routerRoute || !current.eq(routerRoute))
+                        return;
+                    // use the latest state
+                    window.history.replaceState(routerRoute._toState(), '');
+                    if (current.inLivePreview()) {
+                        sessionStorage.setItem('live-preview-scroll', 
+                        // use the latest scrollY
+                        routerRoute.scrollY + '');
+                    }
+                    this.scrollDebounceTimeout = null;
+                }, 280);
+            });
+        }
+        window.addEventListener('popstate', async (e) => {
+            if (!e.state?.route)
+                return;
+            const req = this.targetToRequest(window.location.href);
+            req._fillFromState(e.state);
+            req.origin = 'pop';
+            // todo handle errors
+            this.handleRequest(req, () => { });
+        });
+    }
+    updateScroll(cr, _route) {
+        const req = cr.req;
+        if (req.disableScroll)
+            return;
+        // scroll to target
+        let scrollTo = null;
+        // if the route is a live preview init and we have a scrollY stored
+        // scroll to that
+        if (req.inLivePreview()) {
+            const scrollY = sessionStorage.getItem('live-preview-scroll');
+            if (scrollY) {
+                scrollTo = {
+                    top: parseInt(scrollY),
+                    behavior: 'instant',
+                };
+            }
+            // if we have a hash and the route was not visited
+        }
+        else if (req.hash &&
+            ((req.origin === 'init' && typeof req.scrollY !== 'number') ||
+                req.origin === 'click')) {
+            const el = document.getElementById(req.hash.substring(1));
+            if (el) {
+                scrollTo = {
+                    intoView: el,
+                    behavior: 'smooth',
+                };
+            }
+        }
+        // restore scroll position
+        if (!scrollTo &&
+            req.origin !== 'click' &&
+            typeof req.scrollY === 'number') {
+            scrollTo = {
+                top: req.scrollY,
+                behavior: 'instant',
+            };
+        }
+        // make sure push and replace don't cause a scroll if it is not intended
+        if (!scrollTo && (req.origin === 'push' || req.origin === 'replace'))
+            return;
+        // scroll to the top if nothing else matches
+        if (!scrollTo) {
+            scrollTo = {
+                top: 0,
+                behavior: 'instant',
+            };
+        }
+        if ('top' in scrollTo) {
+            window.scrollTo({
+                top: scrollTo.top,
+                behavior: scrollTo.behavior,
+            });
+        }
+        else {
+            scrollTo.intoView.scrollIntoView({
+                behavior: scrollTo.behavior,
+                block: 'start',
+            });
+        }
+    }
+}

package/dist/routing/LoadRunner.d.ts

@@ -0,0 +1,39 @@
+import { type CrelteRequest } from '../index.js';
+export type LoadRunnerOptions = {
+    debugTiming: boolean;
+};
+export type LoadFn = (cr: CrelteRequest, opts: LoadOptions) => Promise<void> | void;
+export type LoadOptions = {
+    setProgress: (num: number) => void;
+    isCanceled: () => boolean;
+};
+/**
+ * The PageLoader which is responsible for loading page Data
+ */
+export default class LoadRunner {
+    private debugTiming;
+    private preloadedUrls;
+    private loadingVersion;
+    onProgress: (loading: boolean, progress?: number) => void;
+    loadFn: LoadFn;
+    /**
+     * Creates a new PageLoader
+     *
+     * @param {Object} options `{debugTiming}`
+     */
+    constructor(options: LoadRunnerOptions);
+    /**
+     * Discard the current page load if one is happening
+     */
+    discard(): void;
+    /**
+     * @returns true if the load was completed
+     *
+     * ## Throws
+     * if there was an error but not if the request
+     * was cancelled before
+     */
+    load(req: CrelteRequest): Promise<boolean>;
+    preload(cr: CrelteRequest): Promise<void>;
+}
+//# sourceMappingURL=LoadRunner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LoadRunner.d.ts","sourceRoot":"","sources":["../../src/routing/LoadRunner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,MAAM,MAAM,iBAAiB,GAAG;IAC/B,WAAW,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,CACpB,EAAE,EAAE,aAAa,EACjB,IAAI,EAAE,WAAW,KACb,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE1B,MAAM,MAAM,WAAW,GAAG;IACzB,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,UAAU,EAAE,MAAM,OAAO,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC9B,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,aAAa,CAAc;IAEnC,OAAO,CAAC,cAAc,CAAS;IAE/B,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1D,MAAM,EAAE,MAAM,CAAC;IAEf;;;;OAIG;gBACS,OAAO,EAAE,iBAAiB;IAUtC;;OAEG;IACH,OAAO;IAKP;;;;;;OAMG;IACG,IAAI,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IAuC1C,OAAO,CAAC,EAAE,EAAE,aAAa;CAiB/B"}

package/dist/routing/{PageLoader.js → LoadRunner.js}

@@ -1,11 +1,10 @@
 /**
  * The PageLoader which is responsible for loading page Data
  */
-export default class PageLoader {
+export default class LoadRunner {
     debugTiming;
     preloadedUrls;
     loadingVersion;
-    onLoaded;
     onProgress;
     loadFn;
     /**
@@ -17,7 +16,6 @@ export default class PageLoader {
         this.debugTiming = options.debugTiming;
         this.preloadedUrls = new Set();
         this.loadingVersion = 0;
-        this.onLoaded = () => null;
         this.onProgress = () => null;
         this.loadFn = () => null;
     }
@@ -28,43 +26,57 @@ export default class PageLoader {
         this.loadingVersion++;
         this.onProgress(false);
     }
-    async load(req, more) {
+    /**
+     * @returns true if the load was completed
+     *
+     * ## Throws
+     * if there was an error but not if the request
+     * was cancelled before
+     */
+    async load(req) {
         this.onProgress(true);
         const version = ++this.loadingVersion;
         const startTime = this.debugTiming ? Date.now() : null;
+        const isCanceled = () => this.loadingVersion !== version;
         const setProgress = (num) => {
-            if (this.loadingVersion !== version)
+            if (isCanceled())
                 return;
             this.onProgress(true, num);
         };
-        const resp = { success: false, data: null };
+        // a function which should return the response
+        let resp;
         try {
-            resp.data = await this.loadFn(req, { setProgress });
-            resp.success = true;
+            const data = await this.loadFn(req, { isCanceled, setProgress });
+            resp = () => data;
         }
         catch (e) {
-            resp.success = false;
-            resp.data = e;
+            resp = () => {
+                throw e;
+            };
+        }
+        if (isCanceled()) {
+            console.log('route changed quickly, ignoring response');
+            return false;
         }
+        this.onProgress(false);
         if (startTime)
             console.log('page load took ' + (Date.now() - startTime) + 'ms');
-        // if were the last that called loading, trigger the loaded event
-        if (this.loadingVersion !== version)
-            return console.log('route changed quickly, ignoring response');
-        this.onProgress(false);
-        this.onLoaded(resp, req, more);
+        return (resp(), true);
     }
     // you don't need to wait on this call
-    async preload(req) {
-        const url = req.url.origin + req.url.pathname;
+    async preload(cr) {
+        const url = cr.req.url.origin + cr.req.url.pathname;
         if (this.preloadedUrls.has(url))
             return;
         this.preloadedUrls.add(url);
         try {
-            await this.loadFn(req, { setProgress: () => null });
+            await this.loadFn(cr, {
+                isCanceled: () => false,
+                setProgress: () => null,
+            });
         }
-        catch (_e) {
-            console.log('preload failed');
+        catch (e) {
+            console.log('preload failed', e);
             // retry at another time
             this.preloadedUrls.delete(url);
         }

package/dist/routing/Request.d.ts

@@ -1,10 +1,15 @@
 import { Barrier } from 'crelte-std/sync';
-import Route, { RouteOrigin } from './Route.js';
 import Site from './Site.js';
+import { Entry } from '../entry/index.js';
+import BaseRoute, { RouteOrigin } from './BaseRoute.js';
+import Route, { TemplateModule } from './Route.js';
 /**
  * Options to create a Request
  */
 export type RequestOptions = {
+    entry?: Entry;
+    template?: TemplateModule;
+    loadedData?: Record<string, any>;
     scrollY?: number;
     index?: number;
     origin?: RouteOrigin;
@@ -19,7 +24,19 @@ export type RequestOptions = {
  * you get a Request from the onRequest event or
  * in a loadGlobal function.
  */
-export default class Request extends Route {
+export default class Request extends BaseRoute {
+    /**
+     * The entry of the request once loaded
+     */
+    entry: Entry | null;
+    /**
+     * The template module of the request once loaded
+     */
+    template: TemplateModule | null;
+    /**
+     * The loaded data of the request
+     */
+    loadedData: Record<string, any> | null;
     /**
      * Disable scrolling for this request
      * @default false
@@ -36,14 +53,19 @@ export default class Request extends Route {
     statusCode: number | null;
     /** @hidden */
     _renderBarrier: RenderBarrier;
+    private _cancelled;
     /**
      * Create a new Request
      */
     constructor(url: string | URL, site: Site, opts?: RequestOptions);
     /**
      * Create a Request from a Route
+     *
+     * Clears the entry, template, and loadedData
+     * todo should it?
      */
     static fromRoute(route: Route, opts?: RequestOptions): Request;
+    get cancelled(): boolean;
     /**
      * With delayRender you can make sure that the render waits
      * until you are ready. This is useful for building page transitions.
@@ -75,14 +97,24 @@ export default class Request extends Route {
     delayRender(): DelayRender;
     /**
      * Create a copy of the request
+     *
+     * without including the entry, template, loadedData or cancelled state
+     *
+     * Is this what we wan't, maybe it should copy everything
      */
     clone(): Request;
     /**
      * Create a Route from the Request
+     *
+     * ## Throws
+     * if the entry, template or loadedData is missing
+     * or the request was cancelled
      */
     toRoute(): Route;
     /** @hidden */
     _updateOpts(opts?: RequestOptions): void;
+    /** @hidden */
+    _cancel(): void;
 }
 export declare function isRequest(req: any): req is Request;
 declare class RenderBarrier {
@@ -95,7 +127,7 @@ declare class RenderBarrier {
     /** @hidden */
     cancel(): void;
     /** @hidden */
-    ready(): Promise<boolean>;
+    ready(): Promise<boolean> | boolean;
 }
 /**
  * DelayRender is returned by `Request.delayRender`

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

@@ -1 +1 @@
-{"version":3,"file":"Request.d.ts","sourceRoot":"","sources":["../../src/routing/Request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,IAAI,MAAM,WAAW,CAAC;AAG7B;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,OAAQ,SAAQ,KAAK;IACzC;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B,cAAc;IACd,cAAc,EAAE,aAAa,CAAC;IAE9B;;OAEG;gBACS,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAE,cAAmB;IASpE;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,cAAmB;IAWxD;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,WAAW,IAAI,WAAW;IAI1B;;OAEG;IACH,KAAK;IAaL;;OAEG;IACH,OAAO;IAUP,cAAc;IACd,WAAW,CAAC,IAAI,GAAE,cAAmB;CAUrC;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,OAAO,CAElD;AAED,cAAM,aAAa;IAClB,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,WAAW,CAAC;;IAQlB,MAAM,IAAI,OAAO;IAIjB,GAAG,IAAI,WAAW;IAclB,cAAc;IACd,MAAM;IAQN,cAAc;IACd,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;CAGzB;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACzB;;;;;OAKG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9B;;OAEG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC"}
+{"version":3,"file":"Request.d.ts","sourceRoot":"","sources":["../../src/routing/Request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,SAAS,EAAE,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC5B,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,OAAQ,SAAQ,SAAS;IAC7C;;OAEG;IACH,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAEpB;;OAEG;IACH,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAEhC;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IAEvC;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B,cAAc;IACd,cAAc,EAAE,aAAa,CAAC;IAE9B,OAAO,CAAC,UAAU,CAAU;IAE5B;;OAEG;gBACS,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAE,cAAmB;IAapE;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,cAAmB;IAWxD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,WAAW,IAAI,WAAW;IAI1B;;;;;;OAMG;IACH,KAAK;IAsBL;;;;;;OAMG;IACH,OAAO;IA8BP,cAAc;IACd,WAAW,CAAC,IAAI,GAAE,cAAmB;IAiBrC,cAAc;IACd,OAAO;CAIP;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,OAAO,CAElD;AAED,cAAM,aAAa;IAClB,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,WAAW,CAAC;;IAQlB,MAAM,IAAI,OAAO;IAIjB,GAAG,IAAI,WAAW;IAclB,cAAc;IACd,MAAM;IAWN,cAAc;IACd,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO;CAGnC;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACzB;;;;;OAKG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9B;;OAEG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC"}

package/dist/routing/Request.js

@@ -1,12 +1,25 @@
 import { Barrier } from 'crelte-std/sync';
-import Route from './Route.js';
 import { objClone } from '../utils.js';
+import BaseRoute from './BaseRoute.js';
+import Route from './Route.js';
 /**
  * A Request is a Route with some extra options
  * you get a Request from the onRequest event or
  * in a loadGlobal function.
  */
-export default class Request extends Route {
+export default class Request extends BaseRoute {
+    /**
+     * The entry of the request once loaded
+     */
+    entry;
+    /**
+     * The template module of the request once loaded
+     */
+    template;
+    /**
+     * The loaded data of the request
+     */
+    loadedData;
     /**
      * Disable scrolling for this request
      * @default false
@@ -23,18 +36,26 @@ export default class Request extends Route {
     statusCode;
     /** @hidden */
     _renderBarrier;
+    _cancelled;
     /**
      * Create a new Request
      */
     constructor(url, site, opts = {}) {
         super(url, site, opts);
+        this.entry = opts.entry ?? null;
+        this.template = opts.template ?? null;
+        this.loadedData = opts.loadedData ?? null;
         this.disableScroll = opts.disableScroll ?? false;
         this.disableLoadData = opts.disableLoadData ?? false;
         this.statusCode = opts.statusCode ?? null;
         this._renderBarrier = new RenderBarrier();
+        this._cancelled = false;
     }
     /**
      * Create a Request from a Route
+     *
+     * Clears the entry, template, and loadedData
+     * todo should it?
      */
     static fromRoute(route, opts = {}) {
         return new Request(route.url.href, route.site, {
@@ -46,6 +67,9 @@ export default class Request extends Route {
             ...opts,
         });
     }
+    get cancelled() {
+        return this._cancelled;
+    }
     /**
      * With delayRender you can make sure that the render waits
      * until you are ready. This is useful for building page transitions.
@@ -79,9 +103,20 @@ export default class Request extends Route {
     }
     /**
      * Create a copy of the request
+     *
+     * without including the entry, template, loadedData or cancelled state
+     *
+     * Is this what we wan't, maybe it should copy everything
      */
     clone() {
-        return new Request(this.url.href, this.site, {
+        // todo should this clone the entry
+        // the route for example does not do it
+        //
+        // todo should this clone keep the entry?
+        const req = new Request(this.url.href, this.site, {
+            // entry: objClone(this.entry),
+            // template: this.template ?? undefined,
+            // loadedData: objClone(this.loadedData),
             scrollY: this.scrollY ?? undefined,
             index: this.index,
             origin: this.origin,
@@ -91,21 +126,37 @@ export default class Request extends Route {
             disableLoadData: this.disableLoadData,
             statusCode: this.statusCode ?? undefined,
         });
+        return req;
     }
     /**
      * Create a Route from the Request
+     *
+     * ## Throws
+     * if the entry, template or loadedData is missing
+     * or the request was cancelled
      */
     toRoute() {
-        return new Route(this.url.href, this.site, {
+        if (this.cancelled)
+            throw new Error('cannot create a new route because it was cancelled');
+        if (!this.entry || !this.template || !this.loadedData)
+            throw new Error('cannot create a new route because entry, template or loadedData is missing');
+        const route = new Route(this.url.href, this.site, this.entry, this.template, this.loadedData, {
             scrollY: this.scrollY ?? undefined,
             index: this.index,
             origin: this.origin,
             state: objClone(this._state),
             context: this._context,
         });
+        route.entryChanged = !this.disableLoadData;
+        return route;
     }
     /** @hidden */
     _updateOpts(opts = {}) {
+        // todo maybe should check that if entry is updated
+        // template and loadedData is also updated
+        this.entry = opts.entry ?? this.entry;
+        this.template = opts.template ?? this.template;
+        this.loadedData = opts.loadedData ?? this.loadedData;
         this.scrollY = opts.scrollY ?? this.scrollY;
         this.index = opts.index ?? this.index;
         this.origin = opts.origin ?? this.origin;
@@ -115,6 +166,11 @@ export default class Request extends Route {
         this.disableLoadData = opts.disableLoadData ?? this.disableLoadData;
         this.statusCode = opts.statusCode ?? this.statusCode;
     }
+    /** @hidden */
+    _cancel() {
+        this._cancelled = true;
+        this._renderBarrier.cancel();
+    }
 }
 export function isRequest(req) {
     return typeof req === 'object' && req !== null && req instanceof Request;
@@ -147,12 +203,15 @@ class RenderBarrier {
     }
     /** @hidden */
     cancel() {
+        // if the barrier is already open
+        // we don't wan't to flag the render as cancelled
+        // because it already happened
         if (this.inner.isOpen())
             return;
         this.cancelled = true;
         this.root.remove();
     }
-    // returns if the render was cancelled
+    // returns true if the render was cancelled
     /** @hidden */
     ready() {
         return this.root.ready();