@lokalise/playwright-reporters 1.5.0 → 1.7.0

package/README.md

@@ -42,6 +42,42 @@ export default defineConfig({
 });
 ```
 
+## Steps Duration Reporter
+
+This reporter aggregates the duration of each discrete test step and reports their total duration at the end of the test run. The reporter uses the custom [Playwright Reporter](https://playwright.dev/docs/test-reporters#custom-reporters) implementation to collect the step durations. Follow the steps in the [official Playwright documentation](https://playwright.dev/docs/test-reporters#multiple-reporters) to add the custom reporter to your test suite.
+
+### Usage
+
+Once the reporter is enabled, it will output a `JSON` file `./reporters/results/steps.json` containing the duration of each step in the test suite.
+
+## Test Similarity Reporter
+
+This reporter calculates the similarity between tests based on the test steps. The reporter does not use the custom [Playwright Reporter](https://playwright.dev/docs/test-reporters#custom-reporters) implementation. Instead, it takes the simplified reporter from the undocumented `timeline` reporter.
+
+### Usage
+
+1. Run the test suite with the `timeline` reporter enabled. This will generate a `JSON` file `./reporters/results/timeline.json`
+1. Run the similarity reporter with the following command: `npx ts-node reporters/testSimilarity.ts`
+1. After analysing the results, the reporter will output a `JSON` file `./reporters/results/distance.json` containing the similarity between tests based on the test steps.
+
+### Output
+
+The report has the following format:
+
+```json
+[
+	{
+		"title": "Title of the test being compared",
+		"relatedTests": [
+			["Title of the first related test", 0],
+			["Title of the second related test", 50]
+		]
+	}
+]
+```
+
+The `relatedTests` array contains the title of the related test and the distance score. The similarity percentage is calculated based on the [Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance) between the test steps. The lower the distance, the higher the similarity between the tests.
+
 ## Husky
 
 By default, pre-commit hook will run `npm run lint:fix`. Feel free to remove that if it's undesirable or add your own

package/dist/analytics/transform.d.ts

@@ -15,7 +15,7 @@ export declare const formFailedTestData: (test: TestCase, result: TestResult, te
     name: string;
     team: string | null;
     testRunId: string;
-    status: import("playwright/types/test").TestStatus;
+    status: "failed" | "interrupted" | "passed" | "timedOut" | "skipped";
     hooksDuration: number;
     beforeHookDuration: number;
     afterHookDuration: number;
@@ -32,7 +32,7 @@ export declare const formFlakyTestData: (test: TestCase, result: TestResult, tes
     name: string;
     team: string | null;
     testRunId: string;
-    status: import("playwright/types/test").TestStatus;
+    status: "failed" | "interrupted" | "passed" | "timedOut" | "skipped";
     hooksDuration: number;
     beforeHookDuration: number;
     afterHookDuration: number;

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 import AnalyticsReporter, { defineAnalyticsReporterConfig } from './analytics/reporter';
+import PermissionsReporter, { definePermissionsReporterConfig } from './permissions/reporter';
 import RetryReporter, { defineRetryReporterConfig } from './retry/reporter';
-export { AnalyticsReporter, defineAnalyticsReporterConfig, RetryReporter, defineRetryReporterConfig, };
+import StepDurationReporter, { defineStepDurationReporterConfig } from './stepDuration/reporter';
+import TimelineReporter, { defineTimelineReporterConfig } from './timeline/reporter';
+export { AnalyticsReporter, defineAnalyticsReporterConfig, RetryReporter, defineRetryReporterConfig, TimelineReporter, defineTimelineReporterConfig, StepDurationReporter, defineStepDurationReporterConfig, PermissionsReporter, definePermissionsReporterConfig };

package/dist/index.js

@@ -23,10 +23,19 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineRetryReporterConfig = exports.RetryReporter = exports.defineAnalyticsReporterConfig = exports.AnalyticsReporter = void 0;
+exports.definePermissionsReporterConfig = exports.PermissionsReporter = exports.defineStepDurationReporterConfig = exports.StepDurationReporter = exports.defineTimelineReporterConfig = exports.TimelineReporter = exports.defineRetryReporterConfig = exports.RetryReporter = exports.defineAnalyticsReporterConfig = exports.AnalyticsReporter = void 0;
 const reporter_1 = __importStar(require("./analytics/reporter"));
 exports.AnalyticsReporter = reporter_1.default;
 Object.defineProperty(exports, "defineAnalyticsReporterConfig", { enumerable: true, get: function () { return reporter_1.defineAnalyticsReporterConfig; } });
-const reporter_2 = __importStar(require("./retry/reporter"));
-exports.RetryReporter = reporter_2.default;
-Object.defineProperty(exports, "defineRetryReporterConfig", { enumerable: true, get: function () { return reporter_2.defineRetryReporterConfig; } });
+const reporter_2 = __importStar(require("./permissions/reporter"));
+exports.PermissionsReporter = reporter_2.default;
+Object.defineProperty(exports, "definePermissionsReporterConfig", { enumerable: true, get: function () { return reporter_2.definePermissionsReporterConfig; } });
+const reporter_3 = __importStar(require("./retry/reporter"));
+exports.RetryReporter = reporter_3.default;
+Object.defineProperty(exports, "defineRetryReporterConfig", { enumerable: true, get: function () { return reporter_3.defineRetryReporterConfig; } });
+const reporter_4 = __importStar(require("./stepDuration/reporter"));
+exports.StepDurationReporter = reporter_4.default;
+Object.defineProperty(exports, "defineStepDurationReporterConfig", { enumerable: true, get: function () { return reporter_4.defineStepDurationReporterConfig; } });
+const reporter_5 = __importStar(require("./timeline/reporter"));
+exports.TimelineReporter = reporter_5.default;
+Object.defineProperty(exports, "defineTimelineReporterConfig", { enumerable: true, get: function () { return reporter_5.defineTimelineReporterConfig; } });

package/dist/permissions/elastic.d.ts

@@ -0,0 +1,13 @@
+import type { PermissionsReportData } from "./reporter";
+export type ElasticOptions = {
+    permissionsIndex: string;
+    elasticUrl: string;
+    elasticToken: string;
+};
+export declare class Elastic {
+    private readonly options;
+    private request;
+    constructor(options: ElasticOptions);
+    setRequestContext(): Promise<void>;
+    savePermissionsData(testData: PermissionsReportData): Promise<void>;
+}

package/dist/permissions/elastic.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Elastic = void 0;
+const test_1 = require("@playwright/test");
+class Elastic {
+    constructor(options) {
+        this.options = options;
+    }
+    async setRequestContext() {
+        this.request = await test_1.request.newContext({
+            baseURL: this.options.elasticUrl,
+            ignoreHTTPSErrors: true,
+            ...(this.options.elasticToken && {
+                extraHTTPHeaders: { Authorization: `ApiKey ${this.options.elasticToken}` },
+            }),
+        });
+    }
+    async savePermissionsData(testData) {
+        try {
+            await this.request.post(`/${this.options.permissionsIndex}/_doc`, { data: testData });
+        }
+        catch (error) {
+            console.error("Failed to save permissions data");
+            console.error(error);
+        }
+    }
+}
+exports.Elastic = Elastic;

package/dist/permissions/reporter.d.ts

@@ -0,0 +1,25 @@
+import type { TestCase, TestResult, Reporter, TestStep } from '@playwright/test/reporter';
+import { type ElasticOptions } from './elastic';
+type ReporterOptions = {
+    annotationName: string;
+    stepName: string;
+    debug: boolean;
+} & ElasticOptions;
+export type PermissionsReportData = {
+    title: string;
+    permissions: Record<string, boolean>;
+    failedStep: string;
+    timestamp: number;
+};
+export default class PermissionsReporter implements Reporter {
+    private readonly options;
+    private readonly elastic;
+    private readonly debugLogging;
+    private failedTestData;
+    constructor(options: ReporterOptions);
+    onBegin(): Promise<void>;
+    onTestEnd(test: TestCase): Promise<void>;
+    onStepEnd(test: TestCase, _result: TestResult, step: TestStep): void;
+}
+export declare const definePermissionsReporterConfig: (options: ConstructorParameters<typeof PermissionsReporter>[0]) => ReporterOptions;
+export {};

package/dist/permissions/reporter.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definePermissionsReporterConfig = void 0;
+const elastic_1 = require("./elastic");
+// eslint-disable-next-line import/no-default-export
+class PermissionsReporter {
+    constructor(options) {
+        this.elastic = new elastic_1.Elastic(options);
+        this.options = options;
+        this.failedTestData = {};
+        this.debugLogging = options.debug ? console.info : () => { };
+    }
+    async onBegin() {
+        await this.elastic.setRequestContext();
+    }
+    async onTestEnd(test) {
+        // Omit the results if the test is passing
+        if (test.outcome() === 'expected') {
+            this.debugLogging('Not reporting test - test passed');
+            return;
+        }
+        // Omit the results if the test does not contain the annotation
+        if (!test.annotations.find((annotation) => annotation.type === this.options.annotationName)) {
+            this.debugLogging('Not reporting test - no permission annotation');
+            return;
+        }
+        // Test Title
+        const testTitle = test.title;
+        // Permissions as object
+        const testPermissions = test.annotations.find((annotation) => annotation.type === this.options.annotationName);
+        const permissionContents = testPermissions?.description ? JSON.parse(testPermissions.description) : {};
+        // Which step failed
+        const failedStep = this.failedTestData[test.id];
+        // Send payload body
+        const reportData = {
+            title: testTitle,
+            permissions: permissionContents,
+            failedStep,
+            timestamp: Date.now()
+        };
+        await this.elastic.savePermissionsData(reportData);
+    }
+    onStepEnd(test, _result, step) {
+        if (!step.title.includes(this.options.stepName)) {
+            this.debugLogging('Not reporting step - no step annotation', step.title);
+            return;
+        }
+        if (!step.error) {
+            this.debugLogging("Not reporting step - no error");
+            return;
+        }
+        this.debugLogging('Captured step name with error:', step.title);
+        this.failedTestData[test.id] = step.title;
+    }
+}
+exports.default = PermissionsReporter;
+const definePermissionsReporterConfig = (options) => options;
+exports.definePermissionsReporterConfig = definePermissionsReporterConfig;

package/dist/stepDuration/reporter.d.ts

@@ -0,0 +1,15 @@
+import type { Reporter, TestCase, TestResult, TestStep } from '@playwright/test/reporter';
+interface ReporterOptions {
+    writeToFile: boolean;
+    filePath?: string;
+}
+declare class StepDurationReporter implements Reporter {
+    private stepStorage;
+    private readonly ignoredSteps;
+    private readonly options;
+    constructor(options: ReporterOptions);
+    onStepEnd(_test: TestCase, _result: TestResult, step: TestStep): void;
+    onEnd(): void;
+}
+export default StepDurationReporter;
+export declare const defineStepDurationReporterConfig: (options: ConstructorParameters<typeof StepDurationReporter>[0]) => ReporterOptions;

package/dist/stepDuration/reporter.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineStepDurationReporterConfig = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+class StepDurationReporter {
+    constructor(options) {
+        this.options = options;
+        this.stepStorage = {};
+        this.ignoredSteps = [
+            'expect.',
+            /attach.*(response|request|trace|login)/i,
+            /hook(s?)$/i,
+            /tracing\.(start|stop)/,
+            /apiResponse\.(json|text)/,
+            /sending .* to/,
+        ];
+    }
+    onStepEnd(_test, _result, step) {
+        const stepName = step.title;
+        const shouldIgnoreStep = this.ignoredSteps.some((ignoredStep) => {
+            if (typeof ignoredStep === 'string') {
+                return stepName.toLowerCase().includes(ignoredStep);
+            }
+            return ignoredStep.test(stepName.toLowerCase());
+        });
+        if (shouldIgnoreStep) {
+            return;
+        }
+        if (!(stepName in this.stepStorage)) {
+            this.stepStorage[stepName] = { totalTime: 0, minTime: 0, maxTime: 0, count: 0 };
+        }
+        const stepDuration = Date.now() - step.startTime.getTime();
+        this.stepStorage[stepName].totalTime += stepDuration;
+        this.stepStorage[stepName].count += 1;
+        this.stepStorage[stepName].minTime = Math.min(this.stepStorage[stepName].minTime === 0 ? stepDuration : this.stepStorage[stepName].minTime, stepDuration);
+        this.stepStorage[stepName].maxTime = Math.max(this.stepStorage[stepName].maxTime, stepDuration);
+    }
+    onEnd() {
+        const sortedSteps = Object.fromEntries(Object.entries(this.stepStorage).sort((a, b) => b[1].totalTime - a[1].totalTime));
+        const reportString = JSON.stringify(sortedSteps, null, 2);
+        if (this.options.writeToFile) {
+            const filePath = this.options.filePath ?? './reporters/results/steps.json';
+            node_fs_1.default.writeFileSync(filePath, reportString);
+        }
+        else {
+            console.log(reportString);
+        }
+    }
+}
+// eslint-disable-next-line import/no-default-export
+exports.default = StepDurationReporter;
+const defineStepDurationReporterConfig = (options) => options;
+exports.defineStepDurationReporterConfig = defineStepDurationReporterConfig;

package/dist/testSimilarity/reporter.d.ts

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

package/dist/testSimilarity/reporter.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const fastest_levenshtein_1 = require("fastest-levenshtein");
+const replaceTitleParameters = (title) => {
+    const numberInUrl = /\/(\d+)(?:\/|$)/gm;
+    const projectId = /[a-z0-9]+\.[a-z0-9]+/gm;
+    return title.replace(numberInUrl, '/:id/').replace(projectId, ':projectId');
+};
+const updateLog = (message) => {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    process.stdout.write(message);
+};
+const stepsToIgnore = [
+    'Create Browser',
+    'Sending post to /signup/test-user',
+    'open and match condition at Application',
+];
+const pathVariable = process.env.REPORTS_PATH;
+const timelinePath = node_path_1.default.resolve(node_path_1.default.join(pathVariable, './results/timeline.json'));
+const timeline = JSON.parse(node_fs_1.default.readFileSync(timelinePath, 'utf-8'));
+const timelineWithoutEmptySteps = timeline.tests.filter((test) => {
+    return test.steps.length > 0;
+});
+const simplifiedTimeline = timelineWithoutEmptySteps.map((test) => {
+    return {
+        title: test.title,
+        steps: test.steps
+            .filter((step) => step.category === 'test.step')
+            .filter((step) => !stepsToIgnore.includes(step.title))
+            .map((step) => replaceTitleParameters(step.title)),
+    };
+});
+const timelineAsText = simplifiedTimeline.map((test) => {
+    return {
+        ...test,
+        stepsAsText: test.steps.join(' '),
+    };
+});
+const distances = {};
+const iterationCount = (timelineAsText.length * (timelineAsText.length - 1)) / 2;
+let currentIteration = 0;
+for (let testIndex = 0; testIndex < timelineAsText.length; testIndex++) {
+    updateLog(`Processing iteration ${currentIteration} of ${iterationCount} (${Math.floor((currentIteration / iterationCount) * 100)}%)`);
+    currentIteration += timelineAsText.length - testIndex;
+    const keyName = timelineAsText[testIndex].title;
+    if (!(keyName in distances)) {
+        distances[keyName] = [];
+    }
+    for (let compareIndex = testIndex + 1; compareIndex < timelineAsText.length; compareIndex++) {
+        const currentTest = timelineAsText[testIndex];
+        const compareTest = timelineAsText[compareIndex];
+        const distanceValue = (0, fastest_levenshtein_1.distance)(currentTest.stepsAsText, compareTest.stepsAsText);
+        distances[keyName].push([compareTest.title, distanceValue]);
+    }
+}
+const sortedDistances = Object.entries(distances)
+    .map(([key, value]) => {
+    return {
+        title: key,
+        relatedTests: value.sort((a, b) => a[1] - b[1]),
+    };
+})
+    .sort((a, b) => a.relatedTests[0][1] - b.relatedTests[0][1]);
+const resultsPath = node_path_1.default.join(pathVariable, './results/distances.json');
+node_fs_1.default.writeFileSync(resultsPath, JSON.stringify(sortedDistances, null, 2));
+console.log(`\nDone. Check the results in ${resultsPath}`);

package/dist/timeline/reporter.d.ts

@@ -0,0 +1,47 @@
+import type { FullResult, Reporter, TestCase, TestResult, TestStatus, TestStep } from '@playwright/test/reporter';
+export interface TestRunData {
+    startTime: number;
+    endTime: number;
+    duration: number;
+    tests: TestData[];
+}
+export interface TestData {
+    title: string;
+    startTime: number;
+    endTime: number;
+    status: TestStatus | 'running';
+    parallelIndex: number;
+    id: string;
+    retry: number;
+    steps: TestStepData[];
+}
+type StepCategory = 'hook' | 'expect' | 'pw:api' | 'test.step' | 'fixture' | 'attach';
+export interface TestStepData {
+    title: string;
+    id: string;
+    category: StepCategory;
+    isWithinHook?: boolean;
+    startTime: number;
+    endTime: number;
+    depth: number;
+    hasError: boolean;
+}
+interface ReporterOptions {
+    writeToFile: boolean;
+    filePath?: string;
+}
+declare class TimelineReporter implements Reporter {
+    private readonly testData;
+    private readonly options;
+    constructor(options?: ReporterOptions);
+    private findMatchingTest;
+    onBegin(): void;
+    onTestBegin(test: TestCase, result: TestResult): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onStepEnd(test: TestCase, result: TestResult, step: TestStep): void;
+    onEnd(result: FullResult): void;
+    private writeReportToFile;
+    getReport(): TestRunData;
+}
+export default TimelineReporter;
+export declare const defineTimelineReporterConfig: (options: ConstructorParameters<typeof TimelineReporter>[0]) => ReporterOptions | undefined;

package/dist/timeline/reporter.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTimelineReporterConfig = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const getStepDepthFromStepPath = (step) => {
+    const stepPath = step.titlePath();
+    const stepDepth = stepPath.length - 1;
+    return stepDepth;
+};
+const isStepWithinHook = (step) => {
+    if (step === undefined) {
+        return false;
+    }
+    if (step.category === 'hook') {
+        return true;
+    }
+    return isStepWithinHook(step?.parent);
+};
+class TimelineReporter {
+    constructor(options) {
+        this.options = { writeToFile: true, ...options };
+        this.testData = {
+            startTime: 0,
+            endTime: 0,
+            duration: 0,
+            tests: [],
+        };
+    }
+    findMatchingTest(test, result) {
+        const matchingTest = this.testData.tests.find((testData) => {
+            const matchesId = testData.id === test.id;
+            const matchesRetry = testData.retry === (result?.retry ?? 0);
+            return matchesId && matchesRetry;
+        });
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return matchingTest;
+    }
+    onBegin() {
+        this.testData.startTime = Date.now();
+    }
+    onTestBegin(test, result) {
+        this.testData.tests.push({
+            title: test.title,
+            startTime: result.startTime.getTime(),
+            endTime: 0,
+            retry: result?.retry ?? 0,
+            status: 'running',
+            parallelIndex: result.parallelIndex,
+            id: test.id,
+            steps: [],
+        });
+    }
+    onTestEnd(test, result) {
+        const finishedTest = this.findMatchingTest(test, result);
+        finishedTest.endTime = finishedTest.startTime + result.duration;
+        finishedTest.status = result.status;
+    }
+    onStepEnd(test, result, step) {
+        const matchingTest = this.findMatchingTest(test, result);
+        const startTime = step.startTime.getTime();
+        const endTime = startTime + step.duration;
+        matchingTest.steps.push({
+            category: step.category,
+            isWithinHook: isStepWithinHook(step),
+            title: step.title,
+            id: node_crypto_1.default.randomUUID(),
+            startTime,
+            endTime,
+            depth: getStepDepthFromStepPath(step),
+            hasError: step.error !== undefined,
+        });
+    }
+    onEnd(result) {
+        this.testData.endTime = Date.now();
+        this.testData.duration = result.duration;
+        if (this?.options?.writeToFile === true) {
+            this.writeReportToFile();
+        }
+    }
+    writeReportToFile() {
+        const filePath = this.options?.filePath ?? 'customResults.json';
+        const report = this.getReport();
+        const reportString = JSON.stringify(report, null, 2);
+        node_fs_1.default.writeFileSync(filePath, reportString);
+    }
+    getReport() {
+        return this.testData;
+    }
+}
+// eslint-disable-next-line import/no-default-export
+exports.default = TimelineReporter;
+const defineTimelineReporterConfig = (options) => options;
+exports.defineTimelineReporterConfig = defineTimelineReporterConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lokalise/playwright-reporters",
-	"version": "1.5.0",
+	"version": "1.7.0",
 	"scripts": {
 		"lint:eslint": "eslint --cache . --ext .js,.cjs,.ts",
 		"lint:ts": "tsc --noEmit",
@@ -29,35 +29,52 @@
 		"./analytics": {
 			"import": "./dist/analytics/reporter.js",
 			"require": "./dist/analytics/reporter.js"
+		},
+		"./timeline": {
+			"import": "./dist/timeline/reporter.js",
+			"require": "./dist/timeline/reporter.js"
+		},
+		"./stepDuration": {
+			"import": "./dist/stepDuration/reporter.js",
+			"require": "./dist/stepDuration/reporter.js"
+		},
+		"./testSimilarity": {
+			"import": "./dist/testSimilarity/reporter.js",
+			"require": "./dist/testSimilarity/reporter.js"
+		},
+		"./permissions": {
+			"import": "./dist/permissions/reporter.js",
+			"require": "./dist/permissions/reporter.js"
 		}
 	},
 	"publishConfig": {
 		"access": "public"
 	},
 	"devDependencies": {
-		"@commitlint/cli": "19.1.0",
-		"@commitlint/config-conventional": "19.1.0",
-		"@commitlint/prompt-cli": "19.1.0",
-		"@lokalise/eslint-config-frontend": "^4.3.2",
-		"@lokalise/prettier-config": "^1.0.0",
+		"@commitlint/cli": "19.3.0",
+		"@commitlint/config-conventional": "19.2.2",
+		"@commitlint/prompt-cli": "19.3.1",
+		"@lokalise/eslint-config-frontend": "^4.6.0",
+		"@lokalise/prettier-config": "^1.0.1",
 		"@semantic-release/changelog": "6.0.3",
-		"@semantic-release/commit-analyzer": "11.1.0",
+		"@semantic-release/commit-analyzer": "13.0.0",
 		"@semantic-release/git": "10.0.1",
-		"@semantic-release/github": "10.0.2",
-		"@semantic-release/npm": "11.0.3",
-		"@semantic-release/release-notes-generator": "12.1.0",
-		"@types/lodash": "^4.17.0",
-		"@types/node": "^20.11.27",
+		"@semantic-release/github": "10.0.6",
+		"@semantic-release/npm": "12.0.1",
+		"@semantic-release/release-notes-generator": "13.0.0",
+		"@types/lodash": "^4.17.5",
+		"@types/node": "^20.14.2",
 		"eslint-config-prettier": "^9.1.0",
 		"eslint-plugin-prettier": "^5.1.3",
 		"husky": "9.0.11",
-		"prettier": "^3.2.5",
-		"semantic-release": "23.0.2",
-		"typescript": "5.4.2"
+		"prettier": "^3.3.2",
+		"semantic-release": "23.1.1",
+		"typescript": "5.4.5"
 	},
 	"dependencies": {
 		"@faker-js/faker": "^8.4.1",
-		"@playwright/test": "^1.42.1",
+		"@playwright/test": "^1.44.1",
+		"fastest-levenshtein": "^1.0.16",
 		"lodash": "^4.17.21"
 	},
 	"prettier": "@lokalise/prettier-config"