@codeperfect/eslint-config 1.0.0 → 1.1.0

package/dist/.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/config-composition.ts","../src/diagnostics.ts","../src/index-spec-helpers.ts","../src/index.ts","../src/module-taxonomy.ts","../src/plugin-loaders.ts","../src/types.ts","../src/utilities.ts","../src/architecture/boundaries.ts","../src/architecture/import-x.ts","../src/architecture/index.ts","../src/configs/index.ts","../src/core/eslint.ts","../src/core/index.ts","../src/core/resolver.ts","../src/core/typescript.ts","../src/docs/comments.ts","../src/docs/index.ts","../src/docs/jsdoc.ts","../src/domain/index.ts","../src/domain/rxjs-x.ts","../src/style/index.ts","../src/style/perfectionist.ts","../src/style/prettier.ts","../src/style/stylistic.ts","../src/style/unicorn.ts","../src/testing/index.ts","../src/testing/jasmine.ts","../src/testing/jest.ts","../src/testing/playwright.ts","../src/testing/vitest.ts","../conventional-changelog-conventionalcommits.d.ts","../eslint-plugin-jasmine.d.ts"],"version":"5.9.3"}
+{"root":["../src/config-composition.ts","../src/diagnostics.ts","../src/index.ts","../src/module-taxonomy.ts","../src/plugin-loaders.ts","../src/types.ts","../src/utilities.ts","../src/architecture/boundaries.ts","../src/architecture/import-x.ts","../src/architecture/index.ts","../src/configs/index.ts","../src/core/eslint.ts","../src/core/index.ts","../src/core/resolver.ts","../src/core/typescript.ts","../src/docs/comments.ts","../src/docs/index.ts","../src/docs/jsdoc-examples.ts","../src/docs/jsdoc-processor.ts","../src/docs/jsdoc.ts","../src/domain/index.ts","../src/domain/rxjs-x.ts","../src/style/index.ts","../src/style/perfectionist.ts","../src/style/prettier.ts","../src/style/stylistic.ts","../src/style/unicorn.ts","../src/testing/index.ts","../src/testing/jasmine.ts","../src/testing/jest.ts","../src/testing/playwright.ts","../src/testing/vitest.ts","../conventional-changelog-conventionalcommits.d.ts","../eslint-plugin-jasmine.d.ts"],"version":"5.9.3"}

package/dist/docs/jsdoc-examples.d.ts

@@ -0,0 +1,56 @@
+import type { Linter } from "eslint";
+import type { getJsdocProcessorPlugin as getJsdocProcessorPluginType } from "eslint-plugin-jsdoc";
+import type { parser as parserType, configs as typeScriptConfigsType, plugin as typeScriptPluginType } from "typescript-eslint";
+/** Options for building TypeScript example configs. */
+interface BuildTypeScriptExampleConfigOptions {
+    /** Rule overrides that disable typed-only checks for snippets. */
+    disableTypeCheckedRules: Linter.RulesRecord;
+    /** Upstream processor factory when the plugin exports it. */
+    getJsdocProcessorPlugin: JsdocProcessorPluginFactory | undefined;
+    /** Parser used for host files and snippet files. */
+    parser: Parser;
+    /** TypeScript ESLint plugin used by the virtual snippet configs. */
+    typeScriptPlugin: TypeScriptPlugin;
+}
+/** Function signature for the JSDoc processor factory. */
+type JsdocProcessorPluginFactory = typeof getJsdocProcessorPluginType;
+/** Parser accepted by the JSDoc example processor. */
+type Parser = typeof parserType;
+/** TypeScript ESLint config map. */
+type TypeScriptConfigs = typeof typeScriptConfigsType;
+/** TypeScript ESLint plugin instance used for snippet-only rule configs. */
+type TypeScriptPlugin = typeof typeScriptPluginType;
+/**
+ * Build TypeScript-aware processor configs for JSDoc examples and default expressions.
+ * @param options Config input for the TypeScript snippet support.
+ * @param options.disableTypeCheckedRules Rule overrides that disable typed-only checks.
+ * @param options.getJsdocProcessorPlugin Upstream processor factory when present.
+ * @param options.parser Parser used for host files and snippets.
+ * @param options.typeScriptPlugin TypeScript ESLint plugin instance.
+ * @returns The processor and virtual-file configs.
+ * @example
+ * console.log(buildTypeScriptExampleConfigs({ disableTypeCheckedRules: {}, getJsdocProcessorPlugin: void 0, parser: {} as Parser, typeScriptPlugin: {} as TypeScriptPlugin }).length);
+ */
+declare function buildTypeScriptExampleConfigs({ disableTypeCheckedRules, getJsdocProcessorPlugin, parser, typeScriptPlugin, }: BuildTypeScriptExampleConfigOptions): Linter.Config[];
+/**
+ * Resolve the TypeScript rule overrides that disable typed-only linting for snippets.
+ * @param typeScriptConfigs The exported TypeScript ESLint config map.
+ * @returns The disable-type-checked rule overrides.
+ * @example
+ * console.log(resolveDisableTypeCheckedRules({ disableTypeChecked: { rules: { example: "off" } } } as TypeScriptConfigs).example);
+ */
+declare function resolveDisableTypeCheckedRules(typeScriptConfigs: TypeScriptConfigs): Linter.RulesRecord;
+/**
+ * Resolve the optional processor factory from the JSDoc plugin module.
+ * @param jsdocModule The loaded JSDoc plugin module.
+ * @returns The processor factory when the module exports it.
+ * @example
+ * console.log(resolveJsdocProcessorPlugin({}) === void 0);
+ */
+declare function resolveJsdocProcessorPlugin(jsdocModule: Readonly<{
+    /** Optional exported JSDoc processor factory. */
+    getJsdocProcessorPlugin?: JsdocProcessorPluginFactory;
+}>): JsdocProcessorPluginFactory | undefined;
+export { buildTypeScriptExampleConfigs, resolveDisableTypeCheckedRules, resolveJsdocProcessorPlugin, };
+export type { Parser, TypeScriptConfigs, TypeScriptPlugin };
+//# sourceMappingURL=jsdoc-examples.d.ts.map

package/dist/docs/jsdoc-examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsdoc-examples.d.ts","sourceRoot":"","sources":["../../src/docs/jsdoc-examples.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,uBAAuB,IAAI,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAClG,OAAO,KAAK,EACV,MAAM,IAAI,UAAU,EACpB,OAAO,IAAI,qBAAqB,EAChC,MAAM,IAAI,oBAAoB,EAC/B,MAAM,mBAAmB,CAAC;AAI3B,uDAAuD;AACvD,UAAU,mCAAmC;IAC3C,kEAAkE;IAClE,uBAAuB,EAAE,MAAM,CAAC,WAAW,CAAC;IAE5C,6DAA6D;IAC7D,uBAAuB,EAAE,2BAA2B,GAAG,SAAS,CAAC;IAEjE,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IAEf,oEAAoE;IACpE,gBAAgB,EAAE,gBAAgB,CAAC;CACpC;AAED,0DAA0D;AAC1D,KAAK,2BAA2B,GAAG,OAAO,2BAA2B,CAAC;AAEtE,sDAAsD;AACtD,KAAK,MAAM,GAAG,OAAO,UAAU,CAAC;AAEhC,oCAAoC;AACpC,KAAK,iBAAiB,GAAG,OAAO,qBAAqB,CAAC;AAEtD,4EAA4E;AAC5E,KAAK,gBAAgB,GAAG,OAAO,oBAAoB,CAAC;AAkFpD;;;;;;;;;;GAUG;AACH,iBAAS,6BAA6B,CAAC,EACrC,uBAAuB,EACvB,uBAAuB,EACvB,MAAM,EACN,gBAAgB,GACjB,EAAE,mCAAmC,GAAG,MAAM,CAAC,MAAM,EAAE,CA4BvD;AAgFD;;;;;;GAMG;AACH,iBAAS,8BAA8B,CACrC,iBAAiB,EAAE,iBAAiB,GACnC,MAAM,CAAC,WAAW,CAGpB;AAED;;;;;;GAMG;AACH,iBAAS,2BAA2B,CAClC,WAAW,EAAE,QAAQ,CAAC;IACpB,iDAAiD;IACjD,uBAAuB,CAAC,EAAE,2BAA2B,CAAC;CACvD,CAAC,GACD,2BAA2B,GAAG,SAAS,CAIzC;AAED,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,EAC9B,2BAA2B,GAC5B,CAAC;AACF,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/docs/jsdoc-examples.js

