@webround/editor 0.0.0-stage → 0.3.0

package/dist/check/aria.d.ts

@@ -0,0 +1,19 @@
+export declare const ARIA_ATTRIBUTES: ReadonlySet<string>;
+export declare const ARIA_ROLES: ReadonlySet<string>;
+/** A role is valid when it is one of these, or one of the digital-publishing (`doc-…`) and graphics (`graphics-…`) modules'. Several roles may be listed: the first the browser knows wins. */
+export declare const isKnownRole: (role: string) => boolean;
+/** The attributes a role cannot be used without (the ones with no default that tell a screen reader what the thing is doing). */
+export declare const REQUIRED_BY_ROLE: Readonly<Record<string, readonly string[]>>;
+/** Elements that take the keyboard focus by themselves. */
+export declare const FOCUSABLE_TAGS: ReadonlySet<string>;
+/** Elements that are only a container: a name on them is not announced unless they have a role. */
+export declare const GENERIC_TAGS: ReadonlySet<string>;
+/** Link texts that say nothing about where the link goes (WCAG 2.4.4), by language: lowercase, without punctuation. */
+export declare const GENERIC_LINK_TEXTS: ReadonlySet<string>;
+/** A link's text the way it is compared: lowercase, no punctuation or arrows, one space between words. */
+export declare const normalizedLinkText: (text: string) => string;
+/** Is this a value `autocomplete` can have: `on`, `off`, or [section-x] [shipping|billing] [home|work|mobile|fax|pager] field [webauthn]. */
+export declare function isValidAutocomplete(value: string): boolean;
+/** The `autocomplete` a field should have, from what it is (its type, its name): undefined when it is not asking about the person or we cannot tell. */
+export declare function expectedAutocomplete(attrs: Record<string, string>): string | undefined;
+//# sourceMappingURL=aria.d.ts.map

package/dist/check/aria.js

