@gravity-ui/playwright-tools 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 YANDEX LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# playwright-tools
+
+A library of additional utilities for writing tests using Playwright Test.
+
+## Maintainers
+
+[@Avol-V](https://github.com/Avol-V)
+[SwinX](https://github.com/SwinX)
+[@vegancat63](https://github.com/vegancat63)

package/actions/addExtraHttpHeader.d.ts

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

package/actions/addExtraHttpHeader.js

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

package/actions/addExtraHttpHeaders.d.ts

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

package/actions/addExtraHttpHeaders.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addExtraHttpHeaders = addExtraHttpHeaders;
+const extraHttpHeaders_1 = require("../data/extraHttpHeaders");
+/**
+ * Add headers to internal extraHttpHeaders list and extra HTTP headers in browser context
+ */
+async function addExtraHttpHeaders(browserContext, additionalHeaders) {
+    if (!extraHttpHeaders_1.extraHttpHeaders.has(browserContext)) {
+        extraHttpHeaders_1.extraHttpHeaders.set(browserContext, new Map());
+    }
+    const headers = extraHttpHeaders_1.extraHttpHeaders.get(browserContext);
+    for (const [headerName, headerValue] of Object.entries(additionalHeaders)) {
+        headers.set(headerName.toLowerCase(), headerValue);
+    }
+    await browserContext.setExtraHTTPHeaders(Object.fromEntries(headers.entries()));
+}

package/actions/assertElementsHidden.d.ts

@@ -0,0 +1,13 @@
+import type { Locator } from '@playwright/test';
+/**
+ * Waits for all elements matching the locator to hide
+ *
+ * Optionally checks that the element was initially visible (wait for it to appear).
+ * If the element has not become visible after the timeout (300 ms by default),
+ * then it is considered that it managed to hide before that, this does not cause an error.
+ *
+ * @param locator Locator of elements that should hide
+ * @param waitForVisible Enable checking that it is initially present
+ * (if `true` - with the default timeout, if a number - with the specified one)
+ */
+export declare function assertElementsHidden(locator: Locator, waitForVisible?: boolean | number): Promise<void>;

package/actions/assertElementsHidden.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertElementsHidden = assertElementsHidden;
+const test_1 = require("@playwright/test");
+const globalSettings_1 = require("../data/globalSettings");
+/**
+ * Waits for all elements matching the locator to hide
+ *
+ * Optionally checks that the element was initially visible (wait for it to appear).
+ * If the element has not become visible after the timeout (300 ms by default),
+ * then it is considered that it managed to hide before that, this does not cause an error.
+ *
+ * @param locator Locator of elements that should hide
+ * @param waitForVisible Enable checking that it is initially present
+ * (if `true` - with the default timeout, if a number - with the specified one)
+ */
+async function assertElementsHidden(locator, waitForVisible = false) {
+    if (waitForVisible !== false) {
+        await locator
+            .first()
+            .waitFor({
+            state: 'visible',
+            timeout: typeof waitForVisible === 'number'
+                ? waitForVisible
+                : globalSettings_1.globalSettings.assertElementsHidden.defaultWaitForVisibleTimeout,
+        })
+            .catch(() => { });
+    }
+    const itemsCount = await locator.count();
+    for (let i = 0; i < itemsCount; i++) {
+        await (0, test_1.expect)(locator.nth(i)).toBeHidden();
+    }
+}

package/actions/clearExtraHttpHeaders.d.ts

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

package/actions/clearExtraHttpHeaders.js

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

package/actions/collectPageActivity/collectPageActivity.d.ts

@@ -0,0 +1,11 @@
+import type { Page } from '@playwright/test';
+import type { Config, ExpectedMessage, ResponseFailure } from './types';
+export declare function collectPageActivity(page: Page, config: Config): {
+    unsubscribe: () => void;
+    results: {
+        uncaughtErrors: Error[];
+        pageCrashes: Page[];
+        unexpectedMessages: ExpectedMessage[];
+        failedResponses: ResponseFailure[];
+    };
+};

package/actions/collectPageActivity/collectPageActivity.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectPageActivity = collectPageActivity;
+const globalSettings_1 = require("../../data/globalSettings");
+const isSameMessage_1 = require("./isSameMessage");
+const isSameResponse_1 = require("./isSameResponse");
+const STUB_HOSTNAME = 'https://stub';
+function collectPageActivity(page, config) {
+    const { ignoredMessageTypes = globalSettings_1.globalSettings.collectPageActivity.ignoredMessageTypes, expectedMessages = globalSettings_1.globalSettings.collectPageActivity.expectedMessages, ignoredResponseStatuses = globalSettings_1.globalSettings.collectPageActivity.ignoredResponseStatuses, expectedResponses = globalSettings_1.globalSettings.collectPageActivity.expectedResponses, requestIdHeader = globalSettings_1.globalSettings.collectPageActivity.requestIdHeader, } = config;
+    const uncaughtErrors = [];
+    const pageCrashes = [];
+    const unexpectedMessages = [];
+    const failedResponses = [];
+    const handlePageError = (error) => uncaughtErrors.push(error);
+    page.on('pageerror', handlePageError);
+    const handleCrash = (error) => pageCrashes.push(error);
+    page.on('crash', handleCrash);
+    const handleConsole = (message) => {
+        const type = message.type();
+        const text = message.text();
+        if (!ignoredMessageTypes.includes(type) &&
+            !expectedMessages.some((0, isSameMessage_1.isSameMessage)(type, text))) {
+            unexpectedMessages.push({ text, type });
+        }
+    };
+    page.on('console', handleConsole);
+    const handleResponse = (response) => {
+        const status = response.status();
+        const url = response.url();
+        let redirect = response.headers()['location'];
+        // If the request has a relative location,
+        // then we substitute the origin of the original request for it.
+        // For example, on the example.com page, the request https://example.com/watch/123456?...,
+        // with location = /watch/654321?...,
+        // will be compared as https://example.com/watch/654321?...
+        if (redirect) {
+            const { origin: redirectOrigin } = new URL(redirect, STUB_HOSTNAME);
+            if (redirectOrigin === STUB_HOSTNAME) {
+                const { origin: currentOrigin } = new URL(url);
+                const { href: newRedirect } = new URL(redirect, currentOrigin);
+                redirect = newRedirect;
+            }
+        }
+        const resultUrl = redirect || url;
+        if (!ignoredResponseStatuses.includes(status) &&
+            !expectedResponses.some((0, isSameResponse_1.isSameResponse)(status, resultUrl, config.baseUrl))) {
+            const result = { status, url: resultUrl };
+            if (redirect) {
+                result.originalUrl = url;
+            }
+            const requestId = response.headers()[requestIdHeader];
+            if (requestId) {
+                result.requestId = requestId;
+            }
+            failedResponses.push(result);
+        }
+    };
+    page.on('response', handleResponse);
+    const unsubscribe = () => {
+        page.off('pageerror', handlePageError);
+        page.off('crash', handleCrash);
+        page.off('console', handleConsole);
+        page.off('response', handleResponse);
+    };
+    return {
+        unsubscribe,
+        results: {
+            uncaughtErrors,
+            pageCrashes,
+            unexpectedMessages,
+            failedResponses,
+        },
+    };
+}

package/actions/collectPageActivity/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultIgnoredMessageTypes: string[];
+export declare const defaultIgnoredResponseStatuses: number[];

package/actions/collectPageActivity/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultIgnoredResponseStatuses = exports.defaultIgnoredMessageTypes = void 0;
+exports.defaultIgnoredMessageTypes = [
+    'dir',
+    'dirxml',
+    'table',
+    'clear',
+    'startGroup',
+    'startGroupCollapsed',
+    'endGroup',
+    'profile',
+    'profileEnd',
+    'count',
+    'timeEnd',
+];
+exports.defaultIgnoredResponseStatuses = [200];

package/actions/collectPageActivity/index.d.ts

@@ -0,0 +1,2 @@
+export { collectPageActivity } from './collectPageActivity';
+export type { Config } from './types';

package/actions/collectPageActivity/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectPageActivity = void 0;
+var collectPageActivity_1 = require("./collectPageActivity");
+Object.defineProperty(exports, "collectPageActivity", { enumerable: true, get: function () { return collectPageActivity_1.collectPageActivity; } });

package/actions/collectPageActivity/isSameMessage.d.ts

@@ -0,0 +1,2 @@
+import type { ExpectedMessage } from './types';
+export declare const isSameMessage: (type: string, text: string) => (message: ExpectedMessage) => boolean;

package/actions/collectPageActivity/isSameMessage.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameMessage = void 0;
+const isSameMessage = (type, text) => {
+    return (message) => {
+        const isSameText = message.text instanceof RegExp ? message.text.test(text) : message.text === text;
+        return message.type === type && isSameText;
+    };
+};
+exports.isSameMessage = isSameMessage;

package/actions/collectPageActivity/isSameResponse.d.ts

@@ -0,0 +1,2 @@
+import type { ExpectedResponse } from './types';
+export declare function isSameResponse(status: number, url: string, baseUrl: string): (expectedResponse: ExpectedResponse) => boolean;

package/actions/collectPageActivity/isSameResponse.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameResponse = isSameResponse;
+const normalizePathname_1 = require("./normalizePathname");
+const EMPTY_PATHNAME = '/';
+function isSameResponse(status, url, baseUrl) {
+    return (expectedResponse) => {
+        const expectedUrl = new URL(expectedResponse.url, baseUrl);
+        const failedUrl = new URL(url);
+        let result = expectedResponse.status === status && expectedUrl.origin === failedUrl.origin;
+        if (result && expectedUrl.pathname !== EMPTY_PATHNAME) {
+            result =
+                (0, normalizePathname_1.normalizePathname)(expectedUrl.pathname) === (0, normalizePathname_1.normalizePathname)(failedUrl.pathname);
+        }
+        return result;
+    };
+}

package/actions/collectPageActivity/normalizePathname.d.ts

@@ -0,0 +1 @@
+export declare const normalizePathname: (pathname: string) => string;

package/actions/collectPageActivity/normalizePathname.js

@@ -0,0 +1,8 @@
+"use strict";
+// remove the last '/'
+// for the case if pathname was not specified in the URL, since by default it is equal to '/'
+// for the case if '/search' is compared with '/search/'
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePathname = void 0;
+const normalizePathname = (pathname) => pathname.replace(/\/$/, '');
+exports.normalizePathname = normalizePathname;

package/actions/collectPageActivity/types.d.ts

@@ -0,0 +1,23 @@
+export type ResponseFailure = {
+    status: number;
+    url: string;
+    originalUrl?: string;
+    requestId?: string;
+};
+export type ExpectedMessage = {
+    type: string;
+    text: string | RegExp;
+};
+export type ExpectedResponse = {
+    status: number;
+    url: string;
+};
+export type Config = {
+    /** Url where app is available */
+    baseUrl: string;
+    expectedMessages?: ExpectedMessage[];
+    ignoredMessageTypes?: string[];
+    expectedResponses?: ExpectedResponse[];
+    ignoredResponseStatuses?: number[];
+    requestIdHeader?: string;
+};

package/actions/collectPageActivity/types.js

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

package/actions/disableAnimation.d.ts

@@ -0,0 +1,8 @@
+import type { Page } from '@playwright/test';
+/**
+ * Disables animation in CSS
+ *
+ * @param page
+ * @param allowFor CSS selectors for elements to enable animation for
+ */
+export declare function disableAnimations(page: Page, allowFor?: string[]): Promise<void>;

package/actions/disableAnimation.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disableAnimations = disableAnimations;
+const styleForDisableAnimation = /* css */ `{
+    transition-duration: 1ms !important;
+    transition-delay: 0s !important;
+    animation-duration: 1ms !important;
+    animation-delay: 0s !important;
+    animation-iteration-count: 1 !important;
+}`;
+/**
+ * Disables animation in CSS
+ *
+ * @param page
+ * @param allowFor CSS selectors for elements to enable animation for
+ */
+function disableAnimations(page, allowFor) {
+    const selector = allowFor && allowFor.length !== 0 ? `:not(${allowFor.join(',')})` : '*';
+    return page.addInitScript(({ selector, styleForDisableAnimation, }) => {
+        function injectStyles() {
+            const style = document.createElement('style');
+            style.textContent = selector + styleForDisableAnimation;
+            document.head.appendChild(style);
+        }
+        // Script added via addInitScript runs before DOM is built
+        if (document.readyState === 'complete') {
+            injectStyles();
+        }
+        else {
+            document.addEventListener('DOMContentLoaded', () => {
+                injectStyles();
+            });
+        }
+    }, { selector, styleForDisableAnimation });
+}

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

@@ -0,0 +1,3 @@
+import type { Request } from '@playwright/test';
+import type { ExpectRequestFnMatcher, ExpectRequestFnOptions } from './types';
+export declare function expectRequest(requests: Map<string, Request>, url: string | RegExp, matcher?: ExpectRequestFnMatcher, options?: ExpectRequestFnOptions): Promise<void>;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectRequest = expectRequest;
+const match_body_1 = require("./matchers/match-body");
+const match_method_1 = require("./matchers/match-method");
+const match_query_1 = require("./matchers/match-query");
+const match_url_1 = require("./matchers/match-url");
+const poll_with_timeout_1 = require("./poll-with-timeout");
+async function expectRequest(requests, url, matcher = {}, options = {}) {
+    const { method, query, body } = matcher;
+    const { timeout, exact = false } = options;
+    let methodDiff = null;
+    let bodyDiff = null;
+    let queryDiff = null;
+    let isRequestMade = false;
+    await (0, poll_with_timeout_1.pollWithTimeout)({
+        callbackFn: async () => {
+            for (const [requestUrl, request] of requests.entries()) {
+                if (!(0, match_url_1.matchUrl)(requestUrl, url)) {
+                    continue;
+                }
+                isRequestMade = true;
+                methodDiff = (0, match_method_1.matchMethod)(request, method);
+                bodyDiff = (0, match_body_1.matchBody)(request, body, { exact });
+                queryDiff = (0, match_query_1.matchQuery)(request, query, { exact });
+                if (!(methodDiff || bodyDiff || queryDiff)) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        condition: (result) => result,
+        timeout,
+        onTimeout: ({ resolve }) => {
+            resolve(true);
+        },
+    });
+    if (!isRequestMade) {
+        throw new Error('Asserted request was not made.');
+    }
+    const diffMessage = makeDiffMessage({ methodDiff, queryDiff, bodyDiff });
+    if (diffMessage) {
+        throw new Error(diffMessage);
+    }
+}
+function makeDiffMessage(params) {
+    const { methodDiff, queryDiff, bodyDiff } = params;
+    if (!(methodDiff || queryDiff || bodyDiff)) {
+        return null;
+    }
+    const message = ['\n\n- Expected\n+ Received'];
+    if (methodDiff) {
+        message.push(`Request method match:\n\n${methodDiff}`);
+    }
+    if (queryDiff) {
+        message.push(`Request query match:\n\n${queryDiff}`);
+    }
+    if (bodyDiff) {
+        message.push(`Request body match:\n\n${bodyDiff}`);
+    }
+    return message.join('\n\n\n');
+}

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

@@ -0,0 +1,2 @@
+export type { ExpectRequestFnMatcher, ExpectRequestFnOptions } from './types';
+export { expectRequest } from './expect-request';

package/actions/expect-request/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectRequest = void 0;
+var expect_request_1 = require("./expect-request");
+Object.defineProperty(exports, "expectRequest", { enumerable: true, get: function () { return expect_request_1.expectRequest; } });

package/actions/expect-request/matchers/compare/DiffLogger.d.ts

@@ -0,0 +1,9 @@
+import type { DiffContextItem, DiffItemBase, DiffLog } from './types';
+export declare class DiffLogger {
+    private context;
+    private _diffLog;
+    get diffLog(): DiffLog;
+    addDiffItem(diffItem: DiffItemBase): void;
+    addContext(context: DiffContextItem): void;
+    removeContext(): void;
+}

package/actions/expect-request/matchers/compare/DiffLogger.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffLogger = void 0;
+class DiffLogger {
+    context = [];
+    _diffLog = [];
+    get diffLog() {
+        return this._diffLog;
+    }
+    addDiffItem(diffItem) {
+        this.diffLog.push({ ...diffItem, context: [...this.context] });
+    }
+    addContext(context) {
+        this.context.push(context);
+    }
+    removeContext() {
+        this.context.pop();
+    }
+}
+exports.DiffLogger = DiffLogger;

package/actions/expect-request/matchers/compare/DiffPrinter.d.ts

@@ -0,0 +1,16 @@
+import type { Json } from '../../types';
+interface DiffPrinterParams {
+    left: Json;
+    right: Json;
+}
+export declare class DiffPrinter {
+    private left;
+    private right;
+    constructor({ left, right }: DiffPrinterParams);
+    printDiff(params: {
+        side: 'left' | 'right';
+        exact?: boolean;
+    }): string;
+    private makePathFromContext;
+}
+export {};

package/actions/expect-request/matchers/compare/DiffPrinter.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffPrinter = void 0;
+const compare_1 = require("./compare");
+const constants_1 = require("./constants");
+const print_json_diff_1 = require("./print-json-diff");
+class DiffPrinter {
+    left;
+    right;
+    constructor({ left, right }) {
+        this.left = left;
+        this.right = right;
+    }
+    printDiff(params) {
+        const { side, exact } = params;
+        const diffLog = (0, compare_1.compare)({ left: this.left, right: this.right, exactArrays: exact });
+        const filteredLog = diffLog.reduce((acc, logItem) => {
+            if (logItem.side === side) {
+                acc.push(logItem);
+            }
+            else if (exact && logItem.type === constants_1.DiffType.ObjectMissingProperty) {
+                acc.push({
+                    type: constants_1.DiffType.ValueMismatch,
+                    received: logItem.expected.value,
+                    side,
+                    context: [...logItem.context, { objectField: logItem.expected.key }],
+                });
+            }
+            return acc;
+        }, []);
+        if (!filteredLog.length) {
+            return '';
+        }
+        const pathAnnotations = filteredLog.reduce((acc, logItem) => {
+            const { context, type } = logItem;
+            const path = this.makePathFromContext(context);
+            if (!acc[path]) {
+                /* eslint-disable no-return-assign, no-param-reassign */
+                acc[path] = [];
+            }
+            if (type === constants_1.DiffType.ValueMismatch) {
+                if (logItem.expected === undefined && logItem.received !== undefined) {
+                    acc[path].push({ type: constants_1.PathAnnotationType.ObjectExtraProperty });
+                }
+                else {
+                    acc[path].push({
+                        type: constants_1.PathAnnotationType.ValueMismatch,
+                        expected: logItem.expected,
+                        received: logItem.received,
+                    });
+                }
+            }
+            else if (type === constants_1.DiffType.ObjectMissingProperty) {
+                acc[path].push({
+                    type: constants_1.PathAnnotationType.ObjectMissingProperty,
+                    expected: logItem.expected,
+                });
+            }
+            else if (type === constants_1.DiffType.ArrayMissingValue) {
+                acc[path].push({
+                    type: constants_1.PathAnnotationType.ArrayMissingValue,
+                    expected: logItem.expected,
+                });
+            }
+            return acc;
+        }, {});
+        return (0, print_json_diff_1.printJsonDiff)({ json: side === 'left' ? this.left : this.right, pathAnnotations });
+    }
+    makePathFromContext(context) {
+        return context
+            .map(({ objectField, arrayIndex }) => {
+            if (arrayIndex !== undefined) {
+                return `[${arrayIndex}]`;
+            }
+            return `${objectField}`;
+        })
+            .join('.');
+    }
+}
+exports.DiffPrinter = DiffPrinter;

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

@@ -0,0 +1,6 @@
+import type { Json } from '../../types';
+export declare function compare(params: {
+    left: Json;
+    right: Json;
+    exactArrays?: boolean;
+}): import("./types").DiffLog;