@@ -0,0 +1,186 @@
+import { createWrappedJsdocProcessorPlugin } from "./jsdoc-processor.js";
+/** TypeScript source files that should run through the JSDoc snippet processor. */
+const typeScriptSourceFiles = ["**/*.cts", "**/*.mts", "**/*.ts", "**/*.tsx"];
+/** Virtual example files emitted by the upstream JSDoc processor. */
+const typeScriptExampleFiles = ["**/*.md/*.js"];
+/** Virtual files emitted for JSDoc default-expression checks. */
+const typeScriptDefaultExpressionFiles = [
+    "**/*.jsdoc-defaults",
+    "**/*.jsdoc-params",
+    "**/*.jsdoc-properties",
+];
+/**
+ * Build relaxed rules for extracted default-expression snippets.
+ * @returns The snippet rule overrides.
+ * @example
+ * console.log(buildDefaultExpressionSnippetRules());
+ */
+function buildDefaultExpressionSnippetRules() {
+    return {
+        ...buildExampleSnippetRules(),
+        "@stylistic/quotes": ["error", "double"],
+        "@stylistic/semi": ["error", "never"],
+        "@typescript-eslint/no-unused-expressions": "off",
+        "chai-friendly/no-unused-expressions": "off",
+        "no-empty-function": "off",
+        "no-new": "off",
+        "no-unused-expressions": "off",
+        strict: "off",
+    };
+}
+/**
+ * Build relaxed rules for extracted example snippets.
+ * @returns The snippet rule overrides.
+ * @example
+ * console.log(buildExampleSnippetRules());
+ */
+function buildExampleSnippetRules() {
+    return {
+        "@stylistic/eol-last": "off",
+        "@stylistic/no-multiple-empty-lines": "off",
+        "@stylistic/padded-blocks": "off",
+        "@typescript-eslint/no-unused-expressions": "off",
+        "@typescript-eslint/no-unused-vars": "off",
+        "chai-friendly/no-unused-expressions": "off",
+        "import/no-unresolved": "off",
+        "import/unambiguous": "off",
+        "jsdoc/require-file-overview": "off",
+        "jsdoc/require-jsdoc": "off",
+        "n/no-missing-import": "off",
+        "n/no-missing-require": "off",
+        "no-console": "off",
+        "no-undef": "off",
+        "no-unused-expressions": "off",
+        "no-unused-vars": "off",
+        "node/no-missing-import": "off",
+        "node/no-missing-require": "off",
+    };
+}
+/**
+ * Build TypeScript-aware processor configs for JSDoc examples and default expressions.
+ * @param options Config input for the TypeScript snippet support.
+ * @param options.disableTypeCheckedRules Rule overrides that disable typed-only checks.
+ * @param options.getJsdocProcessorPlugin Upstream processor factory when present.
+ * @param options.parser Parser used for host files and snippets.
+ * @param options.typeScriptPlugin TypeScript ESLint plugin instance.
+ * @returns The processor and virtual-file configs.
+ * @example
+ * console.log(buildTypeScriptExampleConfigs({ disableTypeCheckedRules: {}, getJsdocProcessorPlugin: void 0, parser: {} as Parser, typeScriptPlugin: {} as TypeScriptPlugin }).length);
+ */
+function buildTypeScriptExampleConfigs({ disableTypeCheckedRules, getJsdocProcessorPlugin, parser, typeScriptPlugin, }) {
+    if (getJsdocProcessorPlugin === void 0) {
+        return [];
+    }
+    return [
+        buildTypeScriptProcessorConfig(getJsdocProcessorPlugin, parser),
+        buildTypeScriptSnippetRuleConfig({
+            files: typeScriptExampleFiles,
+            name: "jsdoc/typescript-examples/rules",
+            parser,
+            rules: {
+                ...disableTypeCheckedRules,
+                ...buildExampleSnippetRules(),
+            },
+            typeScriptPlugin,
+        }),
+        buildTypeScriptSnippetRuleConfig({
+            files: typeScriptDefaultExpressionFiles,
+            name: "jsdoc/typescript-default-expressions/rules",
+            parser,
+            rules: {
+                ...disableTypeCheckedRules,
+                ...buildDefaultExpressionSnippetRules(),
+            },
+            typeScriptPlugin,
+        }),
+    ];
+}
+/**
+ * Build the processor config for TypeScript source files.
+ * @param getJsdocProcessorPlugin Upstream JSDoc processor factory.
+ * @param parser Parser used for host TypeScript files.
+ * @returns The processor-backed ESLint config entry.
+ * @example
+ * console.log(buildTypeScriptProcessorConfig(((_config) => ({ processors: { examples: {} } })) as JsdocProcessorPluginFactory, {} as Parser).processor);
+ */
+function buildTypeScriptProcessorConfig(getJsdocProcessorPlugin, parser) {
+    return {
+        files: typeScriptSourceFiles,
+        name: "jsdoc/typescript-examples-and-default-expressions/processor",
+        plugins: {
+            examples: createWrappedJsdocProcessorPlugin({
+                checkDefaults: true,
+                checkParams: true,
+                checkProperties: true,
+                getJsdocProcessorPlugin,
+                parser,
+                sourceType: "module",
+            }),
+        },
+        processor: "examples/examples",
+    };
+}
+/**
+ * Build language options for extracted TypeScript snippets.
+ * @param parser Parser used for snippet files.
+ * @returns The language options for virtual snippet files.
+ * @example
+ * console.log(buildTypeScriptSnippetLanguageOptions({} as Parser).sourceType);
+ */
+function buildTypeScriptSnippetLanguageOptions(parser) {
+    return {
+        parser,
+        parserOptions: {
+            projectService: false,
+        },
+        sourceType: "module",
+    };
+}
+/**
+ * Build a TypeScript snippet rule config for virtual files.
+ * @param options Config input for the snippet rule block.
+ * @param options.files Virtual file globs targeted by the config.
+ * @param options.name Config name shown in ESLint diagnostics.
+ * @param options.parser Parser used for extracted snippet content.
+ * @param options.rules Rule overrides applied to the virtual snippet files.
+ * @param options.typeScriptPlugin TypeScript ESLint plugin instance.
+ * @returns The ESLint config for the virtual snippet files.
+ * @example
+ * console.log(buildTypeScriptSnippetRuleConfig({ files: ["virtual-example-file"], name: "example", parser: {} as Parser, rules: {}, typeScriptPlugin: {} as TypeScriptPlugin }).name);
+ */
+function buildTypeScriptSnippetRuleConfig({ files, name, parser, rules, typeScriptPlugin, }) {
+    return {
+        files,
+        languageOptions: buildTypeScriptSnippetLanguageOptions(parser),
+        name,
+        plugins: {
+            "@typescript-eslint": typeScriptPlugin,
+        },
+        rules,
+    };
+}
+/**
+ * Resolve the TypeScript rule overrides that disable typed-only linting for snippets.
+ * @param typeScriptConfigs The exported TypeScript ESLint config map.
+ * @returns The disable-type-checked rule overrides.
+ * @example
+ * console.log(resolveDisableTypeCheckedRules({ disableTypeChecked: { rules: { example: "off" } } } as TypeScriptConfigs).example);
+ */
+function resolveDisableTypeCheckedRules(typeScriptConfigs) {
+    return (typeScriptConfigs.disableTypeChecked.rules ??
+        {});
+}
+/**
+ * Resolve the optional processor factory from the JSDoc plugin module.
+ * @param jsdocModule The loaded JSDoc plugin module.
+ * @returns The processor factory when the module exports it.
+ * @example
+ * console.log(resolveJsdocProcessorPlugin({}) === void 0);
+ */
+function resolveJsdocProcessorPlugin(jsdocModule) {
+    return "getJsdocProcessorPlugin" in jsdocModule
+        ? jsdocModule.getJsdocProcessorPlugin
+        : void 0;
+}
+export { buildTypeScriptExampleConfigs, resolveDisableTypeCheckedRules, resolveJsdocProcessorPlugin, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsdoc-examples.js","sourceRoot":"","sources":["../../src/docs/jsdoc-examples.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Linter } from \"eslint\";\nimport type { getJsdocProcessorPlugin as getJsdocProcessorPluginType } from \"eslint-plugin-jsdoc\";\nimport type {\n  parser as parserType,\n  configs as typeScriptConfigsType,\n  plugin as typeScriptPluginType,\n} from \"typescript-eslint\";\n\nimport { createWrappedJsdocProcessorPlugin } from \"./jsdoc-processor.js\";\n\n/** Options for building TypeScript example configs. */\ninterface BuildTypeScriptExampleConfigOptions {\n  /** Rule overrides that disable typed-only checks for snippets. */\n  disableTypeCheckedRules: Linter.RulesRecord;\n\n  /** Upstream processor factory when the plugin exports it. */\n  getJsdocProcessorPlugin: JsdocProcessorPluginFactory | undefined;\n\n  /** Parser used for host files and snippet files. */\n  parser: Parser;\n\n  /** TypeScript ESLint plugin used by the virtual snippet configs. */\n  typeScriptPlugin: TypeScriptPlugin;\n}\n\n/** Function signature for the JSDoc processor factory. */\ntype JsdocProcessorPluginFactory = typeof getJsdocProcessorPluginType;\n\n/** Parser accepted by the JSDoc example processor. */\ntype Parser = typeof parserType;\n\n/** TypeScript ESLint config map. */\ntype TypeScriptConfigs = typeof typeScriptConfigsType;\n\n/** TypeScript ESLint plugin instance used for snippet-only rule configs. */\ntype TypeScriptPlugin = typeof typeScriptPluginType;\n\n/** Options for a TypeScript virtual snippet rule config. */\ninterface TypeScriptSnippetRuleConfigOptions {\n  /** Virtual file globs targeted by the config. */\n  files: string[];\n\n  /** Config name shown in ESLint diagnostics. */\n  name: string;\n\n  /** Parser used for the extracted snippet content. */\n  parser: Parser;\n\n  /** Rule overrides applied to the extracted snippet files. */\n  rules: Linter.RulesRecord;\n\n  /** TypeScript ESLint plugin instance. */\n  typeScriptPlugin: TypeScriptPlugin;\n}\n\n/** TypeScript source files that should run through the JSDoc snippet processor. */\nconst typeScriptSourceFiles = [\"**/*.cts\", \"**/*.mts\", \"**/*.ts\", \"**/*.tsx\"];\n\n/** Virtual example files emitted by the upstream JSDoc processor. */\nconst typeScriptExampleFiles = [\"**/*.md/*.js\"];\n\n/** Virtual files emitted for JSDoc default-expression checks. */\nconst typeScriptDefaultExpressionFiles = [\n  \"**/*.jsdoc-defaults\",\n  \"**/*.jsdoc-params\",\n  \"**/*.jsdoc-properties\",\n];\n\n/**\n * Build relaxed rules for extracted default-expression snippets.\n * @returns The snippet rule overrides.\n * @example\n * console.log(buildDefaultExpressionSnippetRules());\n */\nfunction buildDefaultExpressionSnippetRules(): Linter.RulesRecord {\n  return {\n    ...buildExampleSnippetRules(),\n    \"@stylistic/quotes\": [\"error\", \"double\"],\n    \"@stylistic/semi\": [\"error\", \"never\"],\n    \"@typescript-eslint/no-unused-expressions\": \"off\",\n    \"chai-friendly/no-unused-expressions\": \"off\",\n    \"no-empty-function\": \"off\",\n    \"no-new\": \"off\",\n    \"no-unused-expressions\": \"off\",\n    strict: \"off\",\n  };\n}\n\n/**\n * Build relaxed rules for extracted example snippets.\n * @returns The snippet rule overrides.\n * @example\n * console.log(buildExampleSnippetRules());\n */\nfunction buildExampleSnippetRules(): Linter.RulesRecord {\n  return {\n    \"@stylistic/eol-last\": \"off\",\n    \"@stylistic/no-multiple-empty-lines\": \"off\",\n    \"@stylistic/padded-blocks\": \"off\",\n    \"@typescript-eslint/no-unused-expressions\": \"off\",\n    \"@typescript-eslint/no-unused-vars\": \"off\",\n    \"chai-friendly/no-unused-expressions\": \"off\",\n    \"import/no-unresolved\": \"off\",\n    \"import/unambiguous\": \"off\",\n    \"jsdoc/require-file-overview\": \"off\",\n    \"jsdoc/require-jsdoc\": \"off\",\n    \"n/no-missing-import\": \"off\",\n    \"n/no-missing-require\": \"off\",\n    \"no-console\": \"off\",\n    \"no-undef\": \"off\",\n    \"no-unused-expressions\": \"off\",\n    \"no-unused-vars\": \"off\",\n    \"node/no-missing-import\": \"off\",\n    \"node/no-missing-require\": \"off\",\n  };\n}\n\n/**\n * Build TypeScript-aware processor configs for JSDoc examples and default expressions.\n * @param options Config input for the TypeScript snippet support.\n * @param options.disableTypeCheckedRules Rule overrides that disable typed-only checks.\n * @param options.getJsdocProcessorPlugin Upstream processor factory when present.\n * @param options.parser Parser used for host files and snippets.\n * @param options.typeScriptPlugin TypeScript ESLint plugin instance.\n * @returns The processor and virtual-file configs.\n * @example\n * console.log(buildTypeScriptExampleConfigs({ disableTypeCheckedRules: {}, getJsdocProcessorPlugin: void 0, parser: {} as Parser, typeScriptPlugin: {} as TypeScriptPlugin }).length);\n */\nfunction buildTypeScriptExampleConfigs({\n  disableTypeCheckedRules,\n  getJsdocProcessorPlugin,\n  parser,\n  typeScriptPlugin,\n}: BuildTypeScriptExampleConfigOptions): Linter.Config[] {\n  if (getJsdocProcessorPlugin === void 0) {\n    return [];\n  }\n\n  return [\n    buildTypeScriptProcessorConfig(getJsdocProcessorPlugin, parser),\n    buildTypeScriptSnippetRuleConfig({\n      files: typeScriptExampleFiles,\n      name: \"jsdoc/typescript-examples/rules\",\n      parser,\n      rules: {\n        ...disableTypeCheckedRules,\n        ...buildExampleSnippetRules(),\n      },\n      typeScriptPlugin,\n    }),\n    buildTypeScriptSnippetRuleConfig({\n      files: typeScriptDefaultExpressionFiles,\n      name: \"jsdoc/typescript-default-expressions/rules\",\n      parser,\n      rules: {\n        ...disableTypeCheckedRules,\n        ...buildDefaultExpressionSnippetRules(),\n      },\n      typeScriptPlugin,\n    }),\n  ];\n}\n\n/**\n * Build the processor config for TypeScript source files.\n * @param getJsdocProcessorPlugin Upstream JSDoc processor factory.\n * @param parser Parser used for host TypeScript files.\n * @returns The processor-backed ESLint config entry.\n * @example\n * console.log(buildTypeScriptProcessorConfig(((_config) => ({ processors: { examples: {} } })) as JsdocProcessorPluginFactory, {} as Parser).processor);\n */\nfunction buildTypeScriptProcessorConfig(\n  getJsdocProcessorPlugin: JsdocProcessorPluginFactory,\n  parser: Parser,\n): Linter.Config {\n  return {\n    files: typeScriptSourceFiles,\n    name: \"jsdoc/typescript-examples-and-default-expressions/processor\",\n    plugins: {\n      examples: createWrappedJsdocProcessorPlugin({\n        checkDefaults: true,\n        checkParams: true,\n        checkProperties: true,\n        getJsdocProcessorPlugin,\n        parser,\n        sourceType: \"module\",\n      }),\n    },\n    processor: \"examples/examples\",\n  };\n}\n\n/**\n * Build language options for extracted TypeScript snippets.\n * @param parser Parser used for snippet files.\n * @returns The language options for virtual snippet files.\n * @example\n * console.log(buildTypeScriptSnippetLanguageOptions({} as Parser).sourceType);\n */\nfunction buildTypeScriptSnippetLanguageOptions(\n  parser: Parser,\n): NonNullable<Linter.Config[\"languageOptions\"]> {\n  return {\n    parser,\n    parserOptions: {\n      projectService: false,\n    },\n    sourceType: \"module\",\n  };\n}\n\n/**\n * Build a TypeScript snippet rule config for virtual files.\n * @param options Config input for the snippet rule block.\n * @param options.files Virtual file globs targeted by the config.\n * @param options.name Config name shown in ESLint diagnostics.\n * @param options.parser Parser used for extracted snippet content.\n * @param options.rules Rule overrides applied to the virtual snippet files.\n * @param options.typeScriptPlugin TypeScript ESLint plugin instance.\n * @returns The ESLint config for the virtual snippet files.\n * @example\n * console.log(buildTypeScriptSnippetRuleConfig({ files: [\"virtual-example-file\"], name: \"example\", parser: {} as Parser, rules: {}, typeScriptPlugin: {} as TypeScriptPlugin }).name);\n */\nfunction buildTypeScriptSnippetRuleConfig({\n  files,\n  name,\n  parser,\n  rules,\n  typeScriptPlugin,\n}: TypeScriptSnippetRuleConfigOptions): Linter.Config {\n  return {\n    files,\n    languageOptions: buildTypeScriptSnippetLanguageOptions(parser),\n    name,\n    plugins: {\n      \"@typescript-eslint\": typeScriptPlugin,\n    },\n    rules,\n  };\n}\n\n/**\n * Resolve the TypeScript rule overrides that disable typed-only linting for snippets.\n * @param typeScriptConfigs The exported TypeScript ESLint config map.\n * @returns The disable-type-checked rule overrides.\n * @example\n * console.log(resolveDisableTypeCheckedRules({ disableTypeChecked: { rules: { example: \"off\" } } } as TypeScriptConfigs).example);\n */\nfunction resolveDisableTypeCheckedRules(\n  typeScriptConfigs: TypeScriptConfigs,\n): Linter.RulesRecord {\n  return (typeScriptConfigs.disableTypeChecked.rules ??\n    {}) as Linter.RulesRecord;\n}\n\n/**\n * Resolve the optional processor factory from the JSDoc plugin module.\n * @param jsdocModule The loaded JSDoc plugin module.\n * @returns The processor factory when the module exports it.\n * @example\n * console.log(resolveJsdocProcessorPlugin({}) === void 0);\n */\nfunction resolveJsdocProcessorPlugin(\n  jsdocModule: Readonly<{\n    /** Optional exported JSDoc processor factory. */\n    getJsdocProcessorPlugin?: JsdocProcessorPluginFactory;\n  }>,\n): JsdocProcessorPluginFactory | undefined {\n  return \"getJsdocProcessorPlugin\" in jsdocModule\n    ? jsdocModule.getJsdocProcessorPlugin\n    : void 0;\n}\n\nexport {\n  buildTypeScriptExampleConfigs,\n  resolveDisableTypeCheckedRules,\n  resolveJsdocProcessorPlugin,\n};\nexport type { Parser, TypeScriptConfigs, TypeScriptPlugin };\n"]}

