swup 4.3.3 → 4.4.0

package/src/modules/__test__/cache.test.ts

@@ -1,159 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import Swup from '../../Swup.js';
-import { Cache, CacheData } from '../Cache.js';
-import { Visit } from '../Visit.js';
-
-interface CacheTtlData {
-	ttl: number;
-	created: number;
-}
-
-interface CacheIndexData {
-	index: number;
-}
-
-interface AugmentedCacheData extends CacheData, CacheTtlData, CacheIndexData {}
-
-const swup = new Swup();
-const visit = swup.visit;
-const cache = new Cache(swup);
-
-const page1 = { url: '/page-1', html: '1' };
-const page2 = { url: '/page-2', html: '2' };
-const page3 = { url: '/page-3', html: '3' };
-
-describe('Cache', () => {
-	beforeEach(() => {
-		cache.clear();
-	});
-
-	it('should be empty', () => {
-		expect(cache.size).toBe(0);
-	});
-
-	it('should append pages', () => {
-		cache.set(page1.url, page1);
-		expect(cache.size).toBe(1);
-	});
-
-	it('should have pages', () => {
-		cache.set(page1.url, page1);
-		expect(cache.has(page1.url)).toBe(true);
-	});
-
-	it('should get pages', () => {
-		cache.set(page1.url, page1);
-		expect(cache.get(page1.url)).toEqual(page1);
-	});
-
-	it('should delete pages', () => {
-		cache.set(page1.url, page1);
-		expect(cache.has(page1.url)).toBe(true);
-		cache.delete(page1.url);
-		expect(cache.has(page1.url)).toBe(false);
-	});
-
-	it('should clear', () => {
-		cache.set(page1.url, page1);
-		expect(cache.size).toBe(1);
-		cache.clear();
-		expect(cache.size).toBe(0);
-	});
-
-	it('should overwrite identical pages', () => {
-		cache.set(page1.url, page1);
-		expect(cache.size).toBe(1);
-		cache.set(page1.url, page1);
-		expect(cache.size).toBe(1);
-	});
-
-	it('should not overwrite different pages', () => {
-		cache.set(page1.url, page1);
-		expect(cache.size).toBe(1);
-		cache.set(page2.url, page2);
-		expect(cache.size).toBe(2);
-	});
-
-	it('should trigger a hook on set', () => {
-		const handler = vi.fn();
-
-		swup.hooks.on('cache:set', handler);
-
-		cache.set(page1.url, page1);
-
-		expect(handler).toBeCalledTimes(1);
-		expect(handler).toBeCalledWith(visit, { page: page1 }, undefined);
-	});
-
-	it('should allow augmenting cache entries on save', () => {
-		const now = Date.now();
-
-		swup.hooks.on('cache:set', (_, { page }) => {
-			const ttl: CacheTtlData = { ttl: 1000, created: now };
-			cache.update(page.url, ttl);
-		});
-
-		cache.set('/page', { url: '/page', html: '' });
-
-		const page = cache.get('/page');
-
-		expect(page).toEqual({ url: '/page', html: '', ttl: 1000, created: now });
-	});
-
-	it('should allow manual pruning', () => {
-		swup.hooks.on('cache:set', (_, { page }) => {
-			cache.update(page.url, { index: cache.size });
-		});
-
-		cache.set(page1.url, page1);
-		cache.set(page2.url, page2);
-		cache.set(page3.url, page3);
-
-		cache.prune((url, page) => (page as AugmentedCacheData).index > 2);
-
-		expect(cache.size).toBe(2);
-		expect(cache.has(page1.url)).toBe(true);
-		expect(cache.has(page2.url)).toBe(true);
-		expect(cache.has(page3.url)).toBe(false);
-	});
-
-	it('should return a copy from cache.get()', () => {
-		cache.set(page1.url, page1);
-		const page = cache.get(page1.url);
-		page!.html = 'new';
-		expect(cache.get(page1.url)?.html).toEqual(page1.html);
-	});
-
-	it('should return a new Map with shallow copies from cache.all', () => {
-		cache.set(page1.url, page1);
-		cache.set(page2.url, page2);
-
-		const all = cache.all;
-		all.get(page1.url)!.html = 'new';
-
-		expect(cache.get(page1.url)?.html).toEqual(page1.html);
-	});
-});
-
-describe('Types', () => {
-	it('error when necessary', async () => {
-		const swup = new Swup();
-		const cache = new Cache(swup);
-
-		// @ts-expect-no-error
-		swup.hooks.on('history:popstate', (visit: Visit, { event: PopStateEvent }) => {});
-		// @ts-expect-no-error
-		await swup.hooks.call('history:popstate', { event: new PopStateEvent('') });
-
-		try {
-			// @ts-expect-error
-			cache.set();
-			// @ts-expect-error
-			cache.set(url);
-			// @ts-expect-error
-			cache.set(url, {});
-			// @ts-expect-error
-			cache.set({ url: '/test' });
-		} catch (error) {}
-	});
-});

