@gravity-ui/playwright-tools 0.4.1

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compare = compare;
+const utils_1 = require("../utils");
+const DiffLogger_1 = require("./DiffLogger");
+const constants_1 = require("./constants");
+function compare(params) {
+    const { left, right, exactArrays } = params;
+    const logger = new DiffLogger_1.DiffLogger();
+    compareInner({
+        left,
+        right,
+        exactArrays,
+        logger: logger,
+    });
+    compareInner({
+        left: right,
+        right: left,
+        forwardComparison: false,
+        exactArrays,
+        logger: logger,
+    });
+    return logger.diffLog;
+}
+function compareInner(params) {
+    const { left, right, exactArrays, logger, forwardComparison = true } = params;
+    const innerLogger = logger ? logger : new DiffLogger_1.DiffLogger();
+    if (left === right) {
+        return innerLogger;
+    }
+    if (left === null) {
+        innerLogger.addDiffItem({
+            type: constants_1.DiffType.ValueMismatch,
+            side: forwardComparison ? 'left' : 'right',
+            expected: right,
+            received: left,
+        });
+        return innerLogger;
+    }
+    if (Array.isArray(left) && Array.isArray(right)) {
+        if (exactArrays) {
+            if (left.length === right.length) {
+                for (let i = 0; i < left.length; ++i) {
+                    const leftItem = left[i] ?? null;
+                    const rightItem = right[i] ?? null;
+                    innerLogger.addContext({ arrayIndex: i });
+                    compareInner({
+                        left: leftItem,
+                        right: rightItem,
+                        forwardComparison: forwardComparison,
+                        exactArrays,
+                        logger: innerLogger,
+                    });
+                    innerLogger.removeContext();
+                }
+            }
+            else {
+                innerLogger.addDiffItem({
+                    type: constants_1.DiffType.ValueMismatch,
+                    side: forwardComparison ? 'left' : 'right',
+                    expected: right,
+                    received: left,
+                });
+            }
+        }
+        else {
+            const rightCopy = [...right];
+            for (const leftItem of left) {
+                const index = rightCopy.findIndex((rightItem) => {
+                    const logger = compareInner({
+                        left: leftItem,
+                        right: rightItem,
+                        exactArrays,
+                        forwardComparison,
+                    });
+                    return logger.diffLog.length === 0;
+                });
+                if (index >= 0) {
+                    rightCopy.splice(index, 1);
+                }
+                if (rightCopy.length === 0) {
+                    break;
+                }
+            }
+            for (const item of rightCopy) {
+                innerLogger.addDiffItem({
+                    type: constants_1.DiffType.ArrayMissingValue,
+                    side: forwardComparison ? 'left' : 'right',
+                    expected: item,
+                });
+            }
+        }
+    }
+    else if ((0, utils_1.isObject)(left) && (0, utils_1.isObject)(right)) {
+        for (const [rightKey, rightValue] of Object.entries(right)) {
+            innerLogger.addContext({ objectField: rightKey });
+            if (!Object.hasOwn(left, rightKey)) {
+                innerLogger.removeContext();
+                innerLogger.addDiffItem({
+                    type: constants_1.DiffType.ObjectMissingProperty,
+                    side: forwardComparison ? 'left' : 'right',
+                    expected: {
+                        key: rightKey,
+                        value: rightValue,
+                    },
+                });
+                continue;
+            }
+            const leftValue = left[rightKey] ?? null;
+            compareInner({
+                left: leftValue,
+                right: rightValue,
+                forwardComparison,
+                exactArrays,
+                logger: innerLogger,
+            });
+            innerLogger.removeContext();
+        }
+    }
+    else if (left !== right) {
+        innerLogger.addDiffItem({
+            type: constants_1.DiffType.ValueMismatch,
+            side: forwardComparison ? 'left' : 'right',
+            expected: right,
+            received: left,
+        });
+    }
+    return innerLogger;
+}

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

