forgebook 0.1.7 → 0.2.0

package/dist/src/vite/autoTitle.d.ts

@@ -25,4 +25,3 @@ export declare const patternBase: (pattern: string) => string;
  * @param file - the file, relative to the same folder as `base`.
  */
 export declare const autoTitle: (base: string, file: string) => string | undefined;
-//# sourceMappingURL=autoTitle.d.ts.map

package/dist/src/vite/autoTitle.js

@@ -41,4 +41,3 @@ export const autoTitle = (base, file) => {
         segments.push(last);
     return segments.length === 0 ? undefined : segments.join("/");
 };
-//# sourceMappingURL=autoTitle.js.map

package/dist/src/vite/axeScript.d.ts

@@ -0,0 +1,20 @@
+import type { AxeAddress } from "./pages.ts";
+/**
+ * How the frame's entry gets axe's address: a `?url` import on a dev server, the build's file under the base in a
+ * build.
+ *
+ * @param command - whether a dev server runs, or a build.
+ * @param packageDir - the core's folder.
+ * @returns the address, or none when axe cannot be found.
+ */
+export declare const axeAddress: (command: "serve" | "build", packageDir: string) => AxeAddress | undefined;
+/**
+ * The file a build writes: axe's script, gzipped.
+ *
+ * @param packageDir - the core's folder.
+ * @returns its name and bytes; none when axe cannot be found.
+ */
+export declare const axeBuildAsset: (packageDir: string) => {
+    readonly fileName: string;
+    readonly source: Buffer;
+} | undefined;

package/dist/src/vite/axeScript.js

@@ -0,0 +1,60 @@
+/**
+ * Where a frame finds axe's script, for the Accessibility card: Vite serves the file on a dev server, and a build
+ * writes it gzipped.
+ *
+ * @remarks
+ * axe is a minified file already, more than half a megabyte, for a card most visits never open. Loaded as a module it
+ * would pass through Vite's pre-bundling on every cold start and through the minifier on every build; loaded as a
+ * script it does neither (`checkStory.ts`). A build keeps it gzipped, since it would otherwise be close to half of what
+ * a static catalogue weighs, and the frame unpacks it when asked.
+ *
+ * @module
+ */
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { gzipSync } from "node:zlib";
+import { codeLiteral } from "../codeLiteral.js";
+import { packageResolver } from "./configFile.js";
+/**
+ * axe's script, in the core's dependencies; none when it cannot be found.
+ *
+ * @param packageDir - the core's folder.
+ */
+const axeScript = (packageDir) => packageResolver(packageDir)("axe-core/axe.min.js");
+/**
+ * A build's compressed copy of axe's script: its name, from its text, so a new version of axe is a new file. `.bin`,
+ * since `.gz` makes some hosts send it with `Content-Encoding: gzip`, which the browser would unpack before the frame.
+ *
+ * @param text - the script's text.
+ */
+const axeBuildFile = (text) => `assets/axe-${createHash("sha256").update(text).digest("hex").slice(0, 8)}.bin`;
+/**
+ * How the frame's entry gets axe's address: a `?url` import on a dev server, the build's file under the base in a
+ * build.
+ *
+ * @param command - whether a dev server runs, or a build.
+ * @param packageDir - the core's folder.
+ * @returns the address, or none when axe cannot be found.
+ */
+export const axeAddress = (command, packageDir) => {
+    const file = axeScript(packageDir);
+    if (file === undefined)
+        return undefined;
+    if (command === "serve")
+        return { imports: [`import axeUrl from ${codeLiteral(`${file}?url`)};`], value: "axeUrl" };
+    const name = axeBuildFile(readFileSync(file));
+    return { imports: [], value: `import.meta.env.BASE_URL + ${codeLiteral(name)}` };
+};
+/**
+ * The file a build writes: axe's script, gzipped.
+ *
+ * @param packageDir - the core's folder.
+ * @returns its name and bytes; none when axe cannot be found.
+ */
+export const axeBuildAsset = (packageDir) => {
+    const file = axeScript(packageDir);
+    if (file === undefined)
+        return undefined;
+    const text = readFileSync(file);
+    return { fileName: axeBuildFile(text), source: gzipSync(text, { level: 9 }) };
+};