package/src/modules/__test__/delegateEvent.test.ts

@@ -1,36 +0,0 @@
-import { DelegateEvent } from 'delegate-it';
-import { describe, it } from 'vitest';
-
-import { delegateEvent } from '../../helpers/delegateEvent.js';
-
-describe('delegateEvent', () => {
-	it('should return correct types', () => {
-		delegateEvent('form', 'submit', (event) => {});
-
-		// @ts-expect-no-error
-		delegateEvent('form', 'submit', (event: SubmitEvent) => {});
-		// @ts-expect-error
-		delegateEvent('form', 'submit', (event: MouseEvent) => {});
-
-		// @ts-expect-no-error
-		delegateEvent('form', 'submit', (event: DelegateEvent<SubmitEvent>) => {});
-		// @ts-expect-error
-		delegateEvent('form', 'submit', (event: DelegateEvent<MouseEvent>) => {});
-
-		// @ts-expect-no-error
-		delegateEvent('form', 'submit', (event: DelegateEvent<SubmitEvent, HTMLFormElement>) => {});
-		delegateEvent(
-			'form',
-			'submit',
-			// @ts-expect-error
-			(event: DelegateEvent<MouseEvent, HTMLAnchorElement>) => {}
-		);
-
-		delegateEvent('form', 'submit', (event) => {
-			// @ts-expect-no-error
-			const el: HTMLFormElement = event.delegateTarget;
-		});
-		// @ts-expect-error
-		delegateEvent('form', 'submit', (event: MouseEvent) => {});
-	});
-});

package/src/modules/__test__/hooks.test.ts

