@alignable/bifrost 0.0.8 → 0.0.10

package/dist/lib/turbolinks/snapshot_renderer.js

@@ -0,0 +1,139 @@
+import { Renderer } from "./renderer";
+import { array } from "./util";
+export class SnapshotRenderer extends Renderer {
+    static render(delegate, callback, currentSnapshot, newSnapshot, isPreview) {
+        return new this(delegate, currentSnapshot, newSnapshot, isPreview).render(callback);
+    }
+    constructor(delegate, currentSnapshot, newSnapshot, isPreview) {
+        super();
+        this.delegate = delegate;
+        this.currentSnapshot = currentSnapshot;
+        this.currentHeadDetails = currentSnapshot.headDetails;
+        this.newSnapshot = newSnapshot;
+        this.newHeadDetails = newSnapshot.headDetails;
+        this.newBody = newSnapshot.bodyElement;
+        this.isPreview = isPreview;
+    }
+    render(callback) {
+        if (this.shouldRender()) {
+            this.mergeHead();
+            this.renderView(() => {
+                this.replaceBody();
+                if (!this.isPreview) {
+                    this.focusFirstAutofocusableElement();
+                }
+                callback();
+            });
+        }
+        else {
+            this.invalidateView();
+        }
+    }
+    mergeHead() {
+        this.copyNewHeadStylesheetElements();
+        this.copyNewHeadScriptElements();
+        this.removeCurrentHeadProvisionalElements();
+        this.copyNewHeadProvisionalElements();
+    }
+    replaceBody() {
+        const placeholders = this.relocateCurrentBodyPermanentElements();
+        this.activateNewBodyScriptElements();
+        this.assignNewBody();
+        this.replacePlaceholderElementsWithClonedPermanentElements(placeholders);
+    }
+    shouldRender() {
+        return this.newSnapshot.isVisitable() && this.trackedElementsAreIdentical();
+    }
+    trackedElementsAreIdentical() {
+        return (this.currentHeadDetails.getTrackedElementSignature() ==
+            this.newHeadDetails.getTrackedElementSignature());
+    }
+    copyNewHeadStylesheetElements() {
+        for (const element of this.getNewHeadStylesheetElements()) {
+            document.head.appendChild(element);
+        }
+    }
+    copyNewHeadScriptElements() {
+        for (const element of this.getNewHeadScriptElements()) {
+            document.head.appendChild(this.createScriptElement(element));
+        }
+    }
+    removeCurrentHeadProvisionalElements() {
+        for (const element of this.getCurrentHeadProvisionalElements()) {
+            document.head.removeChild(element);
+        }
+    }
+    copyNewHeadProvisionalElements() {
+        for (const element of this.getNewHeadProvisionalElements()) {
+            document.head.appendChild(element);
+        }
+    }
+    relocateCurrentBodyPermanentElements() {
+        return this.getCurrentBodyPermanentElements().reduce((placeholders, permanentElement) => {
+            const newElement = this.newSnapshot.getPermanentElementById(permanentElement.id);
+            if (newElement) {
+                const placeholder = createPlaceholderForPermanentElement(permanentElement);
+                replaceElementWithElement(permanentElement, placeholder.element);
+                replaceElementWithElement(newElement, permanentElement);
+                return [...placeholders, placeholder];
+            }
+            else {
+                return placeholders;
+            }
+        }, []);
+    }
+    replacePlaceholderElementsWithClonedPermanentElements(placeholders) {
+        for (const { element, permanentElement } of placeholders) {
+            const clonedElement = permanentElement.cloneNode(true);
+            replaceElementWithElement(element, clonedElement);
+        }
+    }
+    activateNewBodyScriptElements() {
+        for (const inertScriptElement of this.getNewBodyScriptElements()) {
+            const activatedScriptElement = this.createScriptElement(inertScriptElement);
+            replaceElementWithElement(inertScriptElement, activatedScriptElement);
+        }
+    }
+    assignNewBody() {
+        replaceElementWithElement(document.querySelector("#alignablewebnextjsframe").firstElementChild, this.newBody);
+    }
+    focusFirstAutofocusableElement() {
+        const element = this.newSnapshot.findFirstAutofocusableElement();
+        if (elementIsFocusable(element)) {
+            element.focus();
+        }
+    }
+    getNewHeadStylesheetElements() {
+        return this.newHeadDetails.getStylesheetElementsNotInDetails(this.currentHeadDetails);
+    }
+    getNewHeadScriptElements() {
+        return this.newHeadDetails.getScriptElementsNotInDetails(this.currentHeadDetails);
+    }
+    getCurrentHeadProvisionalElements() {
+        return this.currentHeadDetails.getProvisionalElements();
+    }
+    getNewHeadProvisionalElements() {
+        return this.newHeadDetails.getProvisionalElements();
+    }
+    getCurrentBodyPermanentElements() {
+        return this.currentSnapshot.getPermanentElementsPresentInSnapshot(this.newSnapshot);
+    }
+    getNewBodyScriptElements() {
+        return array(this.newBody.querySelectorAll("script"));
+    }
+}
+function createPlaceholderForPermanentElement(permanentElement) {
+    const element = document.createElement("meta");
+    element.setAttribute("name", "turbolinks-permanent-placeholder");
+    element.setAttribute("content", permanentElement.id);
+    return { element, permanentElement };
+}
+function replaceElementWithElement(fromElement, toElement) {
+    const parentElement = fromElement.parentElement;
+    if (parentElement) {
+        return parentElement.replaceChild(toElement, fromElement);
+    }
+}
+function elementIsFocusable(element) {
+    return element && typeof element.focus == "function";
+}

