@codeperfect/eslint-config 1.3.0 → 1.5.0

package/dist/infrastructure/docs/jsdoc-config.js

@@ -0,0 +1,126 @@
+import { defineConfig } from "eslint/config";
+/** Upstream JSDoc flat preset names consumed by this config. */
+const jsdocPresetNames = [
+    "flat/recommended-typescript-error",
+    "flat/contents-typescript-error",
+    "flat/logical-typescript-error",
+    "flat/requirements-typescript-error",
+    "flat/stylistic-typescript-error",
+];
+/** Repo-owned JSDoc rules enabled when the plugin exposes them. */
+const jsdocErrorRuleNames = [
+    "check-indentation",
+    "convert-to-jsdoc-comments",
+    "require-description",
+    "require-description-complete-sentence",
+    "require-template",
+    "require-throws",
+    "sort-tags",
+];
+/** AST contexts that must include JSDoc. */
+const requireJsdocContexts = [
+    "Program > FunctionDeclaration",
+    "Program > ExportDefaultDeclaration > FunctionDeclaration",
+    "Program > ExportNamedDeclaration > FunctionDeclaration",
+    "Program > VariableDeclaration",
+    'Program > ExportNamedDeclaration[declaration.type="VariableDeclaration"]',
+    "TSInterfaceDeclaration",
+    "TSTypeAliasDeclaration",
+    "TSPropertySignature",
+    "TSMethodSignature",
+    "TSCallSignatureDeclaration",
+    "TSConstructSignatureDeclaration",
+    "TSIndexSignature",
+];
+/**
+ * Build the custom jsdoc error rules based on available plugin rules.
+ * @param availableRules Set of available jsdoc rule names.
+ * @returns The rules record for ESLint.
+ * @example
+ * ```typescript
+ *  console.log(buildCustomErrorRules(new Set(["require-throws"])));
+ * ```
+ */
+function buildCustomErrorRules(availableRules) {
+    return Object.fromEntries(jsdocErrorRuleNames
+        .filter((rule) => availableRules.has(rule))
+        .map((rule) => [`jsdoc/${rule}`, "error"]));
+}
+/**
+ * Select only the upstream flat presets that are available in the current plugin version.
+ * @param configs Upstream JSDoc config map.
+ * @returns The available flat presets.
+ * @example
+ * ```typescript
+ *  console.log(buildPresetConfigs({ "flat/recommended-typescript-error": {} as Linter.Config }).length);
+ * ```
+ */
+function buildPresetConfigs(configs) {
+    return jsdocPresetNames.flatMap((configName) => {
+        const config = configs[configName];
+        if (config === void 0 ||
+            Array.isArray(config) ||
+            typeof config !== "object") {
+            return [];
+        }
+        return [config];
+    });
+}
+/**
+ * Build the final repo-owned JSDoc configs on top of the upstream presets.
+ * @param customError Repo-owned JSDoc rule overrides.
+ * @returns The final ESLint config array.
+ * @example
+ * ```typescript
+ *  console.log(buildRepoJsdocConfigs({}).length);
+ * ```
+ */
+function buildRepoJsdocConfigs(customError) {
+    return defineConfig({
+        name: "jsdoc/custom",
+        rules: {
+            ...customError,
+            "jsdoc/convert-to-jsdoc-comments": [
+                "error",
+                { enforceJsdocLineStyle: "single" },
+            ],
+            "jsdoc/text-escaping": "off",
+        },
+    }, {
+        name: "jsdoc/require-jsdoc-alias",
+        rules: {
+            "jsdoc/require-description": [
+                "error",
+                { contexts: requireJsdocContexts },
+            ],
+            "jsdoc/require-jsdoc": ["error", { contexts: requireJsdocContexts }],
+        },
+    }, {
+        files: ["**/*.spec.ts", "**/*.e2e.ts"],
+        name: "jsdoc/custom-spec",
+        rules: {
+            "jsdoc/convert-to-jsdoc-comments": [
+                "error",
+                { allowedPrefixes: ["Arrange", "Act", "Assert"] },
+            ],
+        },
+    });
+}
+/**
+ * Build the repo's final JSDoc configs from an upstream plugin shape.
+ * @param configs Upstream JSDoc config map.
+ * @param rules Upstream JSDoc rules map.
+ * @returns The final ESLint config array.
+ * @example
+ * ```typescript
+ *  console.log(createJsdocConfigs({}, {}).length);
+ * ```
+ */
+function createJsdocConfigs(configs, rules) {
+    const availableRules = new Set(Object.keys(rules ?? {}));
+    const customError = buildCustomErrorRules(availableRules);
+    const presetConfigs = buildPresetConfigs(configs);
+    return defineConfig(...presetConfigs, ...buildRepoJsdocConfigs(customError));
+}
+export { createJsdocConfigs };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsdoc-config.js","sourceRoot":"","sources":["../../../src/infrastructure/docs/jsdoc-config.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Linter } from \"eslint\";\r\n\r\nimport { defineConfig } from \"eslint/config\";\r\n\r\n/** Upstream JSDoc flat preset names consumed by this config. */\r\nconst jsdocPresetNames = [\r\n  \"flat/recommended-typescript-error\",\r\n  \"flat/contents-typescript-error\",\r\n  \"flat/logical-typescript-error\",\r\n  \"flat/requirements-typescript-error\",\r\n  \"flat/stylistic-typescript-error\",\r\n] as const;\r\n\r\n/** Repo-owned JSDoc rules enabled when the plugin exposes them. */\r\nconst jsdocErrorRuleNames = [\r\n  \"check-indentation\",\r\n  \"convert-to-jsdoc-comments\",\r\n  \"require-description\",\r\n  \"require-description-complete-sentence\",\r\n  \"require-template\",\r\n  \"require-throws\",\r\n  \"sort-tags\",\r\n];\r\n\r\n/** AST contexts that must include JSDoc. */\r\nconst requireJsdocContexts = [\r\n  \"Program > FunctionDeclaration\",\r\n  \"Program > ExportDefaultDeclaration > FunctionDeclaration\",\r\n  \"Program > ExportNamedDeclaration > FunctionDeclaration\",\r\n  \"Program > VariableDeclaration\",\r\n  'Program > ExportNamedDeclaration[declaration.type=\"VariableDeclaration\"]',\r\n  \"TSInterfaceDeclaration\",\r\n  \"TSTypeAliasDeclaration\",\r\n  \"TSPropertySignature\",\r\n  \"TSMethodSignature\",\r\n  \"TSCallSignatureDeclaration\",\r\n  \"TSConstructSignatureDeclaration\",\r\n  \"TSIndexSignature\",\r\n];\r\n\r\n/**\r\n * Build the custom jsdoc error rules based on available plugin rules.\r\n * @param availableRules Set of available jsdoc rule names.\r\n * @returns The rules record for ESLint.\r\n * @example\r\n * ```typescript\r\n *  console.log(buildCustomErrorRules(new Set([\"require-throws\"])));\r\n * ```\r\n */\r\nfunction buildCustomErrorRules(\r\n  availableRules: Set<string>,\r\n): Linter.RulesRecord {\r\n  return Object.fromEntries(\r\n    jsdocErrorRuleNames\r\n      .filter((rule) => availableRules.has(rule))\r\n      .map((rule) => [`jsdoc/${rule}`, \"error\"] as const),\r\n  );\r\n}\r\n\r\n/**\r\n * Select only the upstream flat presets that are available in the current plugin version.\r\n * @param configs Upstream JSDoc config map.\r\n * @returns The available flat presets.\r\n * @example\r\n * ```typescript\r\n *  console.log(buildPresetConfigs({ \"flat/recommended-typescript-error\": {} as Linter.Config }).length);\r\n * ```\r\n */\r\nfunction buildPresetConfigs(configs: Record<string, unknown>): Linter.Config[] {\r\n  return jsdocPresetNames.flatMap((configName) => {\r\n    const config = configs[configName];\r\n\r\n    if (\r\n      config === void 0 ||\r\n      Array.isArray(config) ||\r\n      typeof config !== \"object\"\r\n    ) {\r\n      return [];\r\n    }\r\n\r\n    return [config as Linter.Config];\r\n  });\r\n}\r\n\r\n/**\r\n * Build the final repo-owned JSDoc configs on top of the upstream presets.\r\n * @param customError Repo-owned JSDoc rule overrides.\r\n * @returns The final ESLint config array.\r\n * @example\r\n * ```typescript\r\n *  console.log(buildRepoJsdocConfigs({}).length);\r\n * ```\r\n */\r\nfunction buildRepoJsdocConfigs(\r\n  customError: Linter.RulesRecord,\r\n): Linter.Config[] {\r\n  return defineConfig(\r\n    {\r\n      name: \"jsdoc/custom\",\r\n      rules: {\r\n        ...customError,\r\n        \"jsdoc/convert-to-jsdoc-comments\": [\r\n          \"error\",\r\n          { enforceJsdocLineStyle: \"single\" },\r\n        ],\r\n        \"jsdoc/text-escaping\": \"off\",\r\n      },\r\n    },\r\n    {\r\n      name: \"jsdoc/require-jsdoc-alias\",\r\n      rules: {\r\n        \"jsdoc/require-description\": [\r\n          \"error\",\r\n          { contexts: requireJsdocContexts },\r\n        ],\r\n        \"jsdoc/require-jsdoc\": [\"error\", { contexts: requireJsdocContexts }],\r\n      },\r\n    },\r\n    {\r\n      files: [\"**/*.spec.ts\", \"**/*.e2e.ts\"],\r\n      name: \"jsdoc/custom-spec\",\r\n      rules: {\r\n        \"jsdoc/convert-to-jsdoc-comments\": [\r\n          \"error\",\r\n          { allowedPrefixes: [\"Arrange\", \"Act\", \"Assert\"] },\r\n        ],\r\n      },\r\n    },\r\n  );\r\n}\r\n\r\n/**\r\n * Build the repo's final JSDoc configs from an upstream plugin shape.\r\n * @param configs Upstream JSDoc config map.\r\n * @param rules Upstream JSDoc rules map.\r\n * @returns The final ESLint config array.\r\n * @example\r\n * ```typescript\r\n *  console.log(createJsdocConfigs({}, {}).length);\r\n * ```\r\n */\r\nfunction createJsdocConfigs(\r\n  configs: Record<string, unknown>,\r\n  rules: Record<string, unknown> | undefined,\r\n): Linter.Config[] {\r\n  const availableRules = new Set(Object.keys(rules ?? {}));\r\n  const customError = buildCustomErrorRules(availableRules);\r\n  const presetConfigs = buildPresetConfigs(configs);\r\n\r\n  return defineConfig(...presetConfigs, ...buildRepoJsdocConfigs(customError));\r\n}\r\n\r\nexport { createJsdocConfigs };\r\n"]}