@@ -1,319 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import Swup from '../../Swup.js';
-import { DefaultHandler, Handler, Hooks } from '../Hooks.js';
-import { Visit } from '../Visit.js';
-
-describe('Hook registry', () => {
-	it('should add handlers', () => {
-		const swup = new Swup();
-		const handler = vi.fn();
-
-		// Make private fields public for this test
-		const HooksWithAccess = class extends Hooks {
-			getRegistry() {
-				return this.registry;
-			}
-		};
-		const hooks = new HooksWithAccess(swup);
-
-		hooks.on('enable', handler);
-		const ledger = hooks.getRegistry().get('enable');
-
-		expect(ledger).toBeDefined();
-		expect(ledger).toBeInstanceOf(Map);
-		expect(ledger!.size).toBe(1);
-
-		const registrations = Array.from(ledger!.values());
-		const registration = registrations.find((reg) => reg.handler === handler);
-
-		expect(registration?.handler).toEqual(handler);
-	});
-
-	it('should remove handlers', async () => {
-		const swup = new Swup();
-		const handler1 = vi.fn();
-		const handler2 = vi.fn();
-
-		swup.hooks.on('enable', handler1);
-		swup.hooks.on('enable', handler2);
-
-		await swup.hooks.call('enable', undefined);
-
-		expect(handler1).toBeCalledTimes(1);
-		expect(handler2).toBeCalledTimes(1);
-
-		swup.hooks.off('enable', handler2);
-
-		await swup.hooks.call('enable', undefined);
-
-		expect(handler1).toBeCalledTimes(2);
-		expect(handler2).toBeCalledTimes(1);
-	});
-
-	it('should return a function to unregister the handler', async () => {
-		const swup = new Swup();
-		const handler1 = vi.fn();
-		const handler2 = vi.fn();
-
-		const unregister1 = swup.hooks.on('enable', handler1);
-		const unregister2 = swup.hooks.on('enable', handler2);
-
-		expect(unregister1).toBeTypeOf('function');
-
-		await swup.hooks.call('enable', undefined);
-
-		expect(handler1).toBeCalledTimes(1);
-		expect(handler2).toBeCalledTimes(1);
-
-		unregister2();
-
-		await swup.hooks.call('enable', undefined);
-
-		expect(handler1).toBeCalledTimes(2);
-		expect(handler2).toBeCalledTimes(1);
-	});
-
-	it('should trigger custom handlers', async () => {
-		const swup = new Swup();
-		const handler = vi.fn();
-
-		swup.hooks.on('enable', handler);
-
-		await swup.hooks.call('enable', undefined);
-
-		expect(handler).toBeCalledTimes(1);
-	});
-
-	it('should only trigger custom handlers once if requested', async () => {
-		const swup = new Swup();
-		const handler = vi.fn();
-
-		swup.hooks.on('enable', handler, { once: true });
-
-		await swup.hooks.call('enable', undefined, () => {});
-		await swup.hooks.call('enable', undefined, () => {});
-
-		expect(handler).toBeCalledTimes(1);
-	});
-
-	it('should only trigger custom handlers once if using alias', async () => {
-		const swup = new Swup();
-		const handler = vi.fn();
-
-		swup.hooks.once('enable', handler);
-
-		await swup.hooks.call('enable', undefined, () => {});
-		await swup.hooks.call('enable', undefined, () => {});
-
-		expect(handler).toBeCalledTimes(1);
-	});
-
-	it('should trigger original handlers', async () => {
-		const swup = new Swup();
-		const handler = vi.fn();
-
-		await swup.hooks.call('enable', undefined, handler);
-
-		expect(handler).toBeCalledTimes(1);
-	});
-
-	it('should allow triggering custom handlers before original handler', async () => {
-		const swup = new Swup();
-
-		let called: Array<string> = [];
-		const handlers = {
-			before: () => {
-				called.push('before');
-			},
-			original: () => {
-				called.push('original');
-			},
-			normal: () => {
-				called.push('normal');
-			},
-			after: () => {
-				called.push('after');
-			}
-		};
-
-		swup.hooks.on('disable', handlers.before, { before: true });
-		swup.hooks.on('disable', handlers.normal, {});
-		swup.hooks.on('disable', handlers.after, {});
-
-		await swup.hooks.call('disable', undefined, handlers.original);
-
-		expect(called).toEqual(['before', 'original', 'normal', 'after']);
-	});
-
-	it('should sort custom handlers by priority', async () => {
-		const swup = new Swup();
-
-		let called: Array<number> = [];
-		const handlers = {
-			1: () => {
-				called.push(1);
-			},
-			2: () => {
-				called.push(2);
-			},
-			3: () => {
-				called.push(3);
-			},
-			4: () => {
-				called.push(4);
-			},
-			5: () => {
-				called.push(5);
-			},
-			6: () => {
-				called.push(6);
-			},
-			7: () => {
-				called.push(7);
-			},
-			8: () => {
-				called.push(8);
-			},
-			9: () => {
-				called.push(9);
-			}
-		};
-
-		swup.hooks.on('disable', handlers['1'], { priority: 2, before: true });
-		swup.hooks.on('disable', handlers['2'], { priority: -1, before: true });
-		swup.hooks.on('disable', handlers['3'], { priority: 1 });
-		swup.hooks.on('disable', handlers['9']);
-		swup.hooks.on('disable', handlers['4']);
-		swup.hooks.on('disable', handlers['8'], { priority: 4 });
-		swup.hooks.on('disable', handlers['7'], { priority: 4 });
-
-		await swup.hooks.call('disable', undefined, handlers['5']);
-
-		expect(called).toEqual([2, 1, 5, 9, 4, 3, 8, 7]);
-	});
-
-	it('should allow replacing original handlers', async () => {
-		const swup = new Swup();
-		const customHandler = vi.fn();
-		const defaultHandler = vi.fn();
-
-		swup.hooks.on('enable', customHandler, { replace: true });
-
-		await swup.hooks.call('enable', undefined, defaultHandler);
-
-		expect(defaultHandler).toBeCalledTimes(0);
-		expect(customHandler).toBeCalledTimes(1);
-	});
-
-	it('should only execute the last replacing handler', async () => {
-		const swup = new Swup();
-		const firstHandler = vi.fn();
-		const secondHandler = vi.fn();
-		const defaultHandler = vi.fn();
-
-		swup.hooks.on('enable', firstHandler, { replace: true });
-		swup.hooks.on('enable', secondHandler, { replace: true });
-
-		await swup.hooks.call('enable', undefined, defaultHandler);
-
-		expect(defaultHandler).toBeCalledTimes(0);
-		expect(firstHandler).toBeCalledTimes(0);
-		expect(secondHandler).toBeCalledTimes(1);
-	});
-
-	it('should pass original handler into replacing handlers', async () => {
-		const swup = new Swup();
-		const args = { foo: 'bar' };
-		const customHandler = vi.fn((c, a, handler) => handler(c, args));
-		const defaultHandler = vi.fn();
-		const visit = swup.visit;
-
-		swup.hooks.on('enable', customHandler, { replace: true });
-
-		await swup.hooks.call('enable', undefined, defaultHandler);
-
-		expect(customHandler).toBeCalledWith(visit, undefined, defaultHandler);
-		expect(defaultHandler).toBeCalledWith(visit, args);
-	});
-
-	it('should return result of replacing handler', async () => {
-		const swup = new Swup();
-		const customHandler = vi.fn(async () => 'foo');
-		const defaultHandler = vi.fn(async () => 'bar');
-
-		swup.hooks.on('enable', customHandler, { replace: true });
-
-		const result = await swup.hooks.call('enable', undefined, defaultHandler);
-
-		expect(result).toEqual('foo');
-	});
-
-	it('should pass previous handler into nested replacing handlers', async () => {
-		const swup = new Swup();
-		const args1 = { foo: 'bar' };
-		const args2 = { foo: 'baz' };
-		const args3 = { foo: 'bag' };
-		const defaultHandler = vi.fn();
-		const firstHandler = vi.fn((c, a, handler) => handler(c, args1));
-		const secondHandler = vi.fn((c, a, handler) => handler(c, args2));
-		const thirdHandler = vi.fn((c, a, handler) => handler(c, args3, handler));
-		const visit = swup.visit;
-
-		swup.hooks.on('enable', firstHandler, { replace: true });
-		swup.hooks.on('enable', secondHandler, { replace: true });
-		swup.hooks.on('enable', thirdHandler, { replace: true });
-
-		await swup.hooks.call('enable', undefined, defaultHandler);
-
-		expect(defaultHandler).toBeCalledWith(visit, args1);
-		expect(thirdHandler).toBeCalledWith(visit, undefined, expect.any(Function));
-		expect(secondHandler).toBeCalledWith(visit, args3, expect.any(Function));
-		expect(firstHandler).toBeCalledWith(visit, args2, expect.any(Function));
-	});
-
-	it('should not pass original handler into normal handlers', async () => {
-		const swup = new Swup();
-		const listener = vi.fn();
-		const handler = vi.fn();
-		const visit = swup.visit;
-
-		swup.hooks.on('enable', listener);
-
-		await swup.hooks.call('enable', undefined, handler);
-
-		expect(listener).toBeCalledWith(visit, undefined, undefined);
-	});
-
-	it('should trigger event handler with visit and args', async () => {
-		const swup = new Swup();
-		const handler: Handler<'history:popstate'> = vi.fn();
-		const visit = swup.visit;
-		const args = { event: new PopStateEvent('') };
-
-		swup.hooks.on('history:popstate', handler);
-		await swup.hooks.call('history:popstate', args);
-
-		expect(handler).toBeCalledTimes(1);
-		expect(handler).toBeCalledWith(visit, args, undefined);
-	});
-});
-
-describe('Types', () => {
-	it('error when necessary', async () => {
-		const swup = new Swup();
-
-		// @ts-expect-no-error
-		swup.hooks.on('history:popstate', (visit: Visit, { event }: { event: PopStateEvent }) => {});
-		// @ts-expect-no-error
-		await swup.hooks.call('history:popstate', { event: new PopStateEvent('') });
-
-		// @ts-expect-error: first arg must be Visit object
-		swup.hooks.on('history:popstate', ({ event: MouseEvent }) => {});
-		// @ts-expect-error: event arg must be PopStateEvent
-		swup.hooks.on('history:popstate', (visit: Visit, { event }: { event: MouseEvent }) => {});
-		// @ts-expect-error: event arg must be PopStateEvent
-		await swup.hooks.call('history:popstate', { event: new MouseEvent('') });
-		// @ts-expect-error: handler arg must be optional: handler?
-		swup.hooks.replace('enable', (visit: Visit, args: undefined, handler: DefaultHandler<'enable'>) => {});
-	});
-});

