@webround/editor 0.0.0-stage → 0.3.0

package/dist/check/producer-code.js

@@ -0,0 +1,379 @@
+import fs from 'fs';
+import path from 'path';
+import { Project, SyntaxKind } from 'ts-morph';
+import { WR_COMPONENT_TO_KIND, wrTagOf } from '@webround/core/kinds';
+import { wrAriaLabel, wrLocalized } from '@webround/core/localized';
+import { WR_SHARED_SCOPES, wrPageConfigPath } from '@webround/core/routing';
+import { wrJsonLdProblems, wrSeoPageOf } from '@webround/core/seo';
+import { findPageRoot, syntaxErrors } from '../vite-plugins/jsx-tree.js';
+import { createOperationContext } from '../operations/context.js';
+import { readJsonFile, readLangs, readRoutes, readSeoSite, scopesOfPage, sharedScopesOf } from '../operations/ops/project.js';
+import { multilangFieldsOf } from '../schema.js';
+import { htmlNodes } from './html.js';
+import { findOrphanKeys, idsLabelledInCode } from './orphans.js';
+import { readCss } from './css.js';
+import { stripTags } from './types.js';
+/** 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 function sharedFollower(ctx) {
+    const own = Object.values(WR_SHARED_SCOPES).map(scope => scope.name);
+    const scopes = sharedScopesOf(ctx).filter(scope => !own.includes(scope.name)).map(scope => ({ name: scope.name, file: scope.file, json: wrPageConfigPath(scope.name) }));
+    return { ctx, scopes, seen: new Set(), syntax: [] };
+}
+/** The file (relative to `src/`) the component `tag` is imported from, when it is a relative or `@/` import; null if it is not one of the file's imports. */
+function importedFileOf(el, tag, ctx) {
+    const sourceFile = el.getSourceFile();
+    for (const declaration of sourceFile.getImportDeclarations()) {
+        const binds = declaration.getDefaultImport()?.getText() === tag
+            || declaration.getNamedImports().some(named => (named.getAliasNode()?.getText() ?? named.getName()) === tag);
+        if (!binds)
+            continue;
+        const specifier = declaration.getModuleSpecifierValue();
+        const base = specifier.startsWith('@/') ? path.join(ctx.srcRoot, specifier.slice(2)) : specifier.startsWith('.') ? path.resolve(path.dirname(sourceFile.getFilePath()), specifier) : null;
+        if (!base)
+            return null;
+        const found = [base, `${base}.tsx`, path.join(base, 'index.tsx')].find(candidate => candidate.endsWith('.tsx') && fs.existsSync(candidate));
+        if (!found)
+            return null;
+        const relative = path.relative(ctx.srcRoot, found).split(path.sep).join('/');
+        return relative.startsWith('..') ? null : relative;
+    }
+    return null;
+}
+/** What a shared component the page uses holds, read from its own file: nothing if `tag` is not one, or it was already read for this page. */
+function sharedNodesOf(el, tag, options) {
+    const follow = options.follow;
+    if (!follow)
+        return [];
+    const file = importedFileOf(el, tag, follow.ctx);
+    const scope = file ? follow.scopes.find(candidate => candidate.file === file) : undefined;
+    if (!scope || follow.seen.has(scope.name))
+        return [];
+    const read = checkScopeFromCode(follow.ctx, scope, { includeHidden: options.includeHidden, lang: options.lang, follow });
+    follow.syntax.push(...read.syntax);
+    return read.nodes;
+}
+/** What the visitor of a language reads (the default one's when it is not translated: the components do the same). */
+const inLang = (value, options) => wrLocalized(value, options.lang ?? 'default');
+// What stands for text the code decides at run time: it is not empty, we just cannot read it
+const DYNAMIC_TEXT = '{…}';
+const isJsx = (n) => n.isKind(SyntaxKind.JsxElement) || n.isKind(SyntaxKind.JsxSelfClosingElement);
+function attrOf(node, name) {
+    const opening = node.isKind(SyntaxKind.JsxElement) ? node.getOpeningElement() : node;
+    const attr = opening.getAttribute(name);
+    if (!attr || !attr.isKind(SyntaxKind.JsxAttribute))
+        return undefined;
+    const init = attr.getInitializer();
+    if (!init)
+        return true;
+    switch (init.getKind()) {
+        case SyntaxKind.StringLiteral:
+            return init.getLiteralValue();
+        case SyntaxKind.JsxExpression: {
+            const expr = init.getExpression();
+            switch (expr?.getKind()) {
+                case SyntaxKind.StringLiteral:
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
+                    return expr.getLiteralValue();
+                case SyntaxKind.NumericLiteral:
+                    return expr.getText();
+                case SyntaxKind.PrefixUnaryExpression:
+                    return /^-\s*\d+(\.\d+)?$/.test(expr.getText()) ? expr.getText().replace(/\s+/g, '') : DYNAMIC_TEXT;
+                case SyntaxKind.TrueKeyword:
+                    return true;
+                case SyntaxKind.FalseKeyword:
+                    return 'false';
+                default:
+                    return DYNAMIC_TEXT; // set by an expression: present, value unknown
+            }
+        }
+        default:
+            return undefined;
+    }
+}
+const str = (v) => typeof v === 'string' ? v : undefined;
+/** The JSX directly under a node, looking through `{cond && <X/>}`, fragments and the like. */
+function jsxUnder(node, out = []) {
+    node.forEachChild(child => {
+        if (isJsx(child))
+            out.push(child);
+        else
+            jsxUnder(child, out);
+    });
+    return out;
+}
+function textOf(node, children) {
+    if (node.isKind(SyntaxKind.JsxSelfClosingElement))
+        return '';
+    const own = node.getJsxChildren().map(child => {
+        if (child.isKind(SyntaxKind.JsxText))
+            return child.getText();
+        if (child.isKind(SyntaxKind.JsxExpression) && child.getExpression() && jsxUnder(child).length === 0)
+            return DYNAMIC_TEXT;
+        return '';
+    }).join(' ');
+    return stripTags([own, ...children.map(c => c.text)].join(' '));
+}
+/** The sides of the conditions between a JSX element and the node that holds it: which side of a `c ? a : b` it is on, or of a `c && a` (against a `!c && b`). */
+function branchesOf(el, parent) {
+    const out = [];
+    for (let child = el, up = el.getParent(); up && up !== parent; child = up, up = up.getParent()) {
+        if (up.isKind(SyntaxKind.ConditionalExpression)) {
+            if (child === up.getWhenTrue())
+                out.unshift({ key: `?${up.getStart()}`, side: 'then' });
+            else if (child === up.getWhenFalse())
+                out.unshift({ key: `?${up.getStart()}`, side: 'else' });
+        }
+        else if (up.isKind(SyntaxKind.BinaryExpression) && up.getOperatorToken().isKind(SyntaxKind.AmpersandAmpersandToken) && child === up.getRight()) {
+            const condition = up.getLeft().getText().replace(/\s+/g, '');
+            const negated = /^!(?!=)/.test(condition);
+            out.unshift({ key: `&&${negated ? condition.slice(1) : condition}`, side: negated ? 'not' : 'is' });
+        }
+    }
+    return out;
+}
+/** The nodes, and what is inside them, are under these sides of conditions: the ones they were already under are the inner ones. */
+function markBranches(nodes, branch) {
+    if (branch.length === 0)
+        return;
+    for (const node of nodes) {
+        node.branch = [...branch, ...(node.branch ?? [])];
+        markBranches(node.children, branch);
+    }
+}
+function nodesUnder(parent, config, file, options) {
+    const nodes = [];
+    for (const el of jsxUnder(parent)) {
+        const made = fromJsx(el, config, file, options);
+        markBranches(made, branchesOf(el, parent));
+        nodes.push(...made);
+    }
+    return nodes;
+}
+/** What a field says in each language: the JSON's (a plain string is the default language's), with the code's value as the default when the JSON has none. */
+function valuesOf(jsonValue, codeDefault) {
+    const map = typeof jsonValue === 'string' ? { default: jsonValue }
+        : typeof jsonValue === 'object' && jsonValue !== null ? Object.fromEntries(Object.entries(jsonValue).filter((entry) => typeof entry[1] === 'string')) : {};
+    if (map.default === undefined && codeDefault !== undefined)
+        map.default = codeDefault;
+    return Object.keys(map).length > 0 ? map : undefined;
+}
+/** Event props that make a button do something, and the attributes that make the browser do it (a submit, a popover…). */
+const ACTION_PROPS = /^(on[A-Z]\w*|form|formAction|popoverTarget|command|commandFor)$/;
+/** Elements that give a button around which it something to do: a form it belongs to, a link it is inside. */
+const ACTING_ANCESTORS = new Set(['form', 'a', 'WrLink', 'Link', 'NavLink']);
+/**
+ * Does pressing this button do anything? Yes when it has a handler (`onClick`…), is a submit/reset button (a `type` the code decides counts),
+ * has props spread into it (they may bring a handler: not knowable, not accused), or sits inside a form or a link. A button that is none of
+ * these is a drawing of a button.
+ */
+function buttonActs(el) {
+    const opening = el.isKind(SyntaxKind.JsxElement) ? el.getOpeningElement() : el;
+    for (const attribute of opening.getAttributes()) {
+        if (attribute.isKind(SyntaxKind.JsxSpreadAttribute))
+            return true;
+        const name = attribute.isKind(SyntaxKind.JsxAttribute) ? attribute.getNameNode().getText() : '';
+        if (ACTION_PROPS.test(name))
+            return true;
+        if (name === 'type') {
+            const type = str(attrOf(el, 'type'));
+            if (type !== 'button')
+                return true;
+        }
+    }
+    return el.getAncestors().some(ancestor => {
+        if (!isJsx(ancestor))
+            return false;
+        const tag = (ancestor.isKind(SyntaxKind.JsxElement) ? ancestor.getOpeningElement() : ancestor).getTagNameNode().getText();
+        return ACTING_ANCESTORS.has(tag);
+    });
+}
+/** Attributes of an element only the accessibility rules read. `{spread}` says props are spread into it: what they bring is not knowable. */
+const A11Y_ATTRS = ['title', 'role', 'type', 'name', 'autoComplete', 'className', 'tabIndex', 'aria-labelledby', 'aria-describedby', 'aria-hidden', 'autoPlay', 'controls', 'muted'];
+const KEY_HANDLERS = ['onKeyDown', 'onKeyUp', 'onKeyPress'];
+function accessibilityAttrs(el) {
+    const out = {};
+    const opening = el.isKind(SyntaxKind.JsxElement) ? el.getOpeningElement() : el;
+    for (const name of A11Y_ATTRS) {
+        const value = attrOf(el, name);
+        if (value !== undefined)
+            out[name === 'className' ? 'class' : name.toLowerCase()] = value === true ? 'true' : String(value);
+    }
+    const names = opening.getAttributes().map(a => (a.isKind(SyntaxKind.JsxAttribute) ? a.getNameNode().getText() : '{spread}'));
+    if (names.includes('onClick'))
+        out.onclick = 'true';
+    if (KEY_HANDLERS.some(handler => names.includes(handler)))
+        out.onkeydown = 'true';
+    if (names.includes('{spread}'))
+        out['{spread}'] = 'true';
+    // Every aria-* the code writes (the names: a typo is found by them), and whether it has a value
+    const aria = names.filter(name => name.startsWith('aria-'));
+    if (aria.length > 0)
+        out['{aria}'] = aria.join(' ');
+    return out;
+}
+function fromJsx(el, config, file, options) {
+    const opening = el.isKind(SyntaxKind.JsxElement) ? el.getOpeningElement() : el;
+    const name = opening.getTagNameNode().getText();
+    const wrKind = WR_COMPONENT_TO_KIND[name];
+    const id = str(attrOf(el, 'id'));
+    const json = (wrKind && id ? config[id] : undefined) ?? {};
+    const hidden = json.hidden === true;
+    if (hidden && !options.includeHidden)
+        return []; // does not render
+    const tag = wrKind ? wrTagOf(wrKind, str(attrOf(el, 'tag'))) : name.toLowerCase();
+    const kind = wrKind ?? 'element';
+    const children = el.isKind(SyntaxKind.JsxElement) ? nodesUnder(el, config, file, options) : [];
+    // Plain components we know nothing about (`<Card>`) are only transparent: what they hold is what counts. A shared one is entered: what it renders is part of the page
+    if (!wrKind && /^[A-Z]/.test(name))
+        return [...sharedNodesOf(el, name, options), ...children];
+    const attrs = {};
+    const alt = inLang(json.alt, options) ?? str(attrOf(el, 'alt'));
+    if (alt !== undefined)
+        attrs.alt = alt;
+    const aria = wrAriaLabel(json, str(attrOf(el, 'aria-label')), options.lang ?? 'default');
+    if (aria !== undefined)
+        attrs['aria-label'] = aria;
+    const href = str(attrOf(el, 'href'));
+    if (href !== undefined)
+        attrs.href = href;
+    Object.assign(attrs, accessibilityAttrs(el));
+    const content = inLang(json.content, options) ?? (wrKind === 'text' ? str(attrOf(el, 'html')) : undefined);
+    const text = content !== undefined ? stripTags(content) : textOf(el, children);
+    // The fields that are translated (the schema says which), in each language
+    const codeDefault = (field) => {
+        switch (field) {
+            case 'content': return wrKind === 'text' ? str(attrOf(el, 'html')) : textOf(el, children) || undefined;
+            case 'alt': return str(attrOf(el, 'alt'));
+            case 'ariaLabel': return str(attrOf(el, 'aria-label'));
+            case 'label':
+            case 'placeholder': return str(attrOf(el, field));
+            default: return undefined;
+        }
+    };
+    const values = {};
+    if (wrKind) {
+        for (const field of multilangFieldsOf(wrKind)) {
+            const perLanguage = valuesOf(json[field], codeDefault(field));
+            if (perLanguage)
+                values[field] = perLanguage;
+        }
+    }
+    // A rich text holds headings and links the code does not show: they are part of the page (the JSON's string is all there is to read)
+    const inside = wrKind === 'text' && content !== undefined
+        ? htmlNodes(content).map(node => ({ ...node, ...(options.scope ? { scope: options.scope } : {}), where: { file, line: el.getStartLineNumber() } }))
+        : [];
+    // The entries of a menu are links the JSON holds
+    const entries = wrKind === 'nav' && Array.isArray(json.items)
+        ? json.items.map((item) => ({
+            kind: 'element', tag: 'a', attrs: typeof item.href === 'string' ? { href: item.href } : {}, text: inLang(item.label, options) ?? '', children: [],
+            ...(options.scope ? { scope: options.scope } : {}), where: { file, line: el.getStartLineNumber() },
+        }))
+        : [];
+    return [{
+            ...(id ? { id } : {}), kind, tag, attrs, text, children: [...children, ...inside, ...entries],
+            ...(tag === 'button' ? { acts: buttonActs(el) } : {}),
+            ...(['input', 'select', 'textarea'].includes(tag) ? { insideLabel: el.getAncestors().some(a => isJsx(a) && (a.isKind(SyntaxKind.JsxElement) ? a.getOpeningElement() : a).getTagNameNode().getText() === 'label') } : {}),
+            ...(options.scope ? { scope: options.scope } : {}),
+            ...(hidden ? { hidden: true } : {}),
+            ...(Object.keys(values).length > 0 ? { values } : {}),
+            where: { file, line: el.getStartLineNumber() },
+        }];
+}
+/**
+ * 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 function checkScopeFromCode(ctx, scope, options = {}) {
+    const syntax = [];
+    options.follow?.seen.add(scope.name);
+    const abs = ctx.resolveInSrc(scope.file);
+    if (!abs)
+        return { name: scope.name, file: scope.file, nodes: [], syntax };
+    const project = ctx.project();
+    let sourceFile;
+    try {
+        sourceFile = project.addSourceFileAtPath(abs);
+    }
+    catch {
+        return { name: scope.name, file: scope.file, nodes: [], syntax };
+    }
+    sourceFile.refreshFromFileSystemSync();
+    for (const { message, line } of syntaxErrors(sourceFile.compilerNode))
+        syntax.push({ file: scope.file, line, message });
+    const rootJsx = findPageRoot(sourceFile);
+    if (!rootJsx)
+        return { name: scope.name, file: scope.file, nodes: [], syntax };
+    const config = readJsonFile(ctx, scope.json) ?? {};
+    const read = { ...options, scope: options.scope ?? scope.name };
+    const nodes = isJsx(rootJsx) ? fromJsx(rootJsx, config, scope.file, read) : nodesUnder(rootJsx, config, scope.file, read);
+    return { name: scope.name, file: scope.file, nodes, syntax };
+}
+/** What a page tells search engines, as the rules read it: every text by language key (a plain string is the default's). */
+function seoOfPage(ctx, name) {
+    const seo = wrSeoPageOf(readJsonFile(ctx, wrPageConfigPath(name)) ?? undefined);
+    const byLang = (value) => typeof value === 'string' ? { default: value } : { ...(value ?? {}) };
+    return { title: byLang(seo.title), description: byLang(seo.description), noindex: seo.noindex === true, family: /\[[^\]]+\]/.test(name), jsonLdProblems: wrJsonLdProblems(seo.jsonLd) };
+}
+/** What a link may lead to: the routes, the languages and the files served as they are. */
+function projectOf(ctx) {
+    const langs = readLangs(ctx);
+    return {
+        routes: Object.keys(readRoutes(ctx)),
+        ...(langs ? { langs: { default: langs.default, available: langs.available } } : {}),
+        publicFiles: listFiles(ctx.publicRoot),
+    };
+}
+/** Every file under a folder, as paths from it (`/robots.txt`, `/media/a.pdf`); none when there is no such folder. */
+function listFiles(dir, prefix = '') {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir, { withFileTypes: true }).flatMap(entry => entry.isDirectory() ? listFiles(path.join(dir, entry.name), `${prefix}/${entry.name}`) : [`${prefix}/${entry.name}`]);
+}
+/**
+ * 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 function checkPagesFromCode(root, lang = 'default') {
+    const ctx = createOperationContext(root, { project: () => new Project({ skipAddingFilesFromTsConfig: true, compilerOptions: { jsx: 4 } }) });
+    const langs = readLangs(ctx);
+    const multilingual = langs !== null && langs.available.length > 1;
+    const project = projectOf(ctx);
+    const labelledIds = idsLabelledInCode(ctx);
+    return Object.keys(readRoutes(ctx)).map(name => {
+        const follow = sharedFollower(ctx);
+        const scopes = scopesOfPage(ctx, name).map(scope => checkScopeFromCode(ctx, scope, { lang, follow }));
+        const syntax = [...scopes.flatMap(scope => scope.syntax), ...follow.syntax];
+        return {
+            name, nodes: scopes.flatMap(scope => scope.nodes), ...(syntax.length ? { syntax } : {}),
+            ...(multilingual ? { lang } : {}), project, labelledIds, seo: seoOfPage(ctx, name),
+        };
+    });
+}
+/**
+ * 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 function languagesOf(root) {
+    const langs = readLangs(createOperationContext(root));
+    if (!langs || langs.available.length < 2)
+        return [{ key: 'default', code: langs?.default ?? 'default' }];
+    return [{ key: 'default', code: langs.default }, ...langs.available.filter(code => code !== langs.default).map(code => ({ key: code, code }))];
+}
+/** What `index.html` says that matters here: the language of the page and the viewport. */
+function readIndexHtml(root) {
+    const file = path.join(root, 'index.html');
+    if (!fs.existsSync(file))
+        return null;
+    const html = fs.readFileSync(file, 'utf-8');
+    const lang = /<html\b[^>]*\blang\s*=\s*["']([^"']+)["']/i.exec(html)?.[1] ?? null;
+    const viewport = /<meta\b[^>]*\bname\s*=\s*["']viewport["'][^>]*\bcontent\s*=\s*["']([^"']*)["']/i.exec(html)?.[1]
+        ?? /<meta\b[^>]*\bcontent\s*=\s*["']([^"']*)["'][^>]*\bname\s*=\s*["']viewport["']/i.exec(html)?.[1] ?? null;
+    return { lang, viewport };
+}
+/** What the checks know of the site as a whole. */
+export function checkSiteFromCode(root) {
+    const ctx = createOperationContext(root);
+    const { orphans, dynamicIds } = findOrphanKeys(ctx);
+    return { seo: readSeoSite(ctx), index: readIndexHtml(ctx.root), css: readCss(ctx.srcRoot), orphans, dynamicIds };
+}
+//# sourceMappingURL=producer-code.js.map

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

@@ -0,0 +1,21 @@
+import type { CheckPage } from './types.js';
+/** What the page holds, as plain data: `wrType` is the raw `data-wr-type`, not yet checked against the kinds. */
+export interface DomNode {
+    id?: string;
+    wrType: string | null;
+    tag: string;
+    attrs: Record<string, string>;
+    text: string;
+    /** A form field that has a `<label>`: it sits inside one, or one points at it (`for`). */
+    labelled?: true;
+    children: DomNode[];
+}
+/**
+ * Reads the children of `root` as plain data. SELF-CONTAINED ON PURPOSE: its source is sent to a browser to be run there
+ * (`serializeDom.toString()`), so it must not import or refer to anything outside itself.
+ */
+export declare function serializeDom(root: Element): DomNode[];
+/** The tree a rule sees, from what `serializeDom` read (wherever it ran). */
+export declare function checkPageFromSerialized(name: string, nodes: readonly DomNode[]): CheckPage;
+export declare function checkPageFromDom(name: string, root: Element): CheckPage;
+//# sourceMappingURL=producer-dom.d.ts.map

package/dist/check/producer-dom.js

@@ -0,0 +1,52 @@
+import { isWrKind } from '@webround/core/kinds';
+/**
+ * Reads the children of `root` as plain data. SELF-CONTAINED ON PURPOSE: its source is sent to a browser to be run there
+ * (`serializeDom.toString()`), so it must not import or refer to anything outside itself.
+ */
+export function serializeDom(root) {
+    const skip = ['script', 'style', 'noscript', 'template'];
+    const attributes = ['alt', 'aria-label', 'aria-labelledby', 'title', 'href'];
+    const fields = ['input', 'select', 'textarea'];
+    // The fields some `<label for>` points at (`closest` and `ownerDocument` are asked with `?.`: a stand-in for the DOM in a test does not have them)
+    const pointedAt = new Set(Array.from(root.ownerDocument?.querySelectorAll('label[for]') ?? []).map(label => label.getAttribute('for')));
+    const visible = (parent) => Array.from(parent.children).filter(child => !skip.includes(child.tagName.toLowerCase()));
+    const read = (el) => {
+        const attrs = {};
+        for (const name of attributes) {
+            const value = el.getAttribute(name);
+            if (value !== null)
+                attrs[name] = value;
+        }
+        const id = el.getAttribute('data-wr-id');
+        const tag = el.tagName.toLowerCase();
+        const fieldId = el.getAttribute('id');
+        const labelled = fields.includes(tag) && (el.closest?.('label') != null || (fieldId !== null && pointedAt.has(fieldId)));
+        return {
+            ...(id ? { id } : {}),
+            wrType: el.getAttribute('data-wr-type'),
+            tag,
+            attrs,
+            ...(labelled ? { labelled: true } : {}),
+            text: (el.textContent ?? '').replace(/\s+/g, ' ').trim(),
+            children: visible(el).map(read),
+        };
+    };
+    return visible(root).map(read);
+}
+function toCheckNode(node) {
+    return {
+        ...(node.id ? { id: node.id } : {}),
+        kind: isWrKind(node.wrType) ? node.wrType : 'element',
+        tag: node.tag, attrs: node.attrs, text: node.text,
+        ...(node.labelled ? { insideLabel: true } : {}),
+        children: node.children.map(toCheckNode),
+    };
+}
+/** The tree a rule sees, from what `serializeDom` read (wherever it ran). */
+export function checkPageFromSerialized(name, nodes) {
+    return { name, source: 'dom', nodes: nodes.map(toCheckNode) };
+}
+export function checkPageFromDom(name, root) {
+    return checkPageFromSerialized(name, serializeDom(root));
+}
+//# sourceMappingURL=producer-dom.js.map

package/dist/check/project.d.ts

@@ -0,0 +1,20 @@
+import { type Issue } from './types.js';
+/**
+ * The same problem found in several languages (by their codes) is ONE issue that says in which: a notification per language would be the same
+ * one n times. The same goes for a problem in a shared component (the header, the footer, a card): it is in every page that has it, but it is one
+ * problem, found in the first. `sharedFiles` are the files of those components.
+ */
+export declare function mergeLanguages(perLanguage: readonly {
+    lang: string;
+    issues: readonly Issue[];
+}[], sharedFiles: readonly string[]): Issue[];
+/**
+ * Everything the checks find in a project: its pages (header and footer included, the way a visitor of each language sees them) and the site
+ * as a whole. ONE function: `wr-check`, and with it the container's tools and a Claude Code hook, and the editor's notifications all call this.
+ * A problem that happens in some languages says which (`langs`); a site with one language says nothing about languages.
+ */
+export declare function checkProject(root: string): Issue[];
+/** Problems the person chose to leave: `src/config/checks.json`, `{ "muted": [key…] }`. */
+export declare const CHECKS_FILE = "config/checks.json";
+export declare const mutedKeys: (root: string) => string[];
+//# sourceMappingURL=project.d.ts.map

package/dist/check/project.js

@@ -0,0 +1,51 @@
+import { checkPagesFromCode, checkSiteFromCode, languagesOf } from './producer-code.js';
+import { runRules, runSiteRules } from './rules.js';
+import { createOperationContext } from '../operations/context.js';
+import { readJsonFile, sharedScopesOf } from '../operations/ops/project.js';
+import { issueKey } from './types.js';
+/**
+ * The same problem found in several languages (by their codes) is ONE issue that says in which: a notification per language would be the same
+ * one n times. The same goes for a problem in a shared component (the header, the footer, a card): it is in every page that has it, but it is one
+ * problem, found in the first. `sharedFiles` are the files of those components.
+ */
+export function mergeLanguages(perLanguage, sharedFiles) {
+    const merged = new Map();
+    for (const { lang, issues } of perLanguage) {
+        for (const issue of issues) {
+            const shared = issue.where !== undefined && sharedFiles.includes(issue.where.file);
+            const same = JSON.stringify([issue.rule, shared ? null : issue.page, issue.nodeId, issue.where, issue.message]);
+            const known = merged.get(same);
+            if (known) {
+                if (!known.langs?.includes(lang))
+                    known.langs = [...(known.langs ?? []), lang];
+            }
+            // A shared component is in every page that has it: its problems are the site's, whichever page found them first
+            else
+                merged.set(same, { ...issue, langs: [lang], key: shared ? issueKey({ rule: issue.rule, page: '_shared', subject: issue.subject, fix: issue.fix }) : issue.key });
+        }
+    }
+    return [...merged.values()];
+}
+/**
+ * Everything the checks find in a project: its pages (header and footer included, the way a visitor of each language sees them) and the site
+ * as a whole. ONE function: `wr-check`, and with it the container's tools and a Claude Code hook, and the editor's notifications all call this.
+ * A problem that happens in some languages says which (`langs`); a site with one language says nothing about languages.
+ */
+export function checkProject(root) {
+    const muted = new Set(mutedKeys(root));
+    return withMuted(checkAll(root), muted);
+}
+/** Problems the person chose to leave: `src/config/checks.json`, `{ "muted": [key…] }`. */
+export const CHECKS_FILE = 'config/checks.json';
+export const mutedKeys = (root) => {
+    const muted = readJsonFile(createOperationContext(root), CHECKS_FILE)?.muted;
+    return Array.isArray(muted) ? muted.filter((key) => typeof key === 'string') : [];
+};
+const withMuted = (issues, muted) => issues.map(issue => (muted.has(issue.key) ? { ...issue, muted: true } : issue));
+function checkAll(root) {
+    const languages = languagesOf(root);
+    const sharedFiles = sharedScopesOf(createOperationContext(root)).map(scope => scope.file);
+    const pages = mergeLanguages(languages.map(({ key, code }) => ({ lang: code, issues: runRules(checkPagesFromCode(root, key)) })), sharedFiles);
+    return [...(languages.length > 1 ? pages : pages.map(({ langs: _langs, ...issue }) => issue)), ...runSiteRules(checkSiteFromCode(root))];
+}
+//# sourceMappingURL=project.js.map

package/dist/check/rules.d.ts

@@ -0,0 +1,7 @@
+import { type CheckPage, type CheckSite, type Issue, type Rule, type SiteRule } from './types.js';
+export declare const RULES: readonly Rule[];
+export declare const SITE_RULES: readonly SiteRule[];
+export declare function runRules(pages: readonly CheckPage[], rules?: readonly Rule[]): Issue[];
+/** What is wrong with the site as a whole, not with one page. */
+export declare function runSiteRules(site: CheckSite, rules?: readonly SiteRule[]): Issue[];
+//# sourceMappingURL=rules.d.ts.map