swup 3.1.1 → 4.0.0-rc.20

package/dist/types/index.d.ts

@@ -1,7 +1,10 @@
-import Swup, { Options } from './Swup.js';
-import { Plugin } from './modules/plugins.js';
-import { Handler } from './modules/events.js';
+import Swup, { type Options } from './Swup.js';
+import type { CacheData } from './modules/Cache.js';
+import type { Context, FromContext, ToContext, AnimationContext, ScrollContext, HistoryContext } from './modules/Context.js';
+import type { Plugin } from './modules/plugins.js';
+import type { HookDefinitions, HookName, HookOptions, HookUnregister, Handler } from './modules/Hooks.js';
+import type { Path } from 'path-to-regexp';
 export default Swup;
 export * from './helpers.js';
 export * from './utils.js';
-export type { Options, Plugin, Handler };
+export type { Options, Plugin, CacheData, Context, FromContext, ToContext, AnimationContext, ScrollContext, HistoryContext, HookDefinitions, HookName, HookOptions, HookUnregister, Handler, Path };

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

@@ -1,19 +1,19 @@
 import Swup from '../Swup.js';
-import { PageData } from './getPageData.js';
-export interface PageRecord extends PageData {
-    url: string;
-    responseURL: string;
+import { PageData } from './fetchPage.js';
+export interface CacheData extends PageData {
 }
 export declare class Cache {
-    pages: Record<string, PageRecord>;
-    last: PageRecord | null;
-    swup: Swup;
+    private swup;
+    private pages;
     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;
+    get size(): number;
+    get all(): Map<string, CacheData>;
+    has(url: string): boolean;
+    get(url: string): CacheData | undefined;
+    set(url: string, page: CacheData): void;
+    update(url: string, page: CacheData): void;
+    delete(url: string): void;
+    clear(): void;
+    prune(predicate: (url: string, page: CacheData) => boolean): void;
+    private resolve;
 }

package/dist/types/modules/Classes.d.ts

@@ -0,0 +1,13 @@
+import Swup from '../Swup.js';
+export declare class Classes {
+    swup: Swup;
+    swupClasses: string[];
+    constructor(swup: Swup);
+    get selectors(): string[];
+    get selector(): string;
+    get targets(): HTMLElement[];
+    add(...classes: string[]): void;
+    remove(...classes: string[]): void;
+    clear(): void;
+    private isSwupClass;
+}

package/dist/types/modules/Context.d.ts

@@ -0,0 +1,73 @@
+import Swup, { Options } from '../Swup.js';
+import { HistoryAction, HistoryDirection } from './visit.js';
+export interface Context<TEvent = Event> {
+    /** The previous page, about to leave */
+    from: FromContext;
+    /** The next page, about to enter */
+    to: ToContext;
+    /** The content containers, about to be replaced */
+    containers: Options['containers'];
+    /** Information about animated page transitions */
+    animation: AnimationContext;
+    /** What triggered this visit */
+    trigger: TriggerContext<TEvent>;
+    /** Browser history behavior on this visit */
+    history: HistoryContext;
+    /** Scroll behavior on this visit */
+    scroll: ScrollContext;
+}
+export interface FromContext {
+    /** The URL of the previous page */
+    url: string;
+}
+export interface ToContext {
+    /** The URL of the next page */
+    url?: string;
+    /** The HTML content of the next page */
+    html?: string;
+}
+export interface AnimationContext {
+    /** Whether this visit is animated. Default: `true` */
+    animate: boolean;
+    /** Whether to wait for the next page to load before starting the animation. Default: `false` */
+    wait: boolean;
+    /** Name of a custom animation to run. */
+    name?: string;
+    /** Elements on which to add animation classes. Default: `html` element */
+    scope: 'html' | 'containers' | string[];
+    /** Selector for detecting animation timing. Default: `[class*="transition-"]` */
+    selector: Options['animationSelector'];
+}
+export interface ScrollContext {
+    /** Whether to reset the scroll position after the visit. Default: `true` */
+    reset: boolean;
+    /** Anchor element to scroll to on the next page. */
+    target?: string;
+}
+export interface TriggerContext<TEvent = Event> {
+    /** DOM element that triggered this visit. */
+    el?: Element;
+    /** DOM event that triggered this visit. */
+    event?: TEvent;
+}
+export interface HistoryContext {
+    /** History action to perform: `push` for creating a new history entry, `replace` for replacing the current entry. Default: `push` */
+    action: HistoryAction;
+    /** Whether this visit was triggered by a browser history navigation. */
+    popstate: boolean;
+    /** The direction of travel in case of a browser history navigation: backward or forward. */
+    direction: HistoryDirection | undefined;
+}
+export interface ContextInitOptions {
+    to: string | undefined;
+    from?: string;
+    hash?: string;
+    animate?: boolean;
+    animation?: string;
+    targets?: string[];
+    el?: Element;
+    event?: Event;
+    action?: HistoryAction;
+    resetScroll?: boolean;
+}
+export declare function createContext(this: Swup, { to, from, hash: target, animate, animation: name, el, event, action, resetScroll: reset }: ContextInitOptions): Context;

package/dist/types/modules/Hooks.d.ts

@@ -0,0 +1,241 @@
+import { DelegateEvent } from 'delegate-it';
+import Swup from '../Swup.js';
+import { Context } from './Context.js';
+import { FetchOptions, PageData } from './fetchPage.js';
+import { AnimationDirection } from './awaitAnimations.js';
+export interface HookDefinitions {
+    'animation:out:start': undefined;
+    'animation:out:end': undefined;
+    'animation:in:start': undefined;
+    'animation:in:end': undefined;
+    'animation:skip': undefined;
+    'animation:await': {
+        direction: AnimationDirection;
+    };
+    'cache:clear': undefined;
+    'cache:set': {
+        page: PageData;
+    };
+    'content:replace': {
+        page: PageData;
+    };
+    'content:scroll': {
+        options: ScrollIntoViewOptions;
+    };
+    'enable': undefined;
+    'disable': undefined;
+    'fetch:request': {
+        url: string;
+        options: FetchOptions;
+    };
+    'fetch:error': {
+        url: string;
+        status: number;
+        response: Response;
+    };
+    'history:popstate': {
+        event: PopStateEvent;
+    };
+    'link:click': {
+        el: HTMLAnchorElement;
+        event: DelegateEvent<MouseEvent>;
+    };
+    'link:self': undefined;
+    'link:anchor': {
+        hash: string;
+        options: ScrollIntoViewOptions;
+    };
+    'link:newtab': {
+        href: string;
+    };
+    'page:request': {
+        url: string;
+        options: FetchOptions;
+    };
+    'page:load': {
+        page: PageData;
+        cache?: boolean;
+    };
+    'page:view': {
+        url: string;
+        title: string;
+    };
+    'visit:start': undefined;
+    'visit:end': undefined;
+}
+export type HookArguments<T extends HookName> = HookDefinitions[T];
+export type HookName = keyof HookDefinitions;
+export type Handler<T extends HookName> = (
+/** The global context object for the current visit */
+context: Context, 
+/** The local arguments passed into the handler */
+args: HookArguments<T>, 
+/** The default handler to be executed, available if replacing an internal hook handler */
+defaultHandler?: Handler<T>) => Promise<any> | void;
+export type Handlers = {
+    [K in HookName]: Handler<K>[];
+};
+export type HookUnregister = () => void;
+export type HookOptions = {
+    /** Execute the hook once, then remove the handler */
+    once?: boolean;
+    /** Execute the hook before the internal default handler */
+    before?: boolean;
+    /** Set a priority for when to execute this hook. Lower numbers execute first. Default: `0` */
+    priority?: number;
+    /** Replace the internal default handler with this hook handler */
+    replace?: boolean;
+};
+export type HookRegistration<T extends HookName> = {
+    id: number;
+    hook: T;
+    handler: Handler<T>;
+} & HookOptions;
+type HookLedger<T extends HookName> = Map<Handler<T>, HookRegistration<T>>;
+interface HookRegistry extends Map<HookName, HookLedger<HookName>> {
+    get<K extends HookName>(key: K): HookLedger<K> | undefined;
+    set<K extends HookName>(key: K, value: HookLedger<K>): this;
+}
+/**
+ * Hook registry.
+ *
+ * Create, trigger and handle hooks.
+ *
+ */
+export declare class Hooks {
+    protected swup: Swup;
+    protected registry: HookRegistry;
+    readonly hooks: HookName[];
+    constructor(swup: Swup);
+    /**
+     * Create ledgers for all core hooks.
+     */
+    protected init(): void;
+    /**
+     * Register a new hook.
+     */
+    create(hook: HookName): void;
+    /**
+     * Check if a hook is registered.
+     */
+    has(hook: HookName): boolean;
+    /**
+     * Get the ledger with all registrations for a hook.
+     */
+    protected get<T extends HookName>(hook: T): HookLedger<T> | undefined;
+    /**
+     * Remove all handlers of all hooks.
+     */
+    clear(): void;
+    /**
+     * Register a new hook handler.
+     * @param hook Name of the hook to listen for
+     * @param handler The handler function to execute
+     * @param options Object to specify how and when the handler is executed
+     *                Available options:
+     *                - `once`: Only execute the handler once
+     *                - `before`: Execute the handler before the default handler
+     *                - `priority`: Specify the order in which the handlers are executed
+     *                - `replace`: Replace the default handler with this handler
+     * @returns A function to unregister the handler
+     */
+    on<T extends HookName>(hook: T, handler: Handler<T>): HookUnregister;
+    on<T extends HookName>(hook: T, handler: Handler<T>, options: HookOptions): HookUnregister;
+    /**
+     * Register a new hook handler to run before the default handler.
+     * Shortcut for `hooks.on(hook, handler, { before: true })`.
+     * @param hook Name of the hook to listen for
+     * @param handler The handler function to execute
+     * @param options Any other event options (see `hooks.on()` for details)
+     * @returns A function to unregister the handler
+     * @see on
+     */
+    before<T extends HookName>(hook: T, handler: Handler<T>): HookUnregister;
+    before<T extends HookName>(hook: T, handler: Handler<T>, options: HookOptions): HookUnregister;
+    /**
+     * Register a new hook handler to replace the default handler.
+     * Shortcut for `hooks.on(hook, handler, { replace: true })`.
+     * @param hook Name of the hook to listen for
+     * @param handler The handler function to execute instead of the default handler
+     * @param options Any other event options (see `hooks.on()` for details)
+     * @returns A function to unregister the handler
+     * @see on
+     */
+    replace<T extends HookName>(hook: T, handler: Handler<T>): HookUnregister;
+    replace<T extends HookName>(hook: T, handler: Handler<T>, options: HookOptions): HookUnregister;
+    /**
+     * Register a new hook handler to run once.
+     * Shortcut for `hooks.on(hook, handler, { once: true })`.
+     * @param hook Name of the hook to listen for
+     * @param handler The handler function to execute
+     * @param options Any other event options (see `hooks.on()` for details)
+     * @see on
+     */
+    once<T extends HookName>(hook: T, handler: Handler<T>): HookUnregister;
+    once<T extends HookName>(hook: T, handler: Handler<T>, options: HookOptions): HookUnregister;
+    /**
+     * Unregister a hook handler.
+     * @param hook Name of the hook the handler is registered for
+     * @param handler The handler function that was registered.
+     *                If omitted, all handlers for the hook will be removed.
+     */
+    off<T extends HookName>(hook: T): void;
+    off<T extends HookName>(hook: T, handler: Handler<T>): void;
+    /**
+     * Trigger a hook asynchronously, executing its default handler and all registered handlers.
+     * Will execute all handlers in order and `await` any `Promise`s they return.
+     * @param hook Name of the hook to trigger
+     * @param args Arguments to pass to the handler
+     * @param defaultHandler A default implementation of this hook to execute
+     * @returns The resolved return value of the executed default handler
+     */
+    trigger<T extends HookName>(hook: T, args?: HookArguments<T>, defaultHandler?: Handler<T>): Promise<any>;
+    /**
+     * Trigger a hook synchronously, executing its default handler and all registered handlers.
+     * Will execute all handlers in order, but will **not** `await` any `Promise`s they return.
+     * @param hook Name of the hook to trigger
+     * @param args Arguments to pass to the handler
+     * @param defaultHandler A default implementation of this hook to execute
+     * @returns The (possibly unresolved) return value of the executed default handler
+     */
+    triggerSync<T extends HookName>(hook: T, args?: HookArguments<T>, defaultHandler?: Handler<T>): any;
+    /**
+     * Execute the handlers for a hook, in order, as `Promise`s that will be `await`ed.
+     * @param registrations The registrations (handler + options) to execute
+     * @param args Arguments to pass to the handler
+     */
+    execute<T extends HookName>(registrations: HookRegistration<T>[], args?: HookArguments<T>, defaultHandler?: Handler<T>): Promise<any>;
+    /**
+     * Execute the handlers for a hook, in order, without `await`ing any returned `Promise`s.
+     * @param registrations The registrations (handler + options) to execute
+     * @param args Arguments to pass to the handler
+     */
+    executeSync<T extends HookName>(registrations: HookRegistration<T>[], args?: HookArguments<T>, defaultHandler?: Handler<T>): any[];
+    /**
+     * Get all registered handlers for a hook, sorted by priority and registration order.
+     * @param hook Name of the hook
+     * @param defaultHandler The optional default handler of this hook
+     * @returns An object with the handlers sorted into `before` and `after` arrays,
+     *          as well as a flag indicating if the original handler was replaced
+     */
+    getHandlers<T extends HookName>(hook: T, defaultHandler?: Handler<T>): {
+        found: boolean;
+        before: HookRegistration<T>[];
+        handler: HookRegistration<T>[];
+        after: HookRegistration<T>[];
+        replaced: boolean;
+    };
+    /**
+     * Sort two hook registrations by priority and registration order.
+     * @param a The registration object to compare
+     * @param b The other registration object to compare with
+     * @returns The sort direction
+     */
+    sortRegistrations<T extends HookName>(a: HookRegistration<T>, b: HookRegistration<T>): number;
+    /**
+     * Trigger a custom event on the `document`. Prefixed with `swup:`
+     * @param hook Name of the hook to trigger.
+     */
+    dispatchDomEvent<T extends HookName>(hook: T, args?: HookArguments<T>): void;
+}
+export {};

package/dist/types/modules/__test__/cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/__test__/hooks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/__test__/replaceContent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/awaitAnimations.d.ts

@@ -0,0 +1,21 @@
+import Swup, { Options } from '../Swup.js';
+declare const TRANSITION = "transition";
+declare const ANIMATION = "animation";
+type AnimationTypes = typeof TRANSITION | typeof ANIMATION;
+export type AnimationDirection = 'in' | 'out';
+/**
+ * Return a Promise that resolves when all animations are done on the page.
+ *
+ * @note We don't make use of the `direction` argument, but it's required by JS plugin
+ */
+export declare function awaitAnimations(this: Swup, { elements, selector }: {
+    selector: Options['animationSelector'];
+    elements?: NodeListOf<HTMLElement> | HTMLElement[];
+    direction?: AnimationDirection;
+}): Promise<void>;
+export declare function getTransitionInfo(element: Element, expectedType?: AnimationTypes): {
+    type: AnimationTypes | null;
+    timeout: number;
+    propCount: number;
+};
+export {};

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

@@ -1,3 +1,6 @@
 import Swup from '../Swup.js';
-import { PageRenderOptions } from './renderPage.js';
-export declare const enterPage: (this: Swup, { event, skipTransition }?: PageRenderOptions) => Promise<void>[];
+/**
+ * Perform the in/enter animation of the next page.
+ * @returns Promise<void>
+ */
+export declare const enterPage: (this: Swup) => Promise<void>;

package/dist/types/modules/fetchPage.d.ts

@@ -1,4 +1,24 @@
 import Swup from '../Swup.js';
-import { TransitionOptions } from './loadPage.js';
-import { PageRecord } from './Cache.js';
-export declare function fetchPage(this: Swup, data: TransitionOptions): Promise<PageRecord>;
+export interface PageData {
+    url: string;
+    html: string;
+}
+export interface FetchOptions extends RequestInit {
+    method?: 'GET' | 'POST';
+    body?: string | FormData | URLSearchParams;
+    headers?: Record<string, string>;
+}
+export declare class FetchError extends Error {
+    url: string;
+    status: number;
+    constructor(message: string, details: {
+        url: string;
+        status: number;
+    });
+}
+/**
+ * Fetch a page from the server, return it and cache it.
+ */
+export declare function fetchPage(this: Swup, url: URL | string, options?: FetchOptions & {
+    triggerHooks?: boolean;
+}): Promise<PageData>;

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

@@ -1,8 +1,9 @@
 /**
  * Find the anchor element for a given hash.
- * @see https://html.spec.whatwg.org/#find-a-potential-indicated-element
  *
  * @param hash Hash with or without leading '#'
  * @returns The element, if found, or null.
+ *
+ * @see https://html.spec.whatwg.org/#find-a-potential-indicated-element
  */
 export declare const getAnchorElement: (hash: string) => Element | null;

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

@@ -1,3 +1,6 @@
 import Swup from '../Swup.js';
-import { PageRenderOptions } from './renderPage.js';
-export declare const leavePage: (this: Swup, { event, skipTransition }?: PageRenderOptions) => Promise<void>[];
+/**
+ * Perform the out/leave animation of the current page.
+ * @returns Promise<void>
+ */
+export declare const leavePage: (this: Swup) => Promise<void>;

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

@@ -1,11 +1,18 @@
 import Swup from '../Swup.js';
 export type Plugin = {
+    /** Name of this plugin */
     name: string;
+    /** Identify as a swup plugin */
     isSwupPlugin: true;
+    /** Run on mount */
     mount: () => void;
+    /** Run on unmount */
     unmount: () => void;
+    /** The swup instance that mounted this plugin */
     swup?: Swup;
+    /** Version of this plugin. Currently not in use, defined here for backward compatiblity. */
     version?: string;
+    /** Version requirements of this plugin. Example: `{ swup: '>=4' }` */
     requires?: Record<string, string>;
     _beforeMount?: () => void;
     _afterUnmount?: () => void;

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

@@ -1,7 +1,7 @@
 import Swup from '../Swup.js';
-import { PageRecord } from './Cache.js';
-export type PageRenderOptions = {
-    event?: PopStateEvent;
-    skipTransition?: boolean;
-};
-export declare const renderPage: (this: Swup, page: PageRecord, { event, skipTransition }?: PageRenderOptions) => void;
+import { PageData } from './fetchPage.js';
+/**
+ * Render the next page: replace the content and update scroll position.
+ * @returns Promise<void>
+ */
+export declare const renderPage: (this: Swup, requestedUrl: string, page: PageData) => Promise<void>;

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

@@ -1,16 +1,13 @@
+import Swup, { Options } from '../Swup.js';
+import { PageData } from './fetchPage.js';
 /**
  * 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 returned from `fetchPage` and a list
+ * of container selectors to replace.
  *
- * 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
+ * @returns Whether all containers were replaced.
  */
-export declare const replaceContent: ({ blocks, title }: {
-    blocks: string[];
-    title: string;
-}) => Promise<void>;
+export declare const replaceContent: (this: Swup, { html }: PageData, { containers }?: {
+    containers: Options['containers'];
+}) => boolean;

package/dist/types/modules/visit.d.ts

@@ -0,0 +1,33 @@
+import Swup from '../Swup.js';
+import { FetchOptions } from './fetchPage.js';
+import { ContextInitOptions } from './Context.js';
+export type HistoryAction = 'push' | 'replace';
+export type HistoryDirection = 'forwards' | 'backwards';
+type VisitOptions = {
+    /** Whether this visit is animated. Default: `true` */
+    animate?: boolean;
+    /** Name of a custom animation to run. */
+    animation?: string;
+    /** History action to perform: `push` for creating a new history entry, `replace` for replacing the current entry. Default: `push` */
+    history?: HistoryAction;
+};
+/**
+ * Navigate to a new URL.
+ * @param url The URL to navigate to.
+ * @param options Options for how to perform this visit.
+ * @returns Promise<void>
+ */
+export declare function visit(this: Swup, url: string, options?: VisitOptions & FetchOptions, context?: Omit<ContextInitOptions, 'to'>): void;
+/**
+ * Start a visit to a new URL.
+ *
+ * Internal method that assumes the global context has already been set up.
+ *
+ * As a user, you should call `swup.visit(url)` instead.
+ *
+ * @param url The URL to navigate to.
+ * @param options Options for how to perform this visit.
+ * @returns Promise<void>
+ */
+export declare function performVisit(this: Swup, url: string, options?: VisitOptions & FetchOptions): Promise<void>;
+export {};

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

@@ -1,5 +1,7 @@
 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 nextTick: () => Promise<void>;
+export declare function isPromise<T>(obj: any): obj is PromiseLike<T>;
+export declare function runAsPromise(func: Function, args?: any[], ctx?: any): Promise<any>;
 export declare const escapeCssIdentifier: (ident: string) => string;
 export declare const toMs: (s: string) => number;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "swup",
   "amdName": "Swup",
-  "version": "3.1.1",
-  "description": "Complete, flexible, extensible, and easy-to-use page transition library for your server-side rendered website.",
+  "version": "4.0.0-rc.20",
+  "description": "Versatile and extensible page transition library for server-rendered websites",
   "type": "module",
   "source": "./src/Swup.ts",
   "main": "./dist/Swup.cjs",
@@ -29,11 +29,12 @@
     "format": "npm run lint:ts && npm run lint:prettier -- --write",
     "lint:ts": "tsc --noEmit --skipLibCheck",
     "lint:prettier": "prettier 'src/**/*.ts'",
-    "prepublish": "npm run build",
+    "prepublishOnly": "npm run build",
     "postinstall": "opencollective-postinstall || true",
     "test": "npm run test:unit && npm run test:e2e",
     "test:ci": "npm run test:unit && npm run test:e2e:ci",
     "test:unit": "vitest run --config ./vitest/vitest.config.ts",
+    "test:unit:watch": "vitest --config ./vitest/vitest.config.ts",
     "test:e2e": "start-server-and-test test:e2e:start 8274 cy:run",
     "test:e2e:ci": "start-server-and-test test:e2e:start 8274 cy:run:record",
     "test:e2e:dev": "start-server-and-test test:e2e:start 8274 cy:open",
@@ -49,32 +50,35 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/gmrchk/swup.git"
+    "url": "https://github.com/swup/swup.git"
   },
   "keywords": [
     "css",
-    "animation",
     "page",
-    "transition"
+    "transition",
+    "animation"
   ],
   "dependencies": {
     "delegate-it": "^6.0.0",
-    "opencollective-postinstall": "^2.0.2"
+    "opencollective-postinstall": "^2.0.2",
+    "path-to-regexp": "^6.2.1"
   },
   "devDependencies": {
     "@babel/preset-typescript": "^7.18.6",
     "@cypress/code-coverage": "^3.10.0",
     "@swup/browserslist-config": "^1.0.0",
     "@swup/prettier-config": "^1.0.0",
+    "@types/jsdom": "^21.1.1",
     "cypress": "^12.3.0",
     "http-server": "^14.1.1",
     "husky": "^8.0.0",
     "istanbul-lib-coverage": "^3.2.0",
+    "jsdom": "^22.1.0",
     "microbundle": "^0.15.0",
     "nyc": "^15.1.0",
     "prettier": "^2.8.2",
-    "start-server-and-test": "^1.14.0",
-    "vitest": "^0.29.8"
+    "start-server-and-test": "^2.0.0",
+    "vitest": "^0.31.2"
   },
   "collective": {
     "type": "opencollective",