swup 2.0.19 → 3.0.0-rc.1

package/dist/src/index.d.ts

@@ -0,0 +1,97 @@
+import Cache from './modules/Cache.js';
+import getAnimationPromises from './modules/getAnimationPromises.js';
+import { Plugin } from "./modules/plugins";
+import { Handlers, Transition } from "./types";
+import delegate from "delegate-it";
+import { Unsubscribe } from "./helpers/delegateEvent";
+export type Options = {
+    animateHistoryBrowsing: boolean;
+    animationSelector: string | false;
+    linkSelector: string;
+    cache: boolean;
+    containers: string[];
+    requestHeaders: Record<string, string>;
+    plugins: Plugin[];
+    skipPopStateHandling: (event: any) => boolean;
+    ignoreVisit: (href: string, { el }: {
+        el?: Element;
+    }) => boolean;
+    resolveUrl: (url: string) => string;
+};
+type DelegatedListeners = {
+    click?: Unsubscribe;
+};
+export default class Swup {
+    version: string;
+    _handlers: Handlers;
+    scrollToElement: string | null;
+    preloadPromise: (Promise<any> & {
+        route: string;
+    }) | null;
+    options: Options;
+    plugins: Plugin[];
+    transition: Transition;
+    cache: Cache;
+    currentPageUrl: string;
+    delegatedListeners: DelegatedListeners;
+    boundPopStateHandler: (event: PopStateEvent) => void;
+    loadPage: (this: Swup, data: import("./types").TransitionOptions, popstate: PopStateEvent | null) => void;
+    leavePage: (this: Swup, data: import("./types").TransitionOptions, { popstate, skipTransition }?: {
+        popstate: PopStateEvent | null;
+        skipTransition?: boolean | undefined;
+    }) => Promise<void>[];
+    renderPage: (this: Swup, page: import("./modules/Cache.js").PageRecord, { popstate, skipTransition }?: {
+        popstate: PopStateEvent | null;
+        skipTransition?: boolean | undefined;
+    }) => void;
+    replaceContent: ({ blocks, title }: {
+        blocks: string[];
+        title: string;
+    }) => Promise<void>;
+    enterPage: (this: Swup, { popstate, skipTransition }: {
+        popstate?: PopStateEvent | undefined;
+        skipTransition?: boolean | undefined;
+    }) => Promise<void>[];
+    triggerEvent: (this: Swup, eventName: import("./types").EventType, originalEvent?: PopStateEvent | MouseEvent | undefined) => void;
+    delegateEvent: <Selector extends string, TEvent extends keyof GlobalEventHandlersEventMap>(selector: Selector, type: TEvent, callback: delegate.EventHandler<GlobalEventHandlersEventMap[TEvent], Element>, { base, ...eventOptions }?: {
+        base?: Document | undefined;
+    }) => Unsubscribe;
+    on: (this: Swup, event: import("./types").EventType, handler: import("./types").Handler) => void;
+    off: (this: Swup, event?: import("./types").EventType | undefined, handler?: import("./types").Handler | undefined) => void;
+    updateTransition: (this: Swup, from: string, to: string, custom?: string | undefined) => void;
+    getAnimationPromises: typeof getAnimationPromises;
+    getPageData: (this: Swup, request: XMLHttpRequest) => import("./modules/getPageData.js").PageData | null;
+    getAnchorElement: (hash: string) => Element | null;
+    log: (message: string, context?: any) => void;
+    use: (this: Swup, plugin: Plugin) => Plugin[] | undefined;
+    unuse: (this: Swup, plugin: Plugin) => Plugin[] | undefined;
+    findPlugin: (this: Swup, pluginName: string) => Plugin | undefined;
+    getCurrentUrl: ({ hash }?: {
+        hash?: boolean | undefined;
+    }) => string;
+    cleanupAnimationClasses: () => void;
+    constructor(setOptions: Partial<Options>);
+    enable(): void;
+    destroy(): void;
+    shouldIgnoreVisit(href: string, { el }?: {
+        el?: Element;
+    }): boolean;
+    linkClickHandler(event: delegate.Event<MouseEvent>): void;
+    handleLinkToSamePage(url: string, hash: string, event: MouseEvent): void;
+    triggerWillOpenNewWindow(triggerEl: Element): boolean;
+    popStateHandler(event: PopStateEvent): void;
+    /**
+     * Utility function to validate and run the global option 'resolveUrl'
+     * @param {string} url
+     * @returns {string} the resolved url
+     */
+    resolveUrl(url: string): string;
+    /**
+     * Compares the resolved version of two paths and returns true if they are the same
+     * @param {string} url1
+     * @param {string} url2
+     * @returns {boolean}
+     */
+    isSameResolvedUrl(url1: string, url2: string): boolean;
+}
+export {};