@@ -0,0 +1,20 @@
+export declare const DiffType: {
+    readonly ValueMismatch: "value-mismatch";
+    readonly ObjectMissingProperty: "object-missing-property";
+    readonly ArrayMissingValue: "array-missing-value";
+};
+export declare const DecoratedLineType: {
+    readonly ObjectOpen: "object-open";
+    readonly ObjectClose: "object-close";
+    readonly ArrayOpen: "array-open";
+    readonly ArrayClose: "array-close";
+    readonly PrimitiveValue: "primitive-value";
+    readonly EmptyObject: "empty-object";
+    readonly EmptyArray: "empty-array";
+};
+export declare const PathAnnotationType: {
+    readonly ValueMismatch: "value-mismatch";
+    readonly ObjectMissingProperty: "object-missing-property";
+    readonly ObjectExtraProperty: "object-extra-property";
+    readonly ArrayMissingValue: "array-missing-value";
+};

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathAnnotationType = exports.DecoratedLineType = exports.DiffType = void 0;
+exports.DiffType = {
+    ValueMismatch: 'value-mismatch',
+    ObjectMissingProperty: 'object-missing-property',
+    ArrayMissingValue: 'array-missing-value',
+};
+exports.DecoratedLineType = {
+    ObjectOpen: 'object-open',
+    ObjectClose: 'object-close',
+    ArrayOpen: 'array-open',
+    ArrayClose: 'array-close',
+    PrimitiveValue: 'primitive-value',
+    EmptyObject: 'empty-object',
+    EmptyArray: 'empty-array',
+};
+exports.PathAnnotationType = {
+    ValueMismatch: 'value-mismatch',
+    ObjectMissingProperty: 'object-missing-property',
+    ObjectExtraProperty: 'object-extra-property',
+    ArrayMissingValue: 'array-missing-value',
+};

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