package/src/modules/__test__/plugins.test.ts

@@ -1,89 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import Swup from '../../index.js';
-
-function createPlugin(plugin = {}) {
-	return {
-		name: 'SwupTestPlugin',
-		isSwupPlugin: true as const,
-		mount: vi.fn(() => {}),
-		unmount: vi.fn(() => {}),
-		_checkRequirements: vi.fn(() => true),
-		...plugin
-	};
-}
-
-describe('Plugins', () => {
-	it('should mount and unmount plugins', function () {
-		const plugin = createPlugin();
-		const swup = new Swup();
-		swup.use(plugin);
-		swup.unuse(plugin);
-
-		expect(plugin.mount.mock.calls).toHaveLength(1);
-		expect(plugin.unmount.mock.calls).toHaveLength(1);
-	});
-
-	it('should mount plugins from options', function () {
-		const plugin = createPlugin();
-		const swup = new Swup({ plugins: [plugin] });
-		expect(plugin.mount.mock.calls).toHaveLength(1);
-	});
-
-	it('should find a plugin instance by reference', function () {
-		const plugin = createPlugin({ name: 'SwupExamplePlugin' });
-		const swup = new Swup({ plugins: [plugin] });
-		const instance = swup.findPlugin(plugin);
-
-		expect(instance).toEqual(expect.objectContaining({ name: 'SwupExamplePlugin' }));
-	});
-
-	it('should not find a plugin instance by wrong reference', function () {
-		const plugin = createPlugin({ name: 'SwupExamplePlugin' });
-		const otherPlugin = createPlugin({ name: 'SwupOtherPlugin' });
-		const swup = new Swup({ plugins: [plugin] });
-		const instance = swup.findPlugin(otherPlugin);
-
-		expect(instance).toEqual(undefined);
-	});
-
-	it('should find a plugin instance by name', function () {
-		const plugin = createPlugin({ name: 'SwupExamplePlugin' });
-		const swup = new Swup({ plugins: [plugin] });
-		const instance = swup.findPlugin('SwupExamplePlugin');
-
-		expect(instance).toEqual(expect.objectContaining({ name: 'SwupExamplePlugin' }));
-	});
-
-	it('should find a plugin instance by unprefixed name', function () {
-		const plugin = createPlugin({ name: 'SwupExamplePlugin' });
-		const swup = new Swup({ plugins: [plugin] });
-		const instance = swup.findPlugin('ExamplePlugin');
-
-		expect(instance).toEqual(expect.objectContaining({ name: 'SwupExamplePlugin' }));
-	});
-
-	it('should check plugin requirements', function () {
-		const plugin = createPlugin();
-		const swup = new Swup({ plugins: [plugin] });
-		expect(plugin._checkRequirements.mock.calls).toHaveLength(1);
-	});
-
-	it('should reject plugins with unmet requirements', function () {
-		const allowedPlugin = createPlugin({
-			name: 'AllowedPlugin',
-			_checkRequirements: () => true
-		});
-		const unallowedPlugin = createPlugin({
-			name: 'UnallowedPlugin',
-			_checkRequirements: () => false
-		});
-		const swup = new Swup({ plugins: [allowedPlugin, unallowedPlugin] });
-
-		const allowedInstance = swup.findPlugin(allowedPlugin);
-		expect(allowedInstance).toEqual(expect.objectContaining({ name: 'AllowedPlugin' }));
-
-		const unallowedInstance = swup.findPlugin(unallowedPlugin);
-		expect(unallowedInstance).toBeUndefined();
-	});
-});