package/dist/src/modules/Cache.d.ts

@@ -0,0 +1,20 @@
+import Swup from '../index';
+import { PageData } from './getPageData';
+export interface PageRecord extends PageData {
+    url: string;
+    responseURL: string;
+}
+export declare class Cache {
+    pages: Record<string, PageRecord>;
+    last: PageRecord | null;
+    swup: Swup;
+    constructor(swup: Swup);
+    getCacheUrl(url: string): string;
+    cacheUrl(page: PageRecord): void;
+    getPage(url: string): PageRecord;
+    getCurrentPage(): PageRecord;
+    exists(url: string): boolean;
+    empty(): void;
+    remove(url: string): void;
+}
+export default Cache;

package/dist/src/modules/enterPage.d.ts

@@ -0,0 +1,6 @@
+import Swup from '../index';
+declare const enterPage: (this: Swup, { popstate, skipTransition }: {
+    popstate?: PopStateEvent | undefined;
+    skipTransition?: boolean | undefined;
+}) => Promise<void>[];
+export default enterPage;

package/dist/src/modules/getAnchorElement.d.ts

@@ -0,0 +1,2 @@
+declare const getAnchorElement: (hash: string) => Element | null;
+export default getAnchorElement;

package/dist/src/modules/getAnimationPromises.d.ts

@@ -0,0 +1,7 @@
+import Swup from '../index';
+export default function getAnimationPromises(this: Swup): Promise<void>[];
+export declare function getTransitionInfo(element: Element, expectedType?: 'animation' | 'transition' | null): {
+    type: string | null;
+    timeout: number;
+    propCount: number;
+};

package/dist/src/modules/getPageData.d.ts

@@ -0,0 +1,7 @@
+import Swup from '../index';
+import { PageHtmlData } from '../helpers/getDataFromHtml';
+export type PageData = PageHtmlData & {
+    responseURL: string;
+};
+declare const getPageData: (this: Swup, request: XMLHttpRequest) => PageData | null;
+export default getPageData;

package/dist/src/modules/leavePage.d.ts

@@ -0,0 +1,7 @@
+import Swup from '../index';
+import { TransitionOptions } from '../types';
+declare const leavePage: (this: Swup, data: TransitionOptions, { popstate, skipTransition }?: {
+    popstate: PopStateEvent | null;
+    skipTransition?: boolean | undefined;
+}) => Promise<void>[];
+export default leavePage;

package/dist/src/modules/loadPage.d.ts

@@ -0,0 +1,4 @@
+import Swup from '../index';
+import { TransitionOptions } from '../types';
+declare const loadPage: (this: Swup, data: TransitionOptions, popstate: PopStateEvent | null) => void;
+export default loadPage;

package/dist/src/modules/off.d.ts

@@ -0,0 +1,4 @@
+import Swup from '../index';
+import { EventType, Handler } from '../types';
+declare const off: (this: Swup, event?: EventType, handler?: Handler) => void;
+export default off;

package/dist/src/modules/on.d.ts

@@ -0,0 +1,4 @@
+import { EventType, Handler } from '../types';
+import Swup from '../index';
+declare const on: (this: Swup, event: EventType, handler: Handler) => void;
+export default on;

package/dist/src/modules/plugins.d.ts