package/dist/src/vite/builtTexts.d.ts

@@ -0,0 +1,75 @@
+/**
+ * A build's story-file texts: each file's component docs, code and page, written as data in a module of their group's
+ * rather than imported as a module each.
+ *
+ * @remarks
+ * A dev server imports each text from its query (`?forgebook-docs`, `-code`, `-page`), so an edit renews the one it
+ * changes. A build knows every file's texts, and a module each costs it a script per file and its loader in the group's
+ * module, which every first load fetches. So a text is a gzipped file (the docs, a page that has something to say),
+ * read when the page asks, as "Used in" is; and one that would weigh no more than its file's address (a story file
+ * whose stories are all args has no code, most components have no page) is written in the module itself. Either way
+ * the loader answers the text, as the query's module's default did.
+ *
+ * The texts are a module of their own (`TEXTS_PREFIX`), imported by the group's module alone, so the bundler keeps
+ * them in its chunk. Reading them waits for every component's docs, seconds on a large library: written in the group's
+ * module, they would hold back the stories it imports, and everything those import, until the last docs were read. As
+ * a module of their own, the group's module is written at once and the build loads the stories while the docs are
+ * read; the reading starts with the group's module (`starter`), and the texts' module waits for it.
+ *
+ * @module
+ */
+import { type EmitAsset } from "./packedModule.ts";
+import { type IndexedStoryFile } from "./storyFilesModule.ts";
+import type { ComponentPageText, KeptCode, TextModuleContext } from "./textModules.ts";
+/** A story file's texts as their queries' modules answer them: its component's docs, its stories' code, its page. */
+export type FileTexts = readonly [docs: unknown, code: KeptCode, page: ComponentPageText];
+/**
+ * The code of a group's texts module: the functions its loaders call, then, as its default, each file's loaders of its
+ * docs, code and page, in the order of the group's rows.
+ *
+ * @param texts - each file's texts, in the files' order.
+ * @param emit - writes a packed file.
+ */
+export declare const textsModuleCode: (texts: readonly FileTexts[], emit: EmitAsset) => string;
+/** What the plugin gives a build's texts: the docs as the panel reads them, and what reading a page needs. */
+export type TextSources = Pick<TextModuleContext, "watch" | "resolveImport" | "componentFiles"> & {
+    /** A story file's component docs as the panel reads them, or `{ error }`. */
+    readonly docsOf: (storyFile: string) => Promise<unknown>;
+};
+/** The module a build's texts are answered as. */
+type TextsModule = {
+    readonly code: string;
+    readonly moduleType: "js";
+};
+/** A build's texts, by group: read from when the group's module is written, answered as the texts' module. */
+export type GroupTexts = {
+    /**
+     * What starts reading a pattern's texts as its module is written: the build loads the stories meanwhile.
+     *
+     * @param id - the pattern's module's id (`FILES_PREFIX`, then the group).
+     * @param sources - what reading them needs.
+     * @returns what starts the reading, given the story files in the order of the module's rows.
+     */
+    readonly starter: (id: string, sources: TextSources) => (files: readonly IndexedStoryFile[]) => void;
+    /**
+     * A group's texts module once its texts are read, when the id names one (`TEXTS_ID_PREFIX`). The files the reading
+     * watched are watched by this module, the one an edit of them changes.
+     *
+     * @param id - the module's id.
+     * @param sources - what reading them needs: its own `watch`, and the rest when its pattern's module did not start
+     * the reading (a module loaded again).
+     * @param emit - writes a packed file.
+     * @returns the module; none for another id.
+     */
+    readonly moduleOf: (id: string, sources: TextSources, emit: EmitAsset) => Promise<TextsModule | undefined>;
+};
+/**
+ * A build's texts, by group.
+ *
+ * @remarks
+ * A reading started is kept until its module takes it, and marked handled at once: a failure before the module asks
+ * would otherwise end the process, and the module's load still reports it. The reading outlives the load of the
+ * pattern's module that started it, so it records the files it watches and the texts' module watches them.
+ */
+export declare const groupTexts: () => GroupTexts;
+export {};

package/dist/src/vite/builtTexts.js