package/dist/docs/jsdoc-processor.d.ts

@@ -0,0 +1,63 @@
+import type { Linter } from "eslint";
+import type { getJsdocProcessorPlugin as getJsdocProcessorPluginType } from "eslint-plugin-jsdoc";
+import type { parser as parserType } from "typescript-eslint";
+/** Options for creating the wrapped JSDoc processor plugin. */
+interface CreateWrappedJsdocProcessorPluginOptions {
+    /** Whether to lint default value snippets. */
+    checkDefaults: boolean;
+    /** Whether to lint parameter default snippets. */
+    checkParams: boolean;
+    /** Whether to lint property default snippets. */
+    checkProperties: boolean;
+    /** Upstream JSDoc processor factory. */
+    getJsdocProcessorPlugin: JsdocProcessorPluginFactory;
+    /** Parser passed through to the upstream processor. */
+    parser: Parser;
+    /** Source type for extracted snippets. */
+    sourceType: "module" | "script";
+}
+/** Minimal upstream example processor contract used by the wrapper. */
+interface IExampleProcessor {
+    /** Optional processor metadata. */
+    meta?: IProcessorMeta;
+    /** Remap virtual-file lint messages back onto the host file. */
+    postprocess: (messages: Linter.LintMessage[][], filename: string) => Linter.LintMessage[];
+    /** Extract virtual snippet files from a host file. */
+    preprocess: (text: string, filename: string) => ProcessorFile[];
+    /** Whether the upstream processor supports autofix. */
+    supportsAutofix?: boolean;
+}
+/** Minimal meta shape used by the wrapped processor. */
+interface IProcessorMeta {
+    /** Processor name shown to ESLint. */
+    name?: string;
+    /** Processor version shown to ESLint. */
+    version?: string;
+}
+/** Minimal upstream plugin contract used by the wrapper. */
+interface IProcessorPlugin {
+    /** Optional plugin metadata. */
+    meta?: IProcessorMeta;
+    /** Available processors exported by the plugin. */
+    processors?: {
+        /** JSDoc example/default-expression processor. */
+        examples?: Partial<IExampleProcessor>;
+    };
+}
+/** Function signature for the upstream JSDoc processor factory. */
+type JsdocProcessorPluginFactory = typeof getJsdocProcessorPluginType;
+/** Parser accepted by the upstream JSDoc processor. */
+type Parser = typeof parserType;
+/** Virtual files emitted by a processor preprocess step. */
+type ProcessorFile = Linter.ProcessorFile | string;
+/**
+ * Create a wrapped JSDoc processor plugin with per-file upstream isolation.
+ * @param options The wrapper options.
+ * @returns A plugin whose examples processor uses fresh upstream state per file.
+ * @example
+ * console.log(createWrappedJsdocProcessorPlugin({ checkDefaults: true, checkParams: true, checkProperties: true, getJsdocProcessorPlugin: (() => ({ processors: { examples: {} } })) as JsdocProcessorPluginFactory, parser: {} as Parser, sourceType: "module" }).processors?.examples !== void 0);
+ */
+declare function createWrappedJsdocProcessorPlugin(options: CreateWrappedJsdocProcessorPluginOptions): IProcessorPlugin;
+export { createWrappedJsdocProcessorPlugin };
+export type { JsdocProcessorPluginFactory, Parser };
+//# sourceMappingURL=jsdoc-processor.d.ts.map