@@ -0,0 +1,13 @@
+import Swup from '../index';
+export type Plugin = {
+    name: string;
+    mount: () => void;
+    unmount: () => void;
+    isSwupPlugin: true;
+    swup?: Swup;
+    _beforeMount?: () => void;
+    _afterUnmount?: () => void;
+};
+export declare const use: (this: Swup, plugin: Plugin) => Plugin[] | undefined;
+export declare const unuse: (this: Swup, plugin: Plugin) => Plugin[] | undefined;
+export declare const findPlugin: (this: Swup, pluginName: string) => Plugin | undefined;

package/dist/src/modules/renderPage.d.ts

@@ -0,0 +1,7 @@
+import Swup from '../index';
+import { PageRecord } from './Cache';
+declare const renderPage: (this: Swup, page: PageRecord, { popstate, skipTransition }?: {
+    popstate: PopStateEvent | null;
+    skipTransition?: boolean | undefined;
+}) => void;
+export default renderPage;

package/dist/src/modules/replaceContent.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Perform the replacement of content after loading a page.
+ *
+ * This method can be replaced or augmented by plugins to allow pausing.
+ *
+ * It takes an object with the page data as return from `getPageData` and has to
+ * return a Promise that resolves once all content has been replaced and the
+ * site is ready to start animating in the new page.
+ *
+ * @param {object} page The page object
+ * @returns Promise
+ */
+declare const replaceContent: ({ blocks, title }: {
+    blocks: string[];
+    title: string;
+}) => Promise<void>;
+export default replaceContent;

package/dist/src/modules/triggerEvent.d.ts

@@ -0,0 +1,4 @@
+import { EventType } from '../types';
+import Swup from '../index';
+declare const triggerEvent: (this: Swup, eventName: EventType, originalEvent?: PopStateEvent | MouseEvent) => void;
+export default triggerEvent;

package/dist/src/modules/updateTransition.d.ts

@@ -0,0 +1,3 @@
+import Swup from '../index';
+declare const updateTransition: (this: Swup, from: string, to: string, custom?: string) => void;
+export default updateTransition;

package/dist/src/src/config/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Import swup's current version from package.json
+ */
+declare const _default: string;
+export default _default;

package/dist/src/src/helpers/Location.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A helper for creating a Location from either an element
+ * or a URL object/string
+ *
+ * Note: this could be implemented as a class inheriting from URL
+ * Except: Babel will add tons of boilerplate for ES6 classes + getters
+ * So for now it's implemented as an augmented URL object with custom getter
+ *
+ * class Location extends URL {
+ *   get url() {
+ *	 return this.pathname + this.search;
+ *   }
+ * }
+ *
+ */
+export default class Location extends URL {
+    constructor(url: string, base?: string);
+    get url(): string;
+    /**
+     * Instantiate a Location from an element's href attribute
+     * @param {Element} el
+     * @return new Location instance
+     */
+    static fromElement(el: HTMLAnchorElement): Location;
+    /**
+     * Instantiate a Location from a URL object or string
+     * @param {URL|string} url
+     * @return new Location instance
+     */
+    static fromUrl(url: string): Location;
+}

package/dist/src/src/helpers/classify.d.ts

@@ -0,0 +1,2 @@
+declare const classify: (text: string, fallback?: string) => string;
+export default classify;

package/dist/src/src/helpers/cleanupAnimationClasses.d.ts

@@ -0,0 +1,2 @@
+declare const cleanupAnimationClasses: () => void;
+export default cleanupAnimationClasses;

package/dist/src/src/helpers/createHistoryRecord.d.ts

@@ -0,0 +1,2 @@
+declare const createHistoryRecord: (url: string, customData?: Record<string, unknown>) => void;
+export default createHistoryRecord;

package/dist/src/src/helpers/delegateEvent.d.ts

