swup 4.0.0-rc.31 → 4.0.0

package/src/modules/Cache.ts

@@ -9,10 +9,10 @@ export interface CacheData extends PageData {}
  */
 export class Cache {
 	/** Swup instance this cache belongs to */
-	private swup: Swup;
+	protected swup: Swup;
 
 	/** Cached pages, indexed by URL */
-	private pages: Map<string, CacheData> = new Map();
+	protected pages: Map<string, CacheData> = new Map();
 
 	constructor(swup: Swup) {
 		this.swup = swup;
@@ -29,17 +29,17 @@ export class Cache {
 	}
 
 	/** Check if the given URL has been cached. */
-	public has(url: string): boolean {
+	has(url: string): boolean {
 		return this.pages.has(this.resolve(url));
 	}
 
 	/** Return the cached page object if cached. */
-	public get(url: string): CacheData | undefined {
+	get(url: string): CacheData | undefined {
 		return this.pages.get(this.resolve(url));
 	}
 
 	/** Create a cache record for the specified URL. */
-	public set(url: string, page: CacheData) {
+	set(url: string, page: CacheData) {
 		url = this.resolve(url);
 		page = { ...page, url };
 		this.pages.set(url, page);
@@ -47,25 +47,25 @@ export class Cache {
 	}
 
 	/** Update a cache record, overwriting or adding custom data. */
-	public update(url: string, page: CacheData) {
+	update(url: string, page: CacheData) {
 		url = this.resolve(url);
 		page = { ...this.get(url), ...page, url };
 		this.pages.set(url, page);
 	}
 
 	/** Delete a cache record. */
-	public delete(url: string): void {
+	delete(url: string): void {
 		this.pages.delete(this.resolve(url));
 	}
 
 	/** Empty the cache. */
-	public clear(): void {
+	clear(): void {
 		this.pages.clear();
 		this.swup.hooks.callSync('cache:clear');
 	}
 
 	/** Remove all cache entries that return true for a given predicate function.  */
-	public prune(predicate: (url: string, page: CacheData) => boolean): void {
+	prune(predicate: (url: string, page: CacheData) => boolean): void {
 		this.pages.forEach((page, url) => {
 			if (predicate(url, page)) {
 				this.delete(url);
@@ -74,7 +74,7 @@ export class Cache {
 	}
 
 	/** Resolve URLs by making them local and letting swup resolve them. */
-	private resolve(urlToResolve: string): string {
+	protected resolve(urlToResolve: string): string {
 		const { url } = Location.fromUrl(urlToResolve);
 		return this.swup.resolveUrl(url);
 	}

package/src/modules/Classes.ts

@@ -2,15 +2,14 @@ import Swup from '../Swup.js';
 import { queryAll } from '../utils.js';
 
 export class Classes {
-	public swup: Swup;
-
-	swupClasses = ['to-', 'is-changing', 'is-rendering', 'is-popstate', 'is-animating'];
+	protected swup: Swup;
+	protected swupClasses = ['to-', 'is-changing', 'is-rendering', 'is-popstate', 'is-animating'];
 
 	constructor(swup: Swup) {
 		this.swup = swup;
 	}
 
-	get selectors(): string[] {
+	protected get selectors(): string[] {
 		const { scope } = this.swup.visit.animation;
 		if (scope === 'containers') return this.swup.visit.containers;
 		if (scope === 'html') return ['html'];
@@ -18,31 +17,31 @@ export class Classes {
 		return [];
 	}
 
-	get selector(): string {
+	protected get selector(): string {
 		return this.selectors.join(',');
 	}
 
-	get targets(): HTMLElement[] {
+	protected get targets(): HTMLElement[] {
 		if (!this.selector.trim()) return [];
 		return queryAll(this.selector) as HTMLElement[];
 	}
 
-	public add(...classes: string[]): void {
+	add(...classes: string[]): void {
 		this.targets.forEach((target) => target.classList.add(...classes));
 	}
 
-	public remove(...classes: string[]): void {
+	remove(...classes: string[]): void {
 		this.targets.forEach((target) => target.classList.remove(...classes));
 	}
 
-	public clear(): void {
+	clear(): void {
 		this.targets.forEach((target) => {
 			const remove = target.className.split(' ').filter((c) => this.isSwupClass(c));
 			target.classList.remove(...remove);
 		});
 	}
 
-	private isSwupClass(className: string): boolean {
+	protected isSwupClass(className: string): boolean {
 		return this.swupClasses.some((c) => className.startsWith(c));
 	}
 }

package/src/modules/Hooks.ts

@@ -326,7 +326,7 @@ export class Hooks {
 	 * @param registrations The registrations (handler + options) to execute
 	 * @param args Arguments to pass to the handler
 	 */
-	private async run<T extends HookName>(
+	protected async run<T extends HookName>(
 		registrations: HookRegistration<T>[],
 		args?: HookArguments<T>
 	): Promise<any> {
@@ -346,7 +346,7 @@ export class Hooks {
 	 * @param registrations The registrations (handler + options) to execute
 	 * @param args Arguments to pass to the handler
 	 */
-	private runSync<T extends HookName>(
+	protected runSync<T extends HookName>(
 		registrations: HookRegistration<T>[],
 		args?: HookArguments<T>
 	): any[] {
@@ -374,7 +374,7 @@ export class Hooks {
 	 * @returns An object with the handlers sorted into `before` and `after` arrays,
 	 *          as well as a flag indicating if the original handler was replaced
 	 */
-	private getHandlers<T extends HookName>(hook: T, defaultHandler?: Handler<T>) {
+	protected getHandlers<T extends HookName>(hook: T, defaultHandler?: Handler<T>) {
 		const ledger = this.get(hook);
 		if (!ledger) {
 			return { found: false, before: [], handler: [], after: [], replaced: false };
@@ -422,7 +422,7 @@ export class Hooks {
 	 * @param b The other registration object to compare with
 	 * @returns The sort direction
 	 */
-	private sortRegistrations<T extends HookName>(
+	protected sortRegistrations<T extends HookName>(
 		a: HookRegistration<T>,
 		b: HookRegistration<T>
 	): number {
@@ -435,7 +435,7 @@ export class Hooks {
 	 * Dispatch a custom event on the `document` for a hook. Prefixed with `swup:`
 	 * @param hook Name of the hook.
 	 */
-	private dispatchDomEvent<T extends HookName>(hook: T, args?: HookArguments<T>): void {
+	protected dispatchDomEvent<T extends HookName>(hook: T, args?: HookArguments<T>): void {
 		const detail = { hook, args, visit: this.swup.visit };
 		document.dispatchEvent(new CustomEvent(`swup:${hook}`, { detail }));
 	}

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

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { describe, expect, it, vi, afterEach } from 'vitest';
 import Swup from '../../Swup.js';
 import type { PageData } from '../fetchPage.js';
 import { JSDOM } from 'jsdom';