package/dist/docs/jsdoc-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsdoc-processor.d.ts","sourceRoot":"","sources":["../../src/docs/jsdoc-processor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,uBAAuB,IAAI,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAClG,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE9D,+DAA+D;AAC/D,UAAU,wCAAwC;IAChD,8CAA8C;IAC9C,aAAa,EAAE,OAAO,CAAC;IAEvB,kDAAkD;IAClD,WAAW,EAAE,OAAO,CAAC;IAErB,iDAAiD;IACjD,eAAe,EAAE,OAAO,CAAC;IAEzB,wCAAwC;IACxC,uBAAuB,EAAE,2BAA2B,CAAC;IAErD,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IAEf,0CAA0C;IAC1C,UAAU,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACjC;AAED,uEAAuE;AACvE,UAAU,iBAAiB;IACzB,mCAAmC;IACnC,IAAI,CAAC,EAAE,cAAc,CAAC;IAEtB,gEAAgE;IAChE,WAAW,EAAE,CACX,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,EAAE,EAChC,QAAQ,EAAE,MAAM,KACb,MAAM,CAAC,WAAW,EAAE,CAAC;IAE1B,sDAAsD;IACtD,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,aAAa,EAAE,CAAC;IAEhE,uDAAuD;IACvD,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,wDAAwD;AACxD,UAAU,cAAc;IACtB,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,4DAA4D;AAC5D,UAAU,gBAAgB;IACxB,gCAAgC;IAChC,IAAI,CAAC,EAAE,cAAc,CAAC;IAEtB,mDAAmD;IACnD,UAAU,CAAC,EAAE;QACX,kDAAkD;QAClD,QAAQ,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;KACvC,CAAC;CACH;AAED,mEAAmE;AACnE,KAAK,2BAA2B,GAAG,OAAO,2BAA2B,CAAC;AAEtE,uDAAuD;AACvD,KAAK,MAAM,GAAG,OAAO,UAAU,CAAC;AAEhC,4DAA4D;AAC5D,KAAK,aAAa,GAAG,MAAM,CAAC,aAAa,GAAG,MAAM,CAAC;AAwBnD;;;;;;GAMG;AACH,iBAAS,iCAAiC,CACxC,OAAO,EAAE,wCAAwC,GAChD,gBAAgB,CA0ClB;AA2FD,OAAO,EAAE,iCAAiC,EAAE,CAAC;AAC7C,YAAY,EAAE,2BAA2B,EAAE,MAAM,EAAE,CAAC"}

package/dist/docs/jsdoc-processor.js