@@ -0,0 +1,8 @@
+import delegate from 'delegate-it';
+export type Unsubscribe = {
+    destroy: () => void;
+};
+declare const delegateEvent: <Selector extends string, TEvent extends keyof GlobalEventHandlersEventMap>(selector: Selector, type: TEvent, callback: delegate.EventHandler<GlobalEventHandlersEventMap[TEvent], Element>, { base, ...eventOptions }?: {
+    base?: Document | undefined;
+}) => Unsubscribe;
+export default delegateEvent;

package/dist/src/src/helpers/fetch.d.ts

@@ -0,0 +1,6 @@
+import { TransitionOptions } from '../modules/loadPage';
+import { Options } from '../index';
+declare const fetch: (setOptions: TransitionOptions & {
+    headers: Options['requestHeaders'];
+}, callback: (request: XMLHttpRequest) => void) => XMLHttpRequest;
+export default fetch;

package/dist/src/src/helpers/getCurrentUrl.d.ts

@@ -0,0 +1,4 @@
+declare const getCurrentUrl: ({ hash }?: {
+    hash?: boolean | undefined;
+}) => string;
+export default getCurrentUrl;

package/dist/src/src/helpers/getDataFromHtml.d.ts

@@ -0,0 +1,8 @@
+export type PageHtmlData = {
+    title: string;
+    originalContent: string;
+    blocks: string[];
+    pageClass?: string;
+};
+declare const getDataFromHtml: (html: string, containers: string[]) => PageHtmlData;
+export default getDataFromHtml;

package/dist/src/src/helpers/index.d.ts

@@ -0,0 +1,11 @@
+export { default as classify } from './classify.js';
+export { default as createHistoryRecord } from './createHistoryRecord.js';
+export { default as updateHistoryRecord } from './updateHistoryRecord.js';
+export { default as delegateEvent } from './delegateEvent.js';
+export { default as getDataFromHtml } from './getDataFromHtml.js';
+export { default as fetch } from './fetch.js';
+export { default as getCurrentUrl } from './getCurrentUrl.js';
+export { default as Location } from './Location.js';
+export { default as markSwupElements } from './markSwupElements.js';
+export { default as cleanupAnimationClasses } from './cleanupAnimationClasses.js';
+export { default as versionSatisfies } from './versionSatisfies.js';

package/dist/src/src/helpers/markSwupElements.d.ts

@@ -0,0 +1,2 @@
+declare const markSwupElements: (element: Element, containers: string[]) => void;
+export default markSwupElements;

package/dist/src/src/helpers/updateHistoryRecord.d.ts

@@ -0,0 +1,2 @@
+declare const updateHistoryRecord: (url?: string | null, customData?: Record<string, unknown>) => void;
+export default updateHistoryRecord;

package/dist/src/src/helpers/versionSatisfies.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Check if a version satisfies all given version requirements
+ *
+ * versionSatisfies('2.1.0', ['>=2', '<4']) // true
+ * versionSatisfies('2.1.0', ['5']) // false
+ *
+ * @param {string} installed Installed version
+ * @param {Array.<string>} requirements Array of requirements that must be satisfied
+ * @returns boolean
+ */
+export declare const versionSatisfies: (installed: string, requirements: string[]) => boolean;
+export default versionSatisfies;

package/dist/src/src/helpers.d.ts

@@ -0,0 +1 @@
+export * from './helpers/index.js';

package/dist/src/src/index.d.ts

