@codeperfect/eslint-config 1.0.0

package/dist/index-spec-helpers.js

@@ -0,0 +1,175 @@
+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":"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","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"]}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { Linter } from "eslint";
+import type { ConfigOptions } from "./types";
+/**
+ * Creates the ESLint configuration with optional plugin and rule customization.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * config();
+ * ```
+ */
+declare function config(options?: ConfigOptions): Promise<Linter.Config[]>;
+export { config };
+export type { BoundariesConfig, ConfigOptions } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AA2C7C;;;;;;;;GAQG;AACH,iBAAe,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAc3E;AAED,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,42 @@
+import { defineConfig } from "eslint/config";
+import { moduleTaxonomy } from "./module-taxonomy";
+import { pluginLoaders } from "./plugin-loaders";
+import { applyRuleOverrides, collectAvailablePlugins, isPluginDisabled, loadPluginConfig, } from "./utilities";
+/**
+ * Builds the list of plugin config loaders.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * buildPluginConfigLoaders({});
+ * ```
+ */
+function buildPluginConfigLoaders(options) {
+    const disabledPlugins = [...(options.disabledPlugins ?? [])];
+    const loaders = [];
+    for (const { pluginName } of moduleTaxonomy) {
+        const loaderEntry = pluginLoaders[pluginName];
+        if (!isPluginDisabled(pluginName, disabledPlugins)) {
+            loaders.push(loadPluginConfig(pluginName, loaderEntry.loader(options), loaderEntry.mode));
+        }
+    }
+    return loaders;
+}
+/**
+ * Creates the ESLint configuration with optional plugin and rule customization.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * config();
+ * ```
+ */
+async function config(options = {}) {
+    const { rules: ruleOverrides } = options;
+    const pluginConfigResults = await Promise.all(buildPluginConfigLoaders(options));
+    const pluginConfigs = pluginConfigResults.flat();
+    const finalConfig = applyRuleOverrides(pluginConfigs, ruleOverrides, collectAvailablePlugins(pluginConfigs));
+    return finalConfig.length === 0 ? [] : defineConfig(...finalConfig);
+}
+export { config };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/module-taxonomy.d.ts

@@ -0,0 +1,63 @@
+import type { PluginName } from "./types";
+/** Taxonomy categories for config modules. */
+type ModuleCategory = "architecture" | "core" | "documentation" | "domain" | "repository-architecture" | "style" | "testing";
+/** Entry describing a documented config module. */
+interface ModuleTaxonomyEntry {
+    /** Category owning the module. */
+    category: ModuleCategory;
+    /** Public module name used in config options and diagnostics. */
+    pluginName: PluginName;
+}
+/** Ordered module taxonomy matching RFC-0003. */
+declare const moduleTaxonomy: readonly [{
+    readonly category: "core";
+    readonly pluginName: "eslint";
+}, {
+    readonly category: "core";
+    readonly pluginName: "resolver";
+}, {
+    readonly category: "core";
+    readonly pluginName: "typescript";
+}, {
+    readonly category: "architecture";
+    readonly pluginName: "import-x";
+}, {
+    readonly category: "documentation";
+    readonly pluginName: "comments";
+}, {
+    readonly category: "documentation";
+    readonly pluginName: "jsdoc";
+}, {
+    readonly category: "testing";
+    readonly pluginName: "jasmine";
+}, {
+    readonly category: "testing";
+    readonly pluginName: "jest";
+}, {
+    readonly category: "testing";
+    readonly pluginName: "playwright";
+}, {
+    readonly category: "testing";
+    readonly pluginName: "vitest";
+}, {
+    readonly category: "domain";
+    readonly pluginName: "rxjs-x";
+}, {
+    readonly category: "style";
+    readonly pluginName: "stylistic";
+}, {
+    readonly category: "style";
+    readonly pluginName: "perfectionist";
+}, {
+    readonly category: "style";
+    readonly pluginName: "unicorn";
+}, {
+    readonly category: "style";
+    readonly pluginName: "prettier";
+}, {
+    readonly category: "repository-architecture";
+    readonly pluginName: "boundaries";
+}];
+export { moduleTaxonomy };
+export type { ModuleCategory, ModuleTaxonomyEntry };
+//# sourceMappingURL=module-taxonomy.d.ts.map