@@ -0,0 +1,142 @@
+/**
+ * A build's story-file texts: each file's component docs, code and page, written as data in a module of their group's
+ * rather than imported as a module each.
+ *
+ * @remarks
+ * A dev server imports each text from its query (`?forgebook-docs`, `-code`, `-page`), so an edit renews the one it
+ * changes. A build knows every file's texts, and a module each costs it a script per file and its loader in the group's
+ * module, which every first load fetches. So a text is a gzipped file (the docs, a page that has something to say),
+ * read when the page asks, as "Used in" is; and one that would weigh no more than its file's address (a story file
+ * whose stories are all args has no code, most components have no page) is written in the module itself. Either way
+ * the loader answers the text, as the query's module's default did.
+ *
+ * The texts are a module of their own (`TEXTS_PREFIX`), imported by the group's module alone, so the bundler keeps
+ * them in its chunk. Reading them waits for every component's docs, seconds on a large library: written in the group's
+ * module, they would hold back the stories it imports, and everything those import, until the last docs were read. As
+ * a module of their own, the group's module is written at once and the build loads the stories while the docs are
+ * read; the reading starts with the group's module (`starter`), and the texts' module waits for it.
+ *
+ * @module
+ */
+import { codeLiteral, codeOfJson } from "../codeLiteral.js";
+import { gzippedJson, packedFileName, packedLoaderMaker } from "./packedModule.js";
+import { FILES_PREFIX, TEXTS_ID_PREFIX } from "./pluginModules.js";
+import { indexedStoryFiles, storyFilesGroupOf, storyFilesGroupText } from "./storyFilesModule.js";
+import { VITE_PATHS } from "./vitePaths.js";
+/** The function that makes a packed file's loader, in the generated code. */
+const PACKED = "packedText";
+/** The function that makes the loader of a text written in the module, in the generated code. */
+const WRITTEN = "writtenText";
+/**
+ * Writes texts as loaders: each in a gzipped file, or in the module when that weighs no more than the file and its
+ * address (an empty page's JSON is shorter than its gzip header and the fetch it would cost). A text written in the
+ * module is written once, however many files share it (most story files have no code and no page), and its loader
+ * shared with them.
+ *
+ * @param emit - writes a packed file.
+ */
+const textWriter = (emit) => {
+    const names = new Map();
+    const written = (json) => {
+        const name = names.get(json) ?? `${WRITTEN}${names.size}`;
+        names.set(json, name);
+        return name;
+    };
+    return {
+        loaderOf: (value) => {
+            const json = JSON.stringify(value);
+            const fileName = packedFileName(json);
+            const address = codeLiteral(fileName);
+            const packed = gzippedJson(json);
+            if (json.length <= address.length + packed.length)
+                return written(json);
+            emit({ type: "asset", fileName, source: packed });
+            return `${PACKED}(${address})`;
+        },
+        written: () => [...names].map(([json, name]) => `const ${name} = () => Promise.resolve(${codeOfJson(json)});`)
+    };
+};
+/**
+ * Every file's texts, read: a build reads them all once, as it would for their modules.
+ *
+ * @param files - the group's story files, indexed.
+ * @param read - reads a file's texts.
+ * @returns each file's texts, in the files' order.
+ */
+const readTexts = (files, read) => Promise.all(files.map(({ file }) => Promise.all([read.docsOf(file), read.codeOf(file), read.pageOf(file)])));
+/**
+ * The code of a group's texts module: the functions its loaders call, then, as its default, each file's loaders of its
+ * docs, code and page, in the order of the group's rows.
+ *
+ * @param texts - each file's texts, in the files' order.
+ * @param emit - writes a packed file.
+ */
+export const textsModuleCode = (texts, emit) => {
+    // written in the files' order once all are read, so the names in the module do not depend on which read ended first
+    const writer = textWriter(emit);
+    const rows = texts.map((each) => `[${each.map((text) => writer.loaderOf(text)).join(", ")}]`);
+    return [packedLoaderMaker(PACKED), ...writer.written(), `export default [${rows.join(",\n")}];`].join("\n");
+};
+/**
+ * A build's readers of the texts: the code and the pages as their queries answer them, read with the modules that
+ * answer them, which load only when a build asks.
+ *
+ * @param sources - the docs, and what reading a page needs.
+ */
+const textReaders = async (sources) => {
+    const { storyFileCode, storyFilePage } = await import("./textModules.js");
+    return {
+        docsOf: sources.docsOf,
+        // a build keeps nothing between runs: it reads each file once
+        codeOf: (storyFile) => storyFileCode(storyFile, undefined),
+        pageOf: (storyFile) => storyFilePage(storyFile, sources)
+    };
+};
+/**
+ * A group as its texts module's id writes it: the pattern's module names the folder as its importer's, the texts'
+ * module in Vite's form (`storyFilesCode`), so both are read back and written the same way.
+ *
+ * @param group - the group (`storyFilesGroupText`).
+ */
+const groupKey = (group) => {
+    const { root, pattern } = storyFilesGroupOf(group);
+    return storyFilesGroupText(VITE_PATHS.normalize(root), pattern);
+};
+/**
+ * A build's texts, by group.
+ *
+ * @remarks
+ * A reading started is kept until its module takes it, and marked handled at once: a failure before the module asks
+ * would otherwise end the process, and the module's load still reports it. The reading outlives the load of the
+ * pattern's module that started it, so it records the files it watches and the texts' module watches them.
+ */
+export const groupTexts = () => {
+    const started = new Map();
+    const read = async (files, sources) => readTexts(files, await textReaders(sources));
+    const code = async (group, sources, emit) => {
+        const key = groupKey(group);
+        const reading = started.get(key);
+        started.delete(key);
+        if (reading === undefined) {
+            const { root, pattern } = storyFilesGroupOf(group);
+            return textsModuleCode(await read(indexedStoryFiles(root, pattern, sources.watch), sources), emit);
+        }
+        const texts = await reading.texts;
+        for (const file of reading.watched)
+            sources.watch(file);
+        return textsModuleCode(texts, emit);
+    };
+    return {
+        starter: (id, sources) => (files) => {
+            const watched = [];
+            const texts = read(files, { ...sources, watch: (file) => void watched.push(file) });
+            texts.catch(() => undefined);
+            started.set(groupKey(id.slice(FILES_PREFIX.length)), { texts, watched });
+        },
+        moduleOf: async (id, sources, emit) => {
+            if (!id.startsWith(TEXTS_ID_PREFIX))
+                return undefined;
+            return { code: await code(id.slice(TEXTS_ID_PREFIX.length), sources, emit), moduleType: "js" };
+        }
+    };
+};