@@ -0,0 +1,103 @@
+import Cache from './modules/Cache.js';
+import getAnimationPromises from './modules/getAnimationPromises.js';
+import { unuse, findPlugin } from './modules/plugins.js';
+import { Plugin } from './modules/plugins';
+import { Handlers } from './modules/on';
+import delegate from 'delegate-it';
+import { Unsubscribe } from './helpers/delegateEvent';
+export type Transition = {
+    from?: string;
+    to?: string;
+    custom?: string;
+};
+type DelegatedListeners = {
+    click?: Unsubscribe;
+};
+export type Options = {
+    animateHistoryBrowsing: boolean;
+    animationSelector: string | false;
+    linkSelector: string;
+    cache: boolean;
+    containers: string[];
+    requestHeaders: Record<string, string>;
+    plugins: Plugin[];
+    skipPopStateHandling: (event: any) => boolean;
+    ignoreVisit: (href: string, { el }: {
+        el?: Element;
+    }) => boolean;
+    resolveUrl: (url: string) => string;
+};
+export default class Swup {
+    version: string;
+    _handlers: Handlers;
+    scrollToElement: string | null;
+    preloadPromise: (Promise<any> & {
+        route: string;
+    }) | null;
+    options: Options;
+    plugins: Plugin[];
+    transition: Transition;
+    cache: Cache;
+    currentPageUrl: string;
+    delegatedListeners: DelegatedListeners;
+    boundPopStateHandler: (event: PopStateEvent) => void;
+    loadPage: (this: Swup, data: import("./modules/loadPage.js").TransitionOptions, popstate: PopStateEvent | null) => void;
+    leavePage: (this: Swup, data: import("./modules/loadPage.js").TransitionOptions, { popstate, skipTransition }?: {
+        popstate: PopStateEvent | null;
+        skipTransition?: boolean | undefined;
+    }) => Promise<void>[];
+    renderPage: (this: Swup, page: import("./modules/Cache.js").PageRecord, { popstate, skipTransition }?: {
+        popstate: PopStateEvent | null;
+        skipTransition?: boolean | undefined;
+    }) => void;
+    replaceContent: ({ blocks, title }: {
+        blocks: string[];
+        title: string;
+    }) => Promise<void>;
+    enterPage: (this: Swup, { popstate, skipTransition }: {
+        popstate?: PopStateEvent | undefined;
+        skipTransition?: boolean | undefined;
+    }) => Promise<void>[];
+    triggerEvent: (this: Swup, eventName: import("./modules/on.js").EventType, originalEvent?: PopStateEvent | MouseEvent | undefined) => void;
+    delegateEvent: <Selector extends string, TEvent extends keyof GlobalEventHandlersEventMap>(selector: Selector, type: TEvent, callback: delegate.EventHandler<GlobalEventHandlersEventMap[TEvent], Element>, { base, ...eventOptions }?: {
+        base?: Document | undefined;
+    }) => Unsubscribe;
+    on: (this: Swup, event: import("./modules/on.js").EventType, handler: import("./modules/on.js").Handler) => void;
+    off: (this: Swup, event?: import("./modules/on.js").EventType | undefined, handler?: import("./modules/on.js").Handler | undefined) => void;
+    updateTransition: (this: Swup, from: string, to: string, custom?: string | undefined) => void;
+    getAnimationPromises: typeof getAnimationPromises;
+    getPageData: (this: Swup, request: XMLHttpRequest) => import("./modules/getPageData.js").PageData | null;
+    getAnchorElement: (hash: string) => Element | null;
+    log: (message: string, context?: any) => void;
+    use: (this: Swup, plugin: Plugin) => Plugin[] | undefined;
+    unuse: typeof unuse;
+    findPlugin: typeof findPlugin;
+    getCurrentUrl: ({ hash }?: {
+        hash?: boolean | undefined;
+    }) => string;
+    cleanupAnimationClasses: () => void;
+    constructor(setOptions: Partial<Options>);
+    enable(): void;
+    destroy(): void;
+    shouldIgnoreVisit(href: string, { el }?: {
+        el?: Element;
+    }): boolean;
+    linkClickHandler(event: delegate.Event<MouseEvent>): void;
+    handleLinkToSamePage(url: string, hash: string, event: MouseEvent): void;
+    triggerWillOpenNewWindow(triggerEl: Element): boolean;
+    popStateHandler(event: PopStateEvent): void;
+    /**
+     * Utility function to validate and run the global option 'resolveUrl'
+     * @param {string} url
+     * @returns {string} the resolved url
+     */
+    resolveUrl(url: string): string;
+    /**
+     * Compares the resolved version of two paths and returns true if they are the same
+     * @param {string} url1
+     * @param {string} url2
+     * @returns {boolean}
+     */
+    isSameResolvedUrl(url1: string, url2: string): boolean;
+}
+export {};

