@gravity-ui/playwright-tools 0.4.1

package/actions/expect-request/matchers/match-method.d.ts

@@ -0,0 +1,2 @@
+import type { Request } from '@playwright/test';
+export declare function matchMethod(request: Request, method?: string): string | null;

package/actions/expect-request/matchers/match-method.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchMethod = matchMethod;
+const DiffPrinter_1 = require("./compare/DiffPrinter");
+function matchMethod(request, method) {
+    if (method === undefined) {
+        return null;
+    }
+    const printer = new DiffPrinter_1.DiffPrinter({
+        left: request.method().toUpperCase(),
+        right: method.toUpperCase(),
+    });
+    return printer.printDiff({ side: 'left' }) || null;
+}

package/actions/expect-request/matchers/match-query.d.ts

@@ -0,0 +1,3 @@
+import type { Request } from '@playwright/test';
+import type { CommonMatcherOptions } from './types';
+export declare function matchQuery(request: Request, query: string | Record<string, string | string[]> | undefined, { exact }: CommonMatcherOptions): string | null;

package/actions/expect-request/matchers/match-query.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchQuery = matchQuery;
+const node_url_1 = require("node:url");
+const DiffPrinter_1 = require("./compare/DiffPrinter");
+function matchQuery(request, query, { exact }) {
+    if (!query) {
+        return null;
+    }
+    const requestSearchParams = new URL(request.url()).searchParams;
+    const querySearchParams = new node_url_1.URLSearchParams(query);
+    const requestEntries = searchParamsToObject(requestSearchParams);
+    const queryEntries = searchParamsToObject(querySearchParams);
+    const printer = new DiffPrinter_1.DiffPrinter({ left: requestEntries, right: queryEntries });
+    return printer.printDiff({ side: 'left', exact }) || null;
+}
+function searchParamsToObject(searchParams) {
+    const result = {};
+    const entries = searchParams.entries();
+    for (const [key, value] of entries) {
+        if (result[key]) {
+            if (Array.isArray(result[key])) {
+                result[key].push(value);
+            }
+            else {
+                result[key] = [result[key], value];
+            }
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/actions/expect-request/matchers/match-url.d.ts

@@ -0,0 +1 @@
+export declare function matchUrl(url: string, pattern: string | RegExp): boolean;

package/actions/expect-request/matchers/match-url.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchUrl = matchUrl;
+const minimatch_1 = require("minimatch");
+function matchUrl(url, pattern) {
+    if (pattern instanceof RegExp) {
+        return pattern.test(url);
+    }
+    else {
+        const expandedPattern = pattern.startsWith('/') ? `**${pattern}` : `**/${pattern}`;
+        return (0, minimatch_1.minimatch)(url, expandedPattern);
+    }
+}

package/actions/expect-request/matchers/match.d.ts

@@ -0,0 +1,3 @@
+import type { Json } from '../types';
+import type { CommonMatcherOptions } from './types';
+export declare function match(actual: Json, expected: Json, options: CommonMatcherOptions): boolean;

package/actions/expect-request/matchers/match.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.match = match;
+const compare_1 = require("./compare");
+function match(actual, expected, options) {
+    const { exact } = options;
+    const diffLog = (0, compare_1.compare)({ left: actual, right: expected, exactArrays: exact });
+    const diffLogForActual = diffLog.filter(({ side }) => side === 'left');
+    return exact ? diffLog.length === 0 : diffLogForActual.length === 0;
+}

package/actions/expect-request/matchers/types.d.ts

@@ -0,0 +1,3 @@
+export type CommonMatcherOptions = {
+    exact: boolean;
+};

package/actions/expect-request/matchers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/actions/expect-request/matchers/utils.d.ts

@@ -0,0 +1 @@
+export declare function isObject(entry: unknown): entry is object;

package/actions/expect-request/matchers/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+function isObject(entry) {
+    const entryType = typeof entry;
+    return (entry !== null &&
+        !Array.isArray(entry) &&
+        (entryType === 'object' || entryType === 'function'));
+}

package/actions/expect-request/poll-with-timeout.d.ts

@@ -0,0 +1,22 @@
+interface PollWithTimeoutParams<T> {
+    /** Function to poll (should return a promise). */
+    callbackFn: () => Promise<T>;
+    /** Function that checks the result to determine if polling should stop. */
+    condition: (result: T) => boolean;
+    /** Time between polls in milliseconds; default value `1000ms`. */
+    interval?: number;
+    /** Maximum time to wait in milliseconds before rejecting; default value `15000ms`. */
+    timeout?: number;
+    /** Called when timeout occurs. */
+    onTimeout?: (params: {
+        /** Lets you resolve with a custom value */
+        resolve: (value: T | PromiseLike<T>) => void;
+        /** Lets you reject with custom error */
+        reject: (reason?: unknown) => void;
+    }) => void;
+}
+/**
+ * Polls a function at a specified interval until a condition is met or timeout is reached.
+ */
+export declare function pollWithTimeout<T>(params: PollWithTimeoutParams<T>): Promise<T>;
+export {};

package/actions/expect-request/poll-with-timeout.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollWithTimeout = pollWithTimeout;
+/**
+ * Polls a function at a specified interval until a condition is met or timeout is reached.
+ */
+async function pollWithTimeout(params) {
+    const { callbackFn, condition, interval = 1000, timeout = 5000, onTimeout } = params;
+    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+        const checkTimeout = () => {
+            if (timeout && Date.now() - startTime >= timeout) {
+                if (onTimeout) {
+                    onTimeout({ resolve, reject });
+                }
+                else {
+                    reject(new Error(`Request polling timed out after ${timeout}ms`));
+                }
+                return;
+            }
+        };
+        const executePoll = async () => {
+            try {
+                checkTimeout();
+                const result = await callbackFn();
+                if (condition(result)) {
+                    resolve(result);
+                }
+                else {
+                    setTimeout(executePoll, interval);
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        void executePoll();
+    });
+}

package/actions/expect-request/types.d.ts

@@ -0,0 +1,18 @@
+export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
+export type QueryParams = Record<string, string | string[]>;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonArray = Json[];
+export type JsonObject = {
+    [key: string]: Json;
+};
+export type JsonComposite = JsonArray | JsonObject;
+export type Json = JsonPrimitive | JsonComposite;
+export type ExpectRequestFnMatcher = {
+    method?: HttpMethod;
+    query?: string | QueryParams;
+    body?: Json;
+};
+export type ExpectRequestFnOptions = {
+    timeout?: number;
+    exact?: boolean;
+};

package/actions/expect-request/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/actions/getExtraHttpHeader.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserContext } from '@playwright/test';
+/**
+ * Return extra HTTP header value from internal extraHttpHeaders list
+ */
+export declare function getExtraHttpHeader(browserContext: BrowserContext, headerName: string): string | undefined;

package/actions/getExtraHttpHeader.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtraHttpHeader = getExtraHttpHeader;
+const extraHttpHeaders_1 = require("../data/extraHttpHeaders");
+/**
+ * Return extra HTTP header value from internal extraHttpHeaders list
+ */
+function getExtraHttpHeader(browserContext, headerName) {
+    if (!extraHttpHeaders_1.extraHttpHeaders.has(browserContext)) {
+        return undefined;
+    }
+    const headers = extraHttpHeaders_1.extraHttpHeaders.get(browserContext);
+    return headers.get(headerName.toLowerCase());
+}

package/actions/getExtraHttpHeaders.d.ts

@@ -0,0 +1,7 @@
+import type { BrowserContext } from '@playwright/test';
+/**
+ * Return extra HTTP headers list from internal extraHttpHeaders list
+ */
+export declare function getExtraHttpHeaders(browserContext: BrowserContext): {
+    [k: string]: string;
+};

package/actions/getExtraHttpHeaders.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtraHttpHeaders = getExtraHttpHeaders;
+const extraHttpHeaders_1 = require("../data/extraHttpHeaders");
+/**
+ * Return extra HTTP headers list from internal extraHttpHeaders list
+ */
+function getExtraHttpHeaders(browserContext) {
+    if (!extraHttpHeaders_1.extraHttpHeaders.has(browserContext)) {
+        return {};
+    }
+    const headers = extraHttpHeaders_1.extraHttpHeaders.get(browserContext);
+    return Object.fromEntries(headers.entries());
+}

package/actions/getGlobalSettings.d.ts

@@ -0,0 +1,5 @@
+import type { GlobalSettings } from '../data/globalSettings';
+/**
+ * Returns global settings for commands for a given section (command)
+ */
+export declare function getGlobalSettings<TSection extends keyof GlobalSettings>(section: TSection): GlobalSettings[TSection];

package/actions/getGlobalSettings.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalSettings = getGlobalSettings;
+const globalSettings_1 = require("../data/globalSettings");
+/**
+ * Returns global settings for commands for a given section (command)
+ */
+function getGlobalSettings(section) {
+    return globalSettings_1.globalSettings[section];
+}

package/actions/getTestSlug.d.ts

@@ -0,0 +1,5 @@
+import type { Page } from '@playwright/test';
+/**
+ * Returns the test slug
+ */
+export declare function getTestSlug(page: Page): string;

package/actions/getTestSlug.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestSlug = getTestSlug;
+const testSlugs_1 = require("../data/testSlugs");
+/**
+ * Returns the test slug
+ */
+function getTestSlug(page) {
+    if (testSlugs_1.testSlugs.has(page)) {
+        return testSlugs_1.testSlugs.get(page);
+    }
+    throw new Error("Can't find slug for test");
+}

package/actions/hasExtraHttpHeader.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserContext } from '@playwright/test';
+/**
+ * Check existence of the extra HTTP header in internal extraHttpHeaders list
+ */
+export declare function hasExtraHttpHeader(browserContext: BrowserContext, headerName: string): boolean;

package/actions/hasExtraHttpHeader.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasExtraHttpHeader = hasExtraHttpHeader;
+const extraHttpHeaders_1 = require("../data/extraHttpHeaders");
+/**
+ * Check existence of the extra HTTP header in internal extraHttpHeaders list
+ */
+function hasExtraHttpHeader(browserContext, headerName) {
+    if (!extraHttpHeaders_1.extraHttpHeaders.has(browserContext)) {
+        return false;
+    }
+    const headers = extraHttpHeaders_1.extraHttpHeaders.get(browserContext);
+    return headers.has(headerName.toLowerCase());
+}

package/actions/index.d.ts

@@ -0,0 +1,18 @@
+export { addExtraHttpHeader } from './addExtraHttpHeader';
+export { addExtraHttpHeaders } from './addExtraHttpHeaders';
+export { assertElementsHidden } from './assertElementsHidden';
+export { clearExtraHttpHeaders } from './clearExtraHttpHeaders';
+export { collectPageActivity } from './collectPageActivity';
+export { disableAnimations } from './disableAnimation';
+export { getExtraHttpHeader } from './getExtraHttpHeader';
+export { getExtraHttpHeaders } from './getExtraHttpHeaders';
+export { getGlobalSettings } from './getGlobalSettings';
+export { getTestSlug } from './getTestSlug';
+export { hasExtraHttpHeader } from './hasExtraHttpHeader';
+export { matchScreenshot } from './matchScreenshot';
+export { mockDate } from './mockDate';
+export { removeExtraHttpHeader } from './removeExtraHttpHeader';
+export { setCacheSettings } from './setCacheSettings';
+export { setGlobalSettings } from './setGlobalSettings';
+export { setTestSlug } from './setTestSlug';
+export { waitForNetworkSettled } from './waitForNetworkSettled';

package/actions/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForNetworkSettled = exports.setTestSlug = exports.setGlobalSettings = exports.setCacheSettings = exports.removeExtraHttpHeader = exports.mockDate = exports.matchScreenshot = exports.hasExtraHttpHeader = exports.getTestSlug = exports.getGlobalSettings = exports.getExtraHttpHeaders = exports.getExtraHttpHeader = exports.disableAnimations = exports.collectPageActivity = exports.clearExtraHttpHeaders = exports.assertElementsHidden = exports.addExtraHttpHeaders = exports.addExtraHttpHeader = void 0;
+var addExtraHttpHeader_1 = require("./addExtraHttpHeader");
+Object.defineProperty(exports, "addExtraHttpHeader", { enumerable: true, get: function () { return addExtraHttpHeader_1.addExtraHttpHeader; } });
+var addExtraHttpHeaders_1 = require("./addExtraHttpHeaders");
+Object.defineProperty(exports, "addExtraHttpHeaders", { enumerable: true, get: function () { return addExtraHttpHeaders_1.addExtraHttpHeaders; } });
+var assertElementsHidden_1 = require("./assertElementsHidden");
+Object.defineProperty(exports, "assertElementsHidden", { enumerable: true, get: function () { return assertElementsHidden_1.assertElementsHidden; } });
+var clearExtraHttpHeaders_1 = require("./clearExtraHttpHeaders");
+Object.defineProperty(exports, "clearExtraHttpHeaders", { enumerable: true, get: function () { return clearExtraHttpHeaders_1.clearExtraHttpHeaders; } });
+var collectPageActivity_1 = require("./collectPageActivity");
+Object.defineProperty(exports, "collectPageActivity", { enumerable: true, get: function () { return collectPageActivity_1.collectPageActivity; } });
+var disableAnimation_1 = require("./disableAnimation");
+Object.defineProperty(exports, "disableAnimations", { enumerable: true, get: function () { return disableAnimation_1.disableAnimations; } });
+var getExtraHttpHeader_1 = require("./getExtraHttpHeader");
+Object.defineProperty(exports, "getExtraHttpHeader", { enumerable: true, get: function () { return getExtraHttpHeader_1.getExtraHttpHeader; } });
+var getExtraHttpHeaders_1 = require("./getExtraHttpHeaders");
+Object.defineProperty(exports, "getExtraHttpHeaders", { enumerable: true, get: function () { return getExtraHttpHeaders_1.getExtraHttpHeaders; } });
+var getGlobalSettings_1 = require("./getGlobalSettings");
+Object.defineProperty(exports, "getGlobalSettings", { enumerable: true, get: function () { return getGlobalSettings_1.getGlobalSettings; } });
+var getTestSlug_1 = require("./getTestSlug");
+Object.defineProperty(exports, "getTestSlug", { enumerable: true, get: function () { return getTestSlug_1.getTestSlug; } });
+var hasExtraHttpHeader_1 = require("./hasExtraHttpHeader");
+Object.defineProperty(exports, "hasExtraHttpHeader", { enumerable: true, get: function () { return hasExtraHttpHeader_1.hasExtraHttpHeader; } });
+var matchScreenshot_1 = require("./matchScreenshot");
+Object.defineProperty(exports, "matchScreenshot", { enumerable: true, get: function () { return matchScreenshot_1.matchScreenshot; } });
+var mockDate_1 = require("./mockDate");
+Object.defineProperty(exports, "mockDate", { enumerable: true, get: function () { return mockDate_1.mockDate; } });
+var removeExtraHttpHeader_1 = require("./removeExtraHttpHeader");
+Object.defineProperty(exports, "removeExtraHttpHeader", { enumerable: true, get: function () { return removeExtraHttpHeader_1.removeExtraHttpHeader; } });
+var setCacheSettings_1 = require("./setCacheSettings");
+Object.defineProperty(exports, "setCacheSettings", { enumerable: true, get: function () { return setCacheSettings_1.setCacheSettings; } });
+var setGlobalSettings_1 = require("./setGlobalSettings");
+Object.defineProperty(exports, "setGlobalSettings", { enumerable: true, get: function () { return setGlobalSettings_1.setGlobalSettings; } });
+var setTestSlug_1 = require("./setTestSlug");
+Object.defineProperty(exports, "setTestSlug", { enumerable: true, get: function () { return setTestSlug_1.setTestSlug; } });
+var waitForNetworkSettled_1 = require("./waitForNetworkSettled");
+Object.defineProperty(exports, "waitForNetworkSettled", { enumerable: true, get: function () { return waitForNetworkSettled_1.waitForNetworkSettled; } });

package/actions/matchScreenshot.d.ts

@@ -0,0 +1,90 @@
+import type { Locator, Page, PageScreenshotOptions } from '@playwright/test';
+export type Theme = 'light' | 'dark';
+export type OnSwitchThemeCallback = (theme: Theme, page: Page) => Promise<void>;
+export type OnBeforeScreenshotCallback = (page: Page) => Promise<void>;
+export type ScreenshotOptions = Omit<PageScreenshotOptions, 'type' | 'quality' | 'path'> & {
+    /**
+     * An acceptable ratio of pixels that are different to the total amount of pixels, between `0` and `1`. Default is
+     * configurable with `TestConfig.expect`. Unset by default.
+     */
+    maxDiffPixelRatio?: number;
+    /**
+     * An acceptable amount of pixels that could be different. Default is configurable with `TestConfig.expect`. Unset by
+     * default.
+     */
+    maxDiffPixels?: number;
+    /**
+     * An acceptable perceived color difference in the [YIQ color space](https://en.wikipedia.org/wiki/YIQ) between the same
+     * pixel in compared images, between zero (strict) and one (lax), default is configurable with `TestConfig.expect`.
+     * Defaults to `0.2`.
+     */
+    threshold?: number;
+};
+export type MatchScreenshotOptions = {
+    /**
+     * The element or page to be screenshotted
+     * @defaultValue `page`
+     */
+    locator?: Locator | Page;
+    /**
+     * The name of the screenshot in the test, it is not necessary to specify it for a single screenshot
+     * @defaultValue globalSettings.matchScreenshot.name
+     */
+    name?: string;
+    /**
+     * Screenshot creation and comparison parameters (parameters of `toHaveScreenshot` call)
+     * @defaultValue globalSettings.matchScreenshot.options
+     */
+    options?: ScreenshotOptions;
+    /**
+     * CSS selectors (pure CSS) of elements to hide
+     * @defaultValue globalSettings.matchScreenshot.hideBySelector
+     */
+    hideBySelector?: string[];
+    /**
+     * Pause before screenshot (ms)
+     * @defaultValue globalSettings.matchScreenshot.pause
+     */
+    pause?: number;
+    /**
+     * Use soft assertion
+     * @defaultValue globalSettings.matchScreenshot.soft
+     */
+    soft?: boolean;
+    /**
+     * Move the mouse cursor to the specified coordinates (to avoid unnecessary hover in the screenshot)
+     */
+    moveMouse?: {
+        x: number;
+        y: number;
+    } | [x: number, y: number] | number;
+    /**
+     * Should I add a slug to the screenshot file name?
+     * @defaultValue globalSettings.matchScreenshot.shouldPrependSlugToName
+     */
+    shouldPrependSlugToName?: boolean;
+    /**
+     * Topics that require a screenshot
+     * By default, screenshots are taken for the current theme. Switching does not occur
+     * @defaultValue globalSettings.matchScreenshot.themes
+     */
+    themes?: Theme[];
+    /**
+     * Callback before taking a screenshot. Useful for any special stabilizing actions
+     * @param page Page current page
+     * @defaultValue globalSettings.matchScreenshot.onBeforeScreenshot
+     */
+    onBeforeScreenshot?: OnBeforeScreenshotCallback;
+    /**
+     * Callback to switch theme to pages before taking screenshot
+     * By default, switches the theme using `page.emulateMedia({ colorScheme: theme });`
+     * @param theme Theme The theme for which the screenshot will be taken
+     * @param page Page current page
+     * @defaultValue globalSettings.matchScreenshot.onSwitchTheme
+     */
+    onSwitchTheme?: OnSwitchThemeCallback;
+};
+/**
+ * Performs a check on a screenshot, with a prefix of the test slug in the name
+ */
+export declare function matchScreenshot(page: Page, { locator, name, options, hideBySelector, pause, soft, moveMouse, shouldPrependSlugToName, themes, onBeforeScreenshot, onSwitchTheme, }?: MatchScreenshotOptions): Promise<void>;

package/actions/matchScreenshot.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchScreenshot = matchScreenshot;
+const test_1 = require("@playwright/test");
+const globalSettings_1 = require("../data/globalSettings");
+const getTestSlug_1 = require("./getTestSlug");
+const stylesForHide = /* css */ `{
+    visibility: hidden !important;
+    opacity: 0 !important;
+}`;
+/**
+ * Performs a check on a screenshot, with a prefix of the test slug in the name
+ */
+async function matchScreenshot(page, { locator = page, name = globalSettings_1.globalSettings.matchScreenshot.name, options = {}, hideBySelector, pause = globalSettings_1.globalSettings.matchScreenshot.pause, soft = globalSettings_1.globalSettings.matchScreenshot.soft, moveMouse, shouldPrependSlugToName = globalSettings_1.globalSettings.matchScreenshot.shouldPrependSlugToName, themes = globalSettings_1.globalSettings.matchScreenshot.themes, onBeforeScreenshot = globalSettings_1.globalSettings.matchScreenshot.onBeforeScreenshot, onSwitchTheme = globalSettings_1.globalSettings.matchScreenshot.onSwitchTheme, } = {}) {
+    const combinedOptions = {
+        ...globalSettings_1.globalSettings.matchScreenshot.options,
+        ...options,
+    };
+    const styleElements = [];
+    const combinedHideBySelector = [
+        ...(globalSettings_1.globalSettings.matchScreenshot.hideBySelector || []),
+        ...(hideBySelector || []),
+    ];
+    if (combinedHideBySelector.length !== 0) {
+        const selector = combinedHideBySelector.join(',');
+        const styles = selector + stylesForHide;
+        styleElements.push(await appendStylesToPage(page, styles));
+    }
+    if (options.style) {
+        styleElements.push(await appendStylesToPage(page, options.style));
+    }
+    if (moveMouse) {
+        let x = 0;
+        let y = 0;
+        if (typeof moveMouse === 'number') {
+            x = y = moveMouse;
+        }
+        else if (Array.isArray(moveMouse)) {
+            x = moveMouse[0];
+            y = moveMouse[1];
+        }
+        else {
+            x = moveMouse.x;
+            y = moveMouse.y;
+        }
+        await page.mouse.move(x, y);
+    }
+    await onBeforeScreenshot?.(page);
+    const slug = (0, getTestSlug_1.getTestSlug)(page);
+    await page.waitForTimeout(pause);
+    if (themes && themes.length) {
+        for (const theme of themes) {
+            await onSwitchTheme?.(theme, page);
+            const resolvedName = name ? `${name}-${theme}` : undefined;
+            await doMatchScreenshot({
+                locator,
+                name: resolvedName,
+                slug,
+                options: combinedOptions,
+                shouldPrependSlugToName,
+                soft,
+            });
+        }
+    }
+    else {
+        await doMatchScreenshot({
+            locator,
+            name,
+            slug,
+            options: combinedOptions,
+            shouldPrependSlugToName,
+            soft,
+        });
+    }
+    for (const styleElement of styleElements) {
+        await styleElement.evaluate((element) => element.remove());
+        await styleElement.dispose();
+    }
+}
+async function doMatchScreenshot(params) {
+    const { locator, name, slug, options, shouldPrependSlugToName, soft } = params;
+    const resolvedName = resolveScreenshotName({ name, slug, shouldPrependSlugToName });
+    const resolvedExpect = soft ? test_1.expect.soft : test_1.expect;
+    if (resolvedName) {
+        await resolvedExpect(locator).toHaveScreenshot(resolvedName, options);
+    }
+    else {
+        await resolvedExpect(locator).toHaveScreenshot(options);
+    }
+}
+function resolveScreenshotName(params) {
+    const { name, slug, shouldPrependSlugToName } = params;
+    if (!name) {
+        return undefined;
+    }
+    const resolvedName = [name + '.png'];
+    if (shouldPrependSlugToName) {
+        resolvedName.unshift(slug);
+    }
+    return resolvedName;
+}
+async function appendStylesToPage(page, styles) {
+    return await page.addStyleTag({ content: styles });
+}

package/actions/mockDate.d.ts

@@ -0,0 +1,10 @@
+import type { Page } from '@playwright/test';
+/**
+ * NOTE:
+ * Replaces the Date object with an object in which the date is set to the specified one.
+ *
+ * The date and time are not fixed, but go at the usual speed, but starting from the specified one.
+ *
+ * Use playwright API Clock https://playwright.dev/docs/clock
+ */
+export declare function mockDate(page: Page, year?: number, month?: number, day?: number, hour?: number, min?: number, sec?: number): Promise<void>;

package/actions/mockDate.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockDate = mockDate;
+const path_1 = require("path");
+const globalSettings_1 = require("../data/globalSettings");
+/**
+ * NOTE:
+ * Replaces the Date object with an object in which the date is set to the specified one.
+ *
+ * The date and time are not fixed, but go at the usual speed, but starting from the specified one.
+ *
+ * Use playwright API Clock https://playwright.dev/docs/clock
+ */
+async function mockDate(page, year = globalSettings_1.globalSettings.mockDate.defaultDate.year, month = globalSettings_1.globalSettings.mockDate.defaultDate.month, day = globalSettings_1.globalSettings.mockDate.defaultDate.day, hour = globalSettings_1.globalSettings.mockDate.defaultDate.hour, min = globalSettings_1.globalSettings.mockDate.defaultDate.min, sec = globalSettings_1.globalSettings.mockDate.defaultDate.sec) {
+    await page.addInitScript({ path: (0, path_1.resolve)(require.resolve('timekeeper')) });
+    await page.addInitScript(({ year, month, day, hour, min, sec, }) => {
+        const date = new Date(year, month, day, hour, min, sec);
+        window.timekeeper.travel(date);
+    }, { year, month, day, hour, min, sec });
+}

package/actions/removeExtraHttpHeader.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserContext } from '@playwright/test';
+/**
+ * Remove header from internal extraHttpHeaders list and extra HTTP headers in browser context
+ */
+export declare function removeExtraHttpHeader(browserContext: BrowserContext, headerName: string): Promise<void>;

package/actions/removeExtraHttpHeader.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeExtraHttpHeader = removeExtraHttpHeader;
+const extraHttpHeaders_1 = require("../data/extraHttpHeaders");
+/**
+ * Remove header from internal extraHttpHeaders list and extra HTTP headers in browser context
+ */
+async function removeExtraHttpHeader(browserContext, headerName) {
+    if (!extraHttpHeaders_1.extraHttpHeaders.has(browserContext)) {
+        return;
+    }
+    const headers = extraHttpHeaders_1.extraHttpHeaders.get(browserContext);
+    headers.delete(headerName.toLowerCase());
+    await browserContext.setExtraHTTPHeaders(Object.fromEntries(headers.entries()));
+}

package/actions/setCacheSettings.d.ts

@@ -0,0 +1,7 @@
+import type { CacheSettings } from '../data/cacheSettings';
+/**
+ * Sets caching options on the file system
+ * @param key Caching object
+ * @param options Caching options
+ */
+export declare function setCacheSettings<TKey extends keyof CacheSettings>(key: TKey, options: Partial<CacheSettings[TKey]>): void;

package/actions/setCacheSettings.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCacheSettings = setCacheSettings;
+const cacheSettings_1 = require("../data/cacheSettings");
+/**
+ * Sets caching options on the file system
+ * @param key Caching object
+ * @param options Caching options
+ */
+function setCacheSettings(key, options) {
+    Object.assign(cacheSettings_1.cacheSettings[key], options);
+}