package/dist/module-taxonomy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-taxonomy.d.ts","sourceRoot":"","sources":["../src/module-taxonomy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,8CAA8C;AAC9C,KAAK,cAAc,GACf,cAAc,GACd,MAAM,GACN,eAAe,GACf,QAAQ,GACR,yBAAyB,GACzB,OAAO,GACP,SAAS,CAAC;AAEd,mDAAmD;AACnD,UAAU,mBAAmB;IAC3B,kCAAkC;IAClC,QAAQ,EAAE,cAAc,CAAC;IAEzB,iEAAiE;IACjE,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,iDAAiD;AACjD,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB+B,CAAC;AAEpD,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/module-taxonomy.js

@@ -0,0 +1,21 @@
+/** Ordered module taxonomy matching RFC-0003. */
+const moduleTaxonomy = [
+    { category: "core", pluginName: "eslint" },
+    { category: "core", pluginName: "resolver" },
+    { category: "core", pluginName: "typescript" },
+    { category: "architecture", pluginName: "import-x" },
+    { category: "documentation", pluginName: "comments" },
+    { category: "documentation", pluginName: "jsdoc" },
+    { category: "testing", pluginName: "jasmine" },
+    { category: "testing", pluginName: "jest" },
+    { category: "testing", pluginName: "playwright" },
+    { category: "testing", pluginName: "vitest" },
+    { category: "domain", pluginName: "rxjs-x" },
+    { category: "style", pluginName: "stylistic" },
+    { category: "style", pluginName: "perfectionist" },
+    { category: "style", pluginName: "unicorn" },
+    { category: "style", pluginName: "prettier" },
+    { category: "repository-architecture", pluginName: "boundaries" },
+];
+export { moduleTaxonomy };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/plugin-loaders.d.ts

@@ -0,0 +1,110 @@
+import type { Linter } from "eslint";
+import type { ConfigOptions, PluginName } from "./types";
+import type { LoadMode } from "./utilities";
+/** Loader function for a single config module. */
+type ConfigLoader = () => Linter.Config[] | Promise<Linter.Config[]>;
+/** Entry describing a single config loader in the final composition order. */
+interface PluginLoaderEntry {
+    /** Loader factory for the module. */
+    loader: (options: ConfigOptions) => ConfigLoader;
+    /** Runtime loading mode for the module. */
+    mode: LoadMode;
+    /** Public module name used in config options and diagnostics. */
+    pluginName: PluginName;
+}
+/**
+ * Creates the boundaries loader factory for repository-owned architecture input.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const factory = createBoundariesLoaderFactory({});
+ * ```
+ */
+declare function createBoundariesLoaderFactory(options: ConfigOptions): ConfigLoader;
+/** Documented config loader registry keyed by public module name. */
+declare const pluginLoaders: {
+    boundaries: {
+        loader: typeof createBoundariesLoaderFactory;
+        mode: "optional";
+        pluginName: "boundaries";
+    };
+    comments: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "comments";
+    };
+    eslint: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "required";
+        pluginName: "eslint";
+    };
+    "import-x": {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "import-x";
+    };
+    jasmine: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "jasmine";
+    };
+    jest: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "jest";
+    };
+    jsdoc: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "jsdoc";
+    };
+    perfectionist: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "perfectionist";
+    };
+    playwright: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "playwright";
+    };
+    prettier: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "prettier";
+    };
+    resolver: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "resolver";
+    };
+    "rxjs-x": {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "rxjs-x";
+    };
+    stylistic: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "stylistic";
+    };
+    typescript: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "required";
+        pluginName: "typescript";
+    };
+    unicorn: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "unicorn";
+    };
+    vitest: {
+        loader: (options: ConfigOptions) => ConfigLoader;
+        mode: "optional";
+        pluginName: "vitest";
+    };
+};
+export { pluginLoaders };
+export type { ConfigLoader, PluginLoaderEntry };
+//# sourceMappingURL=plugin-loaders.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-loaders.d.ts","sourceRoot":"","sources":["../src/plugin-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAqB5C,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;;;;CAuHD,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/plugin-loaders.js