package/dist/src/src/modules/Cache.d.ts

@@ -0,0 +1,20 @@
+import Swup from '../index';
+import { PageData } from './getPageData';
+export interface PageRecord extends PageData {
+    url: string;
+    responseURL: string;
+}
+export declare class Cache {
+    pages: Record<string, PageRecord>;
+    last: PageRecord | null;
+    swup: Swup;
+    constructor(swup: Swup);
+    getCacheUrl(url: string): string;
+    cacheUrl(page: PageRecord): void;
+    getPage(url: string): PageRecord;
+    getCurrentPage(): PageRecord;
+    exists(url: string): boolean;
+    empty(): void;
+    remove(url: string): void;
+}
+export default Cache;

package/dist/src/src/modules/enterPage.d.ts

@@ -0,0 +1,6 @@
+import Swup from '../index';
+declare const enterPage: (this: Swup, { popstate, skipTransition }: {
+    popstate?: PopStateEvent | undefined;
+    skipTransition?: boolean | undefined;
+}) => Promise<void>[];
+export default enterPage;

package/dist/src/src/modules/getAnchorElement.d.ts

@@ -0,0 +1,2 @@
+declare const getAnchorElement: (hash: string) => Element | null;
+export default getAnchorElement;

package/dist/src/src/modules/getAnimationPromises.d.ts

@@ -0,0 +1,7 @@
+import Swup from '../index';
+export default function getAnimationPromises(this: Swup, animationType: 'in' | 'out'): Promise<void>[];
+export declare function getTransitionInfo(element: Element, expectedType?: 'animation' | 'transition' | null): {
+    type: string | null;
+    timeout: number;
+    propCount: number;
+};

package/dist/src/src/modules/getPageData.d.ts

@@ -0,0 +1,7 @@
+import Swup from '../index';
+import { PageHtmlData } from '../helpers/getDataFromHtml';
+export type PageData = PageHtmlData & {
+    responseURL: string;
+};
+declare const getPageData: (this: Swup, request: XMLHttpRequest) => PageData | null;
+export default getPageData;

package/dist/src/src/modules/leavePage.d.ts

@@ -0,0 +1,7 @@
+import Swup from '../index';
+import { TransitionOptions } from './loadPage';
+declare const leavePage: (this: Swup, data: TransitionOptions, { popstate, skipTransition }?: {
+    popstate: PopStateEvent | null;
+    skipTransition?: boolean | undefined;
+}) => Promise<void>[];
+export default leavePage;

package/dist/src/src/modules/loadPage.d.ts

@@ -0,0 +1,7 @@
+import Swup from '../index';
+export type TransitionOptions = {
+    url: string;
+    customTransition?: string;
+};
+declare const loadPage: (this: Swup, data: TransitionOptions, popstate: PopStateEvent | null) => void;
+export default loadPage;

package/dist/src/src/modules/off.d.ts

@@ -0,0 +1,4 @@
+import Swup from '../index';
+import { EventType, Handler } from './on';
+declare const off: (this: Swup, event?: EventType, handler?: Handler) => void;
+export default off;

package/dist/src/src/modules/on.d.ts

@@ -0,0 +1,6 @@
+import Swup from '../index';
+export type EventType = 'animationInDone' | 'animationInStart' | 'animationOutDone' | 'animationOutStart' | 'animationSkipped' | 'clickLink' | 'contentReplaced' | 'disabled' | 'enabled' | 'openPageInNewTab' | 'pageLoaded' | 'pageRetrievedFromCache' | 'pageView' | 'popState' | 'samePage' | 'samePageWithHash' | 'serverError' | 'transitionStart' | 'transitionEnd' | 'willReplaceContent';
+export type Handler = (event?: Event) => void;
+export type Handlers = Record<EventType, Handler[]>;
+declare const on: (this: Swup, event: EventType, handler: Handler) => void;
+export default on;

package/dist/src/src/modules/plugins.d.ts