package/dist/infrastructure/docs/jsdoc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsdoc.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/docs/jsdoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAkIrC;;;;;;;GAOG;AACH,iBAAe,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAU/C;AAED,OAAO,EAAE,KAAK,EAAE,CAAC"}
+{"version":3,"file":"jsdoc.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/docs/jsdoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC;;;;;;;GAOG;AACH,iBAAe,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAI/C;AAED,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/infrastructure/docs/jsdoc.js

@@ -1,110 +1,4 @@
-import { defineConfig } from "eslint/config";
-/** Upstream JSDoc flat preset names consumed by this config. */
-const jsdocPresetNames = [
-    "flat/recommended-typescript-error",
-    "flat/contents-typescript-error",
-    "flat/logical-typescript-error",
-    "flat/requirements-typescript-error",
-    "flat/stylistic-typescript-error",
-];
-/**
- * Build the custom jsdoc error rules based on available plugin rules.
- * @param availableRules Set of available jsdoc rule names.
- * @returns The rules record for ESLint.
- * @example
- * ```typescript
- *  console.log(buildCustomErrorRules(new Set(["require-throws"])));
- * ```
- */
-const buildCustomErrorRules = (availableRules) => {
-    const ruleNames = [
-        "check-indentation",
-        "convert-to-jsdoc-comments",
-        "require-description",
-        "require-description-complete-sentence",
-        "require-template",
-        "require-throws",
-        "sort-tags",
-    ];
-    return Object.fromEntries(ruleNames
-        .filter((rule) => availableRules.has(rule))
-        .map((rule) => [`jsdoc/${rule}`, "error"]));
-};
-/** AST contexts that must include JSDoc. */
-const requireJsdocContexts = [
-    "Program > FunctionDeclaration",
-    "Program > ExportDefaultDeclaration > FunctionDeclaration",
-    "Program > ExportNamedDeclaration > FunctionDeclaration",
-    "Program > VariableDeclaration",
-    "Program > ExportNamedDeclaration > VariableDeclaration",
-    "TSInterfaceDeclaration",
-    "TSTypeAliasDeclaration",
-    "TSPropertySignature",
-    "TSMethodSignature",
-    "TSCallSignatureDeclaration",
-    "TSConstructSignatureDeclaration",
-    "TSIndexSignature",
-];
-/**
- * Select only the upstream flat presets that are available in the current plugin version.
- * @param configs Upstream JSDoc config map.
- * @returns The available flat presets.
- * @example
- * ```typescript
- *  console.log(buildPresetConfigs({ "flat/recommended-typescript-error": {} as Linter.Config }).length);
- * ```
- */
-function buildPresetConfigs(configs) {
-    return jsdocPresetNames.flatMap((configName) => {
-        const config = configs[configName];
-        if (config === void 0 ||
-            Array.isArray(config) ||
-            typeof config !== "object") {
-            return [];
-        }
-        return [config];
-    });
-}
-/**
- * Build the final repo-owned JSDoc configs on top of the upstream presets.
- * @param customError Repo-owned JSDoc rule overrides.
- * @returns The final ESLint config array.
- * @example
- * ```typescript
- *  console.log(buildRepoJsdocConfigs({}).length);
- * ```
- */
-function buildRepoJsdocConfigs(customError) {
-    return defineConfig({
-        name: "jsdoc/custom",
-        rules: {
-            ...customError,
-            "jsdoc/convert-to-jsdoc-comments": [
-                "error",
-                { enforceJsdocLineStyle: "single" },
-            ],
-            "jsdoc/text-escaping": "off",
-        },
-    }, {
-        name: "jsdoc/require-jsdoc-alias",
-        rules: {
-            "jsdoc/require-description": [
-                "error",
-                { contexts: requireJsdocContexts },
-            ],
-            "jsdoc/require-jsdoc": ["error", { contexts: requireJsdocContexts }],
-        },
-    }, {
-        files: ["**/*.spec.ts"],
-        name: "jsdoc/custom-spec",
-        rules: {
-            "jsdoc/convert-to-jsdoc-comments": [
-                "error",
-                { allowedPrefixes: ["Arrange", "Act"] },
-            ],
-        },
-    });
-}
+import { createJsdocConfigs } from "./jsdoc-config.js";
 /**
  * Build the jsdoc plugin configuration and any overrides needed by this project.
  * @returns Return value output.
@@ -114,13 +8,8 @@ function buildRepoJsdocConfigs(customError) {
  * ```
  */
 async function jsdoc() {
-    const jsdocModule = await import("eslint-plugin-jsdoc");
-    const { default: jsdocPlugin } = jsdocModule;
-    const { configs, rules } = jsdocPlugin;
-    const availableRules = new Set(Object.keys(rules ?? {}));
-    const customError = buildCustomErrorRules(availableRules);
-    const presetConfigs = buildPresetConfigs(configs);
-    return defineConfig(...presetConfigs, ...buildRepoJsdocConfigs(customError));
+    const { default: jsdocPlugin } = await import("eslint-plugin-jsdoc");
+    return createJsdocConfigs(jsdocPlugin.configs, jsdocPlugin.rules);
 }
 export { jsdoc };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsdoc.js","sourceRoot":"","sources":["../../../src/infrastructure/docs/jsdoc.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Linter } from \"eslint\";\r\n\r\nimport { defineConfig } from \"eslint/config\";\r\n\r\n/** Upstream JSDoc flat preset names consumed by this config. */\r\nconst jsdocPresetNames = [\r\n  \"flat/recommended-typescript-error\",\r\n  \"flat/contents-typescript-error\",\r\n  \"flat/logical-typescript-error\",\r\n  \"flat/requirements-typescript-error\",\r\n  \"flat/stylistic-typescript-error\",\r\n] as const;\r\n\r\n/**\r\n * Build the custom jsdoc error rules based on available plugin rules.\r\n * @param availableRules Set of available jsdoc rule names.\r\n * @returns The rules record for ESLint.\r\n * @example\r\n * ```typescript\r\n *  console.log(buildCustomErrorRules(new Set([\"require-throws\"])));\r\n * ```\r\n */\r\nconst buildCustomErrorRules = (\r\n  availableRules: Set<string>,\r\n): Linter.RulesRecord => {\r\n  const ruleNames = [\r\n    \"check-indentation\",\r\n    \"convert-to-jsdoc-comments\",\r\n    \"require-description\",\r\n    \"require-description-complete-sentence\",\r\n    \"require-template\",\r\n    \"require-throws\",\r\n    \"sort-tags\",\r\n  ];\r\n\r\n  return Object.fromEntries(\r\n    ruleNames\r\n      .filter((rule) => availableRules.has(rule))\r\n      .map((rule) => [`jsdoc/${rule}`, \"error\"] as const),\r\n  );\r\n};\r\n\r\n/** AST contexts that must include JSDoc. */\r\nconst requireJsdocContexts = [\r\n  \"Program > FunctionDeclaration\",\r\n  \"Program > ExportDefaultDeclaration > FunctionDeclaration\",\r\n  \"Program > ExportNamedDeclaration > FunctionDeclaration\",\r\n  \"Program > VariableDeclaration\",\r\n  \"Program > ExportNamedDeclaration > VariableDeclaration\",\r\n  \"TSInterfaceDeclaration\",\r\n  \"TSTypeAliasDeclaration\",\r\n  \"TSPropertySignature\",\r\n  \"TSMethodSignature\",\r\n  \"TSCallSignatureDeclaration\",\r\n  \"TSConstructSignatureDeclaration\",\r\n  \"TSIndexSignature\",\r\n];\r\n\r\n/**\r\n * Select only the upstream flat presets that are available in the current plugin version.\r\n * @param configs Upstream JSDoc config map.\r\n * @returns The available flat presets.\r\n * @example\r\n * ```typescript\r\n *  console.log(buildPresetConfigs({ \"flat/recommended-typescript-error\": {} as Linter.Config }).length);\r\n * ```\r\n */\r\nfunction buildPresetConfigs(configs: Record<string, unknown>): Linter.Config[] {\r\n  return jsdocPresetNames.flatMap((configName) => {\r\n    const config = configs[configName];\r\n\r\n    if (\r\n      config === void 0 ||\r\n      Array.isArray(config) ||\r\n      typeof config !== \"object\"\r\n    ) {\r\n      return [];\r\n    }\r\n\r\n    return [config as Linter.Config];\r\n  });\r\n}\r\n\r\n/**\r\n * Build the final repo-owned JSDoc configs on top of the upstream presets.\r\n * @param customError Repo-owned JSDoc rule overrides.\r\n * @returns The final ESLint config array.\r\n * @example\r\n * ```typescript\r\n *  console.log(buildRepoJsdocConfigs({}).length);\r\n * ```\r\n */\r\nfunction buildRepoJsdocConfigs(\r\n  customError: Linter.RulesRecord,\r\n): Linter.Config[] {\r\n  return defineConfig(\r\n    {\r\n      name: \"jsdoc/custom\",\r\n      rules: {\r\n        ...customError,\r\n        \"jsdoc/convert-to-jsdoc-comments\": [\r\n          \"error\",\r\n          { enforceJsdocLineStyle: \"single\" },\r\n        ],\r\n        \"jsdoc/text-escaping\": \"off\",\r\n      },\r\n    },\r\n    {\r\n      name: \"jsdoc/require-jsdoc-alias\",\r\n      rules: {\r\n        \"jsdoc/require-description\": [\r\n          \"error\",\r\n          { contexts: requireJsdocContexts },\r\n        ],\r\n        \"jsdoc/require-jsdoc\": [\"error\", { contexts: requireJsdocContexts }],\r\n      },\r\n    },\r\n    {\r\n      files: [\"**/*.spec.ts\"],\r\n      name: \"jsdoc/custom-spec\",\r\n      rules: {\r\n        \"jsdoc/convert-to-jsdoc-comments\": [\r\n          \"error\",\r\n          { allowedPrefixes: [\"Arrange\", \"Act\"] },\r\n        ],\r\n      },\r\n    },\r\n  );\r\n}\r\n\r\n/**\r\n * Build the jsdoc plugin configuration and any overrides needed by this project.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n *  console.log(await jsdoc());\r\n * ```\r\n */\r\nasync function jsdoc(): Promise<Linter.Config[]> {\r\n  const jsdocModule = await import(\"eslint-plugin-jsdoc\");\r\n  const { default: jsdocPlugin } = jsdocModule;\r\n  const { configs, rules } = jsdocPlugin;\r\n\r\n  const availableRules = new Set(Object.keys(rules ?? {}));\r\n  const customError = buildCustomErrorRules(availableRules);\r\n  const presetConfigs = buildPresetConfigs(configs);\r\n\r\n  return defineConfig(...presetConfigs, ...buildRepoJsdocConfigs(customError));\r\n}\r\n\r\nexport { jsdoc };\r\n"]}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNkb2MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW5mcmFzdHJ1Y3R1cmUvZG9jcy9qc2RvYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVwRDs7Ozs7OztHQU9HO0FBQ0gsS0FBSyxVQUFVLEtBQUs7SUFDbEIsTUFBTSxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsR0FBRyxNQUFNLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO0lBRXJFLE9BQU8sa0JBQWtCLENBQUMsV0FBVyxDQUFDLE9BQU8sRUFBRSxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDcEUsQ0FBQztBQUVELE9BQU8sRUFBRSxLQUFLLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTGludGVyIH0gZnJvbSBcImVzbGludFwiO1xyXG5cclxuaW1wb3J0IHsgY3JlYXRlSnNkb2NDb25maWdzIH0gZnJvbSBcIi4vanNkb2MtY29uZmlnXCI7XHJcblxyXG4vKipcclxuICogQnVpbGQgdGhlIGpzZG9jIHBsdWdpbiBjb25maWd1cmF0aW9uIGFuZCBhbnkgb3ZlcnJpZGVzIG5lZWRlZCBieSB0aGlzIHByb2plY3QuXHJcbiAqIEByZXR1cm5zIFJldHVybiB2YWx1ZSBvdXRwdXQuXHJcbiAqIEBleGFtcGxlXHJcbiAqIGBgYHR5cGVzY3JpcHRcclxuICogIGNvbnNvbGUubG9nKGF3YWl0IGpzZG9jKCkpO1xyXG4gKiBgYGBcclxuICovXHJcbmFzeW5jIGZ1bmN0aW9uIGpzZG9jKCk6IFByb21pc2U8TGludGVyLkNvbmZpZ1tdPiB7XHJcbiAgY29uc3QgeyBkZWZhdWx0OiBqc2RvY1BsdWdpbiB9ID0gYXdhaXQgaW1wb3J0KFwiZXNsaW50LXBsdWdpbi1qc2RvY1wiKTtcclxuXHJcbiAgcmV0dXJuIGNyZWF0ZUpzZG9jQ29uZmlncyhqc2RvY1BsdWdpbi5jb25maWdzLCBqc2RvY1BsdWdpbi5ydWxlcyk7XHJcbn1cclxuXHJcbmV4cG9ydCB7IGpzZG9jIH07XHJcbiJdfQ==