@@ -0,0 +1,110 @@
+import { boundaries, comments, eslint, importX, jasmine, jest, jsdoc, perfectionist, playwright, prettier, resolver, rxjsX, stylistic, typescript, unicorn, vitest, } from "./configs";
+/**
+ * Creates the boundaries loader factory for repository-owned architecture input.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const factory = createBoundariesLoaderFactory({});
+ * ```
+ */
+function createBoundariesLoaderFactory(options) {
+    return () => boundaries(options.boundaries);
+}
+/**
+ * Creates a loader factory for modules that do not depend on config options.
+ * @param loader Input loader value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const factory = createStaticLoaderFactory(eslint);
+ * ```
+ */
+function createStaticLoaderFactory(loader) {
+    return () => loader;
+}
+/** Documented config loader registry keyed by public module name. */
+const pluginLoaders = {
+    boundaries: {
+        loader: createBoundariesLoaderFactory,
+        mode: "optional",
+        pluginName: "boundaries",
+    },
+    comments: {
+        loader: createStaticLoaderFactory(comments),
+        mode: "optional",
+        pluginName: "comments",
+    },
+    eslint: {
+        loader: createStaticLoaderFactory(eslint),
+        mode: "required",
+        pluginName: "eslint",
+    },
+    "import-x": {
+        loader: createStaticLoaderFactory(importX),
+        mode: "optional",
+        pluginName: "import-x",
+    },
+    jasmine: {
+        loader: createStaticLoaderFactory(jasmine),
+        mode: "optional",
+        pluginName: "jasmine",
+    },
+    jest: {
+        loader: createStaticLoaderFactory(jest),
+        mode: "optional",
+        pluginName: "jest",
+    },
+    jsdoc: {
+        loader: createStaticLoaderFactory(jsdoc),
+        mode: "optional",
+        pluginName: "jsdoc",
+    },
+    perfectionist: {
+        loader: createStaticLoaderFactory(perfectionist),
+        mode: "optional",
+        pluginName: "perfectionist",
+    },
+    playwright: {
+        loader: createStaticLoaderFactory(playwright),
+        mode: "optional",
+        pluginName: "playwright",
+    },
+    prettier: {
+        loader: createStaticLoaderFactory(prettier),
+        mode: "optional",
+        pluginName: "prettier",
+    },
+    resolver: {
+        loader: createStaticLoaderFactory(resolver),
+        mode: "optional",
+        pluginName: "resolver",
+    },
+    "rxjs-x": {
+        loader: createStaticLoaderFactory(rxjsX),
+        mode: "optional",
+        pluginName: "rxjs-x",
+    },
+    stylistic: {
+        loader: createStaticLoaderFactory(stylistic),
+        mode: "optional",
+        pluginName: "stylistic",
+    },
+    typescript: {
+        loader: createStaticLoaderFactory(typescript),
+        mode: "required",
+        pluginName: "typescript",
+    },
+    unicorn: {
+        loader: createStaticLoaderFactory(unicorn),
+        mode: "optional",
+        pluginName: "unicorn",
+    },
+    vitest: {
+        loader: createStaticLoaderFactory(vitest),
+        mode: "optional",
+        pluginName: "vitest",
+    },
+};
+export { pluginLoaders };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-loaders.js","sourceRoot":"","sources":["../src/plugin-loaders.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Linter } from \"eslint\";\n\nimport type { ConfigOptions, PluginName } from \"./types\";\nimport type { LoadMode } from \"./utilities\";\n\nimport {\n  boundaries,\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  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"]}

package/dist/style/index.d.ts

@@ -0,0 +1,5 @@
+export { perfectionist } from "./perfectionist";
+export { prettier } from "./prettier";
+export { stylistic } from "./stylistic";
+export { unicorn } from "./unicorn";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/style/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC"}

package/dist/style/index.js

@@ -0,0 +1,5 @@
+export { perfectionist } from "./perfectionist";
+export { prettier } from "./prettier";
+export { stylistic } from "./stylistic";
+export { unicorn } from "./unicorn";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDdEMsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUN4QyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgcGVyZmVjdGlvbmlzdCB9IGZyb20gXCIuL3BlcmZlY3Rpb25pc3RcIjtcbmV4cG9ydCB7IHByZXR0aWVyIH0gZnJvbSBcIi4vcHJldHRpZXJcIjtcbmV4cG9ydCB7IHN0eWxpc3RpYyB9IGZyb20gXCIuL3N0eWxpc3RpY1wiO1xuZXhwb3J0IHsgdW5pY29ybiB9IGZyb20gXCIuL3VuaWNvcm5cIjtcbiJdfQ==

package/dist/style/perfectionist.d.ts

@@ -0,0 +1,11 @@
+import type { Linter } from "eslint";
+/**
+ * Build and return the Perfectionist plugin configuration and any overrides.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * await perfectionist();
+ * ```
+ */
+export declare function perfectionist(): Promise<Linter.Config[]>;
+//# sourceMappingURL=perfectionist.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"perfectionist.d.ts","sourceRoot":"","sources":["../../src/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"}