# core/producers/eslint.producer.ts

> 154 lines of code and 35 definitions.

Tree: GovLab Quality
Language: typescript
Layer: application
Canonical: https://banes-lab.com/anatomy/quality#file-quality-core-producers-eslint-producer-ts
Source text: https://banes-lab.com/source/quality/core/producers/eslint.producer.ts.txt

Listed in [core/producers](https://banes-lab.com/api/source/quality/core/producers.md), before [core/producers/quality.producer.ts](https://banes-lab.com/source/quality/core/producers/quality.producer.ts.md).

## Definitions

- `orNull` (lexical_declaration, line 23)
- `count` (lexical_declaration, line 71)
- `manifestVersion` (lexical_declaration, line 11)
- `isRuleMap` (lexical_declaration, line 27)
- `replacedByOf` (lexical_declaration, line 41)
- `builtinRow` (lexical_declaration, line 47)
- `builtinProduct` (lexical_declaration, line 75)
- `builtinRules` (lexical_declaration, line 31)
- `metaOf` (lexical_declaration, line 37)
- `loadPlugin` (lexical_declaration, line 99)
- `BUILTIN_RULES_MODULE` (lexical_declaration, line 7)
- `ESLINT_MANIFEST` (lexical_declaration, line 8)
- `UNKNOWN` (lexical_declaration, line 9)
- `manifest` (lexical_declaration, line 13)
- `PLUGINS` (lexical_declaration, line 17)
- `rules` (lexical_declaration, line 33)
- `{ deprecated }` (lexical_declaration, line 42)
- `replaced` (lexical_declaration, line 43)
- `deprecated` (lexical_declaration, line 50)
- `type` (lexical_declaration, line 51)
- `eslintVersion` (lexical_declaration, line 76)
- `byType` (lexical_declaration, line 78)
- `key` (lexical_declaration, line 80)
- `plugin` (lexical_declaration, line 101)
- `pluginProduct` (lexical_declaration, line 105)
- `loaded` (lexical_declaration, line 106)
- `rows` (lexical_declaration, line 107)
- `meta` (lexical_declaration, line 109)
- `docs` (lexical_declaration, line 110)
- `plugins` (lexical_declaration, line 126)
- `integerKnob` (lexical_declaration, line 136)
- `stack` (lexical_declaration, line 137)
- `node` (lexical_declaration, line 139)
- `properties` (lexical_declaration, line 144)
- `knob` (lexical_declaration, line 161)

## Contained in

- [core/producers](https://banes-lab.com/anatomy/quality/folder-quality-core-producers.md)

## Uses

- [core/selectors/record.selector.ts](https://banes-lab.com/source/quality/core/selectors/record.selector.ts.md)

## Linked from

- [core/producers](https://banes-lab.com/anatomy/quality/folder-quality-core-producers.md)
- [core/selectors](https://banes-lab.com/anatomy/quality/folder-quality-core-selectors.md)

## Source

```typescript
import type { CatalogProduct, CatalogRule, KnobEntry } from "#types/catalog.types";
import { isRecord, recordAt, stringField } from "#core/selectors/record.selector";
import { INTEGER_TYPE } from "#configuration/constants/knob.constants";
import { byRuleId } from "#core/comparators/rule.comparator";
import { defineProducer } from "#core/registries/producer.registry";

const BUILTIN_RULES_MODULE = "eslint/use-at-your-own-risk";
const ESLINT_MANIFEST = "eslint/package.json";
const UNKNOWN = "unknown";

const manifestVersion = async function manifestVersion(specifier: string): Promise<string> {
    const loaded: unknown = await import(specifier, { with: { type: "json" } });
    const manifest = isRecord(loaded) && isRecord(loaded["default"]) ? loaded["default"] : {};
    return stringField(manifest, "version", UNKNOWN);
};

const PLUGINS = [
    { ecosystem: "json", pkg: "eslint-plugin-jsonc", prefix: "jsonc" },
    { ecosystem: "javascript", pkg: "eslint-plugin-unused-imports", prefix: "unused-imports" },
    { ecosystem: "html", pkg: "eslint-plugin-html", prefix: "html" },
];

const orNull = function orNull(value: string): string | null {
    return value === "" ? null : value;
};

const isRuleMap = function isRuleMap(value: unknown): value is Map<string, unknown> {
    return value instanceof Map;
};

const builtinRules = async function builtinRules(): Promise<Map<string, unknown>> {
    const loaded: unknown = await import(BUILTIN_RULES_MODULE);
    const rules = isRecord(loaded) ? loaded["builtinRules"] : null;
    return isRuleMap(rules) ? rules : new Map();
};

const metaOf = function metaOf(rule: unknown): Record<string, unknown> {
    return isRecord(rule) ? recordAt(rule, "meta") : {};
};

const replacedByOf = function replacedByOf(meta: Record<string, unknown>): unknown {
    const { deprecated } = meta;
    const replaced = isRecord(deprecated) ? deprecated["replacedBy"] : undefined;
    return replaced ?? meta["replacedBy"] ?? null;
};

const builtinRow = function builtinRow(ruleId: string, rule: unknown, eslintVersion: string): CatalogRule {
    const meta = metaOf(rule);
    const docs = recordAt(meta, "docs");
    const deprecated = Boolean(meta["deprecated"]);
    const type = orNull(stringField(meta, "type"));
    return {
        canonical: null,
        category: deprecated ? "deprecated" : (type ?? "uncategorized"),
        deprecated,
        description: orNull(stringField(docs, "description")),
        ecosystem: "javascript",
        fixable: orNull(stringField(meta, "fixable")),
        hasSuggestions: Boolean(meta["hasSuggestions"]),
        name: ruleId,
        recommended: Boolean(docs["recommended"]),
        replacedBy: replacedByOf(meta),
        ruleId,
        tool: "eslint",
        toolVersion: eslintVersion,
        type,
        url: orNull(stringField(docs, "url")),
    };
};

const count = function count(rules: readonly CatalogRule[], key: string): number {
    return rules.filter((rule) => Boolean(rule[key])).length;
};

const builtinProduct = async function builtinProduct(rules: Map<string, unknown>): Promise<CatalogProduct> {
    const eslintVersion = await manifestVersion(ESLINT_MANIFEST);
    const rows = [...rules].map(([ruleId, rule]) => builtinRow(ruleId, rule, eslintVersion)).toSorted(byRuleId);
    const byType: Record<string, number> = {};
    for (const row of rows) {
        const key = typeof row["type"] === "string" ? row["type"] : "none";
        byType[key] = (byType[key] ?? 0) + 1;
    }
    return {
        rules: rows,
        source: "eslint",
        summary: {
            byType,
            deprecated: count(rows, "deprecated"),
            fixable: rows.filter((row) => row["fixable"] !== null).length,
            hasSuggestions: count(rows, "hasSuggestions"),
            recommended: count(rows, "recommended"),
            tool: "eslint",
            toolVersion: eslintVersion,
            total: rows.length,
        },
    };
};

const loadPlugin = async function loadPlugin(pkg: string): Promise<{ plugin: unknown; version: string }> {
    const loaded: unknown = await import(pkg);
    const plugin = isRecord(loaded) && isRecord(loaded["default"]) ? loaded["default"] : loaded;
    return { plugin, version: await manifestVersion(`${pkg}/package.json`) };
};

const pluginProduct = async function pluginProduct(): Promise<CatalogProduct> {
    const loaded = await Promise.all(PLUGINS.map(async (entry) => ({ ...entry, ...(await loadPlugin(entry.pkg)) })));
    const rows = loaded.flatMap(({ ecosystem, plugin, prefix, version }) =>
        Object.entries(isRecord(plugin) ? recordAt(plugin, "rules") : {}).map(([name, rule]): CatalogRule => {
            const meta = metaOf(rule);
            const docs = recordAt(meta, "docs");
            return {
                canonical: null,
                category: orNull(stringField(docs, "category")) ?? orNull(stringField(meta, "type")) ?? "plugin",
                deprecated: meta["deprecated"] === true,
                description: orNull(stringField(docs, "description")),
                ecosystem,
                fixable: orNull(stringField(meta, "fixable")),
                name,
                ruleId: `${prefix}/${name}`,
                tool: prefix,
                toolVersion: version,
                url: orNull(stringField(docs, "url")),
            };
        }),
    );
    const plugins = loaded
        .map(({ pkg, prefix }) => ({ count: rows.filter((row) => row["tool"] === prefix).length, pkg, prefix }))
        .filter((entry) => entry.count > 0);
    return {
        rules: rows.toSorted(byRuleId),
        source: "eslint-plugins",
        summary: { plugins, tool: "eslint-plugins", total: rows.length },
    };
};

const integerKnob = function integerKnob(schema: unknown): string | null {
    const stack: unknown[] = [schema];
    while (stack.length > 0) {
        const node = stack.pop();
        if (Array.isArray(node)) {
            stack.push(...node.map((item: unknown) => item));
            continue;
        }
        const properties = isRecord(node) ? recordAt(node, "properties") : {};
        const knob = Object.entries(properties).find(
            ([, spec]) => isRecord(spec) && spec["type"] === INTEGER_TYPE,
        )?.[0];
        if (knob !== undefined) {
            return knob;
        }
        if (isRecord(node)) {
            stack.push(...Object.values(node));
        }
    }
    return null;
};

defineProducer({
    knobs: async (): Promise<KnobEntry[]> =>
        [...(await builtinRules())].flatMap(([ruleId, rule]): KnobEntry[] => {
            const knob = integerKnob(metaOf(rule)["schema"]);
            return knob === null
                ? []
                : [["eslint", ruleId, { default: null, knob, threshold: true, type: INTEGER_TYPE }]];
        }),
    name: "eslint",
    produce: async () => [await builtinProduct(await builtinRules()), await pluginProduct()],
    refresh: "manual",
});
```