package/dist/infrastructure/index.d.ts

@@ -1,5 +1,5 @@
 export type { BoundariesConfig, BoundariesConfigExtension, BoundariesElementTypesOptions, BoundariesElementTypesRuleEntry, ConfigOptions, PluginName, PluginStateOverrides, } from "../domain/index.js";
 export { boundaries, defaultBoundariesConfig, importX } from "./architecture/index.js";
 export { config } from "./config-factory.js";
-export { codeperfect, comments, eslint, jasmine, jest, jsdoc, perfectionist, playwright, prettier, resolver, rxjsX, stylistic, typescript, unicorn, vitest, } from "./configs/index.js";
+export { codeperfect, comments, eslint, jasmine, jest, jsdoc, perfectionist, playwright, prettier, resolver, rxjsX, stylistic, typescript, unicorn, vitest, vitestE2e, } from "./configs/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/infrastructure/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,gBAAgB,EAChB,yBAAyB,EACzB,6BAA6B,EAC7B,+BAA+B,EAC/B,aAAa,EACb,UAAU,EACV,oBAAoB,GACrB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EACL,WAAW,EACX,QAAQ,EACR,MAAM,EACN,OAAO,EACP,IAAI,EACJ,KAAK,EACL,aAAa,EACb,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,SAAS,EACT,UAAU,EACV,OAAO,EACP,MAAM,GACP,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/infrastructure/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,gBAAgB,EAChB,yBAAyB,EACzB,6BAA6B,EAC7B,+BAA+B,EAC/B,aAAa,EACb,UAAU,EACV,oBAAoB,GACrB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EACL,WAAW,EACX,QAAQ,EACR,MAAM,EACN,OAAO,EACP,IAAI,EACJ,KAAK,EACL,aAAa,EACb,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,SAAS,EACT,UAAU,EACV,OAAO,EACP,MAAM,EACN,SAAS,GACV,MAAM,WAAW,CAAC"}

package/dist/infrastructure/index.js

@@ -1,4 +1,4 @@
 export { boundaries, defaultBoundariesConfig, importX } from "./architecture/index.js";
 export { config } from "./config-factory.js";
