@alignable/bifrost 0.0.9 → 0.0.10

package/dist/lib/turbolinks/history.js

@@ -0,0 +1,60 @@
+import { Location } from "./location";
+import { defer } from "./util";
+export class History {
+    constructor(delegate) {
+        this.started = false;
+        this.pageLoaded = false;
+        // Event handlers
+        this.onPopState = (event) => {
+            // return
+            if (!this.shouldHandlePopState())
+                return;
+            if (!event.state)
+                return;
+            const { turbolinks } = event.state;
+            if (!turbolinks)
+                return;
+            const location = Location.currentLocation;
+            const { restorationIdentifier } = turbolinks;
+            this.delegate.historyPoppedToLocationWithRestorationIdentifier(location, restorationIdentifier);
+        };
+        this.onPageLoad = (event) => {
+            defer(() => {
+                this.pageLoaded = true;
+            });
+        };
+        this.delegate = delegate;
+    }
+    start() {
+        if (!this.started) {
+            addEventListener("popstate", this.onPopState, false);
+            addEventListener("load", this.onPageLoad, false);
+            this.started = true;
+        }
+    }
+    stop() {
+        if (this.started) {
+            removeEventListener("popstate", this.onPopState, false);
+            removeEventListener("load", this.onPageLoad, false);
+            this.started = false;
+        }
+    }
+    push(location, restorationIdentifier) {
+        this.update(history.pushState, location, restorationIdentifier);
+    }
+    replace(location, restorationIdentifier) {
+        this.update(history.replaceState, location, restorationIdentifier);
+    }
+    // Private
+    shouldHandlePopState() {
+        // Safari dispatches a popstate event after window's load event, ignore it
+        return this.pageIsLoaded();
+    }
+    pageIsLoaded() {
+        return this.pageLoaded || document.readyState == "complete";
+    }
+    update(method, location, restorationIdentifier) {
+        const state = { turbolinks: { restorationIdentifier } };
+        method.call(history, state, "", location.absoluteURL);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Controller, VisitOptions } from "./controller";
+import { Locatable } from "./location";
+import { Renderer } from "./renderer";
+export declare const Turbolinks: {
+    readonly supported: boolean;
+    controller: Controller;
+    visit(location: Locatable, options?: Partial<VisitOptions>): void;
+    clearCache(): void;
+    setProgressBarDelay(delay: number): void;
+    start(): void;
+    _vpsRenderClientWith(renderer: Renderer): void;
+    _vpsOnRenderClient(renderFn: () => Promise<void>): void;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC,eAAO,MAAM,UAAU;;;oBAOL,SAAS,YAAY,QAAQ,YAAY,CAAC;;+BAQ/B,MAAM;;mCAmBF,QAAQ;iCAaV,MAAM,QAAQ,IAAI,CAAC;CAgBjD,CAAC"}

package/dist/lib/turbolinks/index.js

@@ -0,0 +1,55 @@
+import { Controller } from "./controller";
+const controller = new Controller();
+export const Turbolinks = {
+    get supported() {
+        return Controller.supported;
+    },
+    controller,
+    visit(location, options) {
+        controller.visit(location, options);
+    },
+    clearCache() {
+        controller.clearCache();
+    },
+    setProgressBarDelay(delay) {
+        controller.setProgressBarDelay(delay);
+    },
+    start() {
+        // because this runs after ios hooks, we have to recover. See onRenderHtml
+        if (window.Turbolinks !== Turbolinks &&
+            window.Turbolinks.controller.adapter) {
+            console.log(window.Turbolinks, Turbolinks);
+            window.Turbolinks.controller.adapter.controller = controller;
+            controller.adapter = window.Turbolinks.controller.adapter;
+            console.log(window.Turbolinks, Turbolinks);
+            window.Turbolinks = Turbolinks;
+        }
+        controller.start();
+    },
+    _vpsRenderClientWith(renderer) {
+        if (controller.currentVisit) {
+            // TODO: move to controller
+            controller.currentVisit.renderer = renderer;
+            controller.adapter.visitRequestCompleted(controller.currentVisit);
+            controller.adapter.visitRequestFinished(controller.currentVisit);
+        }
+        else {
+            console.error("controller.currentVisit should exist when onRenderClient fires");
+        }
+    },
+    _vpsOnRenderClient(renderFn) {
+        if (controller.currentVisit) {
+            // TODO: move to controller
+            controller.currentVisit.renderFn = async () => {
+                controller.viewWillRender();
+                await renderFn();
+                controller.viewRendered();
+            };
+            controller.adapter.visitRequestCompleted(controller.currentVisit);
+            controller.adapter.visitRequestFinished(controller.currentVisit);
+        }
+        else {
+            console.error("controller.currentVisit should exist when onRenderClient fires");
+        }
+    },
+};

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

@@ -0,0 +1,23 @@
+export type Locatable = Location | string;
+export declare class Location {
+    static get currentLocation(): Location;
+    static wrap(locatable: Locatable): Location;
+    static wrap(locatable?: Locatable | null): Location | undefined;
+    readonly absoluteURL: string;
+    readonly requestURL: string;
+    readonly anchor?: string;
+    constructor(url: string);
+    getOrigin(): string;
+    getPath(): string;
+    getPathComponents(): string[];
+    getLastPathComponent(): string;
+    getExtension(): string;
+    isHTML(): RegExpMatchArray | null;
+    isPrefixedBy(location: Location): boolean;
+    isEqualTo(location?: Location): boolean | undefined;
+    toCacheKey(): string;
+    toJSON(): string;
+    toString(): string;
+    valueOf(): string;
+}
+//# sourceMappingURL=location.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/location.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE1C,qBAAa,QAAQ;IACnB,MAAM,KAAK,eAAe,aAEzB;IAED,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,GAAG,QAAQ;IAC3C,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,QAAQ,GAAG,SAAS;IAS/D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEb,GAAG,EAAE,MAAM;IAevB,SAAS;IAIT,OAAO;IAIP,iBAAiB;IAIjB,oBAAoB;IAIpB,YAAY;IAIZ,MAAM;IAIN,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAOzC,SAAS,CAAC,QAAQ,CAAC,EAAE,QAAQ;IAI7B,UAAU;IAIV,MAAM;IAIN,QAAQ;IAIR,OAAO;CAGR"}

package/dist/lib/turbolinks/location.js

@@ -0,0 +1,75 @@
+export class Location {
+    static get currentLocation() {
+        return this.wrap(window.location.toString());
+    }
+    static wrap(locatable) {
+        if (typeof locatable == "string") {
+            return new this(locatable);
+        }
+        else if (locatable != null) {
+            return locatable;
+        }
+    }
+    constructor(url) {
+        const linkWithAnchor = document.createElement("a");
+        linkWithAnchor.href = url;
+        this.absoluteURL = linkWithAnchor.href;
+        const anchorLength = linkWithAnchor.hash.length;
+        if (anchorLength < 2) {
+            this.requestURL = this.absoluteURL;
+        }
+        else {
+            this.requestURL = this.absoluteURL.slice(0, -anchorLength);
+            this.anchor = linkWithAnchor.hash.slice(1);
+        }
+    }
+    getOrigin() {
+        return this.absoluteURL.split("/", 3).join("/");
+    }
+    getPath() {
+        return (this.requestURL.match(/\/\/[^/]*(\/[^?;]*)/) || [])[1] || "/";
+    }
+    getPathComponents() {
+        return this.getPath().split("/").slice(1);
+    }
+    getLastPathComponent() {
+        return this.getPathComponents().slice(-1)[0];
+    }
+    getExtension() {
+        return (this.getLastPathComponent().match(/\.[^.]*$/) || [])[0] || "";
+    }
+    isHTML() {
+        return this.getExtension().match(/^(?:|\.(?:htm|html|xhtml))$/);
+    }
+    isPrefixedBy(location) {
+        const prefixURL = getPrefixURL(location);
+        return (this.isEqualTo(location) || stringStartsWith(this.absoluteURL, prefixURL));
+    }
+    isEqualTo(location) {
+        return location && this.absoluteURL === location.absoluteURL;
+    }
+    toCacheKey() {
+        return this.requestURL;
+    }
+    toJSON() {
+        return this.absoluteURL;
+    }
+    toString() {
+        return this.absoluteURL;
+    }
+    valueOf() {
+        return this.absoluteURL;
+    }
+}
+function getPrefixURL(location) {
+    return addTrailingSlash(location.getOrigin() + location.getPath());
+}
+function addTrailingSlash(url) {
+    return stringEndsWith(url, "/") ? url : url + "/";
+}
+function stringStartsWith(string, prefix) {
+    return string.slice(0, prefix.length) === prefix;
+}
+function stringEndsWith(string, suffix) {
+    return string.slice(-suffix.length) === suffix;
+}

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

@@ -0,0 +1,12 @@
+import { Controller, VisitOptions } from "./controller";
+import { Locatable } from "./location";
+declare const _default: {
+    readonly supported: boolean;
+    controller: Controller;
+    visit(location: Locatable, options?: Partial<VisitOptions>): void;
+    clearCache(): void;
+    setProgressBarDelay(delay: number): void;
+    start(): void;
+};
+export default _default;
+//# sourceMappingURL=namespace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/namespace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;;;;oBAWrB,SAAS,YAAY,QAAQ,YAAY,CAAC;;+BAQ/B,MAAM;;;AAfnC,wBAsBE"}

package/dist/lib/turbolinks/namespace.js

@@ -0,0 +1,20 @@
+import { Controller } from "./controller";
+const controller = new Controller();
+export default {
+    get supported() {
+        return Controller.supported;
+    },
+    controller,
+    visit(location, options) {
+        controller.visit(location, options);
+    },
+    clearCache() {
+        controller.clearCache();
+    },
+    setProgressBarDelay(delay) {
+        controller.setProgressBarDelay(delay);
+    },
+    start() {
+        controller.start();
+    },
+};

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

@@ -0,0 +1,32 @@
+import { HeadDetails } from "./head_details";
+import { Renderer, RenderDelegate, RenderCallback } from "./renderer";
+export type PermanentElement = Element & {
+    id: string;
+};
+export type Placeholder = {
+    element: Element;
+    permanentElement: PermanentElement;
+};
+type BodyRenderer = () => void;
+export declare class PassthruRenderer extends Renderer {
+    delegate?: RenderDelegate;
+    readonly currentHeadDetails: HeadDetails;
+    readonly newHeadDetails: HeadDetails;
+    renderBody: BodyRenderer;
+    constructor(currentHeadDetails: HeadDetails, newHeadDetails: HeadDetails, renderBody: BodyRenderer);
+    render(delegate: RenderDelegate, callback: RenderCallback): Promise<void>;
+    mergeHead(): Promise<void>;
+    shouldRender(): boolean;
+    trackedElementsAreIdentical(): boolean;
+    copyNewHeadStylesheetElements(): void;
+    copyNewHeadScriptElements(onScriptsLoaded: () => void): void;
+    removeCurrentHeadProvisionalElements(): void;
+    copyNewHeadProvisionalElements(): void;
+    focusFirstAutofocusableElement(): void;
+    getNewHeadStylesheetElements(): any;
+    getNewHeadScriptElements(): HTMLScriptElement[];
+    getCurrentHeadProvisionalElements(): any;
+    getNewHeadProvisionalElements(): any;
+}
+export {};
+//# sourceMappingURL=passthrough_renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"passthrough_renderer.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/passthrough_renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAItE,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,gBAAgB,EAAE,gBAAgB,CAAC;CACpC,CAAC;AAEF,KAAK,YAAY,GAAG,MAAM,IAAI,CAAC;AAK/B,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC;IACzC,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC;IACrC,UAAU,EAAE,YAAY,CAAC;gBAGvB,kBAAkB,EAAE,WAAW,EAC/B,cAAc,EAAE,WAAW,EAC3B,UAAU,EAAE,YAAY;IAQpB,MAAM,CAAC,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc;IAazD,SAAS;IAmBf,YAAY;IAIZ,2BAA2B;IAO3B,6BAA6B;IAM7B,yBAAyB,CAAC,eAAe,EAAE,MAAM,IAAI;IAmCrD,oCAAoC;IAMpC,8BAA8B;IAM9B,8BAA8B;IAO9B,4BAA4B;IAM5B,wBAAwB;IAMxB,iCAAiC;IAIjC,6BAA6B;CAG9B"}

package/dist/lib/turbolinks/passthrough_renderer.js

@@ -0,0 +1,128 @@
+import { Renderer } from "./renderer";
+import { createScriptElement } from "./util";
+const allHeadScriptsEverRun = {};
+let firstLoad = true;
+export class PassthruRenderer extends Renderer {
+    constructor(currentHeadDetails, newHeadDetails, renderBody) {
+        super();
+        this.currentHeadDetails = currentHeadDetails;
+        this.newHeadDetails = newHeadDetails;
+        this.renderBody = renderBody;
+    }
+    async render(delegate, callback) {
+        this.delegate = delegate;
+        if (this.shouldRender()) {
+            const scriptsLoaded = this.mergeHead();
+            this.renderBody();
+            this.focusFirstAutofocusableElement();
+            await scriptsLoaded;
+            callback();
+        }
+        else {
+            this.invalidateView();
+        }
+    }
+    async mergeHead() {
+        if (firstLoad) {
+            // TODO: messy code
+            for (const [outerHTML, details] of Object.entries(this.currentHeadDetails.detailsByOuterHTML)) {
+                allHeadScriptsEverRun[outerHTML] = true;
+            }
+        }
+        firstLoad = false;
+        return new Promise((resolve) => {
+            this.copyNewHeadStylesheetElements();
+            this.copyNewHeadScriptElements(resolve);
+            this.removeCurrentHeadProvisionalElements();
+            this.copyNewHeadProvisionalElements();
+        });
+    }
+    shouldRender() {
+        return true;
+    }
+    trackedElementsAreIdentical() {
+        return (this.currentHeadDetails.getTrackedElementSignature() ==
+            this.newHeadDetails.getTrackedElementSignature());
+    }
+    copyNewHeadStylesheetElements() {
+        for (const element of this.getNewHeadStylesheetElements()) {
+            document.head.appendChild(element);
+        }
+    }
+    copyNewHeadScriptElements(onScriptsLoaded) {
+        let blockingLoaded = [];
+        const dispatch = () => {
+            this.focusFirstAutofocusableElement();
+            onScriptsLoaded();
+        };
+        for (const element of this.getNewHeadScriptElements()) {
+            const runBefore = element.outerHTML in allHeadScriptsEverRun;
+            if (!runBefore) {
+                let cb = false;
+                if (!element.defer && element.src) {
+                    const idx = blockingLoaded.length;
+                    cb = () => {
+                        blockingLoaded[idx] = true;
+                        if (blockingLoaded.every((v) => v)) {
+                            dispatch();
+                        }
+                    };
+                    blockingLoaded.push(false);
+                }
+                const script = createScriptElement(element);
+                if (cb) {
+                    script.addEventListener("load", cb);
+                }
+                document.head.appendChild(script);
+                allHeadScriptsEverRun[element.outerHTML] = true;
+            }
+        }
+        if (blockingLoaded.length === 0) {
+            // //TODO: raf waits for react to finish... not 100% sure of the reliability
+            requestAnimationFrame(dispatch);
+        }
+    }
+    removeCurrentHeadProvisionalElements() {
+        for (const element of this.getCurrentHeadProvisionalElements()) {
+            document.head.removeChild(element);
+        }
+    }
+    copyNewHeadProvisionalElements() {
+        for (const element of this.getNewHeadProvisionalElements()) {
+            document.head.appendChild(element);
+        }
+    }
+    focusFirstAutofocusableElement() {
+        const element = document.body.querySelector("[autofocus]");
+        if (element && "focus" in element && typeof element.focus === "function") {
+            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();
+    }
+}
+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/progress_bar.d.ts

@@ -0,0 +1,24 @@
+export declare class ProgressBar {
+    static animationDuration: number;
+    static get defaultCSS(): string;
+    readonly stylesheetElement: HTMLStyleElement;
+    readonly progressElement: HTMLDivElement;
+    hiding: boolean;
+    trickleInterval?: number;
+    value: number;
+    visible: boolean;
+    show(): void;
+    hide(): void;
+    setValue(value: number): void;
+    installStylesheetElement(): void;
+    installProgressElement(): void;
+    fadeProgressElement(callback: () => void): void;
+    uninstallProgressElement(): void;
+    startTrickling(): void;
+    stopTrickling(): void;
+    trickle: () => void;
+    refresh(): void;
+    createStylesheetElement(): HTMLStyleElement;
+    createProgressElement(): HTMLDivElement;
+}
+//# sourceMappingURL=progress_bar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"progress_bar.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/progress_bar.ts"],"names":[],"mappings":"AAEA,qBAAa,WAAW;IACtB,MAAM,CAAC,iBAAiB,SAAO;IAE/B,MAAM,KAAK,UAAU,WAkBpB;IAED,QAAQ,CAAC,iBAAiB,mBAAkC;IAC5D,QAAQ,CAAC,eAAe,iBAAgC;IAExD,MAAM,UAAS;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,SAAK;IACV,OAAO,UAAS;IAEhB,IAAI;IASJ,IAAI;IAYJ,QAAQ,CAAC,KAAK,EAAE,MAAM;IAOtB,wBAAwB;IAOxB,sBAAsB;IAOtB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,IAAI;IAKxC,wBAAwB;IAMxB,cAAc;IASd,aAAa;IAKb,OAAO,aAEL;IAEF,OAAO;IAMP,uBAAuB;IAOvB,qBAAqB;CAKtB"}

package/dist/lib/turbolinks/progress_bar.js

@@ -0,0 +1,99 @@
+import { unindent } from "./util";
+class ProgressBar {
+    constructor() {
+        this.stylesheetElement = this.createStylesheetElement();
+        this.progressElement = this.createProgressElement();
+        this.hiding = false;
+        this.value = 0;
+        this.visible = false;
+        this.trickle = () => {
+            this.setValue(this.value + Math.random() / 100);
+        };
+    }
+    static get defaultCSS() {
+        return unindent `
+      .turbolinks-progress-bar {
+        position: fixed;
+        display: block;
+        top: 0;
+        left: 0;
+        height: 3px;
+        background: #0076ff;
+        z-index: 9999;
+        transition:
+          width ${ProgressBar.animationDuration}ms ease-out,
+          opacity ${ProgressBar.animationDuration / 2}ms ${ProgressBar.animationDuration / 2}ms ease-in;
+        transform: translate3d(0, 0, 0);
+      }
+    `;
+    }
+    show() {
+        if (!this.visible) {
+            this.visible = true;
+            this.installStylesheetElement();
+            this.installProgressElement();
+            this.startTrickling();
+        }
+    }
+    hide() {
+        if (this.visible && !this.hiding) {
+            this.hiding = true;
+            this.fadeProgressElement(() => {
+                this.uninstallProgressElement();
+                this.stopTrickling();
+                this.visible = false;
+                this.hiding = false;
+            });
+        }
+    }
+    setValue(value) {
+        this.value = value;
+        this.refresh();
+    }
+    // Private
+    installStylesheetElement() {
+        document.head.insertBefore(this.stylesheetElement, document.head.firstChild);
+    }
+    installProgressElement() {
+        this.progressElement.style.width = "0";
+        this.progressElement.style.opacity = "1";
+        document.documentElement.insertBefore(this.progressElement, document.body);
+        this.refresh();
+    }
+    fadeProgressElement(callback) {
+        this.progressElement.style.opacity = "0";
+        setTimeout(callback, ProgressBar.animationDuration * 1.5);
+    }
+    uninstallProgressElement() {
+        if (this.progressElement.parentNode) {
+            document.documentElement.removeChild(this.progressElement);
+        }
+    }
+    startTrickling() {
+        if (!this.trickleInterval) {
+            this.trickleInterval = window.setInterval(this.trickle, ProgressBar.animationDuration);
+        }
+    }
+    stopTrickling() {
+        window.clearInterval(this.trickleInterval);
+        delete this.trickleInterval;
+    }
+    refresh() {
+        requestAnimationFrame(() => {
+            this.progressElement.style.width = `${10 + this.value * 90}%`;
+        });
+    }
+    createStylesheetElement() {
+        const element = document.createElement("style");
+        element.type = "text/css";
+        element.textContent = ProgressBar.defaultCSS;
+        return element;
+    }
+    createProgressElement() {
+        const element = document.createElement("div");
+        element.className = "turbolinks-progress-bar";
+        return element;
+    }
+}
+ProgressBar.animationDuration = 300; /*ms*/
+export { ProgressBar };

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

@@ -0,0 +1,14 @@
+export type RenderCallback = () => void;
+export interface RenderDelegate {
+    viewWillRender(newBody: HTMLBodyElement): void;
+    viewRendered(newBody: HTMLBodyElement): void;
+    viewInvalidated(): void;
+}
+export declare abstract class Renderer {
+    abstract delegate: RenderDelegate;
+    abstract newBody: HTMLBodyElement;
+    renderView(callback: RenderCallback): void;
+    invalidateView(): void;
+    createScriptElement(element: Element): Element;
+}
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/renderer.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC;AAExC,MAAM,WAAW,cAAc;IAC7B,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/C,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7C,eAAe,IAAI,IAAI,CAAC;CACzB;AAED,8BAAsB,QAAQ;IAC5B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAElC,UAAU,CAAC,QAAQ,EAAE,cAAc;IAMnC,cAAc;IAId,mBAAmB,CAAC,OAAO,EAAE,OAAO;CAWrC"}

package/dist/lib/turbolinks/renderer.js

@@ -0,0 +1,28 @@
+import { array } from "./util";
+export class Renderer {
+    renderView(callback) {
+        this.delegate.viewWillRender(this.newBody);
+        callback();
+        this.delegate.viewRendered(this.newBody);
+    }
+    invalidateView() {
+        this.delegate.viewInvalidated();
+    }
+    createScriptElement(element) {
+        if (element.getAttribute("data-turbolinks-eval") == "false") {
+            return element;
+        }
+        else {
+            const createdScriptElement = document.createElement("script");
+            createdScriptElement.textContent = element.textContent;
+            createdScriptElement.async = false;
+            copyElementAttributes(createdScriptElement, element);
+            return createdScriptElement;
+        }
+    }
+}
+function copyElementAttributes(destinationElement, sourceElement) {
+    for (const { name, value } of array(sourceElement.attributes)) {
+        destinationElement.setAttribute(name, value);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Position } from "./types";
+export interface ScrollManagerDelegate {
+    scrollPositionChanged(position: Position): void;
+}
+export declare class ScrollManager {
+    readonly delegate: ScrollManagerDelegate;
+    started: boolean;
+    constructor(delegate: ScrollManagerDelegate);
+    start(): void;
+    stop(): void;
+    scrollToElement(element: Element): void;
+    scrollToPosition({ x, y }: Position): void;
+    onScroll: () => void;
+    updatePosition(position: Position): void;
+}
+//# sourceMappingURL=scroll_manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scroll_manager.d.ts","sourceRoot":"","sources":["../../../lib/turbolinks/scroll_manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,MAAM,WAAW,qBAAqB;IACpC,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CACjD;AAED,qBAAa,aAAa;IACxB,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IACzC,OAAO,UAAS;gBAEJ,QAAQ,EAAE,qBAAqB;IAI3C,KAAK;IAQL,IAAI;IAOJ,eAAe,CAAC,OAAO,EAAE,OAAO;IAIhC,gBAAgB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ;IAInC,QAAQ,aAEN;IAIF,cAAc,CAAC,QAAQ,EAAE,QAAQ;CAGlC"}

package/dist/lib/turbolinks/scroll_manager.js

@@ -0,0 +1,32 @@
+export class ScrollManager {
+    constructor(delegate) {
+        this.started = false;
+        this.onScroll = () => {
+            this.updatePosition({ x: window.pageXOffset, y: window.pageYOffset });
+        };
+        this.delegate = delegate;
+    }
+    start() {
+        if (!this.started) {
+            addEventListener("scroll", this.onScroll, false);
+            this.onScroll();
+            this.started = true;
+        }
+    }
+    stop() {
+        if (this.started) {
+            removeEventListener("scroll", this.onScroll, false);
+            this.started = false;
+        }
+    }
+    scrollToElement(element) {
+        element.scrollIntoView();
+    }
+    scrollToPosition({ x, y }) {
+        window.scrollTo(x, y);
+    }
+    // Private
+    updatePosition(position) {
+        this.delegate.scrollPositionChanged(position);
+    }
+}