@@ -0,0 +1,4 @@
+export { compare } from './compare';
+export * from './types';
+export * from './utils';
+export { printJsonDiff } from './print-json-diff';

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

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printJsonDiff = exports.compare = void 0;
+var compare_1 = require("./compare");
+Object.defineProperty(exports, "compare", { enumerable: true, get: function () { return compare_1.compare; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+var print_json_diff_1 = require("./print-json-diff");
+Object.defineProperty(exports, "printJsonDiff", { enumerable: true, get: function () { return print_json_diff_1.printJsonDiff; } });

package/actions/expect-request/matchers/compare/print-json-diff.d.ts

@@ -0,0 +1,6 @@
+import type { Json } from '../../types';
+import type { PathAnnotation } from './types';
+export declare function printJsonDiff(params: {
+    json: Json;
+    pathAnnotations?: Record<string, PathAnnotation[]>;
+}): string;

package/actions/expect-request/matchers/compare/print-json-diff.js

@@ -0,0 +1,366 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printJsonDiff = printJsonDiff;
+const utils_1 = require("../utils");
+const constants_1 = require("./constants");
+const utils_2 = require("./utils");
+function printJsonDiff(params) {
+    const { json, pathAnnotations } = params;
+    const lines = makeJsonDecoratedLines({ json, pathAnnotations, level: 0, path: '' });
+    const formattedLines = lines.map(formatDecoratedLine);
+    return formattedLines.join('\n');
+}
+function formatDecoratedLine(line) {
+    const { type, level, fieldName, diffMarker } = line;
+    let content;
+    switch (type) {
+        case constants_1.DecoratedLineType.PrimitiveValue:
+            content = `${fieldName ? formatPrimitive(fieldName) + ': ' : ''}${formatPrimitive(line.value)}${level === 0 ? '' : ','}`;
+            break;
+        case constants_1.DecoratedLineType.ObjectOpen:
+            content = `${fieldName ? formatPrimitive(fieldName) + ': ' : ''}{`;
+            break;
+        case constants_1.DecoratedLineType.ArrayOpen:
+            content = `${fieldName ? formatPrimitive(fieldName) + ': ' : ''}[`;
+            break;
+        case constants_1.DecoratedLineType.ObjectClose:
+            content = `}${level === 0 ? '' : ','}`;
+            break;
+        case constants_1.DecoratedLineType.ArrayClose:
+            content = `]${level === 0 ? '' : ','}`;
+            break;
+        case constants_1.DecoratedLineType.EmptyObject:
+            content = `${fieldName ? formatPrimitive(fieldName) + ': ' : ''}{}${level === 0 ? '' : ','}`;
+            break;
+        case constants_1.DecoratedLineType.EmptyArray:
+            content = `${fieldName ? formatPrimitive(fieldName) + ': ' : ''}[]${level === 0 ? '' : ','}`;
+            break;
+    }
+    let prefix = '';
+    if (diffMarker) {
+        prefix = diffMarker === 'expected' ? '-' : '+';
+    }
+    return `${prefix ? prefix + ' ' : '  '}${Array.from({ length: level })
+        .map(() => '  ')
+        .join('')}${content}`;
+}
+function formatPrimitive(jsonPrimitive) {
+    if (typeof jsonPrimitive === 'string') {
+        return `"${jsonPrimitive}"`;
+    }
+    return `${jsonPrimitive}`;
+}
+function makeJsonDecoratedLines(params) {
+    const { json, path, level, pathAnnotations, decoratedLines: paramsDecoratedLines, contentOnly, diffMarker, fieldName, } = params;
+    const decoratedLines = paramsDecoratedLines ? paramsDecoratedLines : [];
+    if (Array.isArray(json)) {
+        makeArrayDecoratedLines({
+            json,
+            path,
+            level,
+            pathAnnotations,
+            decoratedLines,
+            contentOnly,
+            diffMarker,
+            fieldName,
+        });
+    }
+    else if ((0, utils_1.isObject)(json)) {
+        makeObjectDecoratedLines({
+            json,
+            path,
+            level,
+            pathAnnotations,
+            decoratedLines,
+            contentOnly,
+            diffMarker,
+            fieldName,
+        });
+    }
+    else {
+        const currentPathAnnotations = pathAnnotations?.[path] || [];
+        const valueMismatchAnnotations = currentPathAnnotations.filter(utils_2.isValueMismatchAnnotation);
+        if (valueMismatchAnnotations.length) {
+            for (const { expected, received } of valueMismatchAnnotations) {
+                if (expected !== undefined) {
+                    makeJsonDecoratedLines({
+                        json: expected,
+                        path,
+                        level,
+                        decoratedLines,
+                        diffMarker: 'expected',
+                        fieldName,
+                    });
+                }
+                if (received !== undefined) {
+                    makeJsonDecoratedLines({
+                        json: received,
+                        path,
+                        level,
+                        decoratedLines,
+                        diffMarker: 'received',
+                        fieldName,
+                    });
+                }
+            }
+        }
+        else {
+            decoratedLines.push({
+                type: constants_1.DecoratedLineType.PrimitiveValue,
+                level,
+                value: json,
+                diffMarker,
+                fieldName,
+            });
+        }
+    }
+    return decoratedLines;
+}
+function makeObjectDecoratedLines(params) {
+    const { json, path, decoratedLines, pathAnnotations, contentOnly, diffMarker, level, fieldName, } = params;
+    let innerLevel = level;
+    const objectEntries = Object.entries(json);
+    const objectAnnotations = pathAnnotations?.[path] || [];
+    const missingValueAnnotations = objectAnnotations.filter(utils_2.isObjectMissingPropertyAnnotation);
+    const valueMismatchAnnotation = objectAnnotations.find(utils_2.isValueMismatchAnnotation);
+    if (valueMismatchAnnotation) {
+        const { expected, received } = valueMismatchAnnotation;
+        if (expected !== undefined) {
+            makeJsonDecoratedLines({
+                decoratedLines,
+                json: expected,
+                path,
+                level,
+                diffMarker: 'expected',
+            });
+        }
+        if (received !== undefined) {
+            makeJsonDecoratedLines({
+                decoratedLines,
+                json: received,
+                path,
+                level,
+                diffMarker: 'received',
+            });
+        }
+        return;
+    }
+    if (!missingValueAnnotations.length && !objectEntries.length) {
+        decoratedLines.push({ type: constants_1.DecoratedLineType.EmptyObject, level, diffMarker, fieldName });
+        return;
+    }
+    if (!contentOnly) {
+        decoratedLines.push({
+            type: constants_1.DecoratedLineType.ObjectOpen,
+            level: innerLevel,
+            diffMarker,
+            fieldName,
+        });
+        innerLevel++;
+    }
+    for (const { expected } of missingValueAnnotations) {
+        makeJsonDecoratedLines({
+            json: { [expected.key]: expected.value },
+            path,
+            level: innerLevel,
+            decoratedLines,
+            contentOnly: true,
+            diffMarker: 'expected',
+        });
+    }
+    for (const [key, value] of objectEntries) {
+        const currentPath = `${path ? path + '.' : ''}${key}`;
+        const currentPathAnnotations = pathAnnotations?.[currentPath] || [];
+        const extraPropertyAnnotation = currentPathAnnotations.find(utils_2.isObjectExtraPropertyAnnotation);
+        if (extraPropertyAnnotation) {
+            makeJsonDecoratedLines({
+                json: value,
+                path,
+                level: innerLevel,
+                decoratedLines,
+                diffMarker: 'received',
+                fieldName: key,
+            });
+            continue;
+        }
+        const valueMismatchAnnotation = currentPathAnnotations.find(utils_2.isValueMismatchAnnotation);
+        if (valueMismatchAnnotation) {
+            const { expected, received } = valueMismatchAnnotation;
+            if (expected !== undefined) {
+                makeJsonDecoratedLines({
+                    json: expected,
+                    path,
+                    level: innerLevel,
+                    decoratedLines,
+                    diffMarker: 'expected',
+                    fieldName: key,
+                });
+            }
+            if (received !== undefined) {
+                makeJsonDecoratedLines({
+                    json: received,
+                    path,
+                    level: innerLevel,
+                    decoratedLines,
+                    diffMarker: 'received',
+                    fieldName: key,
+                });
+            }
+            continue;
+        }
+        if (Array.isArray(value)) {
+            makeArrayDecoratedLines({
+                json: value,
+                path: currentPath,
+                level: innerLevel,
+                pathAnnotations,
+                decoratedLines,
+                diffMarker,
+                fieldName: key,
+            });
+        }
+        else if ((0, utils_1.isObject)(value)) {
+            makeObjectDecoratedLines({
+                json: value,
+                path: currentPath,
+                level: innerLevel,
+                pathAnnotations,
+                decoratedLines,
+                diffMarker,
+                fieldName: key,
+            });
+        }
+        else {
+            decoratedLines.push({
+                type: constants_1.DecoratedLineType.PrimitiveValue,
+                level: innerLevel,
+                value,
+                diffMarker,
+                fieldName: key,
+            });
+        }
+    }
+    if (!contentOnly) {
+        innerLevel--;
+        decoratedLines.push({
+            level: innerLevel,
+            type: constants_1.DecoratedLineType.ObjectClose,
+            diffMarker,
+        });
+    }
+}
+function makeArrayDecoratedLines(params) {
+    const { json, path, decoratedLines, pathAnnotations, contentOnly, diffMarker, level, fieldName, } = params;
+    let innerLevel = level;
+    const annotations = pathAnnotations?.[path] || [];
+    const missingValueAnnotations = annotations.filter(utils_2.isArrayMissingValueAnnotation);
+    if (!missingValueAnnotations.length && !json.length) {
+        decoratedLines.push({ level, type: constants_1.DecoratedLineType.EmptyArray, diffMarker, fieldName });
+        return;
+    }
+    const valueMismatchAnnotation = annotations.find(utils_2.isValueMismatchAnnotation);
+    if (valueMismatchAnnotation) {
+        const { expected, received } = valueMismatchAnnotation;
+        if (expected !== undefined) {
+            makeJsonDecoratedLines({
+                decoratedLines,
+                json: expected,
+                path,
+                level,
+                diffMarker: 'expected',
+            });
+        }
+        if (received !== undefined) {
+            makeJsonDecoratedLines({
+                decoratedLines,
+                json: received,
+                path,
+                level,
+                diffMarker: 'received',
+            });
+        }
+        return;
+    }
+    if (!contentOnly) {
+        decoratedLines.push({
+            level: innerLevel,
+            fieldName,
+            type: constants_1.DecoratedLineType.ArrayOpen,
+            diffMarker,
+        });
+        innerLevel++;
+    }
+    for (let i = 0; i < json.length; ++i) {
+        const currentPath = `${path ? path + '.' : ''}[${i}]`;
+        const currentPathAnnotations = pathAnnotations?.[currentPath] || [];
+        const valueMismatchAnnotation = currentPathAnnotations.find(utils_2.isValueMismatchAnnotation);
+        if (valueMismatchAnnotation) {
+            const { expected, received } = valueMismatchAnnotation;
+            if (expected !== undefined) {
+                makeJsonDecoratedLines({
+                    decoratedLines,
+                    json: expected,
+                    path,
+                    level: innerLevel,
+                    diffMarker: 'expected',
+                });
+            }
+            if (received !== undefined) {
+                makeJsonDecoratedLines({
+                    decoratedLines,
+                    json: received,
+                    path,
+                    level: innerLevel,
+                    diffMarker: 'received',
+                });
+            }
+            continue;
+        }
+        const value = json[i];
+        if (Array.isArray(value)) {
+            makeArrayDecoratedLines({
+                json: value,
+                decoratedLines,
+                level: innerLevel,
+                path: currentPath,
+                diffMarker,
+                pathAnnotations,
+            });
+        }
+        else if ((0, utils_1.isObject)(value)) {
+            makeObjectDecoratedLines({
+                json: value,
+                decoratedLines,
+                level: innerLevel,
+                path: currentPath,
+                diffMarker,
+                pathAnnotations,
+            });
+        }
+        else {
+            decoratedLines.push({
+                level: innerLevel,
+                type: constants_1.DecoratedLineType.PrimitiveValue,
+                value,
+                diffMarker,
+            });
+        }
+    }
+    for (const { expected } of missingValueAnnotations) {
+        makeJsonDecoratedLines({
+            decoratedLines,
+            json: expected,
+            path,
+            level: innerLevel,
+            diffMarker: 'expected',
+        });
+    }
+    if (!contentOnly) {
+        innerLevel--;
+        decoratedLines.push({
+            level: innerLevel,
+            type: constants_1.DecoratedLineType.ArrayClose,
+            diffMarker,
+        });
+    }
+}

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

@@ -0,0 +1,59 @@
+import type { Json, JsonPrimitive } from '../../types';
+import type { DecoratedLineType, DiffType, PathAnnotationType } from './constants';
+export type DiffType = (typeof DiffType)[keyof typeof DiffType];
+export type DiffLog = DiffItem[];
+export type DiffItem = DiffItemBase & {
+    context: DiffContextItem[];
+};
+export type DiffItemBase = {
+    side?: 'left' | 'right';
+} & ({
+    type: typeof DiffType.ValueMismatch;
+    expected?: Json;
+    received?: Json;
+} | {
+    type: typeof DiffType.ObjectMissingProperty;
+    expected: {
+        key: string;
+        value: Json;
+    };
+} | {
+    type: typeof DiffType.ArrayMissingValue;
+    expected: Json;
+});
+export type DiffContextItem = {
+    objectField?: string;
+    arrayIndex?: number;
+};
+export type DecoratedLineType = (typeof DecoratedLineType)[keyof typeof DecoratedLineType];
+export type DecoratedLine = {
+    fieldName?: string;
+    level: number;
+    diffMarker?: 'expected' | 'received';
+} & ({
+    type: typeof DecoratedLineType.PrimitiveValue;
+    value: JsonPrimitive;
+} | {
+    type: Exclude<DecoratedLineType, typeof DecoratedLineType.PrimitiveValue>;
+});
+export type PathAnnotation = ObjectMissingPropertyAnnotation | ObjectExtraPropertyAnnotation | ArrayMissingValueAnnotation | ValueMismatchAnnotation;
+export type PathAnnotationType = (typeof PathAnnotationType)[keyof typeof PathAnnotationType];
+export type ObjectMissingPropertyAnnotation = {
+    type: typeof PathAnnotationType.ObjectMissingProperty;
+    expected: {
+        key: string;
+        value: Json;
+    };
+};
+export type ObjectExtraPropertyAnnotation = {
+    type: typeof PathAnnotationType.ObjectExtraProperty;
+};
+export type ArrayMissingValueAnnotation = {
+    type: typeof PathAnnotationType.ArrayMissingValue;
+    expected: Json;
+};
+export type ValueMismatchAnnotation = {
+    type: typeof PathAnnotationType.ValueMismatch;
+    expected?: Json;
+    received?: Json;
+};

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

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

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

@@ -0,0 +1,5 @@
+import type { ArrayMissingValueAnnotation, ObjectMissingPropertyAnnotation, PathAnnotation, ValueMismatchAnnotation } from './types';
+export declare function isValueMismatchAnnotation(annotation: PathAnnotation): annotation is ValueMismatchAnnotation;
+export declare function isObjectMissingPropertyAnnotation(annotation: PathAnnotation): annotation is ObjectMissingPropertyAnnotation;
+export declare function isObjectExtraPropertyAnnotation(annotation: PathAnnotation): annotation is ArrayMissingValueAnnotation;
+export declare function isArrayMissingValueAnnotation(annotation: PathAnnotation): annotation is ArrayMissingValueAnnotation;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValueMismatchAnnotation = isValueMismatchAnnotation;
+exports.isObjectMissingPropertyAnnotation = isObjectMissingPropertyAnnotation;
+exports.isObjectExtraPropertyAnnotation = isObjectExtraPropertyAnnotation;
+exports.isArrayMissingValueAnnotation = isArrayMissingValueAnnotation;
+const constants_1 = require("./constants");
+function isValueMismatchAnnotation(annotation) {
+    return annotation.type === constants_1.PathAnnotationType.ValueMismatch;
+}
+function isObjectMissingPropertyAnnotation(annotation) {
+    return annotation.type === constants_1.PathAnnotationType.ObjectMissingProperty;
+}
+function isObjectExtraPropertyAnnotation(annotation) {
+    return annotation.type === constants_1.PathAnnotationType.ObjectExtraProperty;
+}
+function isArrayMissingValueAnnotation(annotation) {
+    return annotation.type === constants_1.PathAnnotationType.ArrayMissingValue;
+}

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

@@ -0,0 +1,4 @@
+import type { Request } from '@playwright/test';
+import type { Json } from '../types';
+import type { CommonMatcherOptions } from './types';
+export declare function matchBody(request: Request, body: Json | undefined, { exact }: CommonMatcherOptions): string | null;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchBody = matchBody;
+const DiffPrinter_1 = require("./compare/DiffPrinter");
+function matchBody(request, body, { exact }) {
+    if (!body) {
+        return null;
+    }
+    const requestBody = request.postDataJSON();
+    const printer = new DiffPrinter_1.DiffPrinter({ left: requestBody, right: body });
+    return printer.printDiff({ side: 'left', exact }) || null;
+}