package/dist/src/vite/catalogueConfig.d.ts

@@ -0,0 +1,10 @@
+import type { UserConfig } from "vite";
+import { type ResolvedConfig } from "./configFile.ts";
+/**
+ * What the plugin sets in Vite's configuration for a catalogue: its folder as the root, what to pre-bundle, the pages
+ * as the build's inputs, and the dev server's reads kept to each origin.
+ *
+ * @param config - the catalogue's configuration.
+ * @param userConfig - the configuration so far, whose own `server.cors` and build output the plugin leaves alone.
+ */
+export declare const catalogueConfig: (config: ResolvedConfig, userConfig: UserConfig) => UserConfig;

package/dist/src/vite/catalogueConfig.js

@@ -0,0 +1,64 @@
+/**
+ * What Forgebook's plugin sets in Vite's configuration for a catalogue: its folder as the root, what to pre-bundle, the
+ * pages as the build's inputs, the build's script names, and the dev server's reads kept to each origin.
+ *
+ * @module
+ */
+import { readFileSync } from "node:fs";
+import { packageResolver } from "./configFile.js";
+import { pageModulePath } from "./pages.js";
+import { prebundled, scannedEntries } from "./prebundled.js";
+/**
+ * A file's text, or none when it cannot be read.
+ *
+ * @param file - the file.
+ */
+const readTextFile = (file) => {
+    try {
+        return readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Whether an app's configuration names its build's output itself, which the plugin then leaves as it is.
+ *
+ * @param userConfig - the configuration so far.
+ */
+const hasOwnOutput = (userConfig) => userConfig.build?.rolldownOptions?.output !== undefined ||
+    userConfig.build?.rollupOptions?.output !== undefined;
+/**
+ * What the plugin sets in Vite's configuration for a catalogue: its folder as the root, what to pre-bundle, the pages
+ * as the build's inputs, and the dev server's reads kept to each origin.
+ *
+ * @param config - the catalogue's configuration.
+ * @param userConfig - the configuration so far, whose own `server.cors` and build output the plugin leaves alone.
+ */
+export const catalogueConfig = (config, userConfig) => ({
+    root: config.dir,
+    // the pages are generated, so Vite's scanner cannot find what they import: it is named here, and the
+    // story files (the project's and the sources') are scanned for what their components import
+    optimizeDeps: {
+        include: prebundled(config, packageResolver(config.dir)),
+        entries: scannedEntries(config, packageResolver(config.dir), readTextFile)
+    },
+    build: {
+        rolldownOptions: {
+            input: {
+                index: pageModulePath(config.dir, "index.html"),
+                frame: pageModulePath(config.dir, "frame.html")
+            },
+            // a catalogue names each story file's scripts once per loader: a name of its hash alone is a tenth of
+            // what the index weighs, and a catalogue whose builds are read by name keeps Vite's (`readableNames`)
+            ...(config.build.readableNames || hasOwnOutput(userConfig)
+                ? {}
+                : { output: { chunkFileNames: "assets/[hash].js", hashCharacters: "base36" } })
+        }
+    },
+    // Vite lets any localhost page read the server: neither origin needs another's reads, and the guards
+    // would be the only wall left between the frames and the catalogue (unless the app chose its own)
+    ...(config.frames.kind === "isolated" && userConfig.server?.cors === undefined
+        ? { server: { cors: false } }
+        : {})
+});

package/dist/src/vite/checkCode.d.ts

@@ -0,0 +1,67 @@
+/**
+ * What a change adds, checked against the design system: the mistakes agents make, in the lines they wrote.
+ *
+ * @remarks
+ * Pure, and it reads the change and not the project: code that was already there is not this change's to fix, and a
+ * check that lists a project's history is ignored. A check people turn off is worth nothing, so it reads only the files
+ * where a raw value is a mistake (styles and components), never where it belongs (stories, tests, tokens, generated
+ * output), and it does not read a `#` as a colour unless it stands as a value. A raw colour is named whether or not a
+ * token is close; a size only when it equals a token, since most sizes are not the design system's. A fix is the token's
+ * name, not code to paste, and it is offered only when one token clearly fits: forcing the nearest is how a wrong colour
+ * gets a token's name. Props, imports and deprecated components are not checked here.
+ *
+ * @module
+ */
+import type { DesignToken } from "./designTokens.ts";
+/** A line a change adds. */
+export type AddedLine = {
+    /** Its file, as the diff names it. */
+    readonly file: string;
+    /** Its line in the new file. */
+    readonly line: number;
+    /** Its text. */
+    readonly text: string;
+};
+/** The rules. */
+export type CodeRule = "raw-color" | "raw-size" | "suppression" | "deleted-test";
+/** What a check found. */
+export type CodeProblem = {
+    /** The rule. */
+    readonly rule: CodeRule;
+    /** The file, relative to the repository. */
+    readonly file: string;
+    /** The line in it; none for a file that is gone. */
+    readonly line?: number;
+    /** What was written. */
+    readonly value: string;
+    /** The name of the token to use instead, when one clearly fits; a name, not code to paste. */
+    readonly fix?: string;
+    /** What to do, in a sentence. */
+    readonly message: string;
+};
+/**
+ * The lines a unified diff adds. A header is read only outside a hunk, since an added line of `++ x` looks like one.
+ *
+ * @param diff - the diff, with no context lines.
+ */
+export declare const addedLines: (diff: string) => AddedLine[];
+/**
+ * Every line of a new file, as added lines: a new file is what an agent writes most, and a diff does not show it.
+ *
+ * @param file - the file, relative to the repository.
+ * @param text - its text.
+ */
+export declare const fileLines: (file: string, text: string) => AddedLine[];
+/**
+ * The test files a change deletes: the plainest way to make a failing check pass.
+ *
+ * @param deleted - the files it deletes.
+ */
+export declare const deletedTests: (deleted: readonly string[]) => CodeProblem[];
+/**
+ * What lines a change adds break. Only code is read: a rule named in a sentence is not that rule.
+ *
+ * @param lines - the added lines.
+ * @param tokens - the catalogue's tokens; none skips the checks on values, which have nothing to compare with.
+ */
+export declare const checkedCode: (lines: readonly AddedLine[], tokens: readonly DesignToken[]) => CodeProblem[];

package/dist/src/vite/checkCode.js

@@ -0,0 +1,145 @@
+import { nearestTokens } from "./nearestToken.js";
+/** A hex colour standing as a value: not an id, an anchor or a word that happens to start like one. */
+const HEX_COLOR = /(?:^|[\s:'"`(,[=])(#(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{3,4}))(?![0-9a-z_-])/gi;
+/** A colour function, not a function of that name being declared or a template being written. */
+const COLOR_FUNCTION = /(?<![\w.])(?:rgba?|hsla?|oklch|oklab)\((?![^)]*\$\{)[\d\s.,%/-]+\)/gi;
+/** A size, signed or in Tailwind's brackets. */
+const SIZE = /(?:^|[\s:'"`(,[-])(\d*\.?\d+(?:px|rem))\b/g;
+/** A comment that turns a check off. */
+const SUPPRESSION = /(?:\/\/|\/\*|<!--|\{\/\*)\s*(?:@ts-ignore|@ts-expect-error|@ts-nocheck|eslint-disable|biome-ignore|stylelint-disable)/;
+/** What says why after a suppression: the repository's rule allows one with a reason. */
+const HAS_REASON = /(?:biome-ignore [^:]+:\s*\S|eslint-disable[^*]*--\s*\S|@ts-expect-error\s+\S)/;
+/** The files where a raw value is a mistake: styles and components. */
+const CHECKED_FILE = /\.(?:css|scss|sass|less|tsx|jsx|vue|svelte|astro)$/;
+/** Where raw values belong: stories, tests, tokens and what a tool wrote. */
+const LEFT_ALONE = /(?:\.stories\.|\.test\.|\.spec\.|\.e2e\.|\.min\.|(?:^|\/)_?(?:design-)?tokens?(?:\.|\/)|\.tokens?\.|(?:^|\/)theme\.|(?:^|\/)(?:__tests__|tests?|e2e|dist|build|generated|vendor)\/)/;
+/** A test file. */
+const TEST_FILE = /(?:\.test\.|\.spec\.|\.e2e\.|_test\.|(?:^|\/)(?:__tests__|tests?|e2e)\/)/;
+/** A hunk's header: where its lines start in the new file. */
+const HUNK = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+/** A line that defines a value: a custom property or a Sass variable, where raw values belong. */
+const DEFINES_VALUE = /^\s*(?:--[\w-]+|\$[\w-]+)\s*:/;
+/** A media condition, where `var()` does not work, so a token cannot stand in. */
+const MEDIA_CONDITION = /@(?:media|container)\b/;
+/** A selector, whose `#` is an id. */
+const SELECTOR_LINE = /[{,]\s*$/;
+/** A line's code, without what follows a `//` or a comment's start. */
+const withoutComment = (text) => text.replace(/(?:^|\s)\/\/.*$/, "").replace(/\/\*.*$/, "");
+/**
+ * The lines a unified diff adds. A header is read only outside a hunk, since an added line of `++ x` looks like one.
+ *
+ * @param diff - the diff, with no context lines.
+ */
+export const addedLines = (diff) => {
+    const lines = [];
+    let file = "";
+    let next = 0;
+    let remaining = 0;
+    for (const line of diff.split("\n")) {
+        const hunk = HUNK.exec(line);
+        if (hunk !== null) {
+            next = Number(hunk[1]);
+            remaining = Number(/\+\d+,(\d+)/.exec(line)?.[1] ?? 1);
+        }
+        else if (remaining > 0 && line.startsWith("+")) {
+            lines.push({ file, line: next, text: line.slice(1) });
+            next += 1;
+            remaining -= 1;
+        }
+        else if (remaining === 0 && line.startsWith("+++ ")) {
+            file = line.slice(4).replace(/^b\//, "").replace(/\t$/, "");
+        }
+    }
+    return lines;
+};
+/**
+ * Every line of a new file, as added lines: a new file is what an agent writes most, and a diff does not show it.
+ *
+ * @param file - the file, relative to the repository.
+ * @param text - its text.
+ */
+export const fileLines = (file, text) => text.split("\n").map((line, index) => ({ file, line: index + 1, text: line }));
+/**
+ * The test files a change deletes: the plainest way to make a failing check pass.
+ *
+ * @param deleted - the files it deletes.
+ */
+export const deletedTests = (deleted) => deleted
+    .filter((file) => TEST_FILE.test(file))
+    .map((file) => ({
+    rule: "deleted-test",
+    file,
+    value: file,
+    message: "A test was deleted: fix what it found, or say why it no longer applies."
+}));
+/** The problem of a raw colour: a fix only from a token that holds in every theme. */
+const colorProblem = ({ file, line }, value, tokens) => {
+    const match = nearestTokens(tokens, value, "color").matches.find((each) => each.isClose && each.mode === undefined);
+    return {
+        rule: "raw-color",
+        file,
+        line,
+        value,
+        ...(match === undefined ? {} : { fix: match.name }),
+        message: match === undefined
+            ? "A colour written by hand, and no token is close: ask whether the design system has it."
+            : `A colour written by hand: use the token ${match.name} (${match.value}).`
+    };
+};
+/** The raw colours in a line of code. */
+const colorProblems = (added, code, tokens) => {
+    if (SELECTOR_LINE.test(code) || /(?:href|url)\s*[=(]/.test(code))
+        return [];
+    // digits alone are a number more often than a colour (`Order #1042`), unless they stand as a value
+    const hexes = [...code.matchAll(HEX_COLOR)]
+        .flatMap((match) => match[1] ?? [])
+        .filter((value) => !/^#\d+$/.test(value) || new RegExp(`[:=]\\s*['"\`]?${value}`).test(code));
+    const functions = [...code.matchAll(COLOR_FUNCTION)].map((match) => match[0]);
+    return [...hexes, ...functions].map((value) => colorProblem(added, value, tokens));
+};
+/** The sizes in a line that equal one token: two that do say what the size is for, which this cannot tell. */
+const sizeProblems = ({ file, line }, code, tokens) => {
+    if (MEDIA_CONDITION.test(code))
+        return [];
+    return [...code.matchAll(SIZE)].flatMap((found) => {
+        const value = found[1] ?? "";
+        const exact = nearestTokens(tokens, value, "dimension").matches.filter((each) => each.isExact && each.mode === undefined);
+        const [only] = exact;
+        if (only === undefined)
+            return [];
+        const fix = exact.length === 1 ? { fix: only.name } : {};
+        const names = exact.map((each) => each.name).join(" or ");
+        return [
+            { rule: "raw-size", file, line, value, ...fix, message: `A size written by hand: use ${names}.` }
+        ];
+    });
+};
+/** The suppression a line adds, unless it says why. */
+const suppressionProblem = ({ file, line, text }) => SUPPRESSION.test(text) && !HAS_REASON.test(text)
+    ? [
+        {
+            rule: "suppression",
+            file,
+            line,
+            value: text.trim(),
+            message: "A check was turned off with no reason: fix what it found, or say why it is wrong here."
+        }
+    ]
+    : [];
+/**
+ * What lines a change adds break. Only code is read: a rule named in a sentence is not that rule.
+ *
+ * @param lines - the added lines.
+ * @param tokens - the catalogue's tokens; none skips the checks on values, which have nothing to compare with.
+ */
+export const checkedCode = (lines, tokens) => lines.flatMap((added) => {
+    if (!CHECKED_FILE.test(added.file) && !/\.[cm]?[jt]s$/.test(added.file))
+        return [];
+    if (LEFT_ALONE.test(added.file))
+        return [];
+    const suppression = suppressionProblem(added);
+    if (tokens.length === 0 || !CHECKED_FILE.test(added.file) || DEFINES_VALUE.test(added.text))
+        return suppression;
+    const code = withoutComment(added.text);
+    return [...suppression, ...colorProblems(added, code, tokens), ...sizeProblems(added, code, tokens)];
+});