@@ -0,0 +1,106 @@
+// What WAI-ARIA 1.2 says exists: its attributes, its roles, and what a role cannot do without. Data, not code: the rules read it.
+export const ARIA_ATTRIBUTES = new Set([
+    'activedescendant', 'atomic', 'autocomplete', 'braillelabel', 'brailleroledescription', 'busy', 'checked', 'colcount', 'colindex', 'colindextext',
+    'colspan', 'controls', 'current', 'describedby', 'description', 'details', 'disabled', 'dropeffect', 'errormessage', 'expanded', 'flowto', 'grabbed',
+    'haspopup', 'hidden', 'invalid', 'keyshortcuts', 'label', 'labelledby', 'level', 'live', 'modal', 'multiline', 'multiselectable', 'orientation',
+    'owns', 'placeholder', 'posinset', 'pressed', 'readonly', 'relevant', 'required', 'roledescription', 'rowcount', 'rowindex', 'rowindextext',
+    'rowspan', 'selected', 'setsize', 'sort', 'valuemax', 'valuemin', 'valuenow', 'valuetext',
+]);
+export const ARIA_ROLES = new Set([
+    'alert', 'alertdialog', 'application', 'article', 'banner', 'blockquote', 'button', 'caption', 'cell', 'checkbox', 'code', 'columnheader', 'combobox',
+    'complementary', 'contentinfo', 'definition', 'deletion', 'dialog', 'directory', 'document', 'emphasis', 'feed', 'figure', 'form', 'generic', 'grid',
+    'gridcell', 'group', 'heading', 'img', 'insertion', 'link', 'list', 'listbox', 'listitem', 'log', 'main', 'marquee', 'math', 'meter', 'menu', 'menubar',
+    'menuitem', 'menuitemcheckbox', 'menuitemradio', 'navigation', 'none', 'note', 'option', 'paragraph', 'presentation', 'progressbar', 'radio',
+    'radiogroup', 'region', 'row', 'rowgroup', 'rowheader', 'scrollbar', 'search', 'searchbox', 'separator', 'slider', 'spinbutton', 'status', 'strong',
+    'subscript', 'superscript', 'switch', 'tab', 'table', 'tablist', 'tabpanel', 'term', 'textbox', 'time', 'timer', 'toolbar', 'tooltip', 'tree', 'treegrid',
+    'treeitem',
+]);
+/** A role is valid when it is one of these, or one of the digital-publishing (`doc-…`) and graphics (`graphics-…`) modules'. Several roles may be listed: the first the browser knows wins. */
+export const isKnownRole = (role) => ARIA_ROLES.has(role) || /^(doc|graphics)-[a-z]+$/.test(role);
+/** The attributes a role cannot be used without (the ones with no default that tell a screen reader what the thing is doing). */
+export const REQUIRED_BY_ROLE = {
+    checkbox: ['checked'],
+    switch: ['checked'],
+    radio: ['checked'],
+    menuitemcheckbox: ['checked'],
+    menuitemradio: ['checked'],
+    combobox: ['expanded', 'controls'],
+    heading: ['level'],
+    slider: ['valuenow'],
+    scrollbar: ['controls', 'valuenow'],
+    spinbutton: ['valuenow'],
+    option: ['selected'],
+};
+/** Elements that take the keyboard focus by themselves. */
+export const FOCUSABLE_TAGS = new Set(['button', 'select', 'textarea', 'summary']);
+/** Elements that are only a container: a name on them is not announced unless they have a role. */
+export const GENERIC_TAGS = new Set(['div', 'span', 'p']);
+/** Link texts that say nothing about where the link goes (WCAG 2.4.4), by language: lowercase, without punctuation. */
+export const GENERIC_LINK_TEXTS = new Set([
+    'click here', 'click', 'here', 'read more', 'more', 'learn more', 'more info', 'link', 'this link', 'details', 'continue',
+    'clicca qui', 'clicca', 'qui', 'leggi di più', 'leggi di piu', 'scopri di più', 'scopri di piu', 'altro', 'maggiori informazioni', 'dettagli', 'continua',
+    'cliquez ici', 'ici', 'en savoir plus', 'lire la suite', 'plus', 'plus d’infos', "plus d'infos", 'détails',
+    'hier klicken', 'hier', 'mehr', 'mehr erfahren', 'weiterlesen', 'mehr lesen', 'details ansehen',
+    'haz clic aquí', 'haz clic aqui', 'aquí', 'aqui', 'leer más', 'leer mas', 'más información', 'mas informacion', 'saber más', 'saber mas', 'detalles',
+]);
+/** A link's text the way it is compared: lowercase, no punctuation or arrows, one space between words. */
+export const normalizedLinkText = (text) => text.toLowerCase().replace(/[\p{P}\p{S}]+/gu, ' ').replace(/\s+/g, ' ').trim();
+// ── Autocomplete (WCAG 1.3.5): the fields that ask for something about the person say what, in the browser's own words ──
+const AUTOFILL_FIELDS = new Set([
+    'name', 'honorific-prefix', 'given-name', 'additional-name', 'family-name', 'honorific-suffix', 'nickname', 'email', 'username', 'new-password',
+    'current-password', 'one-time-code', 'organization-title', 'organization', 'street-address', 'address-line1', 'address-line2', 'address-line3',
+    'address-level4', 'address-level3', 'address-level2', 'address-level1', 'country', 'country-name', 'postal-code', 'cc-name', 'cc-given-name',
+    'cc-additional-name', 'cc-family-name', 'cc-number', 'cc-exp', 'cc-exp-month', 'cc-exp-year', 'cc-csc', 'cc-type', 'transaction-currency',
+    'transaction-amount', 'language', 'bday', 'bday-day', 'bday-month', 'bday-year', 'sex', 'url', 'photo', 'tel', 'tel-country-code', 'tel-national',
+    'tel-area-code', 'tel-local', 'tel-extension', 'impp',
+]);
+const AUTOFILL_CONTACT = new Set(['home', 'work', 'mobile', 'fax', 'pager']);
+/** Is this a value `autocomplete` can have: `on`, `off`, or [section-x] [shipping|billing] [home|work|mobile|fax|pager] field [webauthn]. */
+export function isValidAutocomplete(value) {
+    const tokens = value.trim().toLowerCase().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return false;
+    if (tokens.length === 1 && (tokens[0] === 'on' || tokens[0] === 'off'))
+        return true;
+    if (tokens[tokens.length - 1] === 'webauthn')
+        tokens.pop();
+    while (tokens[0]?.startsWith('section-'))
+        tokens.shift();
+    if (tokens[0] === 'shipping' || tokens[0] === 'billing')
+        tokens.shift();
+    if (tokens.length === 2 && AUTOFILL_CONTACT.has(tokens[0]) && ['tel', 'tel-country-code', 'tel-national', 'tel-area-code', 'tel-local', 'tel-extension', 'email', 'impp'].includes(tokens[1]))
+        return true;
+    return tokens.length === 1 && AUTOFILL_FIELDS.has(tokens[0]);
+}
+/** Field types that hold something a person chooses (a box to tick, a file) rather than something about them. */
+const NOT_ABOUT_THE_PERSON = new Set(['hidden', 'submit', 'button', 'reset', 'image', 'checkbox', 'radio', 'file', 'range', 'color', 'date', 'datetime-local', 'month', 'week', 'time', 'number', 'search']);
+const BY_NAME = [
+    [/^(e-?mail|email-?address|mail)$/, 'email'],
+    [/^(tel|telephone|phone|phone-?number|mobile|cell|telefono|cellulare)$/, 'tel'],
+    [/^(first-?name|given-?name|fname|nome|prenom|vorname)$/, 'given-name'],
+    [/^(last-?name|family-?name|surname|lname|cognome|nom|nachname)$/, 'family-name'],
+    [/^(full-?name|your-?name|name|nominativo)$/, 'name'],
+    [/^(user-?name|login|user|utente)$/, 'username'],
+    [/^(street|street-?address|address|address-?line-?1|indirizzo|via)$/, 'street-address'],
+    [/^(city|town|citta|città|comune|ville|stadt)$/, 'address-level2'],
+    [/^(zip|zip-?code|postal-?code|postcode|cap|code-?postal|plz)$/, 'postal-code'],
+    [/^(country|nation|paese|pays|land)$/, 'country-name'],
+    [/^(company|organi[sz]ation|azienda|societa|società|ragione-?sociale)$/, 'organization'],
+    [/^(cc-?number|card-?number|credit-?card)$/, 'cc-number'],
+    [/^(bday|birthday|birth-?date|data-?di-?nascita)$/, 'bday'],
+];
+/** The `autocomplete` a field should have, from what it is (its type, its name): undefined when it is not asking about the person or we cannot tell. */
+export function expectedAutocomplete(attrs) {
+    const type = (attrs.type ?? 'text').toLowerCase();
+    if (NOT_ABOUT_THE_PERSON.has(type))
+        return undefined;
+    if (type === 'email')
+        return 'email';
+    if (type === 'tel')
+        return 'tel';
+    if (type === 'password')
+        return 'current-password';
+    const label = (attrs.name ?? '').toLowerCase().replace(/[_\s.]+/g, '-').replace(/\[\]/g, '');
+    return BY_NAME.find(([pattern]) => pattern.test(label))?.[1];
+}
+//# sourceMappingURL=aria.js.map

