swup 4.3.4 → 4.4.1

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');
-	});
-});

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

@@ -1,92 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import Swup from '../../Swup.js';
-import { Visit, createVisit } from '../Visit.js';
-
-class SwupWithPublicVisitMethods extends Swup {
-	public createVisit = createVisit;
-}
-
-const swup = new SwupWithPublicVisitMethods();
-let visit: Visit;
-
-describe('Visit', () => {
-	beforeEach(() => {
-		visit = swup.createVisit({ to: '' });
-	});
-
-	it('is an object', () => {
-		expect(visit).to.be.an('object');
-	});
-
-	it('has an id', () => {
-		expect(visit.id).to.be.a('number');
-	});
-
-	it('generates unique ids', () => {
-		let id = visit.id;
-		visit = swup.createVisit({ to: '' });
-		expect(visit.id).to.not.equal(id);
-	});
-
-	it('has a from object with the current URL', () => {
-		expect(visit.from).to.be.an('object');
-		expect(visit.from.url).to.be.a('string');
-		visit = swup.createVisit({ to: '', from: '/from' });
-		expect(visit.from).toMatchObject({ url: '/from' });
-	});
-
-	it('has a to object with the next URL', () => {
-		expect(visit.to).to.be.an('object');
-		expect(visit.to.url).to.be.a('string');
-		visit = swup.createVisit({ to: '/to' });
-		expect(visit.to).toMatchObject({ url: '/to' });
-	});
-
-	it('has an animation object', () => {
-		expect(visit.animation).to.be.an('object');
-		expect(visit.animation).toMatchObject({
-			animate: true,
-			name: undefined,
-			scope: swup.options.animationScope,
-			selector: swup.options.animationSelector
-		 });
-	});
-
-	it('has a container array', () => {
-		expect(visit.containers).to.be.an('array');
-		expect(visit.containers).toEqual(swup.options.containers);
-	});
-
-	it('has a trigger object', () => {
-		expect(visit.trigger).to.be.an('object');
-		expect(visit.trigger).toMatchObject({
-			el: undefined,
-			event: undefined
-		 });
-	});
-
-	it('has a cache object', () => {
-		expect(visit.cache).to.be.an('object');
-		expect(visit.cache).toEqual({
-			read: swup.options.cache,
-			write: swup.options.cache
-		});
-	});
-
-	it('has a history object', () => {
-		expect(visit.history).to.be.an('object');
-		expect(visit.history).toEqual({
-			action: 'push',
-			popstate: false,
-			direction: undefined
-		});
-	});
-
-	it('has a scroll object', () => {
-		expect(visit.scroll).to.be.an('object');
-		expect(visit.scroll).toEqual({
-			reset: true,
-			target: undefined
-		});
-	});
-});