@@ -0,0 +1,112 @@
+/**
+ * Build the options object forwarded to the upstream processor factory.
+ * @param options The wrapper options.
+ * @returns A shallow options object for the upstream processor.
+ * @example
+ * console.log(buildUpstreamProcessorOptions({ checkDefaults: true, checkParams: true, checkProperties: true, getJsdocProcessorPlugin: (() => ({ processors: { examples: {} } })) as JsdocProcessorPluginFactory, parser: {} as Parser, sourceType: "module" }).sourceType);
+ */
+function buildUpstreamProcessorOptions(options) {
+    return {
+        checkDefaults: options.checkDefaults,
+        checkParams: options.checkParams,
+        checkProperties: options.checkProperties,
+        parser: options.parser,
+        sourceType: options.sourceType,
+    };
+}
+/**
+ * Create a wrapped JSDoc processor plugin with per-file upstream isolation.
+ * @param options The wrapper options.
+ * @returns A plugin whose examples processor uses fresh upstream state per file.
+ * @example
+ * console.log(createWrappedJsdocProcessorPlugin({ checkDefaults: true, checkParams: true, checkProperties: true, getJsdocProcessorPlugin: (() => ({ processors: { examples: {} } })) as JsdocProcessorPluginFactory, parser: {} as Parser, sourceType: "module" }).processors?.examples !== void 0);
+ */
+function createWrappedJsdocProcessorPlugin(options) {
+    const upstreamOptions = buildUpstreamProcessorOptions(options);
+    const basePlugin = options.getJsdocProcessorPlugin(upstreamOptions);
+    const baseProcessor = resolveExamplesProcessor(basePlugin, false);
+    const processorsByFilename = new Map();
+    return {
+        ...(basePlugin.meta === void 0 ? {} : { meta: basePlugin.meta }),
+        processors: {
+            examples: {
+                ...(baseProcessor.meta === void 0 ? {} : { meta: baseProcessor.meta }),
+                postprocess(messages, filename) {
+                    return dequeueProcessor(processorsByFilename, filename).postprocess(messages, filename);
+                },
+                preprocess(text, filename) {
+                    const plugin = options.getJsdocProcessorPlugin(upstreamOptions);
+                    const processor = resolveExamplesProcessor(plugin, true);
+                    const processedFiles = processor.preprocess(text, filename);
+                    queueProcessor(processorsByFilename, filename, processor);
+                    return processedFiles;
+                },
+                ...(baseProcessor.supportsAutofix === void 0
+                    ? {}
+                    : { supportsAutofix: baseProcessor.supportsAutofix }),
+            },
+        },
+    };
+}
+/**
+ * Dequeue the next processor instance for a filename.
+ * @param processorsByFilename Queued processors keyed by source filename.
+ * @param filename The host filename for the processor instance.
+ * @returns The next upstream processor instance.
+ * @throws {Error} Thrown when postprocess is called without a queued processor.
+ * @example
+ * console.log("dequeueProcessor");
+ */
+function dequeueProcessor(processorsByFilename, filename) {
+    const queuedProcessors = processorsByFilename.get(filename);
+    if (queuedProcessors === void 0) {
+        throw new Error(`Wrapped JSDoc processor lost lifecycle state for ${filename}`);
+    }
+    const [processor] = queuedProcessors;
+    if (queuedProcessors.length === 1) {
+        processorsByFilename.delete(filename);
+    }
+    else {
+        queuedProcessors.shift();
+    }
+    return processor;
+}
+/**
+ * Queue a processor instance for a later postprocess call.
+ * @param processorsByFilename Queued processors keyed by source filename.
+ * @param filename The host filename for the processor instance.
+ * @param processor The upstream processor instance.
+ * @example
+ * console.log("queueProcessor");
+ */
+function queueProcessor(processorsByFilename, filename, processor) {
+    const queuedProcessors = processorsByFilename.get(filename);
+    if (queuedProcessors === void 0) {
+        processorsByFilename.set(filename, [processor]);
+        return;
+    }
+    queuedProcessors.push(processor);
+}
+/**
+ * Resolve the upstream examples processor from a plugin instance.
+ * @param plugin The upstream plugin instance.
+ * @param shouldRequireLifecycleMethods Whether preprocess/postprocess must be present.
+ * @returns The upstream examples processor.
+ * @throws {TypeError} Thrown when the upstream plugin omits the examples processor or its lifecycle methods.
+ * @example
+ * console.log(resolveExamplesProcessor({ processors: { examples: {} } }, false) !== void 0);
+ */
+function resolveExamplesProcessor(plugin, shouldRequireLifecycleMethods) {
+    const processor = plugin.processors?.examples;
+    if (processor === void 0) {
+        throw new TypeError("eslint-plugin-jsdoc did not provide processors.examples");
+    }
+    if (shouldRequireLifecycleMethods &&
+        (typeof processor.preprocess !== "function" ||
+            typeof processor.postprocess !== "function")) {
+        throw new TypeError("eslint-plugin-jsdoc processors.examples must provide preprocess and postprocess");
+    }
+    return processor;
+}
+export { createWrappedJsdocProcessorPlugin };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsdoc-processor.js","sourceRoot":"","sources":["../../src/docs/jsdoc-processor.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Linter } from \"eslint\";\nimport type { getJsdocProcessorPlugin as getJsdocProcessorPluginType } from \"eslint-plugin-jsdoc\";\nimport type { parser as parserType } from \"typescript-eslint\";\n\n/** Options for creating the wrapped JSDoc processor plugin. */\ninterface CreateWrappedJsdocProcessorPluginOptions {\n  /** Whether to lint default value snippets. */\n  checkDefaults: boolean;\n\n  /** Whether to lint parameter default snippets. */\n  checkParams: boolean;\n\n  /** Whether to lint property default snippets. */\n  checkProperties: boolean;\n\n  /** Upstream JSDoc processor factory. */\n  getJsdocProcessorPlugin: JsdocProcessorPluginFactory;\n\n  /** Parser passed through to the upstream processor. */\n  parser: Parser;\n\n  /** Source type for extracted snippets. */\n  sourceType: \"module\" | \"script\";\n}\n\n/** Minimal upstream example processor contract used by the wrapper. */\ninterface IExampleProcessor {\n  /** Optional processor metadata. */\n  meta?: IProcessorMeta;\n\n  /** Remap virtual-file lint messages back onto the host file. */\n  postprocess: (\n    messages: Linter.LintMessage[][],\n    filename: string,\n  ) => Linter.LintMessage[];\n\n  /** Extract virtual snippet files from a host file. */\n  preprocess: (text: string, filename: string) => ProcessorFile[];\n\n  /** Whether the upstream processor supports autofix. */\n  supportsAutofix?: boolean;\n}\n\n/** Minimal meta shape used by the wrapped processor. */\ninterface IProcessorMeta {\n  /** Processor name shown to ESLint. */\n  name?: string;\n\n  /** Processor version shown to ESLint. */\n  version?: string;\n}\n\n/** Minimal upstream plugin contract used by the wrapper. */\ninterface IProcessorPlugin {\n  /** Optional plugin metadata. */\n  meta?: IProcessorMeta;\n\n  /** Available processors exported by the plugin. */\n  processors?: {\n    /** JSDoc example/default-expression processor. */\n    examples?: Partial<IExampleProcessor>;\n  };\n}\n\n/** Function signature for the upstream JSDoc processor factory. */\ntype JsdocProcessorPluginFactory = typeof getJsdocProcessorPluginType;\n\n/** Parser accepted by the upstream JSDoc processor. */\ntype Parser = typeof parserType;\n\n/** Virtual files emitted by a processor preprocess step. */\ntype ProcessorFile = Linter.ProcessorFile | string;\n\n/** Non-empty queue of processor instances for one filename. */\ntype ProcessorQueue = [IExampleProcessor, ...IExampleProcessor[]];\n\n/**\n * Build the options object forwarded to the upstream processor factory.\n * @param options The wrapper options.\n * @returns A shallow options object for the upstream processor.\n * @example\n * console.log(buildUpstreamProcessorOptions({ checkDefaults: true, checkParams: true, checkProperties: true, getJsdocProcessorPlugin: (() => ({ processors: { examples: {} } })) as JsdocProcessorPluginFactory, parser: {} as Parser, sourceType: \"module\" }).sourceType);\n */\nfunction buildUpstreamProcessorOptions(\n  options: CreateWrappedJsdocProcessorPluginOptions,\n): Parameters<JsdocProcessorPluginFactory>[0] {\n  return {\n    checkDefaults: options.checkDefaults,\n    checkParams: options.checkParams,\n    checkProperties: options.checkProperties,\n    parser: options.parser,\n    sourceType: options.sourceType,\n  };\n}\n\n/**\n * Create a wrapped JSDoc processor plugin with per-file upstream isolation.\n * @param options The wrapper options.\n * @returns A plugin whose examples processor uses fresh upstream state per file.\n * @example\n * console.log(createWrappedJsdocProcessorPlugin({ checkDefaults: true, checkParams: true, checkProperties: true, getJsdocProcessorPlugin: (() => ({ processors: { examples: {} } })) as JsdocProcessorPluginFactory, parser: {} as Parser, sourceType: \"module\" }).processors?.examples !== void 0);\n */\nfunction createWrappedJsdocProcessorPlugin(\n  options: CreateWrappedJsdocProcessorPluginOptions,\n): IProcessorPlugin {\n  const upstreamOptions = buildUpstreamProcessorOptions(options);\n  const basePlugin = options.getJsdocProcessorPlugin(\n    upstreamOptions,\n  ) as IProcessorPlugin;\n  const baseProcessor = resolveExamplesProcessor(basePlugin, false);\n  const processorsByFilename = new Map<string, ProcessorQueue>();\n\n  return {\n    ...(basePlugin.meta === void 0 ? {} : { meta: basePlugin.meta }),\n    processors: {\n      examples: {\n        ...(baseProcessor.meta === void 0 ? {} : { meta: baseProcessor.meta }),\n        postprocess(\n          messages: Linter.LintMessage[][],\n          filename: string,\n        ): Linter.LintMessage[] {\n          return dequeueProcessor(processorsByFilename, filename).postprocess(\n            messages,\n            filename,\n          );\n        },\n        preprocess(text: string, filename: string): ProcessorFile[] {\n          const plugin = options.getJsdocProcessorPlugin(\n            upstreamOptions,\n          ) as IProcessorPlugin;\n          const processor = resolveExamplesProcessor(\n            plugin,\n            true,\n          ) as IExampleProcessor;\n          const processedFiles = processor.preprocess(text, filename);\n\n          queueProcessor(processorsByFilename, filename, processor);\n\n          return processedFiles;\n        },\n        ...(baseProcessor.supportsAutofix === void 0\n          ? {}\n          : { supportsAutofix: baseProcessor.supportsAutofix }),\n      },\n    },\n  };\n}\n\n/**\n * Dequeue the next processor instance for a filename.\n * @param processorsByFilename Queued processors keyed by source filename.\n * @param filename The host filename for the processor instance.\n * @returns The next upstream processor instance.\n * @throws {Error} Thrown when postprocess is called without a queued processor.\n * @example\n * console.log(\"dequeueProcessor\");\n */\nfunction dequeueProcessor(\n  processorsByFilename: Map<string, ProcessorQueue>,\n  filename: string,\n): IExampleProcessor {\n  const queuedProcessors = processorsByFilename.get(filename);\n\n  if (queuedProcessors === void 0) {\n    throw new Error(\n      `Wrapped JSDoc processor lost lifecycle state for ${filename}`,\n    );\n  }\n\n  const [processor] = queuedProcessors;\n\n  if (queuedProcessors.length === 1) {\n    processorsByFilename.delete(filename);\n  } else {\n    queuedProcessors.shift();\n  }\n\n  return processor;\n}\n\n/**\n * Queue a processor instance for a later postprocess call.\n * @param processorsByFilename Queued processors keyed by source filename.\n * @param filename The host filename for the processor instance.\n * @param processor The upstream processor instance.\n * @example\n * console.log(\"queueProcessor\");\n */\nfunction queueProcessor(\n  processorsByFilename: Map<string, ProcessorQueue>,\n  filename: string,\n  processor: IExampleProcessor,\n): void {\n  const queuedProcessors = processorsByFilename.get(filename);\n\n  if (queuedProcessors === void 0) {\n    processorsByFilename.set(filename, [processor]);\n    return;\n  }\n\n  queuedProcessors.push(processor);\n}\n\n/**\n * Resolve the upstream examples processor from a plugin instance.\n * @param plugin The upstream plugin instance.\n * @param shouldRequireLifecycleMethods Whether preprocess/postprocess must be present.\n * @returns The upstream examples processor.\n * @throws {TypeError} Thrown when the upstream plugin omits the examples processor or its lifecycle methods.\n * @example\n * console.log(resolveExamplesProcessor({ processors: { examples: {} } }, false) !== void 0);\n */\nfunction resolveExamplesProcessor(\n  plugin: IProcessorPlugin,\n  shouldRequireLifecycleMethods: boolean,\n): Partial<IExampleProcessor> {\n  const processor = plugin.processors?.examples;\n\n  if (processor === void 0) {\n    throw new TypeError(\n      \"eslint-plugin-jsdoc did not provide processors.examples\",\n    );\n  }\n\n  if (\n    shouldRequireLifecycleMethods &&\n    (typeof processor.preprocess !== \"function\" ||\n      typeof processor.postprocess !== \"function\")\n  ) {\n    throw new TypeError(\n      \"eslint-plugin-jsdoc processors.examples must provide preprocess and postprocess\",\n    );\n  }\n\n  return processor;\n}\n\nexport { createWrappedJsdocProcessorPlugin };\nexport type { JsdocProcessorPluginFactory, Parser };\n"]}

package/dist/docs/jsdoc.d.ts

@@ -3,10 +3,8 @@ import type { Linter } from "eslint";
  * Build the jsdoc plugin configuration and any overrides needed by this project.
  * @returns Return value output.
  * @example
- * ```typescript
- * await jsdoc();
- * ```
+ * console.log(await jsdoc());
  */
-declare const jsdoc: () => Promise<Linter.Config[]>;
+declare function jsdoc(): Promise<Linter.Config[]>;
 export { jsdoc };
 //# sourceMappingURL=jsdoc.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"jsdoc.d.ts","sourceRoot":"","sources":["../../src/docs/jsdoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAiDrC;;;;;;;GAOG;AACH,QAAA,MAAM,KAAK,QAAa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAsC9C,CAAC;AAEF,OAAO,EAAE,KAAK,EAAE,CAAC"}