package/dist/check/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/check/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import path from 'path';
+import { checkProject } from './project.js';
+import { CHECK_SITE } from './types.js';
+// wr-check [dir] [--json] [--strict]
+// Exits 1 on errors (and on warnings with --strict): the one command a person, a script or an agent runs to know if the site is fine.
+const args = process.argv.slice(2);
+const json = args.includes('--json');
+const strict = args.includes('--strict');
+const root = path.resolve(args.find(a => !a.startsWith('--')) ?? process.cwd());
+const all = checkProject(root);
+// A problem the person silenced is still found, and counted apart: it does not fail the check
+const issues = all.filter(i => !i.muted);
+const silenced = all.length - issues.length;
+if (json) {
+    console.log(JSON.stringify(all, null, 2));
+}
+else if (issues.length === 0) {
+    console.log(`wr-check: no issues.${silenced ? ` (${silenced} silenced)` : ''}`);
+}
+else {
+    for (const i of issues) {
+        const at = i.where ? `src/${i.where.file}:${i.where.line}` : (i.page === CHECK_SITE ? 'the site' : `page ${i.page}`);
+        console.log(`${i.severity === 'error' ? 'error  ' : 'warning'} ${at}  ${i.message}${i.langs ? ` (${i.langs.join(', ')})` : ''} [${i.rule}]`);
+    }
+    const errors = issues.filter(i => i.severity === 'error').length;
+    console.log(`\n${errors} error(s), ${issues.length - errors} warning(s)${silenced ? `, ${silenced} silenced` : ''}.`);
+}
+process.exit(issues.some(i => i.severity === 'error' || strict) ? 1 : 0);
+//# sourceMappingURL=cli.js.map