package/dist/lib/turbolinks/types.d.ts

@@ -0,0 +1,7 @@
+export type Action = "advance" | "replace" | "restore";
+export declare function isAction(action: any): action is Action;
+export type Position = {
+    x: number;
+    y: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/turbolinks/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEvD,wBAAgB,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,IAAI,MAAM,CAEtD;AAED,MAAM,MAAM,QAAQ,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/lib/turbolinks/types.js

@@ -0,0 +1,3 @@
+export function isAction(action) {
+    return action == "advance" || action == "replace" || action == "restore";
+}

package/dist/lib/turbolinks/util.d.ts

@@ -0,0 +1,14 @@
+export declare function array<T>(values: ArrayLike<T>): T[];
+export declare const closest: (element: Element, selector: string) => Element | null;
+export declare function defer(callback: () => any): void;
+export type DispatchOptions = {
+    target: EventTarget;
+    cancelable: boolean;
+    data: any;
+};
+export declare function dispatch(eventName: string, { target, cancelable, data }?: Partial<DispatchOptions>): Event & {
+    data: any;
+};
+export declare function unindent(strings: TemplateStringsArray, ...values: any[]): string;
+export declare function uuid(): string;
+//# sourceMappingURL=util.d.ts.map

package/dist/lib/turbolinks/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/util.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAElD;AAED,eAAO,MAAM,OAAO,YAwBQ,OAAO,YAAY,MAAM,mBAGjD,CAAC;AAEL,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,QAExC;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,GAAG,CAAC;CACX,CAAC;AAEF,wBAAgB,QAAQ,CACtB,SAAS,EAAE,MAAM,EACjB,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,GAAE,OAAO,CAAC,eAAe,CAAM;UAEK,GAAG;EAkBpE;AASD,wBAAgB,QAAQ,CACtB,OAAO,EAAE,oBAAoB,EAC7B,GAAG,MAAM,EAAE,GAAG,EAAE,GACf,MAAM,CAKR;AAaD,wBAAgB,IAAI,WAcnB"}

package/dist/lib/turbolinks/util.js

@@ -0,0 +1,85 @@
+export function array(values) {
+    return Array.prototype.slice.call(values);
+}
+export const closest = (() => {
+    const html = document.documentElement;
+    const match = html.matches ||
+        html.webkitMatchesSelector ||
+        html.msMatchesSelector ||
+        html.mozMatchesSelector;
+    const closest = html.closest ||
+        function (selector) {
+            let element = this;
+            while (element) {
+                if (match.call(element, selector)) {
+                    return element;
+                }
+                else {
+                    element = element.parentElement;
+                }
+            }
+        };
+    return function (element, selector) {
+        return closest.call(element, selector);
+    };
+})();
+export function defer(callback) {
+    setTimeout(callback, 1);
+}
+export function dispatch(eventName, { target, cancelable, data } = {}) {
+    const event = document.createEvent("Events");
+    event.initEvent(eventName, true, cancelable == true);
+    event.data = data || {};
+    // Fix setting `defaultPrevented` when `preventDefault()` is called
+    // http://stackoverflow.com/questions/23349191/event-preventdefault-is-not-working-in-ie-11-for-custom-events
+    if (event.cancelable && !preventDefaultSupported) {
+        const { preventDefault } = event;
+        event.preventDefault = function () {
+            if (!this.defaultPrevented) {
+                Object.defineProperty(this, "defaultPrevented", { get: () => true });
+            }
+            preventDefault.call(this);
+        };
+    }
+    (target || document).dispatchEvent(event);
+    return event;
+}
+const preventDefaultSupported = (() => {
+    const event = document.createEvent("Events");
+    event.initEvent("test", true, true);
+    event.preventDefault();
+    return event.defaultPrevented;
+})();
+export function unindent(strings, ...values) {
+    const lines = trimLeft(interpolate(strings, values)).split("\n");
+    const match = lines[0].match(/^\s+/);
+    const indent = match ? match[0].length : 0;
+    return lines.map((line) => line.slice(indent)).join("\n");
+}
+function trimLeft(string) {
+    return string.replace(/^\n/, "");
+}
+function interpolate(strings, values) {
+    return strings.reduce((result, string, i) => {
+        const value = values[i] == undefined ? "" : values[i];
+        return result + string + value;
+    }, "");
+}
+export function uuid() {
+    return Array.apply(null, { length: 36 })
+        .map((_, i) => {
+        if (i == 8 || i == 13 || i == 18 || i == 23) {
+            return "-";
+        }
+        else if (i == 14) {
+            return "4";
+        }
+        else if (i == 19) {
+            return (Math.floor(Math.random() * 4) + 8).toString(16);
+        }
+        else {
+            return Math.floor(Math.random() * 15).toString(16);
+        }
+    })
+        .join("");
+}

package/dist/lib/turbolinks/view.d.ts

@@ -0,0 +1,21 @@
+import { Location } from "./location";
+import { Snapshot } from "./snapshot";
+import { RenderCallback, RenderDelegate } from "./snapshot_renderer";
+export type RenderOptions = {
+    snapshot: Snapshot;
+    error: string;
+    isPreview: boolean;
+};
+export declare class View {
+    readonly delegate: RenderDelegate;
+    readonly htmlElement: HTMLHtmlElement;
+    constructor(delegate: RenderDelegate);
+    getRootLocation(): Location;
+    getElementForAnchor(anchor: string): Element | null;
+    getSnapshot(): Snapshot;
+    render({ snapshot, error, isPreview }: Partial<RenderOptions>, callback: RenderCallback): void;
+    markAsPreview(isPreview: boolean | undefined): void;
+    renderSnapshot(snapshot: Snapshot, isPreview: boolean | undefined, callback: RenderCallback): void;
+    renderError(error: string | undefined, callback: RenderCallback): void;
+}
+//# sourceMappingURL=view.d.ts.map

package/dist/lib/turbolinks/view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/view.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EACL,cAAc,EACd,cAAc,EAEf,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,qBAAa,IAAI;IACf,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,WAAW,kBAA+C;gBAEvD,QAAQ,EAAE,cAAc;IAIpC,eAAe,IAAI,QAAQ;IAI3B,mBAAmB,CAAC,MAAM,EAAE,MAAM;IAIlC,WAAW,IAAI,QAAQ;IAIvB,MAAM,CACJ,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,OAAO,CAAC,aAAa,CAAC,EACtD,QAAQ,EAAE,cAAc;IAY1B,aAAa,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS;IAQ5C,cAAc,CACZ,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,OAAO,GAAG,SAAS,EAC9B,QAAQ,EAAE,cAAc;IAW1B,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,cAAc;CAGhE"}

package/dist/lib/turbolinks/view.js

@@ -0,0 +1,42 @@
+import { ErrorRenderer } from "./error_renderer";
+import { Snapshot } from "./snapshot";
+import { SnapshotRenderer, } from "./snapshot_renderer";
+export class View {
+    constructor(delegate) {
+        this.htmlElement = document.documentElement;
+        this.delegate = delegate;
+    }
+    getRootLocation() {
+        return this.getSnapshot().getRootLocation();
+    }
+    getElementForAnchor(anchor) {
+        return this.getSnapshot().getElementForAnchor(anchor);
+    }
+    getSnapshot() {
+        return Snapshot.fromHTMLElement(this.htmlElement);
+    }
+    render({ snapshot, error, isPreview }, callback) {
+        this.markAsPreview(isPreview);
+        if (snapshot) {
+            this.renderSnapshot(snapshot, isPreview, callback);
+        }
+        else {
+            this.renderError(error, callback);
+        }
+    }
+    // Private
+    markAsPreview(isPreview) {
+        if (isPreview) {
+            this.htmlElement.setAttribute("data-turbolinks-preview", "");
+        }
+        else {
+            this.htmlElement.removeAttribute("data-turbolinks-preview");
+        }
+    }
+    renderSnapshot(snapshot, isPreview, callback) {
+        SnapshotRenderer.render(this.delegate, callback, this.getSnapshot(), snapshot, isPreview || false);
+    }
+    renderError(error, callback) {
+        ErrorRenderer.render(this.delegate, callback, error || "");
+    }
+}

package/dist/lib/turbolinks/visit.d.ts

@@ -0,0 +1,73 @@
+import { Adapter } from "./adapter";
+import { Controller, RestorationData } from "./controller";
+import { HttpRequest } from "./http_request";
+import { Location } from "./location";
+import { RenderCallback } from "./renderer";
+import { Snapshot } from "./snapshot";
+import { Action } from "./types";
+export declare enum TimingMetric {
+    visitStart = "visitStart",
+    requestStart = "requestStart",
+    requestEnd = "requestEnd",
+    visitEnd = "visitEnd"
+}
+export type TimingMetrics = Partial<{
+    [metric in TimingMetric]: any;
+}>;
+export declare enum VisitState {
+    initialized = "initialized",
+    started = "started",
+    canceled = "canceled",
+    failed = "failed",
+    completed = "completed"
+}
+export declare class Visit {
+    readonly controller: Controller;
+    readonly action: Action;
+    readonly adapter: Adapter;
+    readonly identifier: string;
+    readonly restorationIdentifier: string;
+    readonly timingMetrics: TimingMetrics;
+    followedRedirect: boolean;
+    frame?: number;
+    historyChanged: boolean;
+    location: Location;
+    progress: number;
+    referrer?: Location;
+    redirectedToLocation?: Location;
+    request?: HttpRequest;
+    response?: string;
+    restorationData?: RestorationData;
+    scrolled: boolean;
+    snapshotCached: boolean;
+    state: VisitState;
+    constructor(controller: Controller, location: Location, action: Action, restorationIdentifier?: string);
+    start(): void;
+    cancel(): void;
+    complete(): void;
+    fail(): void;
+    changeHistory(): void;
+    issueRequest(): void;
+    getCachedSnapshot(): Snapshot | undefined;
+    hasCachedSnapshot(): boolean;
+    loadCachedSnapshot(): void;
+    loadResponse(): void;
+    followRedirect(): void;
+    requestStarted(): void;
+    requestProgressed(progress: number): void;
+    requestCompletedWithResponse(response: string, redirectedToLocation?: Location): void;
+    requestFailedWithStatusCode(statusCode: number, response?: string): void;
+    requestFinished(): void;
+    performScroll: () => void;
+    scrollToRestoredPosition(): true | undefined;
+    scrollToAnchor(): true | undefined;
+    scrollToTop(): void;
+    recordTimingMetric(metric: TimingMetric): void;
+    getTimingMetrics(): TimingMetrics;
+    getHistoryMethodForAction(action: Action): (locatable: import("./location").Locatable, restorationIdentifier: string) => void;
+    shouldIssueRequest(): boolean;
+    cacheSnapshot(): void;
+    render(callback: RenderCallback): void;
+    cancelRender(): void;
+}
+//# sourceMappingURL=visit.d.ts.map

package/dist/lib/turbolinks/visit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visit.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/visit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGjC,oBAAY,YAAY;IACtB,UAAU,eAAe;IACzB,YAAY,iBAAiB;IAC7B,UAAU,eAAe;IACzB,QAAQ,aAAa;CACtB;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC;KAAG,MAAM,IAAI,YAAY,GAAG,GAAG;CAAE,CAAC,CAAC;AAEvE,oBAAY,UAAU;IACpB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,SAAS,cAAc;CACxB;AAED,qBAAa,KAAK;IAChB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,UAAU,SAAU;IAC7B,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAM;IAE3C,gBAAgB,UAAS;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,UAAS;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,SAAK;IACb,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,oBAAoB,CAAC,EAAE,QAAQ,CAAC;IAChC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,QAAQ,UAAS;IACjB,cAAc,UAAS;IACvB,KAAK,aAA0B;gBAG7B,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,qBAAqB,GAAE,MAAe;IASxC,KAAK;IAQL,MAAM;IAUN,QAAQ;IASR,IAAI;IAOJ,aAAa;IAWb,YAAY;IAQZ,iBAAiB;IAcjB,iBAAiB;IAIjB,kBAAkB;IAelB,YAAY;IAqBZ,cAAc;IAad,cAAc;IAKd,iBAAiB,CAAC,QAAQ,EAAE,MAAM;IAOlC,4BAA4B,CAC1B,QAAQ,EAAE,MAAM,EAChB,oBAAoB,CAAC,EAAE,QAAQ;IAOjC,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAKjE,eAAe;IAOf,aAAa,aASX;IAEF,wBAAwB;IAUxB,cAAc;IAOd,WAAW;IAMX,kBAAkB,CAAC,MAAM,EAAE,YAAY;IAIvC,gBAAgB,IAAI,aAAa;IAMjC,yBAAyB,CAAC,MAAM,EAAE,MAAM;IAUxC,kBAAkB;IAIlB,aAAa;IAOb,MAAM,CAAC,QAAQ,EAAE,cAAc;IAQ/B,YAAY;CAMb"}

package/dist/lib/turbolinks/visit.js

@@ -0,0 +1,227 @@
+import { HttpRequest } from "./http_request";
+import { Snapshot } from "./snapshot";
+import { uuid } from "./util";
+export var TimingMetric;
+(function (TimingMetric) {
+    TimingMetric["visitStart"] = "visitStart";
+    TimingMetric["requestStart"] = "requestStart";
+    TimingMetric["requestEnd"] = "requestEnd";
+    TimingMetric["visitEnd"] = "visitEnd";
+})(TimingMetric || (TimingMetric = {}));
+export var VisitState;
+(function (VisitState) {
+    VisitState["initialized"] = "initialized";
+    VisitState["started"] = "started";
+    VisitState["canceled"] = "canceled";
+    VisitState["failed"] = "failed";
+    VisitState["completed"] = "completed";
+})(VisitState || (VisitState = {}));
+export class Visit {
+    constructor(controller, location, action, restorationIdentifier = uuid()) {
+        this.identifier = uuid();
+        this.timingMetrics = {};
+        this.followedRedirect = false;
+        this.historyChanged = false;
+        this.progress = 0;
+        this.scrolled = false;
+        this.snapshotCached = false;
+        this.state = VisitState.initialized;
+        // Scrolling
+        this.performScroll = () => {
+            if (!this.scrolled) {
+                if (this.action == "restore") {
+                    this.scrollToRestoredPosition() || this.scrollToTop();
+                }
+                else {
+                    this.scrollToAnchor() || this.scrollToTop();
+                }
+                this.scrolled = true;
+            }
+        };
+        this.controller = controller;
+        this.location = location;
+        this.action = action;
+        this.adapter = controller.adapter;
+        this.restorationIdentifier = restorationIdentifier;
+    }
+    start() {
+        if (this.state == VisitState.initialized) {
+            this.recordTimingMetric(TimingMetric.visitStart);
+            this.state = VisitState.started;
+            this.adapter.visitStarted(this);
+        }
+    }
+    cancel() {
+        if (this.state == VisitState.started) {
+            if (this.request) {
+                this.request.cancel();
+            }
+            this.cancelRender();
+            this.state = VisitState.canceled;
+        }
+    }
+    complete() {
+        if (this.state == VisitState.started) {
+            this.recordTimingMetric(TimingMetric.visitEnd);
+            this.state = VisitState.completed;
+            this.adapter.visitCompleted(this);
+            this.controller.visitCompleted(this);
+        }
+    }
+    fail() {
+        if (this.state == VisitState.started) {
+            this.state = VisitState.failed;
+            this.adapter.visitFailed(this);
+        }
+    }
+    changeHistory() {
+        if (!this.historyChanged) {
+            const actionForHistory = this.location.isEqualTo(this.referrer)
+                ? "replace"
+                : this.action;
+            const method = this.getHistoryMethodForAction(actionForHistory);
+            method.call(this.controller, this.location, this.restorationIdentifier);
+            this.historyChanged = true;
+        }
+    }
+    issueRequest() {
+        if (this.shouldIssueRequest() && !this.request) {
+            this.progress = 0;
+            this.request = new HttpRequest(this, this.location, this.referrer);
+            this.request.send();
+        }
+    }
+    getCachedSnapshot() {
+        const snapshot = this.controller.getCachedSnapshotForLocation(this.location);
+        if (snapshot &&
+            (!this.location.anchor || snapshot.hasAnchor(this.location.anchor))) {
+            if (this.action == "restore" || snapshot.isPreviewable()) {
+                return snapshot;
+            }
+        }
+    }
+    hasCachedSnapshot() {
+        return this.getCachedSnapshot() != null;
+    }
+    loadCachedSnapshot() {
+        const snapshot = this.getCachedSnapshot();
+        if (snapshot) {
+            const isPreview = this.shouldIssueRequest();
+            this.render(() => {
+                this.cacheSnapshot();
+                this.controller.render({ snapshot, isPreview }, this.performScroll);
+                this.adapter.visitRendered(this);
+                if (!isPreview) {
+                    this.complete();
+                }
+            });
+        }
+    }
+    loadResponse() {
+        const { request, response } = this;
+        if (request && response) {
+            this.render(() => {
+                this.cacheSnapshot();
+                if (request.failed) {
+                    this.controller.render({ error: this.response }, this.performScroll);
+                    this.adapter.visitRendered(this);
+                    this.fail();
+                }
+                else {
+                    this.controller.render({ snapshot: Snapshot.fromHTMLString(response) }, this.performScroll);
+                    this.adapter.visitRendered(this);
+                    this.complete();
+                }
+            });
+        }
+    }
+    followRedirect() {
+        if (this.redirectedToLocation && !this.followedRedirect) {
+            this.location = this.redirectedToLocation;
+            this.controller.replaceHistoryWithLocationAndRestorationIdentifier(this.redirectedToLocation, this.restorationIdentifier);
+            this.followedRedirect = true;
+        }
+    }
+    // HTTP request delegate
+    requestStarted() {
+        this.recordTimingMetric(TimingMetric.requestStart);
+        this.adapter.visitRequestStarted(this);
+    }
+    requestProgressed(progress) {
+        this.progress = progress;
+        if (this.adapter.visitRequestProgressed) {
+            this.adapter.visitRequestProgressed(this);
+        }
+    }
+    requestCompletedWithResponse(response, redirectedToLocation) {
+        this.response = response;
+        this.redirectedToLocation = redirectedToLocation;
+        this.adapter.visitRequestCompleted(this);
+    }
+    requestFailedWithStatusCode(statusCode, response) {
+        this.response = response;
+        this.adapter.visitRequestFailedWithStatusCode(this, statusCode);
+    }
+    requestFinished() {
+        this.recordTimingMetric(TimingMetric.requestEnd);
+        this.adapter.visitRequestFinished(this);
+    }
+    scrollToRestoredPosition() {
+        const position = this.restorationData
+            ? this.restorationData.scrollPosition
+            : undefined;
+        if (position) {
+            this.controller.scrollToPosition(position);
+            return true;
+        }
+    }
+    scrollToAnchor() {
+        if (this.location.anchor != null) {
+            this.controller.scrollToAnchor(this.location.anchor);
+            return true;
+        }
+    }
+    scrollToTop() {
+        this.controller.scrollToPosition({ x: 0, y: 0 });
+    }
+    // Instrumentation
+    recordTimingMetric(metric) {
+        this.timingMetrics[metric] = new Date().getTime();
+    }
+    getTimingMetrics() {
+        return { ...this.timingMetrics };
+    }
+    // Private
+    getHistoryMethodForAction(action) {
+        switch (action) {
+            case "replace":
+                return this.controller
+                    .replaceHistoryWithLocationAndRestorationIdentifier;
+            case "advance":
+            case "restore":
+                return this.controller.pushHistoryWithLocationAndRestorationIdentifier;
+        }
+    }
+    shouldIssueRequest() {
+        return this.action == "restore" ? !this.hasCachedSnapshot() : true;
+    }
+    cacheSnapshot() {
+        if (!this.snapshotCached) {
+            this.controller.cacheSnapshot();
+            this.snapshotCached = true;
+        }
+    }
+    render(callback) {
+        this.cancelRender();
+        this.frame = requestAnimationFrame(() => {
+            delete this.frame;
+            callback.call(this);
+        });
+    }
+    cancelRender() {
+        if (this.frame) {
+            cancelAnimationFrame(this.frame);
+            delete this.frame;
+        }
+    }
+}

package/dist/proxy/pages/+config.d.ts

@@ -1,9 +1,9 @@
 declare const _default: {
     route: string;
-    onBeforeRenderPath: string;
-    onRenderClientPath: string;
-    onRenderHtmlPath: string;
-    PagePath: string;
+    onBeforeRender: "import:@alignable/bifrost/proxy/pages/onBeforeRender";
+    onRenderClient: "import:@alignable/bifrost/proxy/pages/onRenderClient";
+    onRenderHtml: "import:@alignable/bifrost/proxy/pages/onRenderHtml";
+    Page: string;
     passToClient: string[];
     clientRouting: true;
     hydrationCanBeAborted: true;

package/dist/proxy/pages/+config.js

@@ -1,9 +1,9 @@
 export default {
     route: "/*",
-    onBeforeRenderPath: "@alignable/bifrost/proxy/pages/onBeforeRender",
-    onRenderClientPath: "@alignable/bifrost/proxy/pages/onRenderClient",
-    onRenderHtmlPath: "@alignable/bifrost/proxy/pages/onRenderHtml",
-    PagePath: "@alignable/bifrost/proxy/pages/Page",
+    onBeforeRender: "import:@alignable/bifrost/proxy/pages/onBeforeRender",
+    onRenderClient: "import:@alignable/bifrost/proxy/pages/onRenderClient",
+    onRenderHtml: "import:@alignable/bifrost/proxy/pages/onRenderHtml",
+    Page: "import:@alignable/bifrost/proxy/pages/Page",
     passToClient: ["proxySendClient", "layout", "layoutProps", "redirectTo"],
     clientRouting: true,
     hydrationCanBeAborted: true,

package/dist/proxy/pages/onPageTransitionStart.d.ts

@@ -0,0 +1,3 @@
+import { PageContextBuiltInClientWithClientRouting } from "vite-plugin-ssr/types";
+export default function onPageTransitionStart(pageContext: PageContextBuiltInClientWithClientRouting): void;
+//# sourceMappingURL=onPageTransitionStart.d.ts.map

package/dist/proxy/pages/onPageTransitionStart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onPageTransitionStart.d.ts","sourceRoot":"","sources":["../../../proxy/pages/onPageTransitionStart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yCAAyC,EAAE,MAAM,uBAAuB,CAAC;AAIlF,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAC3C,WAAW,EAAE,yCAAyC,QAQvD"}