+{"version":3,"file":"jsdoc.d.ts","sourceRoot":"","sources":["../../src/docs/jsdoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAiIrC;;;;;GAKG;AACH,iBAAe,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CA2B/C;AAED,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/docs/jsdoc.js

@@ -1,12 +1,19 @@
 import { defineConfig } from "eslint/config";
+import { buildTypeScriptExampleConfigs, resolveDisableTypeCheckedRules, resolveJsdocProcessorPlugin, } from "./jsdoc-examples.js";
+/** 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
- * const rules = buildCustomErrorRules(new Set(["require-throws"]));
- * ```
+ * console.log(buildCustomErrorRules(new Set(["require-throws"])));
  */
 const buildCustomErrorRules = (availableRules) => {
     const ruleNames = [
@@ -38,19 +45,33 @@ const requireJsdocContexts = [
     "TSIndexSignature",
 ];
 /**
- * Build the jsdoc plugin configuration and any overrides needed by this project.
- * @returns Return value output.
+ * 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
- * await jsdoc();
- * ```
+ * console.log(buildPresetConfigs({ "flat/recommended-typescript-error": {} as Linter.Config }).length);
  */
-const jsdoc = async () => {
-    const jsdocModule = await import("eslint-plugin-jsdoc");
-    const { configs, rules } = jsdocModule.default;
-    const availableRules = new Set(Object.keys(rules ?? {}));
-    const customError = buildCustomErrorRules(availableRules);
-    return defineConfig(configs["flat/recommended-typescript-error"], configs["flat/contents-typescript-error"], configs["flat/logical-typescript-error"], configs["flat/requirements-typescript-error"], configs["flat/stylistic-typescript-error"], {
+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.
+ * @param typeScriptExampleConfigs Processor-backed TypeScript example configs.
+ * @returns The final ESLint config array.
+ * @example
+ * console.log(buildRepoJsdocConfigs({}, []).length);
+ */
+function buildRepoJsdocConfigs(customError, typeScriptExampleConfigs) {
+    return defineConfig(...typeScriptExampleConfigs, {
         name: "jsdoc/custom",
         rules: {
             ...customError,
@@ -59,7 +80,10 @@ const jsdoc = async () => {
     }, {
         name: "jsdoc/require-jsdoc-alias",
         rules: {
-            "jsdoc/require-description": ["error", { contexts: requireJsdocContexts }],
+            "jsdoc/require-description": [
+                "error",
+                { contexts: requireJsdocContexts },
+            ],
             "jsdoc/require-jsdoc": ["error", { contexts: requireJsdocContexts }],
         },
     }, {
@@ -72,6 +96,27 @@ const jsdoc = async () => {
             ],
         },
     });
-};
+}
+/**
+ * Build the jsdoc plugin configuration and any overrides needed by this project.
+ * @returns Return value output.
+ * @example
+ * console.log(await jsdoc());
+ */
+async function jsdoc() {
+    const jsdocModule = await import("eslint-plugin-jsdoc");
+    const typeScriptModule = await import("typescript-eslint");
+    const { default: jsdocPlugin } = jsdocModule;
+    const { configs, rules } = jsdocPlugin;
+    const getJsdocProcessorPlugin = resolveJsdocProcessorPlugin(jsdocModule);
+    const { configs: typeScriptConfigs, parser, plugin: typeScriptPlugin, } = typeScriptModule;
+    const availableRules = new Set(Object.keys(rules ?? {})), customError = buildCustomErrorRules(availableRules), disableTypeCheckedRules = resolveDisableTypeCheckedRules(typeScriptConfigs), presetConfigs = buildPresetConfigs(configs), typeScriptExampleConfigs = buildTypeScriptExampleConfigs({
+        disableTypeCheckedRules,
+        getJsdocProcessorPlugin,
+        parser,
+        typeScriptPlugin,
+    });
+    return defineConfig(...presetConfigs, ...buildRepoJsdocConfigs(customError, typeScriptExampleConfigs));
+}
 export { jsdoc };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsdoc.js","sourceRoot":"","sources":["../../src/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\nimport {\r\n  buildTypeScriptExampleConfigs,\r\n  resolveDisableTypeCheckedRules,\r\n  resolveJsdocProcessorPlugin,\r\n} from \"./jsdoc-examples.js\";\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 * console.log(buildCustomErrorRules(new Set([\"require-throws\"])));\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 * console.log(buildPresetConfigs({ \"flat/recommended-typescript-error\": {} as Linter.Config }).length);\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 * @param typeScriptExampleConfigs Processor-backed TypeScript example configs.\r\n * @returns The final ESLint config array.\r\n * @example\r\n * console.log(buildRepoJsdocConfigs({}, []).length);\r\n */\r\nfunction buildRepoJsdocConfigs(\r\n  customError: Linter.RulesRecord,\r\n  typeScriptExampleConfigs: Linter.Config[],\r\n): Linter.Config[] {\r\n  return defineConfig(\r\n    ...typeScriptExampleConfigs,\r\n    {\r\n      name: \"jsdoc/custom\",\r\n      rules: {\r\n        ...customError,\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 * console.log(await jsdoc());\r\n */\r\nasync function jsdoc(): Promise<Linter.Config[]> {\r\n  const jsdocModule = await import(\"eslint-plugin-jsdoc\");\r\n  const typeScriptModule = await import(\"typescript-eslint\");\r\n  const { default: jsdocPlugin } = jsdocModule;\r\n  const { configs, rules } = jsdocPlugin;\r\n  const getJsdocProcessorPlugin = resolveJsdocProcessorPlugin(jsdocModule);\r\n  const {\r\n    configs: typeScriptConfigs,\r\n    parser,\r\n    plugin: typeScriptPlugin,\r\n  } = typeScriptModule;\r\n\r\n  const availableRules = new Set(Object.keys(rules ?? {})),\r\n    customError = buildCustomErrorRules(availableRules),\r\n    disableTypeCheckedRules = resolveDisableTypeCheckedRules(typeScriptConfigs),\r\n    presetConfigs = buildPresetConfigs(configs),\r\n    typeScriptExampleConfigs = buildTypeScriptExampleConfigs({\r\n      disableTypeCheckedRules,\r\n      getJsdocProcessorPlugin,\r\n      parser,\r\n      typeScriptPlugin,\r\n    });\r\n\r\n  return defineConfig(\r\n    ...presetConfigs,\r\n    ...buildRepoJsdocConfigs(customError, typeScriptExampleConfigs),\r\n  );\r\n}\r\n\r\nexport { jsdoc };\r\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeperfect/eslint-config",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A shareable flat ESLint config for TypeScript repositories",
   "keywords": [
     "eslint",

package/dist/index-spec-helpers.d.ts

@@ -1,44 +0,0 @@
-/** List of supported plugin names used in config tests. */
-declare const allPlugins: ["eslint", "resolver", "typescript", "boundaries", "import-x", "comments", "jsdoc", "jasmine", "jest", "playwright", "vitest", "rxjs-x", "perfectionist", "prettier", "stylistic", "unicorn"];
-/**
- * Mock all plugin loaders to return empty configurations.
- * @example
- * ```typescript
- * mockAllEmpty();
- * ```
- */
-declare function mockAllEmpty(): void;
-/**
- * Mock all plugin loaders to return small sample configurations.
- * @example
- * ```typescript
- * mockAllEnabled();
- * ```
- */
-declare function mockAllEnabled(): void;
-/**
- * Mock architecture loaders so `boundaries` only activates with repository input.
- * @example
- * ```typescript
- * mockBoundariesAware();
- * ```
- */
-declare function mockBoundariesAware(): void;
-/**
- * Mock non-core plugin loaders to return empty configs.
- * @example
- * ```typescript
- * mockNonCoreEmpty();
- * ```
- */
-declare function mockNonCoreEmpty(): void;
-/**
- * Mock a config composition where required loaders succeed and one optional loader fails.
- * @example
- * ```typescript
- * mockOptionalResolverFailure();
- * ```
- */
-declare function mockOptionalResolverFailure(): void;
-export { allPlugins, mockAllEmpty, mockAllEnabled, mockBoundariesAware, mockNonCoreEmpty, mockOptionalResolverFailure, };
-//# sourceMappingURL=index-spec-helpers.d.ts.map

package/dist/index-spec-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-spec-helpers.d.ts","sourceRoot":"","sources":["../src/index-spec-helpers.ts"],"names":[],"mappings":"AAOA,2DAA2D;AAC3D,QAAA,MAAM,UAAU,+LAiBiB,CAAC;AAElC;;;;;;GAMG;AACH,iBAAS,YAAY,IAAI,IAAI,CAuB5B;AAED;;;;;;GAMG;AACH,iBAAS,cAAc,IAAI,IAAI,CAuB9B;AAED;;;;;;GAMG;AACH,iBAAS,mBAAmB,IAAI,IAAI,CAwBnC;AAED;;;;;;GAMG;AACH,iBAAS,gBAAgB,IAAI,IAAI,CAyBhC;AAED;;;;;;GAMG;AACH,iBAAS,2BAA2B,IAAI,IAAI,CA2B3C;AAED,OAAO,EACL,UAAU,EACV,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,2BAA2B,GAC5B,CAAC"}

package/dist/index-spec-helpers.js

@@ -1,175 +0,0 @@
-import { vi } from "vitest";
-/** List of supported plugin names used in config tests. */
-const allPlugins = [
-    "eslint",
-    "resolver",
-    "typescript",
-    "boundaries",
-    "import-x",
-    "comments",
-    "jsdoc",
-    "jasmine",
-    "jest",
-    "playwright",
-    "vitest",
-    "rxjs-x",
-    "perfectionist",
-    "prettier",
-    "stylistic",
-    "unicorn",
-];
-/**
- * Mock all plugin loaders to return empty configurations.
- * @example
- * ```typescript
- * mockAllEmpty();
- * ```
- */
-function mockAllEmpty() {
-    vi.doMock("./configs", () => ({
-        boundaries: () => [],
-        comments: () => [],
-        eslint: () => [],
-        importX: () => [],
-        jasmine: () => [],
-        jest: () => [],
-        jsdoc: () => [],
-        perfectionist: () => [],
-        playwright: () => [],
-        prettier: () => [],
-        resolver: () => [],
-        rxjsX: () => [],
-        stylistic: () => [],
-        typescript: () => [],
-        unicorn: async () => {
-            const configs = await Promise.resolve([]);
-            return configs;
-        },
-        vitest: () => [],
-    }));
-}
-/**
- * Mock all plugin loaders to return small sample configurations.
- * @example
- * ```typescript
- * mockAllEnabled();
- * ```
- */
-function mockAllEnabled() {
-    vi.doMock("./configs", () => ({
-        boundaries: () => [{ name: "architecture-boundaries" }],
-        comments: () => [{ name: "docs-comments" }],
-        eslint: () => [{ name: "core-eslint" }],
-        importX: () => [{ name: "architecture-import-x" }],
-        jasmine: () => [{ name: "testing-jasmine" }],
-        jest: () => [{ name: "testing-jest" }],
-        jsdoc: () => [{ name: "docs-jsdoc" }],
-        perfectionist: () => [{ name: "style-perfectionist" }],
-        playwright: () => [{ name: "testing-playwright" }],
-        prettier: () => [{ name: "style-prettier" }],
-        resolver: () => [{ name: "core-resolver" }],
-        rxjsX: () => [{ name: "domain-rxjs" }],
-        stylistic: () => [{ name: "style-stylistic" }],
-        typescript: () => [{ name: "core-typescript" }],
-        unicorn: async () => {
-            const configs = await Promise.resolve([{ name: "style-unicorn" }]);
-            return configs;
-        },
-        vitest: () => [{ name: "testing-vitest" }],
-    }));
-}
-/**
- * Mock architecture loaders so `boundaries` only activates with repository input.
- * @example
- * ```typescript
- * mockBoundariesAware();
- * ```
- */
-function mockBoundariesAware() {
-    vi.doMock("./configs", () => ({
-        boundaries: (boundaries) => boundaries === void 0 ? [] : [{ name: "architecture-boundaries" }],
-        comments: () => [{ name: "docs-comments" }],
-        eslint: () => [{ name: "core-eslint" }],
-        importX: () => [{ name: "architecture-import-x" }],
-        jasmine: () => [{ name: "testing-jasmine" }],
-        jest: () => [{ name: "testing-jest" }],
-        jsdoc: () => [{ name: "docs-jsdoc" }],
-        perfectionist: () => [{ name: "style-perfectionist" }],
-        playwright: () => [{ name: "testing-playwright" }],
-        prettier: () => [{ name: "style-prettier" }],
-        resolver: () => [{ name: "core-resolver" }],
-        rxjsX: () => [{ name: "domain-rxjs" }],
-        stylistic: () => [{ name: "style-stylistic" }],
-        typescript: () => [{ name: "core-typescript" }],
-        unicorn: async () => {
-            const configs = await Promise.resolve([{ name: "style-unicorn" }]);
-            return configs;
-        },
-        vitest: () => [{ name: "testing-vitest" }],
-    }));
-}
-/**
- * Mock non-core plugin loaders to return empty configs.
- * @example
- * ```typescript
- * mockNonCoreEmpty();
- * ```
- */
-function mockNonCoreEmpty() {
-    vi.doMock("./configs", async () => {
-        const actual = await vi.importActual("./configs");
-        return {
-            ...actual,
-            boundaries: () => [],
-            comments: () => [],
-            importX: () => [],
-            jasmine: () => [],
-            jest: () => [],
-            jsdoc: () => [],
-            perfectionist: () => [],
-            playwright: () => [],
-            prettier: () => [],
-            rxjsX: () => [],
-            stylistic: () => [],
-            unicorn: async () => {
-                const configs = await Promise.resolve([]);
-                return configs;
-            },
-            vitest: () => [],
-        };
-    });
-}
-/**
- * Mock a config composition where required loaders succeed and one optional loader fails.
- * @example
- * ```typescript
- * mockOptionalResolverFailure();
- * ```
- */
-function mockOptionalResolverFailure() {
-    vi.doMock("./configs", () => {
-        return {
-            boundaries: () => [],
-            comments: () => [],
-            eslint: () => [{ name: "core-eslint" }],
-            importX: () => [],
-            jasmine: () => [],
-            jest: () => [],
-            jsdoc: () => [],
-            perfectionist: () => [],
-            playwright: () => [],
-            prettier: () => [],
-            resolver: async () => {
-                await Promise.resolve();
-                throw new Error("Cannot find module 'eslint-import-resolver-typescript'");
-            },
-            rxjsX: () => [],
-            stylistic: () => [],
-            typescript: () => [{ name: "core-typescript" }],
-            unicorn: () => [],
-            vitest: () => [],
-        };
-    });
-}
-export { allPlugins, mockAllEmpty, mockAllEnabled, mockBoundariesAware, mockNonCoreEmpty, mockOptionalResolverFailure, };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index-spec-helpers.js","sourceRoot":"","sources":["../src/index-spec-helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAK5B,2DAA2D;AAC3D,MAAM,UAAU,GAAG;IACjB,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,YAAY;IACZ,UAAU;IACV,UAAU;IACV,OAAO;IACP,SAAS;IACT,MAAM;IACN,YAAY;IACZ,QAAQ;IACR,QAAQ;IACR,eAAe;IACf,UAAU;IACV,WAAW;IACX,SAAS;CACsB,CAAC;AAElC;;;;;;GAMG;AACH,SAAS,YAAY;IACnB,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC;QAC5B,UAAU,EAAE,GAAoB,EAAE,CAAC,EAAE;QACrC,QAAQ,EAAE,GAAoB,EAAE,CAAC,EAAE;QACnC,MAAM,EAAE,GAAoB,EAAE,CAAC,EAAE;QACjC,OAAO,EAAE,GAAoB,EAAE,CAAC,EAAE;QAClC,OAAO,EAAE,GAAoB,EAAE,CAAC,EAAE;QAClC,IAAI,EAAE,GAAoB,EAAE,CAAC,EAAE;QAC/B,KAAK,EAAE,GAAoB,EAAE,CAAC,EAAE;QAChC,aAAa,EAAE,GAAoB,EAAE,CAAC,EAAE;QACxC,UAAU,EAAE,GAAoB,EAAE,CAAC,EAAE;QACrC,QAAQ,EAAE,GAAoB,EAAE,CAAC,EAAE;QACnC,QAAQ,EAAE,GAAoB,EAAE,CAAC,EAAE;QACnC,KAAK,EAAE,GAAoB,EAAE,CAAC,EAAE;QAChC,SAAS,EAAE,GAAoB,EAAE,CAAC,EAAE;QACpC,UAAU,EAAE,GAAoB,EAAE,CAAC,EAAE;QACrC,OAAO,EAAE,KAAK,IAA8B,EAAE;YAC5C,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,EAAqB,CAAC,CAAC;YAE7D,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,MAAM,EAAE,GAAoB,EAAE,CAAC,EAAE;KAClC,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;;;GAMG;AACH,SAAS,cAAc;IACrB,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC;QAC5B,UAAU,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,yBAAyB,EAAE,CAAC;QACxE,QAAQ,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;QAC5D,MAAM,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;QACxD,OAAO,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC;QACnE,OAAO,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QAC7D,IAAI,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;QACvD,KAAK,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;QACtD,aAAa,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC;QACvE,UAAU,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC;QACnE,QAAQ,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;QAC7D,QAAQ,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;QAC5D,KAAK,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;QACvD,SAAS,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QAC/D,UAAU,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QAChE,OAAO,EAAE,KAAK,IAA8B,EAAE;YAC5C,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC;YAEnE,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,MAAM,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;KAC5D,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;;;GAMG;AACH,SAAS,mBAAmB;IAC1B,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC;QAC5B,UAAU,EAAE,CAAC,UAAmB,EAAmB,EAAE,CACnD,UAAU,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,yBAAyB,EAAE,CAAC;QACpE,QAAQ,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;QAC5D,MAAM,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;QACxD,OAAO,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC;QACnE,OAAO,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QAC7D,IAAI,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;QACvD,KAAK,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;QACtD,aAAa,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC;QACvE,UAAU,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC;QACnE,QAAQ,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;QAC7D,QAAQ,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;QAC5D,KAAK,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;QACvD,SAAS,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QAC/D,UAAU,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QAChE,OAAO,EAAE,KAAK,IAA8B,EAAE;YAC5C,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC;YAEnE,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,MAAM,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;KAC5D,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;;;GAMG;AACH,SAAS,gBAAgB;IACvB,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,IAAI,EAAE;QAChC,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,YAAY,CAAuB,WAAW,CAAC,CAAC;QAExE,OAAO;YACL,GAAG,MAAM;YACT,UAAU,EAAE,GAAoB,EAAE,CAAC,EAAE;YACrC,QAAQ,EAAE,GAAoB,EAAE,CAAC,EAAE;YACnC,OAAO,EAAE,GAAoB,EAAE,CAAC,EAAE;YAClC,OAAO,EAAE,GAAoB,EAAE,CAAC,EAAE;YAClC,IAAI,EAAE,GAAoB,EAAE,CAAC,EAAE;YAC/B,KAAK,EAAE,GAAoB,EAAE,CAAC,EAAE;YAChC,aAAa,EAAE,GAAoB,EAAE,CAAC,EAAE;YACxC,UAAU,EAAE,GAAoB,EAAE,CAAC,EAAE;YACrC,QAAQ,EAAE,GAAoB,EAAE,CAAC,EAAE;YACnC,KAAK,EAAE,GAAoB,EAAE,CAAC,EAAE;YAChC,SAAS,EAAE,GAAoB,EAAE,CAAC,EAAE;YACpC,OAAO,EAAE,KAAK,IAA8B,EAAE;gBAC5C,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,EAAqB,CAAC,CAAC;gBAE7D,OAAO,OAAO,CAAC;YACjB,CAAC;YACD,MAAM,EAAE,GAAoB,EAAE,CAAC,EAAE;SAClC,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,SAAS,2BAA2B;IAClC,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,GAAG,EAAE;QAC1B,OAAO;YACL,UAAU,EAAE,GAAoB,EAAE,CAAC,EAAE;YACrC,QAAQ,EAAE,GAAoB,EAAE,CAAC,EAAE;YACnC,MAAM,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;YACxD,OAAO,EAAE,GAAoB,EAAE,CAAC,EAAE;YAClC,OAAO,EAAE,GAAoB,EAAE,CAAC,EAAE;YAClC,IAAI,EAAE,GAAoB,EAAE,CAAC,EAAE;YAC/B,KAAK,EAAE,GAAoB,EAAE,CAAC,EAAE;YAChC,aAAa,EAAE,GAAoB,EAAE,CAAC,EAAE;YACxC,UAAU,EAAE,GAAoB,EAAE,CAAC,EAAE;YACrC,QAAQ,EAAE,GAAoB,EAAE,CAAC,EAAE;YACnC,QAAQ,EAAE,KAAK,IAA8B,EAAE;gBAC7C,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;gBAExB,MAAM,IAAI,KAAK,CACb,wDAAwD,CACzD,CAAC;YACJ,CAAC;YACD,KAAK,EAAE,GAAoB,EAAE,CAAC,EAAE;YAChC,SAAS,EAAE,GAAoB,EAAE,CAAC,EAAE;YACpC,UAAU,EAAE,GAAoB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;YAChE,OAAO,EAAE,GAAoB,EAAE,CAAC,EAAE;YAClC,MAAM,EAAE,GAAoB,EAAE,CAAC,EAAE;SAClC,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED,OAAO,EACL,UAAU,EACV,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,2BAA2B,GAC5B,CAAC","sourcesContent":["import type { Linter } from \"eslint\";\n\nimport { vi } from \"vitest\";\n\nimport type * as ConfigsModule from \"./configs\";\nimport type { PluginName } from \"./types\";\n\n/** List of supported plugin names used in config tests. */\nconst allPlugins = [\n  \"eslint\",\n  \"resolver\",\n  \"typescript\",\n  \"boundaries\",\n  \"import-x\",\n  \"comments\",\n  \"jsdoc\",\n  \"jasmine\",\n  \"jest\",\n  \"playwright\",\n  \"vitest\",\n  \"rxjs-x\",\n  \"perfectionist\",\n  \"prettier\",\n  \"stylistic\",\n  \"unicorn\",\n] as const satisfies PluginName[];\n\n/**\n * Mock all plugin loaders to return empty configurations.\n * @example\n * ```typescript\n * mockAllEmpty();\n * ```\n */\nfunction mockAllEmpty(): void {\n  vi.doMock(\"./configs\", () => ({\n    boundaries: (): Linter.Config[] => [],\n    comments: (): Linter.Config[] => [],\n    eslint: (): Linter.Config[] => [],\n    importX: (): Linter.Config[] => [],\n    jasmine: (): Linter.Config[] => [],\n    jest: (): Linter.Config[] => [],\n    jsdoc: (): Linter.Config[] => [],\n    perfectionist: (): Linter.Config[] => [],\n    playwright: (): Linter.Config[] => [],\n    prettier: (): Linter.Config[] => [],\n    resolver: (): Linter.Config[] => [],\n    rxjsX: (): Linter.Config[] => [],\n    stylistic: (): Linter.Config[] => [],\n    typescript: (): Linter.Config[] => [],\n    unicorn: async (): Promise<Linter.Config[]> => {\n      const configs = await Promise.resolve([] as Linter.Config[]);\n\n      return configs;\n    },\n    vitest: (): Linter.Config[] => [],\n  }));\n}\n\n/**\n * Mock all plugin loaders to return small sample configurations.\n * @example\n * ```typescript\n * mockAllEnabled();\n * ```\n */\nfunction mockAllEnabled(): void {\n  vi.doMock(\"./configs\", () => ({\n    boundaries: (): Linter.Config[] => [{ name: \"architecture-boundaries\" }],\n    comments: (): Linter.Config[] => [{ name: \"docs-comments\" }],\n    eslint: (): Linter.Config[] => [{ name: \"core-eslint\" }],\n    importX: (): Linter.Config[] => [{ name: \"architecture-import-x\" }],\n    jasmine: (): Linter.Config[] => [{ name: \"testing-jasmine\" }],\n    jest: (): Linter.Config[] => [{ name: \"testing-jest\" }],\n    jsdoc: (): Linter.Config[] => [{ name: \"docs-jsdoc\" }],\n    perfectionist: (): Linter.Config[] => [{ name: \"style-perfectionist\" }],\n    playwright: (): Linter.Config[] => [{ name: \"testing-playwright\" }],\n    prettier: (): Linter.Config[] => [{ name: \"style-prettier\" }],\n    resolver: (): Linter.Config[] => [{ name: \"core-resolver\" }],\n    rxjsX: (): Linter.Config[] => [{ name: \"domain-rxjs\" }],\n    stylistic: (): Linter.Config[] => [{ name: \"style-stylistic\" }],\n    typescript: (): Linter.Config[] => [{ name: \"core-typescript\" }],\n    unicorn: async (): Promise<Linter.Config[]> => {\n      const configs = await Promise.resolve([{ name: \"style-unicorn\" }]);\n\n      return configs;\n    },\n    vitest: (): Linter.Config[] => [{ name: \"testing-vitest\" }],\n  }));\n}\n\n/**\n * Mock architecture loaders so `boundaries` only activates with repository input.\n * @example\n * ```typescript\n * mockBoundariesAware();\n * ```\n */\nfunction mockBoundariesAware(): void {\n  vi.doMock(\"./configs\", () => ({\n    boundaries: (boundaries: unknown): Linter.Config[] =>\n      boundaries === void 0 ? [] : [{ name: \"architecture-boundaries\" }],\n    comments: (): Linter.Config[] => [{ name: \"docs-comments\" }],\n    eslint: (): Linter.Config[] => [{ name: \"core-eslint\" }],\n    importX: (): Linter.Config[] => [{ name: \"architecture-import-x\" }],\n    jasmine: (): Linter.Config[] => [{ name: \"testing-jasmine\" }],\n    jest: (): Linter.Config[] => [{ name: \"testing-jest\" }],\n    jsdoc: (): Linter.Config[] => [{ name: \"docs-jsdoc\" }],\n    perfectionist: (): Linter.Config[] => [{ name: \"style-perfectionist\" }],\n    playwright: (): Linter.Config[] => [{ name: \"testing-playwright\" }],\n    prettier: (): Linter.Config[] => [{ name: \"style-prettier\" }],\n    resolver: (): Linter.Config[] => [{ name: \"core-resolver\" }],\n    rxjsX: (): Linter.Config[] => [{ name: \"domain-rxjs\" }],\n    stylistic: (): Linter.Config[] => [{ name: \"style-stylistic\" }],\n    typescript: (): Linter.Config[] => [{ name: \"core-typescript\" }],\n    unicorn: async (): Promise<Linter.Config[]> => {\n      const configs = await Promise.resolve([{ name: \"style-unicorn\" }]);\n\n      return configs;\n    },\n    vitest: (): Linter.Config[] => [{ name: \"testing-vitest\" }],\n  }));\n}\n\n/**\n * Mock non-core plugin loaders to return empty configs.\n * @example\n * ```typescript\n * mockNonCoreEmpty();\n * ```\n */\nfunction mockNonCoreEmpty(): void {\n  vi.doMock(\"./configs\", async () => {\n    const actual = await vi.importActual<typeof ConfigsModule>(\"./configs\");\n\n    return {\n      ...actual,\n      boundaries: (): Linter.Config[] => [],\n      comments: (): Linter.Config[] => [],\n      importX: (): Linter.Config[] => [],\n      jasmine: (): Linter.Config[] => [],\n      jest: (): Linter.Config[] => [],\n      jsdoc: (): Linter.Config[] => [],\n      perfectionist: (): Linter.Config[] => [],\n      playwright: (): Linter.Config[] => [],\n      prettier: (): Linter.Config[] => [],\n      rxjsX: (): Linter.Config[] => [],\n      stylistic: (): Linter.Config[] => [],\n      unicorn: async (): Promise<Linter.Config[]> => {\n        const configs = await Promise.resolve([] as Linter.Config[]);\n\n        return configs;\n      },\n      vitest: (): Linter.Config[] => [],\n    };\n  });\n}\n\n/**\n * Mock a config composition where required loaders succeed and one optional loader fails.\n * @example\n * ```typescript\n * mockOptionalResolverFailure();\n * ```\n */\nfunction mockOptionalResolverFailure(): void {\n  vi.doMock(\"./configs\", () => {\n    return {\n      boundaries: (): Linter.Config[] => [],\n      comments: (): Linter.Config[] => [],\n      eslint: (): Linter.Config[] => [{ name: \"core-eslint\" }],\n      importX: (): Linter.Config[] => [],\n      jasmine: (): Linter.Config[] => [],\n      jest: (): Linter.Config[] => [],\n      jsdoc: (): Linter.Config[] => [],\n      perfectionist: (): Linter.Config[] => [],\n      playwright: (): Linter.Config[] => [],\n      prettier: (): Linter.Config[] => [],\n      resolver: async (): Promise<Linter.Config[]> => {\n        await Promise.resolve();\n\n        throw new Error(\n          \"Cannot find module 'eslint-import-resolver-typescript'\",\n        );\n      },\n      rxjsX: (): Linter.Config[] => [],\n      stylistic: (): Linter.Config[] => [],\n      typescript: (): Linter.Config[] => [{ name: \"core-typescript\" }],\n      unicorn: (): Linter.Config[] => [],\n      vitest: (): Linter.Config[] => [],\n    };\n  });\n}\n\nexport {\n  allPlugins,\n  mockAllEmpty,\n  mockAllEnabled,\n  mockBoundariesAware,\n  mockNonCoreEmpty,\n  mockOptionalResolverFailure,\n};\n"]}