-export { codeperfect, comments, eslint, jasmine, jest, jsdoc, perfectionist, playwright, prettier, resolver, rxjsX, stylistic, typescript, unicorn, vitest, } from "./configs/index.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5mcmFzdHJ1Y3R1cmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsT0FBTyxFQUFFLFVBQVUsRUFBRSx1QkFBdUIsRUFBRSxPQUFPLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM5RSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDMUMsT0FBTyxFQUNMLFdBQVcsRUFDWCxRQUFRLEVBQ1IsTUFBTSxFQUNOLE9BQU8sRUFDUCxJQUFJLEVBQ0osS0FBSyxFQUNMLGFBQWEsRUFDYixVQUFVLEVBQ1YsUUFBUSxFQUNSLFFBQVEsRUFDUixLQUFLLEVBQ0wsU0FBUyxFQUNULFVBQVUsRUFDVixPQUFPLEVBQ1AsTUFBTSxHQUNQLE1BQU0sV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUge1xyXG4gIEJvdW5kYXJpZXNDb25maWcsXHJcbiAgQm91bmRhcmllc0NvbmZpZ0V4dGVuc2lvbixcclxuICBCb3VuZGFyaWVzRWxlbWVudFR5cGVzT3B0aW9ucyxcclxuICBCb3VuZGFyaWVzRWxlbWVudFR5cGVzUnVsZUVudHJ5LFxyXG4gIENvbmZpZ09wdGlvbnMsXHJcbiAgUGx1Z2luTmFtZSxcclxuICBQbHVnaW5TdGF0ZU92ZXJyaWRlcyxcclxufSBmcm9tIFwiLi4vZG9tYWluXCI7XHJcbmV4cG9ydCB7IGJvdW5kYXJpZXMsIGRlZmF1bHRCb3VuZGFyaWVzQ29uZmlnLCBpbXBvcnRYIH0gZnJvbSBcIi4vYXJjaGl0ZWN0dXJlXCI7XHJcbmV4cG9ydCB7IGNvbmZpZyB9IGZyb20gXCIuL2NvbmZpZy1mYWN0b3J5XCI7XHJcbmV4cG9ydCB7XHJcbiAgY29kZXBlcmZlY3QsXHJcbiAgY29tbWVudHMsXHJcbiAgZXNsaW50LFxyXG4gIGphc21pbmUsXHJcbiAgamVzdCxcclxuICBqc2RvYyxcclxuICBwZXJmZWN0aW9uaXN0LFxyXG4gIHBsYXl3cmlnaHQsXHJcbiAgcHJldHRpZXIsXHJcbiAgcmVzb2x2ZXIsXHJcbiAgcnhqc1gsXHJcbiAgc3R5bGlzdGljLFxyXG4gIHR5cGVzY3JpcHQsXHJcbiAgdW5pY29ybixcclxuICB2aXRlc3QsXHJcbn0gZnJvbSBcIi4vY29uZmlnc1wiO1xyXG4iXX0=
+export { codeperfect, comments, eslint, jasmine, jest, jsdoc, perfectionist, playwright, prettier, resolver, rxjsX, stylistic, typescript, unicorn, vitest, vitestE2e, } from "./configs/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5mcmFzdHJ1Y3R1cmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsT0FBTyxFQUFFLFVBQVUsRUFBRSx1QkFBdUIsRUFBRSxPQUFPLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM5RSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDMUMsT0FBTyxFQUNMLFdBQVcsRUFDWCxRQUFRLEVBQ1IsTUFBTSxFQUNOLE9BQU8sRUFDUCxJQUFJLEVBQ0osS0FBSyxFQUNMLGFBQWEsRUFDYixVQUFVLEVBQ1YsUUFBUSxFQUNSLFFBQVEsRUFDUixLQUFLLEVBQ0wsU0FBUyxFQUNULFVBQVUsRUFDVixPQUFPLEVBQ1AsTUFBTSxFQUNOLFNBQVMsR0FDVixNQUFNLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHtcclxuICBCb3VuZGFyaWVzQ29uZmlnLFxyXG4gIEJvdW5kYXJpZXNDb25maWdFeHRlbnNpb24sXHJcbiAgQm91bmRhcmllc0VsZW1lbnRUeXBlc09wdGlvbnMsXHJcbiAgQm91bmRhcmllc0VsZW1lbnRUeXBlc1J1bGVFbnRyeSxcclxuICBDb25maWdPcHRpb25zLFxyXG4gIFBsdWdpbk5hbWUsXHJcbiAgUGx1Z2luU3RhdGVPdmVycmlkZXMsXHJcbn0gZnJvbSBcIi4uL2RvbWFpblwiO1xyXG5leHBvcnQgeyBib3VuZGFyaWVzLCBkZWZhdWx0Qm91bmRhcmllc0NvbmZpZywgaW1wb3J0WCB9IGZyb20gXCIuL2FyY2hpdGVjdHVyZVwiO1xyXG5leHBvcnQgeyBjb25maWcgfSBmcm9tIFwiLi9jb25maWctZmFjdG9yeVwiO1xyXG5leHBvcnQge1xyXG4gIGNvZGVwZXJmZWN0LFxyXG4gIGNvbW1lbnRzLFxyXG4gIGVzbGludCxcclxuICBqYXNtaW5lLFxyXG4gIGplc3QsXHJcbiAganNkb2MsXHJcbiAgcGVyZmVjdGlvbmlzdCxcclxuICBwbGF5d3JpZ2h0LFxyXG4gIHByZXR0aWVyLFxyXG4gIHJlc29sdmVyLFxyXG4gIHJ4anNYLFxyXG4gIHN0eWxpc3RpYyxcclxuICB0eXBlc2NyaXB0LFxyXG4gIHVuaWNvcm4sXHJcbiAgdml0ZXN0LFxyXG4gIHZpdGVzdEUyZSxcclxufSBmcm9tIFwiLi9jb25maWdzXCI7XHJcbiJdfQ==

package/dist/infrastructure/plugin-loaders.d.ts

@@ -109,6 +109,11 @@ declare const pluginLoaders: {
         mode: "optional";
         pluginName: "vitest";
     };
+    "vitest-e2e": {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "vitest-e2e";
+    };
 };
 export { pluginLoaders };
 export type { ConfigLoader, PluginLoaderEntry };