package/dist/check/css.d.ts

@@ -0,0 +1,13 @@
+export interface CheckCss {
+    /** Rules that remove the outline of a focused element and put nothing in its place (WCAG 2.4.7). */
+    focusRemoved: {
+        file: string;
+        selector: string;
+    }[];
+    /** Something is animated by the stylesheets (`animation`, `@keyframes`, a `--animate-*` token). */
+    animates: boolean;
+    /** Some `@media (prefers-reduced-motion)` exists. */
+    reducesMotion: boolean;
+}
+export declare function readCss(srcRoot: string): CheckCss;
+//# sourceMappingURL=css.d.ts.map

package/dist/check/css.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import path from 'path';
+import postcss from 'postcss';
+const REMOVES_OUTLINE = (prop, value) => (prop === 'outline' && /^(none|0|0px|transparent)\b/i.test(value.trim()))
+    || (prop === 'outline-style' && /^none\b/i.test(value.trim()))
+    || (prop === 'outline-width' && /^0(px)?\b/.test(value.trim()));
+/** A value that says there is nothing (a shadow of `none`; note that `0 0 0 3px blue` is a shadow, one that starts with a zero offset). */
+const NOTHING = /^(none|initial|unset|inherit|transparent)\b/i;
+/** Anything else that shows where the focus is. */
+const SHOWS_FOCUS = new Set(['box-shadow', 'border', 'border-color', 'border-width', 'background', 'background-color', 'text-decoration', 'outline-color', 'filter']);
+function cssFiles(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir, { withFileTypes: true }).flatMap(entry => {
+        const full = path.join(dir, entry.name);
+        return entry.isDirectory() ? cssFiles(full) : entry.name.endsWith('.css') ? [full] : [];
+    });
+}
+export function readCss(srcRoot) {
+    const result = { focusRemoved: [], animates: false, reducesMotion: false };
+    for (const file of cssFiles(srcRoot)) {
+        let root;
+        try {
+            root = postcss.parse(fs.readFileSync(file, 'utf-8'));
+        }
+        catch {
+            continue;
+        } // a file half-written: the next check reads it whole
+        const relative = path.relative(srcRoot, file).split(path.sep).join('/');
+        root.walkAtRules(rule => {
+            if (rule.name === 'keyframes')
+                result.animates = true;
+            if (rule.name === 'media' && /prefers-reduced-motion/i.test(rule.params))
+                result.reducesMotion = true;
+        });
+        root.walkDecls(decl => {
+            if (/^animation(-name)?$/.test(decl.prop) && !/^none\b/i.test(decl.value.trim()))
+                result.animates = true;
+            if (decl.prop.startsWith('--animate-'))
+                result.animates = true;
+        });
+        root.walkRules(rule => {
+            if (!/:focus/.test(rule.selector))
+                return;
+            if (rule.parent?.type === 'atrule' && /forced-colors/.test(rule.parent.params))
+                return;
+            let removes = false;
+            let shows = false;
+            rule.walkDecls(decl => {
+                if (REMOVES_OUTLINE(decl.prop, decl.value))
+                    removes = true;
+                else if (SHOWS_FOCUS.has(decl.prop) && !NOTHING.test(decl.value.trim()) && !(/^border(-width)?$/.test(decl.prop) && /^0(px)?(\s|$)/.test(decl.value.trim())))
+                    shows = true;
+                else if (decl.prop === 'outline' && !REMOVES_OUTLINE(decl.prop, decl.value))
+                    shows = true;
+            });
+            if (removes && !shows)
+                result.focusRemoved.push({ file: relative, selector: rule.selector.replace(/\s+/g, ' ').trim() });
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=css.js.map

package/dist/check/html.d.ts

@@ -0,0 +1,8 @@
+import { type CheckNode } from './types.js';
+/**
+ * What the HTML of a rich text holds that the checks care about: its headings and its links (in document order), then its paragraphs. A text is only a container (a `div`): what it is, a heading or a paragraph, is what the editor wrote inside it. The DOM producer sees
+ * them (they are in the page); the code producer only has the string the editor wrote in the JSON (`<h1 class="editor-heading-h1">…`),
+ * so it reads them here. Without this a heading made inside a text is invisible to the rules (a page "without h1" that has one).
+ */
+export declare function htmlNodes(html: string): CheckNode[];
+//# sourceMappingURL=html.d.ts.map

package/dist/check/html.js

@@ -0,0 +1,29 @@
+import { stripTags } from './types.js';
+const ATTR = /([a-zA-Z-]+)\s*=\s*"([^"]*)"|([a-zA-Z-]+)\s*=\s*'([^']*)'/g;
+const attrsOf = (source, names) => {
+    const found = {};
+    for (const [, a, av, b, bv] of source.matchAll(ATTR)) {
+        const name = (a ?? b).toLowerCase();
+        if (names.includes(name))
+            found[name] = av ?? bv;
+    }
+    return found;
+};
+/**
+ * What the HTML of a rich text holds that the checks care about: its headings and its links (in document order), then its paragraphs. A text is only a container (a `div`): what it is, a heading or a paragraph, is what the editor wrote inside it. The DOM producer sees
+ * them (they are in the page); the code producer only has the string the editor wrote in the JSON (`<h1 class="editor-heading-h1">…`),
+ * so it reads them here. Without this a heading made inside a text is invisible to the rules (a page "without h1" that has one).
+ */
+export function htmlNodes(html) {
+    const nodes = [];
+    for (const [, tag, rest, inner] of html.matchAll(/<(h[1-6]|a)\b([^>]*)>([\s\S]*?)<\/\1\s*>/gi)) {
+        const name = tag.toLowerCase();
+        const attrs = name === 'a' ? attrsOf(rest, ['href', 'aria-label']) : {};
+        nodes.push({ kind: 'element', tag: name, attrs, text: stripTags(inner), children: [] });
+    }
+    // Paragraphs after (a link inside one stays a link of its own: the first pass found it)
+    for (const [, inner] of html.matchAll(/<p\b[^>]*>([\s\S]*?)<\/p\s*>/gi))
+        nodes.push({ kind: 'element', tag: 'p', attrs: {}, text: stripTags(inner), children: [] });
+    return nodes;
+}
+//# sourceMappingURL=html.js.map

package/dist/check/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export { RULES, SITE_RULES, runRules, runSiteRules } from './rules.js';
+export { checkPageFromDom, checkPageFromSerialized, serializeDom, type DomNode } from './producer-dom.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/check/index.js

@@ -0,0 +1,5 @@
+// Browser-safe part: the tree, the rules and the DOM producer. The code producer (Node, ts-morph) is `@webround/editor/check/code`.
+export * from './types.js';
+export { RULES, SITE_RULES, runRules, runSiteRules } from './rules.js';
+export { checkPageFromDom, checkPageFromSerialized, serializeDom } from './producer-dom.js';
+//# sourceMappingURL=index.js.map

package/dist/check/links.d.ts

@@ -0,0 +1,7 @@
+import type { CheckProject } from './types.js';
+/**
+ * Does an internal address (`/about`, `/en/about?x=1#top`) lead somewhere in the site: a page (in any language), or a file served as it is?
+ * Addresses to other sites, `mailto:`, `tel:` and in-page anchors are not the site's to judge: they lead somewhere as far as this knows.
+ */
+export declare function leadsSomewhere(href: string, project: CheckProject): boolean;
+//# sourceMappingURL=links.d.ts.map

package/dist/check/links.js

@@ -0,0 +1,23 @@
+import { wrBuildLangPath, wrRoutePattern } from '@webround/core/routing';
+const FOREIGN = /^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/i;
+/** A route path as a pattern that matches addresses: `blog/[slug]` matches `/blog/anything` (one segment). */
+const matcherOf = (route) => {
+    const pattern = wrRoutePattern(route).split('/').map(part => part.startsWith(':') ? '[^/]+' : part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('/');
+    return new RegExp(`^${pattern}/?$`);
+};
+/**
+ * Does an internal address (`/about`, `/en/about?x=1#top`) lead somewhere in the site: a page (in any language), or a file served as it is?
+ * Addresses to other sites, `mailto:`, `tel:` and in-page anchors are not the site's to judge: they lead somewhere as far as this knows.
+ */
+export function leadsSomewhere(href, project) {
+    const target = href.trim();
+    if (!target || FOREIGN.test(target) || !target.startsWith('/'))
+        return true;
+    const pathname = target.split(/[?#]/)[0] || '/';
+    if (project.publicFiles.includes(pathname))
+        return true;
+    const langs = project.langs;
+    const withoutLang = langs ? wrBuildLangPath('default', pathname, langs) : pathname;
+    return project.routes.some(route => matcherOf(route).test(withoutLang));
+}
+//# sourceMappingURL=links.js.map

package/dist/check/orphans.d.ts

@@ -0,0 +1,20 @@
+import type { OperationContext } from '../operations/define.js';
+export declare function sourceFiles(dir: string): string[];
+/** Every id the code of `src/` spells out, and whether some element computes its id. */
+export declare function idsInCode(ctx: OperationContext): {
+    ids: Set<string>;
+    dynamicIds: boolean;
+};
+/** The scopes whose JSON holds a page's values: every page, and every shared component (the header, the footer, the ones the site declares). */
+export declare const jsonScopes: (ctx: OperationContext) => string[];
+/** The keys of each scope's JSON that belong to no element of the code. Keys that are not element ids (`_seo`) are never orphans. */
+export declare function findOrphanKeys(ctx: OperationContext): {
+    orphans: {
+        scope: string;
+        keys: string[];
+    }[];
+    dynamicIds: boolean;
+};
+/** The ids of the form fields some `<label htmlFor="…">` of the code points at (a field with one has a label even if it is not inside it). */
+export declare function idsLabelledInCode(ctx: OperationContext): string[];
+//# sourceMappingURL=orphans.d.ts.map

package/dist/check/orphans.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+import { wrPageConfigPath } from '@webround/core/routing';
+import { readJsonFile, readRoutes, sharedScopesOf } from '../operations/ops/project.js';
+// The JSON of a page holds values keyed by the id of the element they belong to. When the element goes (deleted in VS Code, renamed), its key
+// stays, and comes back to life with the old text if the id is ever used again. Finding them means knowing every id the code has — in ALL of
+// `src/`, not only in the page's file: a component in `src/components/` has elements of its own.
+const SOURCE = /\.(tsx|jsx)$/;
+/** `id="x"`, `id='x'`, `id={"x"}`, `id={'x'}`, id={`x`}: an id the code spells out. */
+const LITERAL_ID = /\bid\s*=\s*(?:"([^"\n]+)"|'([^'\n]+)'|\{\s*(?:"([^"\n]+)"|'([^'\n]+)'|`([^`$\n]+)`)\s*\})/g;
+/** An element of ours whose id the code computes (`id={`card-${i}`}`, `id={id}`): which keys it will use is not readable. */
+const COMPUTED_ID = /<Wr[A-Za-z]*\b[^>]*?\bid\s*=\s*\{(?!\s*(?:"[^"\n]*"|'[^'\n]*'|`[^`$\n]*`)\s*\})/;
+export function sourceFiles(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir, { withFileTypes: true }).flatMap(entry => {
+        const full = path.join(dir, entry.name);
+        return entry.isDirectory() ? sourceFiles(full) : SOURCE.test(entry.name) ? [full] : [];
+    });
+}
+/** Every id the code of `src/` spells out, and whether some element computes its id. */
+export function idsInCode(ctx) {
+    const ids = new Set();
+    let dynamicIds = false;
+    for (const file of sourceFiles(ctx.srcRoot)) {
+        const code = fs.readFileSync(file, 'utf-8');
+        for (const match of code.matchAll(LITERAL_ID))
+            ids.add(match[1] ?? match[2] ?? match[3] ?? match[4] ?? match[5]);
+        if (COMPUTED_ID.test(code))
+            dynamicIds = true;
+    }
+    return { ids, dynamicIds };
+}
+/** The scopes whose JSON holds a page's values: every page, and every shared component (the header, the footer, the ones the site declares). */
+export const jsonScopes = (ctx) => [...Object.keys(readRoutes(ctx)), ...sharedScopesOf(ctx).map(scope => scope.name)];
+/** The keys of each scope's JSON that belong to no element of the code. Keys that are not element ids (`_seo`) are never orphans. */
+export function findOrphanKeys(ctx) {
+    const { ids, dynamicIds } = idsInCode(ctx);
+    const orphans = [];
+    for (const scope of jsonScopes(ctx)) {
+        const json = readJsonFile(ctx, wrPageConfigPath(scope));
+        const keys = Object.keys(json ?? {}).filter(key => !key.startsWith('_') && !ids.has(key));
+        if (keys.length > 0)
+            orphans.push({ scope, keys });
+    }
+    return { orphans, dynamicIds };
+}
+/** The ids of the form fields some `<label htmlFor="…">` of the code points at (a field with one has a label even if it is not inside it). */
+export function idsLabelledInCode(ctx) {
+    const ids = new Set();
+    for (const file of sourceFiles(ctx.srcRoot)) {
+        for (const match of fs.readFileSync(file, 'utf-8').matchAll(/\bhtmlFor\s*=\s*(?:"([^"\n]+)"|'([^'\n]+)'|\{\s*(?:"([^"\n]+)"|'([^'\n]+)')\s*\})/g))
+            ids.add(match[1] ?? match[2] ?? match[3] ?? match[4]);
+    }
+    return [...ids];
+}
+//# sourceMappingURL=orphans.js.map

package/dist/check/producer-code.d.ts

@@ -0,0 +1,53 @@
+import type { OperationContext } from '../operations/define.js';
+import { type ScopeFiles } from '../operations/ops/project.js';
+import { type CheckNode, type CheckPage, type CheckSite } from './types.js';
+/** What reading the tree is for: the checks count what renders; an outline shows what is there, hidden or not. */
+export interface ReadOptions {
+    includeHidden?: boolean;
+    /** Put the scope's name on every node. */
+    scope?: string;
+    /** The language to read (`default`, or a code): what a visitor of it reads, with the same fallback to the default one as the components. */
+    lang?: string;
+    /** Where a shared component a page uses is entered (see `sharedFollower`); without it a component is only transparent. */
+    follow?: SharedFollower;
+}
+/**
+ * The shared components a page uses (a card, a banner: the ones `config/shared.json` declares) are part of the page: reading enters their
+ * file, with their own JSON, where the page uses them. A component is read ONCE per page (`seen`: the same card in a grid, or used twice,
+ * is the same elements: reading it twice would make every id a duplicate), and what is wrong in its file is gathered in `syntax`.
+ */
+export interface SharedFollower {
+    ctx: OperationContext;
+    scopes: ScopeFiles[];
+    seen: Set<string>;
+    syntax: CheckScope['syntax'];
+}
+/** A follower for ONE page: the shared components a site declares, none seen yet. The header and the footer are read as the scopes they are, not followed. */
+export declare function sharedFollower(ctx: OperationContext): SharedFollower;
+export interface CheckScope {
+    name: string;
+    file: string;
+    nodes: CheckNode[];
+    syntax: NonNullable<CheckPage['syntax']>;
+}
+/**
+ * One scope of a site as the neutral tree: the elements of its code, with what its JSON says. Read by the checks (a page is its
+ * scopes together) and by whatever has to know what is on a page, in each language (the outline an agent reads).
+ */
+export declare function checkScopeFromCode(ctx: OperationContext, scope: ScopeFiles, options?: ReadOptions): CheckScope;
+/**
+ * The pages of a site, as the neutral tree: header + page + footer, the way the visitor of a language sees them (`default` unless asked).
+ * The checks run once per language and say, for each problem, in which ones it happens.
+ */
+export declare function checkPagesFromCode(root: string, lang?: string): CheckPage[];
+/**
+ * The languages a site is checked in: `key` is what the JSON calls it (`default`, or the code), `code` is what people call it (`it`).
+ * Just the default one when the site has a single language.
+ */
+export declare function languagesOf(root: string): {
+    key: string;
+    code: string;
+}[];
+/** What the checks know of the site as a whole. */
+export declare function checkSiteFromCode(root: string): CheckSite;
+//# sourceMappingURL=producer-code.d.ts.map