@@ -0,0 +1,14 @@
+import Swup from '../index';
+export type Plugin = {
+    name: string;
+    mount: () => void;
+    unmount: () => void;
+    isSwupPlugin: true;
+    swup?: Swup;
+    _beforeMount?: () => void;
+    _afterUnmount?: () => void;
+    _checkRequirements?: () => boolean;
+};
+export declare const use: (this: Swup, plugin: Plugin) => Plugin[] | undefined;
+export declare function unuse(this: Swup, pluginOrName: Plugin | string): Plugin[] | undefined;
+export declare function findPlugin(this: Swup, pluginOrName: Plugin | string): Plugin | undefined;

package/dist/src/src/modules/renderPage.d.ts

@@ -0,0 +1,7 @@
+import Swup from '../index';
+import { PageRecord } from './Cache';
+declare const renderPage: (this: Swup, page: PageRecord, { popstate, skipTransition }?: {
+    popstate: PopStateEvent | null;
+    skipTransition?: boolean | undefined;
+}) => void;
+export default renderPage;

package/dist/src/src/modules/replaceContent.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Perform the replacement of content after loading a page.
+ *
+ * This method can be replaced or augmented by plugins to allow pausing.
+ *
+ * It takes an object with the page data as return from `getPageData` and has to
+ * return a Promise that resolves once all content has been replaced and the
+ * site is ready to start animating in the new page.
+ *
+ * @param {object} page The page object
+ * @returns Promise
+ */
+declare const replaceContent: ({ blocks, title }: {
+    blocks: string[];
+    title: string;
+}) => Promise<void>;
+export default replaceContent;

package/dist/src/src/modules/triggerEvent.d.ts

@@ -0,0 +1,4 @@
+import { EventType } from './on';
+import Swup from '../index';
+declare const triggerEvent: (this: Swup, eventName: EventType, originalEvent?: PopStateEvent | MouseEvent) => void;
+export default triggerEvent;

package/dist/src/src/modules/updateTransition.d.ts

@@ -0,0 +1,3 @@
+import Swup from '../index';
+declare const updateTransition: (this: Swup, from: string, to: string, custom?: string) => void;
+export default updateTransition;

package/dist/src/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+export declare const query: (selector: string, context?: Document | Element) => HTMLElement | null;
+export declare const queryAll: (selector: string, context?: Document | Element) => HTMLElement[];
+export declare const nextTick: (callback: () => void) => void;
+export declare const escapeCssIdentifier: (ident: string) => string;
+export declare const toMs: (s: string) => number;

package/dist/src/src/utils.d.ts

@@ -0,0 +1 @@
+export * from './utils/index.js';

package/dist/src/types.d.ts

@@ -0,0 +1,12 @@
+export type EventType = 'animationInDone' | 'animationInStart' | 'animationOutDone' | 'animationOutStart' | 'animationSkipped' | 'clickLink' | 'contentReplaced' | 'disabled' | 'enabled' | 'openPageInNewTab' | 'pageLoaded' | 'pageRetrievedFromCache' | 'pageView' | 'popState' | 'samePage' | 'samePageWithHash' | 'serverError' | 'transitionStart' | 'transitionEnd' | 'willReplaceContent';
+export type Handler = (event?: Event) => void;
+export type Handlers = Record<EventType, Handler[]>;
+export type Transition = {
+    from?: string;
+    to?: string;
+    custom?: string;
+};
+export type TransitionOptions = {
+    url: string;
+    customTransition?: string;
+};

package/dist/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+export declare const query: (selector: string, context?: Document | Element) => HTMLElement | null;
+export declare const queryAll: (selector: string, context?: Document | Element) => HTMLElement[];
+export declare const nextTick: (callback: () => void) => void;
+export declare const escapeCssIdentifier: (ident: string) => string;
+export declare const toMs: (s: string) => number;

package/dist/src/utils.d.ts

@@ -0,0 +1 @@
+export * from './utils/index.js';

package/dist/types.cjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.cjs.map

package/dist/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/types.modern.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.modern.js.map