package/src/modules/__test__/replaceContent.test.ts

@@ -1,91 +0,0 @@
-import { describe, expect, it, vi, afterEach } from 'vitest';
-import Swup from '../../Swup.js';
-import type { PageData } from '../fetchPage.js';
-import { JSDOM } from 'jsdom';
-
-const getHtml = (body: string): string => {
-	return /*html*/ `
-		<!DOCTYPE html>
-		<body>
-			${body}
-		</body>
-	`;
-};
-
-const mockPage = (body: string): PageData => {
-	return {
-		url: '',
-		html: getHtml(body)
-	};
-};
-
-const stubGlobalDocument = (body: string): void => {
-	const dom = new JSDOM(getHtml(body));
-	vi.stubGlobal('document', dom.window.document);
-};
-
-describe('replaceContent', () => {
-	afterEach(() => {
-		vi.unstubAllGlobals();
-	});
-
-	it('should replace containers', () => {
-		stubGlobalDocument(/*html*/ `
-			<div id="container-1" data-from="current"></div>
-			<div id="container-2" data-from="current"></div>
-			<div id="container-3" data-from="current"></div>
-		`);
-
-		const page = mockPage(/*html*/ `
-			<div id="container-1" data-from="incoming"></div>
-			<div id="container-2" data-from="incoming"></div>`);
-		const swup = new Swup();
-
-		const result = swup.replaceContent(page, { containers: ['#container-1', '#container-2'] });
-
-		expect(result).toBe(true);
-		expect(document.querySelector('#container-1')?.getAttribute('data-from')).toBe('incoming');
-		expect(document.querySelector('#container-2')?.getAttribute('data-from')).toBe('incoming');
-		expect(document.querySelector('#container-3')?.getAttribute('data-from')).toBe('current');
-	});
-
-	it('should handle missing containers in current DOM', () => {
-		stubGlobalDocument(/*html*/ `
-			<div id="container-1" data-from="current"></div>
-		`);
-		const warn = vi.spyOn(console, 'warn');
-		const page = mockPage(/*html*/ `
-			<div id="container-1" data-from="incoming"></div>
-			<div id="container-2" data-from="incoming"></div>
-			`);
-
-		const swup = new Swup();
-		const result = swup.replaceContent(page, { containers: ['#container-1', '#missing'] });
-
-		expect(result).toBe(false);
-		expect(warn).not.toBeCalledWith(
-			'[swup] Container missing in current document: #container-1'
-		);
-		expect(warn).toBeCalledWith('[swup] Container missing in current document: #missing');
-	});
-
-	it('should handle missing containers in incoming DOM', () => {
-		stubGlobalDocument(/*html*/ `
-			<div id="container-1" data-from="current"></div>
-			<div id="container-2" data-from="current"></div>
-			<div id="container-3" data-from="current"></div>
-		`);
-		const warn = vi.spyOn(console, 'warn');
-		const page = mockPage(/*html*/ `
-			<div id="container-1" data-from="incoming"></div>`);
-
-		const swup = new Swup();
-		const result = swup.replaceContent(page, { containers: ['#container-1', '#missing'] });
-
-		expect(result).toBe(false);
-		expect(warn).not.toBeCalledWith(
-			'[swup] Container missing in incoming document: #container-1'
-		);
-		expect(warn).toBeCalledWith('[swup] Container missing in incoming document: #missing');
-	});
-});