package/dist/infrastructure/plugin-loaders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-loaders.d.ts","sourceRoot":"","sources":["../../src/infrastructure/plugin-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAsB5C,kDAAkD;AAClD,KAAK,YAAY,GAAG,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;AAErE,8EAA8E;AAC9E,UAAU,iBAAiB;IACzB,qCAAqC;IACrC,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,YAAY,CAAC;IAEjD,2CAA2C;IAC3C,IAAI,EAAE,QAAQ,CAAC;IAEf,iEAAiE;IACjE,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,iBAAS,6BAA6B,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CAE3E;AAiBD,qEAAqE;AACrE,QAAA,MAAM,aAAa;;;;;;;0BAtCC,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;CA4HD,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"plugin-loaders.d.ts","sourceRoot":"","sources":["../../src/infrastructure/plugin-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAuB5C,kDAAkD;AAClD,KAAK,YAAY,GAAG,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;AAErE,8EAA8E;AAC9E,UAAU,iBAAiB;IACzB,qCAAqC;IACrC,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,YAAY,CAAC;IAEjD,2CAA2C;IAC3C,IAAI,EAAE,QAAQ,CAAC;IAEf,iEAAiE;IACjE,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,iBAAS,6BAA6B,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CAE3E;AAiBD,qEAAqE;AACrE,QAAA,MAAM,aAAa;;;;;;;0BAtCC,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;;0BAA9B,aAAa,KAAK,YAAY;;;;CAiID,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/infrastructure/plugin-loaders.js

@@ -1,4 +1,4 @@
-import { boundaries, codeperfect, comments, eslint, importX, jasmine, jest, jsdoc, perfectionist, playwright, prettier, resolver, rxjsX, stylistic, typescript, unicorn, vitest, } from "./configs/index.js";
+import { boundaries, codeperfect, comments, eslint, importX, jasmine, jest, jsdoc, perfectionist, playwright, prettier, resolver, rxjsX, stylistic, typescript, unicorn, vitest, vitestE2e, } from "./configs/index.js";
 /**
  * Creates the boundaries loader factory for repository-owned architecture input.
  * @param options Input options value.
@@ -110,6 +110,11 @@ const pluginLoaders = {
         mode: "optional",
         pluginName: "vitest",
     },
+    "vitest-e2e": {
+        loader: createStaticLoaderFactory(vitestE2e),
+        mode: "optional",
+        pluginName: "vitest-e2e",
+    },
 };
 export { pluginLoaders };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-loaders.js","sourceRoot":"","sources":["../../src/infrastructure/plugin-loaders.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Linter } from \"eslint\";\n\nimport type { ConfigOptions, PluginName } from \"../domain\";\nimport type { LoadMode } from \"./utilities\";\n\nimport {\n  boundaries,\n  codeperfect,\n  comments,\n  eslint,\n  importX,\n  jasmine,\n  jest,\n  jsdoc,\n  perfectionist,\n  playwright,\n  prettier,\n  resolver,\n  rxjsX,\n  stylistic,\n  typescript,\n  unicorn,\n  vitest,\n} from \"./configs\";\n\n/** Loader function for a single config module. */\ntype ConfigLoader = () => Linter.Config[] | Promise<Linter.Config[]>;\n\n/** Entry describing a single config loader in the final composition order. */\ninterface PluginLoaderEntry {\n  /** Loader factory for the module. */\n  loader: (options: ConfigOptions) => ConfigLoader;\n\n  /** Runtime loading mode for the module. */\n  mode: LoadMode;\n\n  /** Public module name used in config options and diagnostics. */\n  pluginName: PluginName;\n}\n\n/**\n * Creates the boundaries loader factory for repository-owned architecture input.\n * @param options Input options value.\n * @returns Return value output.\n * @example\n * ```typescript\n * const factory = createBoundariesLoaderFactory({});\n * ```\n */\nfunction createBoundariesLoaderFactory(options: ConfigOptions): ConfigLoader {\n  return (): Linter.Config[] => boundaries(options.boundaries);\n}\n\n/**\n * Creates a loader factory for modules that do not depend on config options.\n * @param loader Input loader value.\n * @returns Return value output.\n * @example\n * ```typescript\n * const factory = createStaticLoaderFactory(eslint);\n * ```\n */\nfunction createStaticLoaderFactory(\n  loader: ConfigLoader,\n): PluginLoaderEntry[\"loader\"] {\n  return (): ConfigLoader => loader;\n}\n\n/** Documented config loader registry keyed by public module name. */\nconst pluginLoaders = {\n  boundaries: {\n    loader: createBoundariesLoaderFactory,\n    mode: \"optional\",\n    pluginName: \"boundaries\",\n  },\n  codeperfect: {\n    loader: createStaticLoaderFactory(codeperfect),\n    mode: \"required\",\n    pluginName: \"codeperfect\",\n  },\n  comments: {\n    loader: createStaticLoaderFactory(comments),\n    mode: \"optional\",\n    pluginName: \"comments\",\n  },\n  eslint: {\n    loader: createStaticLoaderFactory(eslint),\n    mode: \"required\",\n    pluginName: \"eslint\",\n  },\n  \"import-x\": {\n    loader: createStaticLoaderFactory(importX),\n    mode: \"optional\",\n    pluginName: \"import-x\",\n  },\n  jasmine: {\n    loader: createStaticLoaderFactory(jasmine),\n    mode: \"optional\",\n    pluginName: \"jasmine\",\n  },\n  jest: {\n    loader: createStaticLoaderFactory(jest),\n    mode: \"optional\",\n    pluginName: \"jest\",\n  },\n  jsdoc: {\n    loader: createStaticLoaderFactory(jsdoc),\n    mode: \"optional\",\n    pluginName: \"jsdoc\",\n  },\n  perfectionist: {\n    loader: createStaticLoaderFactory(perfectionist),\n    mode: \"optional\",\n    pluginName: \"perfectionist\",\n  },\n  playwright: {\n    loader: createStaticLoaderFactory(playwright),\n    mode: \"optional\",\n    pluginName: \"playwright\",\n  },\n  prettier: {\n    loader: createStaticLoaderFactory(prettier),\n    mode: \"optional\",\n    pluginName: \"prettier\",\n  },\n  resolver: {\n    loader: createStaticLoaderFactory(resolver),\n    mode: \"optional\",\n    pluginName: \"resolver\",\n  },\n  \"rxjs-x\": {\n    loader: createStaticLoaderFactory(rxjsX),\n    mode: \"optional\",\n    pluginName: \"rxjs-x\",\n  },\n  stylistic: {\n    loader: createStaticLoaderFactory(stylistic),\n    mode: \"optional\",\n    pluginName: \"stylistic\",\n  },\n  typescript: {\n    loader: createStaticLoaderFactory(typescript),\n    mode: \"required\",\n    pluginName: \"typescript\",\n  },\n  unicorn: {\n    loader: createStaticLoaderFactory(unicorn),\n    mode: \"optional\",\n    pluginName: \"unicorn\",\n  },\n  vitest: {\n    loader: createStaticLoaderFactory(vitest),\n    mode: \"optional\",\n    pluginName: \"vitest\",\n  },\n} satisfies Record<PluginName, PluginLoaderEntry>;\n\nexport { pluginLoaders };\nexport type { ConfigLoader, PluginLoaderEntry };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-loaders.js","sourceRoot":"","sources":["../../src/infrastructure/plugin-loaders.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Linter } from \"eslint\";\n\nimport type { ConfigOptions, PluginName } from \"../domain\";\nimport type { LoadMode } from \"./utilities\";\n\nimport {\n  boundaries,\n  codeperfect,\n  comments,\n  eslint,\n  importX,\n  jasmine,\n  jest,\n  jsdoc,\n  perfectionist,\n  playwright,\n  prettier,\n  resolver,\n  rxjsX,\n  stylistic,\n  typescript,\n  unicorn,\n  vitest,\n  vitestE2e,\n} from \"./configs\";\n\n/** Loader function for a single config module. */\ntype ConfigLoader = () => Linter.Config[] | Promise<Linter.Config[]>;\n\n/** Entry describing a single config loader in the final composition order. */\ninterface PluginLoaderEntry {\n  /** Loader factory for the module. */\n  loader: (options: ConfigOptions) => ConfigLoader;\n\n  /** Runtime loading mode for the module. */\n  mode: LoadMode;\n\n  /** Public module name used in config options and diagnostics. */\n  pluginName: PluginName;\n}\n\n/**\n * Creates the boundaries loader factory for repository-owned architecture input.\n * @param options Input options value.\n * @returns Return value output.\n * @example\n * ```typescript\n * const factory = createBoundariesLoaderFactory({});\n * ```\n */\nfunction createBoundariesLoaderFactory(options: ConfigOptions): ConfigLoader {\n  return (): Linter.Config[] => boundaries(options.boundaries);\n}\n\n/**\n * Creates a loader factory for modules that do not depend on config options.\n * @param loader Input loader value.\n * @returns Return value output.\n * @example\n * ```typescript\n * const factory = createStaticLoaderFactory(eslint);\n * ```\n */\nfunction createStaticLoaderFactory(\n  loader: ConfigLoader,\n): PluginLoaderEntry[\"loader\"] {\n  return (): ConfigLoader => loader;\n}\n\n/** Documented config loader registry keyed by public module name. */\nconst pluginLoaders = {\n  boundaries: {\n    loader: createBoundariesLoaderFactory,\n    mode: \"optional\",\n    pluginName: \"boundaries\",\n  },\n  codeperfect: {\n    loader: createStaticLoaderFactory(codeperfect),\n    mode: \"required\",\n    pluginName: \"codeperfect\",\n  },\n  comments: {\n    loader: createStaticLoaderFactory(comments),\n    mode: \"optional\",\n    pluginName: \"comments\",\n  },\n  eslint: {\n    loader: createStaticLoaderFactory(eslint),\n    mode: \"required\",\n    pluginName: \"eslint\",\n  },\n  \"import-x\": {\n    loader: createStaticLoaderFactory(importX),\n    mode: \"optional\",\n    pluginName: \"import-x\",\n  },\n  jasmine: {\n    loader: createStaticLoaderFactory(jasmine),\n    mode: \"optional\",\n    pluginName: \"jasmine\",\n  },\n  jest: {\n    loader: createStaticLoaderFactory(jest),\n    mode: \"optional\",\n    pluginName: \"jest\",\n  },\n  jsdoc: {\n    loader: createStaticLoaderFactory(jsdoc),\n    mode: \"optional\",\n    pluginName: \"jsdoc\",\n  },\n  perfectionist: {\n    loader: createStaticLoaderFactory(perfectionist),\n    mode: \"optional\",\n    pluginName: \"perfectionist\",\n  },\n  playwright: {\n    loader: createStaticLoaderFactory(playwright),\n    mode: \"optional\",\n    pluginName: \"playwright\",\n  },\n  prettier: {\n    loader: createStaticLoaderFactory(prettier),\n    mode: \"optional\",\n    pluginName: \"prettier\",\n  },\n  resolver: {\n    loader: createStaticLoaderFactory(resolver),\n    mode: \"optional\",\n    pluginName: \"resolver\",\n  },\n  \"rxjs-x\": {\n    loader: createStaticLoaderFactory(rxjsX),\n    mode: \"optional\",\n    pluginName: \"rxjs-x\",\n  },\n  stylistic: {\n    loader: createStaticLoaderFactory(stylistic),\n    mode: \"optional\",\n    pluginName: \"stylistic\",\n  },\n  typescript: {\n    loader: createStaticLoaderFactory(typescript),\n    mode: \"required\",\n    pluginName: \"typescript\",\n  },\n  unicorn: {\n    loader: createStaticLoaderFactory(unicorn),\n    mode: \"optional\",\n    pluginName: \"unicorn\",\n  },\n  vitest: {\n    loader: createStaticLoaderFactory(vitest),\n    mode: \"optional\",\n    pluginName: \"vitest\",\n  },\n  \"vitest-e2e\": {\n    loader: createStaticLoaderFactory(vitestE2e),\n    mode: \"optional\",\n    pluginName: \"vitest-e2e\",\n  },\n} satisfies Record<PluginName, PluginLoaderEntry>;\n\nexport { pluginLoaders };\nexport type { ConfigLoader, PluginLoaderEntry };\n"]}

package/dist/infrastructure/plugin-state.d.ts

@@ -1,6 +1,6 @@
 import type { PluginName, PluginStateOverrides } from "../domain/index.js";
 /** Plugins that are opt-in rather than enabled by default. */
-declare const defaultDisabledPlugins: readonly ["jasmine", "jest"];
+declare const defaultDisabledPlugins: readonly ["jasmine", "jest", "vitest-e2e"];
 /**
  * Checks whether a plugin is disabled by default.
  * @param pluginName Input pluginName value.

package/dist/infrastructure/plugin-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-state.d.ts","sourceRoot":"","sources":["../../src/infrastructure/plugin-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAIlE,8DAA8D;AAC9D,QAAA,MAAM,sBAAsB,8BAGc,CAAC;AAE3C;;;;;;;;GAQG;AACH,iBAAS,yBAAyB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAElE;AAsBD;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CACzB,UAAU,EAAE,UAAU,EACtB,YAAY,CAAC,EAAE,oBAAoB,GAClC,OAAO,CAeT;AAED,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,kBAAkB,GACnB,CAAC"}
+{"version":3,"file":"plugin-state.d.ts","sourceRoot":"","sources":["../../src/infrastructure/plugin-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAIlE,8DAA8D;AAC9D,QAAA,MAAM,sBAAsB,4CAIc,CAAC;AAE3C;;;;;;;;GAQG;AACH,iBAAS,yBAAyB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAElE;AAsBD;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CACzB,UAAU,EAAE,UAAU,EACtB,YAAY,CAAC,EAAE,oBAAoB,GAClC,OAAO,CAeT;AAED,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,kBAAkB,GACnB,CAAC"}

package/dist/infrastructure/plugin-state.js

@@ -3,6 +3,7 @@ import { reportRedundantPluginState } from "./diagnostics.js";
 const defaultDisabledPlugins = [
     "jasmine",
     "jest",
+    "vitest-e2e",
 ];
 /**
  * Checks whether a plugin is disabled by default.
@@ -51,4 +52,4 @@ function resolvePluginState(pluginName, pluginStates) {
     return defaultEnabled;
 }
 export { defaultDisabledPlugins, isPluginDisabledByDefault, resolvePluginState, };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/infrastructure/rxjs-x.js

@@ -17,11 +17,11 @@ export async function rxjsX() {
             "rxjs-x/no-unbound-methods": "off",
         },
     }, {
-        files: ["**/*.spec.ts"],
+        files: ["**/*.spec.ts", "**/*.e2e.ts"],
         name: "rxjs-x/custom-spec",
         rules: {
             "rxjs-x/no-ignored-error": "off",
         },
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnhqcy14LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2luZnJhc3RydWN0dXJlL3J4anMteC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTdDOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLEtBQUs7SUFDekIsTUFBTSxZQUFZLEdBQUcsTUFBTSxNQUFNLENBQUMsc0JBQXNCLENBQUMsQ0FBQztJQUUxRCxPQUFPLFlBQVksQ0FDakIsWUFBWSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBdUIsRUFDcEQ7UUFDRSxJQUFJLEVBQUUsZUFBZTtRQUNyQixLQUFLLEVBQUU7WUFDTCxpQ0FBaUMsRUFBRSxLQUFLO1lBQ3hDLG9CQUFvQixFQUFFLEtBQUs7WUFDM0IsMkJBQTJCLEVBQUUsS0FBSztTQUNuQztLQUNGLEVBQ0Q7UUFDRSxLQUFLLEVBQUUsQ0FBQyxjQUFjLENBQUM7UUFDdkIsSUFBSSxFQUFFLG9CQUFvQjtRQUMxQixLQUFLLEVBQUU7WUFDTCx5QkFBeUIsRUFBRSxLQUFLO1NBQ2pDO0tBQ0YsQ0FDRixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTGludGVyIH0gZnJvbSBcImVzbGludFwiO1xuXG5pbXBvcnQgeyBkZWZpbmVDb25maWcgfSBmcm9tIFwiZXNsaW50L2NvbmZpZ1wiO1xuXG4vKipcbiAqIEJ1aWxkIGFuZCByZXR1cm4gcnhqcy14IHBsdWdpbiBjb25maWd1cmF0aW9ucyB3aXRoIHBhY2thZ2UtbGV2ZWwgYWRqdXN0bWVudHMuXG4gKiBAcmV0dXJucyBSZXR1cm4gdmFsdWUgb3V0cHV0LlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGF3YWl0IHJ4anNYKCk7XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJ4anNYKCk6IFByb21pc2U8TGludGVyLkNvbmZpZ1tdPiB7XG4gIGNvbnN0IHBsdWdpbk1vZHVsZSA9IGF3YWl0IGltcG9ydChcImVzbGludC1wbHVnaW4tcnhqcy14XCIpO1xuXG4gIHJldHVybiBkZWZpbmVDb25maWcoXG4gICAgcGx1Z2luTW9kdWxlLmRlZmF1bHQuY29uZmlncy5zdHJpY3QgYXMgTGludGVyLkNvbmZpZyxcbiAgICB7XG4gICAgICBuYW1lOiBcInJ4anMteC9jdXN0b21cIixcbiAgICAgIHJ1bGVzOiB7XG4gICAgICAgIFwicnhqcy14L25vLWlnbm9yZWQtZGVmYXVsdC12YWx1ZVwiOiBcIm9mZlwiLFxuICAgICAgICBcInJ4anMteC9uby1zdWJjbGFzc1wiOiBcIm9mZlwiLFxuICAgICAgICBcInJ4anMteC9uby11bmJvdW5kLW1ldGhvZHNcIjogXCJvZmZcIixcbiAgICAgIH0sXG4gICAgfSxcbiAgICB7XG4gICAgICBmaWxlczogW1wiKiovKi5zcGVjLnRzXCJdLFxuICAgICAgbmFtZTogXCJyeGpzLXgvY3VzdG9tLXNwZWNcIixcbiAgICAgIHJ1bGVzOiB7XG4gICAgICAgIFwicnhqcy14L25vLWlnbm9yZWQtZXJyb3JcIjogXCJvZmZcIixcbiAgICAgIH0sXG4gICAgfSxcbiAgKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnhqcy14LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2luZnJhc3RydWN0dXJlL3J4anMteC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTdDOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLEtBQUs7SUFDekIsTUFBTSxZQUFZLEdBQUcsTUFBTSxNQUFNLENBQUMsc0JBQXNCLENBQUMsQ0FBQztJQUUxRCxPQUFPLFlBQVksQ0FDakIsWUFBWSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBdUIsRUFDcEQ7UUFDRSxJQUFJLEVBQUUsZUFBZTtRQUNyQixLQUFLLEVBQUU7WUFDTCxpQ0FBaUMsRUFBRSxLQUFLO1lBQ3hDLG9CQUFvQixFQUFFLEtBQUs7WUFDM0IsMkJBQTJCLEVBQUUsS0FBSztTQUNuQztLQUNGLEVBQ0Q7UUFDRSxLQUFLLEVBQUUsQ0FBQyxjQUFjLEVBQUUsYUFBYSxDQUFDO1FBQ3RDLElBQUksRUFBRSxvQkFBb0I7UUFDMUIsS0FBSyxFQUFFO1lBQ0wseUJBQXlCLEVBQUUsS0FBSztTQUNqQztLQUNGLENBQ0YsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IExpbnRlciB9IGZyb20gXCJlc2xpbnRcIjtcblxuaW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSBcImVzbGludC9jb25maWdcIjtcblxuLyoqXG4gKiBCdWlsZCBhbmQgcmV0dXJuIHJ4anMteCBwbHVnaW4gY29uZmlndXJhdGlvbnMgd2l0aCBwYWNrYWdlLWxldmVsIGFkanVzdG1lbnRzLlxuICogQHJldHVybnMgUmV0dXJuIHZhbHVlIG91dHB1dC5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBhd2FpdCByeGpzWCgpO1xuICogYGBgXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiByeGpzWCgpOiBQcm9taXNlPExpbnRlci5Db25maWdbXT4ge1xuICBjb25zdCBwbHVnaW5Nb2R1bGUgPSBhd2FpdCBpbXBvcnQoXCJlc2xpbnQtcGx1Z2luLXJ4anMteFwiKTtcblxuICByZXR1cm4gZGVmaW5lQ29uZmlnKFxuICAgIHBsdWdpbk1vZHVsZS5kZWZhdWx0LmNvbmZpZ3Muc3RyaWN0IGFzIExpbnRlci5Db25maWcsXG4gICAge1xuICAgICAgbmFtZTogXCJyeGpzLXgvY3VzdG9tXCIsXG4gICAgICBydWxlczoge1xuICAgICAgICBcInJ4anMteC9uby1pZ25vcmVkLWRlZmF1bHQtdmFsdWVcIjogXCJvZmZcIixcbiAgICAgICAgXCJyeGpzLXgvbm8tc3ViY2xhc3NcIjogXCJvZmZcIixcbiAgICAgICAgXCJyeGpzLXgvbm8tdW5ib3VuZC1tZXRob2RzXCI6IFwib2ZmXCIsXG4gICAgICB9LFxuICAgIH0sXG4gICAge1xuICAgICAgZmlsZXM6IFtcIioqLyouc3BlYy50c1wiLCBcIioqLyouZTJlLnRzXCJdLFxuICAgICAgbmFtZTogXCJyeGpzLXgvY3VzdG9tLXNwZWNcIixcbiAgICAgIHJ1bGVzOiB7XG4gICAgICAgIFwicnhqcy14L25vLWlnbm9yZWQtZXJyb3JcIjogXCJvZmZcIixcbiAgICAgIH0sXG4gICAgfSxcbiAgKTtcbn1cbiJdfQ==

package/dist/infrastructure/style/perfectionist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perfectionist.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/style/perfectionist.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAYrC;;;;;;;GAOG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAoB9D"}
+{"version":3,"file":"perfectionist.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/style/perfectionist.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC;;;;;;;GAOG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAO9D"}

package/dist/infrastructure/style/perfectionist.js

@@ -1,11 +1,4 @@
 import { defineConfig } from "eslint/config";
-/** Generated example and default-expression snippets emitted by the JSDoc processor. */
-const generatedSnippetFiles = [
-    "**/*.md/*.js",
-    "**/*.jsdoc-defaults",
-    "**/*.jsdoc-params",
-    "**/*.jsdoc-properties",
-];
 /**
  * Build and return the Perfectionist plugin configuration and any overrides.
  * @returns Return value output.
@@ -16,16 +9,9 @@ const generatedSnippetFiles = [
  */
 export async function perfectionist() {
     const { configs } = await import("eslint-plugin-perfectionist");
-    const generatedSnippetRules = Object.fromEntries(Object.keys(configs["recommended-natural"].rules ?? {})
-        .filter((ruleName) => ruleName.startsWith("perfectionist/"))
-        .map((ruleName) => [ruleName, "off"]));
     return defineConfig(configs["recommended-natural"], {
-        name: "To avoid conflicts",
-        rules: { "sort-keys": "off" },
-    }, {
-        files: generatedSnippetFiles,
-        name: "perfectionist/generated-snippets",
-        rules: generatedSnippetRules,
+        name: "perfectionist/avoid-conflict-with-eslint",
+        rules: { "@typescript-eslint/member-ordering": "off", "sort-keys": "off" },
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVyZmVjdGlvbmlzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pbmZyYXN0cnVjdHVyZS9zdHlsZS9wZXJmZWN0aW9uaXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFN0M7Ozs7Ozs7R0FPRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsYUFBYTtJQUNqQyxNQUFNLEVBQUUsT0FBTyxFQUFFLEdBQUcsTUFBTSxNQUFNLENBQUMsNkJBQTZCLENBQUMsQ0FBQztJQUVoRSxPQUFPLFlBQVksQ0FBQyxPQUFPLENBQUMscUJBQXFCLENBQUMsRUFBRTtRQUNsRCxJQUFJLEVBQUUsMENBQTBDO1FBQ2hELEtBQUssRUFBRSxFQUFFLG9DQUFvQyxFQUFFLEtBQUssRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFO0tBQzNFLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IExpbnRlciB9IGZyb20gXCJlc2xpbnRcIjtcblxuaW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSBcImVzbGludC9jb25maWdcIjtcblxuLyoqXG4gKiBCdWlsZCBhbmQgcmV0dXJuIHRoZSBQZXJmZWN0aW9uaXN0IHBsdWdpbiBjb25maWd1cmF0aW9uIGFuZCBhbnkgb3ZlcnJpZGVzLlxuICogQHJldHVybnMgUmV0dXJuIHZhbHVlIG91dHB1dC5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBhd2FpdCBwZXJmZWN0aW9uaXN0KCk7XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHBlcmZlY3Rpb25pc3QoKTogUHJvbWlzZTxMaW50ZXIuQ29uZmlnW10+IHtcbiAgY29uc3QgeyBjb25maWdzIH0gPSBhd2FpdCBpbXBvcnQoXCJlc2xpbnQtcGx1Z2luLXBlcmZlY3Rpb25pc3RcIik7XG5cbiAgcmV0dXJuIGRlZmluZUNvbmZpZyhjb25maWdzW1wicmVjb21tZW5kZWQtbmF0dXJhbFwiXSwge1xuICAgIG5hbWU6IFwicGVyZmVjdGlvbmlzdC9hdm9pZC1jb25mbGljdC13aXRoLWVzbGludFwiLFxuICAgIHJ1bGVzOiB7IFwiQHR5cGVzY3JpcHQtZXNsaW50L21lbWJlci1vcmRlcmluZ1wiOiBcIm9mZlwiLCBcInNvcnQta2V5c1wiOiBcIm9mZlwiIH0sXG4gIH0pO1xufVxuIl19

package/dist/infrastructure/style/unicorn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unicorn.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/style/unicorn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC;;;;;;;GAOG;AACH,wBAAsB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAKxD"}
+{"version":3,"file":"unicorn.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/style/unicorn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC;;;;;;;GAOG;AACH,wBAAsB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAUxD"}

package/dist/infrastructure/style/unicorn.js

@@ -10,6 +10,11 @@ import { defineConfig } from "eslint/config";
 export async function unicorn() {
     const unicornModule = await import("eslint-plugin-unicorn");
     const { configs } = unicornModule.default;
-    return defineConfig(configs.all);
+    return defineConfig({
+        extends: [configs.all],
+        rules: {
+            "unicorn/prevent-abbreviations": ["error", { ignore: [/e2e|dev/iu] }],
+        },
+    });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pY29ybi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pbmZyYXN0cnVjdHVyZS9zdHlsZS91bmljb3JuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFN0M7Ozs7Ozs7R0FPRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsT0FBTztJQUMzQixNQUFNLGFBQWEsR0FBRyxNQUFNLE1BQU0sQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDO0lBQzVELE1BQU0sRUFBRSxPQUFPLEVBQUUsR0FBRyxhQUFhLENBQUMsT0FBTyxDQUFDO0lBRTFDLE9BQU8sWUFBWSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNuQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBMaW50ZXIgfSBmcm9tIFwiZXNsaW50XCI7XG5cbmltcG9ydCB7IGRlZmluZUNvbmZpZyB9IGZyb20gXCJlc2xpbnQvY29uZmlnXCI7XG5cbi8qKlxuICogQnVpbGQgYW5kIHJldHVybiB0aGUgVW5pY29ybiBwbHVnaW4gY29uZmlndXJhdGlvbi5cbiAqIEByZXR1cm5zIFJldHVybiB2YWx1ZSBvdXRwdXQuXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogYXdhaXQgdW5pY29ybigpO1xuICogYGBgXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB1bmljb3JuKCk6IFByb21pc2U8TGludGVyLkNvbmZpZ1tdPiB7XG4gIGNvbnN0IHVuaWNvcm5Nb2R1bGUgPSBhd2FpdCBpbXBvcnQoXCJlc2xpbnQtcGx1Z2luLXVuaWNvcm5cIik7XG4gIGNvbnN0IHsgY29uZmlncyB9ID0gdW5pY29ybk1vZHVsZS5kZWZhdWx0O1xuXG4gIHJldHVybiBkZWZpbmVDb25maWcoY29uZmlncy5hbGwpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pY29ybi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pbmZyYXN0cnVjdHVyZS9zdHlsZS91bmljb3JuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFN0M7Ozs7Ozs7R0FPRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsT0FBTztJQUMzQixNQUFNLGFBQWEsR0FBRyxNQUFNLE1BQU0sQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDO0lBQzVELE1BQU0sRUFBRSxPQUFPLEVBQUUsR0FBRyxhQUFhLENBQUMsT0FBTyxDQUFDO0lBRTFDLE9BQU8sWUFBWSxDQUFDO1FBQ2xCLE9BQU8sRUFBRSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUM7UUFDdEIsS0FBSyxFQUFFO1lBQ0wsK0JBQStCLEVBQUUsQ0FBQyxPQUFPLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQyxXQUFXLENBQUMsRUFBRSxDQUFDO1NBQ3RFO0tBQ0YsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTGludGVyIH0gZnJvbSBcImVzbGludFwiO1xuXG5pbXBvcnQgeyBkZWZpbmVDb25maWcgfSBmcm9tIFwiZXNsaW50L2NvbmZpZ1wiO1xuXG4vKipcbiAqIEJ1aWxkIGFuZCByZXR1cm4gdGhlIFVuaWNvcm4gcGx1Z2luIGNvbmZpZ3VyYXRpb24uXG4gKiBAcmV0dXJucyBSZXR1cm4gdmFsdWUgb3V0cHV0LlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGF3YWl0IHVuaWNvcm4oKTtcbiAqIGBgYFxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gdW5pY29ybigpOiBQcm9taXNlPExpbnRlci5Db25maWdbXT4ge1xuICBjb25zdCB1bmljb3JuTW9kdWxlID0gYXdhaXQgaW1wb3J0KFwiZXNsaW50LXBsdWdpbi11bmljb3JuXCIpO1xuICBjb25zdCB7IGNvbmZpZ3MgfSA9IHVuaWNvcm5Nb2R1bGUuZGVmYXVsdDtcblxuICByZXR1cm4gZGVmaW5lQ29uZmlnKHtcbiAgICBleHRlbmRzOiBbY29uZmlncy5hbGxdLFxuICAgIHJ1bGVzOiB7XG4gICAgICBcInVuaWNvcm4vcHJldmVudC1hYmJyZXZpYXRpb25zXCI6IFtcImVycm9yXCIsIHsgaWdub3JlOiBbL2UyZXxkZXYvaXVdIH1dLFxuICAgIH0sXG4gIH0pO1xufVxuIl19

package/dist/infrastructure/testing/index.d.ts

@@ -2,4 +2,5 @@ export { jasmine } from "./jasmine.js";
 export { jest } from "./jest.js";
 export { playwright } from "./playwright.js";
 export { vitest } from "./vitest.js";
+export { vitestE2e } from "./vitest-e2e.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/testing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/infrastructure/testing/index.js

@@ -2,4 +2,5 @@ export { jasmine } from "./jasmine.js";
 export { jest } from "./jest.js";
 export { playwright } from "./playwright.js";
 export { vitest } from "./vitest.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW5mcmFzdHJ1Y3R1cmUvdGVzdGluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDOUIsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUMxQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgamFzbWluZSB9IGZyb20gXCIuL2phc21pbmVcIjtcbmV4cG9ydCB7IGplc3QgfSBmcm9tIFwiLi9qZXN0XCI7XG5leHBvcnQgeyBwbGF5d3JpZ2h0IH0gZnJvbSBcIi4vcGxheXdyaWdodFwiO1xuZXhwb3J0IHsgdml0ZXN0IH0gZnJvbSBcIi4vdml0ZXN0XCI7XG4iXX0=
+export { vitestE2e } from "./vitest-e2e.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW5mcmFzdHJ1Y3R1cmUvdGVzdGluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDOUIsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUMxQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ2xDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBqYXNtaW5lIH0gZnJvbSBcIi4vamFzbWluZVwiO1xuZXhwb3J0IHsgamVzdCB9IGZyb20gXCIuL2plc3RcIjtcbmV4cG9ydCB7IHBsYXl3cmlnaHQgfSBmcm9tIFwiLi9wbGF5d3JpZ2h0XCI7XG5leHBvcnQgeyB2aXRlc3QgfSBmcm9tIFwiLi92aXRlc3RcIjtcbmV4cG9ydCB7IHZpdGVzdEUyZSB9IGZyb20gXCIuL3ZpdGVzdC1lMmVcIjtcbiJdfQ==

package/dist/infrastructure/testing/jasmine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jasmine.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/testing/jasmine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC;;;;;;;GAOG;AACH,wBAAsB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAmBxD"}
+{"version":3,"file":"jasmine.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/testing/jasmine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC;;;;;;;GAOG;AACH,wBAAsB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAkBxD"}

package/dist/infrastructure/testing/jasmine.js

@@ -8,7 +8,6 @@ import { defineConfig } from "eslint/config";
  * ```
  */
 export async function jasmine() {
-    // eslint-disable-next-line boundaries/no-unknown -- External package resolution is outside the repository topology.
     const jasmineModule = await import("eslint-plugin-jasmine");
     const globalsModule = await import("globals");
     const { configs, rules } = jasmineModule;
@@ -16,11 +15,11 @@ export async function jasmine() {
     const customError = Object.fromEntries(Object.keys(rules).map((rule) => [`jasmine/${rule}`, "error"]));
     return defineConfig({
         extends: [configs.recommended],
-        files: ["**/*.spec.ts"],
+        files: ["**/*.spec.ts", "**/*.e2e.ts"],
         languageOptions: { globals },
         name: "jasmine/custom",
         plugins: { jasmine: { rules } },
         rules: customError,
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamFzbWluZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pbmZyYXN0cnVjdHVyZS90ZXN0aW5nL2phc21pbmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUU3Qzs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxPQUFPO0lBQzNCLG9IQUFvSDtJQUNwSCxNQUFNLGFBQWEsR0FBRyxNQUFNLE1BQU0sQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDO0lBQzVELE1BQU0sYUFBYSxHQUFHLE1BQU0sTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQzlDLE1BQU0sRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLEdBQUcsYUFBYSxDQUFDO0lBQ3pDLE1BQU0sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLEdBQUcsYUFBYSxDQUFDO0lBRTNDLE1BQU0sV0FBVyxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQ3BDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDLFdBQVcsSUFBSSxFQUFFLEVBQUUsT0FBTyxDQUFVLENBQUMsQ0FDeEUsQ0FBQztJQUVGLE9BQU8sWUFBWSxDQUFDO1FBQ2xCLE9BQU8sRUFBRSxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUM7UUFDOUIsS0FBSyxFQUFFLENBQUMsY0FBYyxDQUFDO1FBQ3ZCLGVBQWUsRUFBRSxFQUFFLE9BQU8sRUFBRTtRQUM1QixJQUFJLEVBQUUsZ0JBQWdCO1FBQ3RCLE9BQU8sRUFBRSxFQUFFLE9BQU8sRUFBRSxFQUFFLEtBQUssRUFBRSxFQUFFO1FBQy9CLEtBQUssRUFBRSxXQUFXO0tBQ25CLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IExpbnRlciB9IGZyb20gXCJlc2xpbnRcIjtcblxuaW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSBcImVzbGludC9jb25maWdcIjtcblxuLyoqXG4gKiBSZXR1cm4gSmFzbWluZS1zcGVjaWZpYyBFU0xpbnQgY29uZmlndXJhdGlvbnMgd2hlbiB0aGUgcGx1Z2luIGlzIGluc3RhbGxlZC5cbiAqIEByZXR1cm5zIFJldHVybiB2YWx1ZSBvdXRwdXQuXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogYXdhaXQgamFzbWluZSgpO1xuICogYGBgXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBqYXNtaW5lKCk6IFByb21pc2U8TGludGVyLkNvbmZpZ1tdPiB7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBib3VuZGFyaWVzL25vLXVua25vd24gLS0gRXh0ZXJuYWwgcGFja2FnZSByZXNvbHV0aW9uIGlzIG91dHNpZGUgdGhlIHJlcG9zaXRvcnkgdG9wb2xvZ3kuXG4gIGNvbnN0IGphc21pbmVNb2R1bGUgPSBhd2FpdCBpbXBvcnQoXCJlc2xpbnQtcGx1Z2luLWphc21pbmVcIik7XG4gIGNvbnN0IGdsb2JhbHNNb2R1bGUgPSBhd2FpdCBpbXBvcnQoXCJnbG9iYWxzXCIpO1xuICBjb25zdCB7IGNvbmZpZ3MsIHJ1bGVzIH0gPSBqYXNtaW5lTW9kdWxlO1xuICBjb25zdCB7IGphc21pbmU6IGdsb2JhbHMgfSA9IGdsb2JhbHNNb2R1bGU7XG5cbiAgY29uc3QgY3VzdG9tRXJyb3IgPSBPYmplY3QuZnJvbUVudHJpZXMoXG4gICAgT2JqZWN0LmtleXMocnVsZXMpLm1hcCgocnVsZSkgPT4gW2BqYXNtaW5lLyR7cnVsZX1gLCBcImVycm9yXCJdIGFzIGNvbnN0KSxcbiAgKTtcblxuICByZXR1cm4gZGVmaW5lQ29uZmlnKHtcbiAgICBleHRlbmRzOiBbY29uZmlncy5yZWNvbW1lbmRlZF0sXG4gICAgZmlsZXM6IFtcIioqLyouc3BlYy50c1wiXSxcbiAgICBsYW5ndWFnZU9wdGlvbnM6IHsgZ2xvYmFscyB9LFxuICAgIG5hbWU6IFwiamFzbWluZS9jdXN0b21cIixcbiAgICBwbHVnaW5zOiB7IGphc21pbmU6IHsgcnVsZXMgfSB9LFxuICAgIHJ1bGVzOiBjdXN0b21FcnJvcixcbiAgfSk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/infrastructure/testing/jest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jest.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/testing/jest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC;;;;;;;GAOG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAoBrD"}
+{"version":3,"file":"jest.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/testing/jest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC;;;;;;;GAOG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAUrD"}