@design.estate/wcctools 6.0.0 → 6.1.0

package/dist_ts/standards/helpers.ast.js

@@ -0,0 +1,172 @@
+import * as plugins from '../plugins.js';
+const ts = plugins.typescript;
+export const parseSource = (fileArg, textArg) => ts.createSourceFile(fileArg, textArg, ts.ScriptTarget.Latest, true);
+/** 1-based line and column of a position. */
+export const lineAndColumn = (sourceFileArg, positionArg) => {
+    const location = sourceFileArg.getLineAndCharacterOfPosition(positionArg);
+    return { line: location.line + 1, column: location.character + 1 };
+};
+/** The called name of `name(...)` or `a.b.name(...)`. */
+export const calleeName = (expressionArg) => {
+    if (ts.isIdentifier(expressionArg)) {
+        return expressionArg.text;
+    }
+    if (ts.isPropertyAccessExpression(expressionArg)) {
+        return expressionArg.name.text;
+    }
+    return null;
+};
+/** The decorator call named `nameArg` on a node, e.g. `@customElement('x')`. */
+export const findDecoratorCall = (nodeArg, namesArg) => {
+    if (!ts.canHaveDecorators(nodeArg)) {
+        return null;
+    }
+    for (const decorator of ts.getDecorators(nodeArg) ?? []) {
+        if (ts.isCallExpression(decorator.expression)) {
+            const name = calleeName(decorator.expression.expression);
+            if (name && namesArg.includes(name)) {
+                return { name, call: decorator.expression };
+            }
+        }
+    }
+    return null;
+};
+export const hasModifier = (nodeArg, kindArg) => ts.canHaveModifiers(nodeArg) && (ts.getModifiers(nodeArg) ?? []).some((modifierArg) => modifierArg.kind === kindArg);
+/** The text of a member name: identifier, private identifier (with '#'), string or numeric literal. */
+export const memberNameText = (memberArg) => {
+    const name = memberArg.name;
+    if (!name) {
+        return null;
+    }
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    if (ts.isPrivateIdentifier(name)) {
+        return name.text;
+    }
+    return null;
+};
+export const isStatic = (memberArg) => hasModifier(memberArg, ts.SyntaxKind.StaticKeyword);
+/** The static property declaration `static <name> = …` of a class. */
+export const findStaticProperty = (classArg, nameArg) => {
+    for (const member of classArg.members) {
+        if (ts.isPropertyDeclaration(member) && isStatic(member) && memberNameText(member) === nameArg) {
+            return member;
+        }
+    }
+    return null;
+};
+export const isStringLiteralLike = (nodeArg) => !!nodeArg && (ts.isStringLiteral(nodeArg) || ts.isNoSubstitutionTemplateLiteral(nodeArg));
+/** A property assignment `key: value` of an object literal, by key. */
+export const objectProperty = (objectArg, keyArg) => {
+    for (const property of objectArg.properties) {
+        if (ts.isPropertyAssignment(property)) {
+            const name = property.name;
+            if ((ts.isIdentifier(name) || ts.isStringLiteral(name)) && name.text === keyArg) {
+                return property;
+            }
+        }
+    }
+    return null;
+};
+/** The source text of an object literal property's value, or null. */
+export const objectPropertyText = (objectArg, keyArg) => objectProperty(objectArg, keyArg)?.initializer.getText() ?? null;
+/** The indentation (leading whitespace) of the line a position is on. */
+export const indentationAt = (textArg, positionArg) => {
+    const lineStart = textArg.lastIndexOf('\n', positionArg - 1) + 1;
+    return /^[ \t]*/.exec(textArg.slice(lineStart))[0];
+};
+/**
+ * The edit that adds `propertyTextArg` (e.g. `reflect: true`) as the last property of an object
+ * literal, following the literal's own layout: inline literals stay on one line, multi-line
+ * literals get a new line with the indentation of their last property.
+ */
+export const appendObjectPropertyEdit = (objectArg, propertyTextArg) => {
+    const sourceText = objectArg.getSourceFile().text;
+    const properties = objectArg.properties;
+    if (properties.length === 0) {
+        return { start: objectArg.getStart(), end: objectArg.end, text: `{ ${propertyTextArg} }` };
+    }
+    const last = properties[properties.length - 1];
+    const closeBrace = objectArg.end - 1;
+    const between = sourceText.slice(last.end, closeBrace);
+    const multiLine = sourceText.slice(objectArg.getStart(), objectArg.end).includes('\n');
+    if (multiLine) {
+        const indentation = indentationAt(sourceText, last.getStart());
+        const commaIndex = between.indexOf(',');
+        if (commaIndex !== -1) {
+            const at = last.end + commaIndex + 1;
+            return { start: at, end: at, text: `\n${indentation}${propertyTextArg},` };
+        }
+        return { start: last.end, end: last.end, text: `,\n${indentation}${propertyTextArg}` };
+    }
+    return { start: last.end, end: last.end, text: `, ${propertyTextArg}` };
+};
+/** The edit that adds `propertyTextArg` (e.g. `type: String`) as the first property of an object literal. */
+export const prependObjectPropertyEdit = (objectArg, propertyTextArg) => {
+    const sourceText = objectArg.getSourceFile().text;
+    const properties = objectArg.properties;
+    if (properties.length === 0) {
+        return { start: objectArg.getStart(), end: objectArg.end, text: `{ ${propertyTextArg} }` };
+    }
+    const first = properties[0];
+    const multiLine = sourceText.slice(objectArg.getStart(), objectArg.end).includes('\n');
+    const start = first.getStart();
+    if (multiLine && sourceText.slice(objectArg.getStart() + 1, start).includes('\n')) {
+        return { start, end: start, text: `${propertyTextArg},\n${indentationAt(sourceText, start)}` };
+    }
+    return { start, end: start, text: `${propertyTextArg}, ` };
+};
+/** The position after the last import declaration, at the start of the following line; 0 without imports. */
+export const afterLastImport = (sourceFileArg) => {
+    let position = 0;
+    for (const statement of sourceFileArg.statements) {
+        if (ts.isImportDeclaration(statement) || ts.isImportEqualsDeclaration(statement)) {
+            position = statement.end;
+        }
+    }
+    if (position === 0) {
+        return 0;
+    }
+    const newline = sourceFileArg.text.indexOf('\n', position);
+    return newline === -1 ? sourceFileArg.text.length : newline + 1;
+};
+/** The module an identifier is imported from in a file, e.g. `html` → `lit`. */
+export const importSourceOf = (sourceFileArg, identifierArg) => {
+    for (const statement of sourceFileArg.statements) {
+        if (!ts.isImportDeclaration(statement) || !statement.importClause || !ts.isStringLiteral(statement.moduleSpecifier)) {
+            continue;
+        }
+        const clause = statement.importClause;
+        if (clause.name?.text === identifierArg) {
+            return statement.moduleSpecifier.text;
+        }
+        const bindings = clause.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings) && bindings.name.text === identifierArg) {
+            return statement.moduleSpecifier.text;
+        }
+        if (bindings && ts.isNamedImports(bindings) && bindings.elements.some((elementArg) => elementArg.name.text === identifierArg)) {
+            return statement.moduleSpecifier.text;
+        }
+    }
+    return null;
+};
+/** Every relative-capable module specifier literal of a file: imports, re-exports, dynamic `import()` and `import('…')` types. */
+export const moduleSpecifierLiterals = (sourceFileArg) => {
+    const found = [];
+    const visit = (nodeArg) => {
+        if ((ts.isImportDeclaration(nodeArg) || ts.isExportDeclaration(nodeArg)) && nodeArg.moduleSpecifier && isStringLiteralLike(nodeArg.moduleSpecifier)) {
+            found.push(nodeArg.moduleSpecifier);
+        }
+        else if (ts.isCallExpression(nodeArg) && nodeArg.expression.kind === ts.SyntaxKind.ImportKeyword && isStringLiteralLike(nodeArg.arguments[0])) {
+            found.push(nodeArg.arguments[0]);
+        }
+        else if (ts.isImportTypeNode(nodeArg) && ts.isLiteralTypeNode(nodeArg.argument) && isStringLiteralLike(nodeArg.argument.literal)) {
+            found.push(nodeArg.argument.literal);
+        }
+        ts.forEachChild(nodeArg, visit);
+    };
+    visit(sourceFileArg);
+    return found;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.ast.js","sourceRoot":"","sources":["../../../ts/standards/helpers.ast.ts"],"names":[],"mappings":"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"}

package/dist_ts/standards/helpers.paths.d.ts

@@ -0,0 +1,36 @@
+export declare const toPosix: (pathArg: string) => string;
+export declare const dirOf: (fileArg: string) => string;
+export declare const baseOf: (fileArg: string) => string;
+export declare const joinPath: (...partsArg: string[]) => string;
+/** A demo file: `<name>.demo.ts`, `demo.ts`, `<name>.demodata.ts` (and similar), or any file under `ts_web/demos/`. */
+export declare const isDemoFile: (fileArg: string) => boolean;
+export declare const isTypeScriptSource: (fileArg: string) => boolean;
+/**
+ * True for a path the fixer may write: relative to the repository root, '/' separators, already
+ * normalised, and without '.' or '..' segments, so it cannot leave the root lexically.
+ */
+export declare const isRepoPath: (pathArg: string) => boolean;
+/**
+ * How a relative module specifier spells its target: `exact` names the file itself (`./x.ts`,
+ * `./data.json`, `./x.d.ts`), `js` names a TypeScript file by its emitted extension (`./x.js` for
+ * `x.ts` or `x.d.ts`), `none` leaves the extension out (`./x`, or `./folder` for its index file).
+ */
+type TSpecifierStyle = 'exact' | 'js' | 'none';
+export interface IResolvedSpecifier {
+    /** The resolved repository path. */
+    target: string;
+    style: TSpecifierStyle;
+    /** True when the specifier names a folder and resolved to its index file. */
+    viaFolder: boolean;
+}
+/**
+ * Resolves a relative module specifier against the importing file the way NodeNext resolution
+ * does: an emitted `.js` specifier maps back to its `.ts`, `.tsx` or `.d.ts` source, any other
+ * specifier that names a known file exactly resolves to it (`.ts`, `.json`, `.css`, `.d.ts`, …), and
+ * an extensionless one to a source or a folder's index file. Returns null for package specifiers
+ * and for targets that are not among the known files.
+ */
+export declare const resolveSpecifier: (fromFileArg: string, specifierArg: string, existsArg: (fileArg: string) => boolean) => IResolvedSpecifier | null;
+/** The relative specifier from a file to a target, spelled in the given style. */
+export declare const specifierFor: (fromFileArg: string, targetArg: string, styleArg: TSpecifierStyle, viaFolderArg?: boolean) => string;
+export {};

package/dist_ts/standards/helpers.paths.js

@@ -0,0 +1,86 @@
+import * as plugins from '../plugins.js';
+/**
+ * Repository paths in the standard are relative to the repository root with '/' separators.
+ */
+const posix = plugins.path.posix;
+export const toPosix = (pathArg) => pathArg.split(plugins.path.sep).join('/');
+export const dirOf = (fileArg) => posix.dirname(fileArg);
+export const baseOf = (fileArg) => posix.basename(fileArg);
+export const joinPath = (...partsArg) => posix.normalize(posix.join(...partsArg));
+/** A demo file: `<name>.demo.ts`, `demo.ts`, `<name>.demodata.ts` (and similar), or any file under `ts_web/demos/`. */
+export const isDemoFile = (fileArg) => /(^|[./-])demo(data)?\.ts$/.test(baseOf(fileArg)) || fileArg.startsWith('ts_web/demos/');
+export const isTypeScriptSource = (fileArg) => /\.(ts|tsx|mts|cts)$/.test(fileArg) && !/\.d\.(ts|mts|cts)$/.test(fileArg);
+/**
+ * True for a path the fixer may write: relative to the repository root, '/' separators, already
+ * normalised, and without '.' or '..' segments, so it cannot leave the root lexically.
+ */
+export const isRepoPath = (pathArg) => pathArg.length > 0
+    && !pathArg.includes('\\')
+    && !pathArg.includes('\0')
+    && posix.normalize(pathArg) === pathArg
+    && pathArg.split('/').every((segmentArg) => segmentArg !== '' && segmentArg !== '.' && segmentArg !== '..');
+/** The files an emitted extension stands for, in NodeNext resolution order. */
+const sourcesOfEmittedExtension = {
+    '.js': ['.ts', '.tsx', '.d.ts'],
+    '.jsx': ['.tsx'],
+    '.mjs': ['.mts', '.d.mts'],
+    '.cjs': ['.cts', '.d.cts'],
+};
+/** The files an extensionless specifier stands for, in resolution order. */
+const extensionlessSuffixes = ['.ts', '.tsx', '.d.ts'];
+const folderIndexSuffixes = ['/index.ts', '/index.tsx', '/index.d.ts'];
+const typeScriptExtension = /(\.d)?\.(ts|tsx|mts|cts)$/;
+/**
+ * Resolves a relative module specifier against the importing file the way NodeNext resolution
+ * does: an emitted `.js` specifier maps back to its `.ts`, `.tsx` or `.d.ts` source, any other
+ * specifier that names a known file exactly resolves to it (`.ts`, `.json`, `.css`, `.d.ts`, …), and
+ * an extensionless one to a source or a folder's index file. Returns null for package specifiers
+ * and for targets that are not among the known files.
+ */
+export const resolveSpecifier = (fromFileArg, specifierArg, existsArg) => {
+    if (!specifierArg.startsWith('./') && !specifierArg.startsWith('../')) {
+        return null;
+    }
+    const raw = joinPath(dirOf(fromFileArg), specifierArg);
+    const extension = posix.extname(raw);
+    for (const sourceExtension of sourcesOfEmittedExtension[extension] ?? []) {
+        const target = raw.slice(0, -extension.length) + sourceExtension;
+        if (existsArg(target)) {
+            return { target, style: 'js', viaFolder: false };
+        }
+    }
+    if (existsArg(raw)) {
+        return { target: raw, style: 'exact', viaFolder: false };
+    }
+    for (const suffix of extensionlessSuffixes) {
+        if (existsArg(`${raw}${suffix}`)) {
+            return { target: `${raw}${suffix}`, style: 'none', viaFolder: false };
+        }
+    }
+    for (const suffix of folderIndexSuffixes) {
+        if (existsArg(`${raw}${suffix}`)) {
+            return { target: `${raw}${suffix}`, style: 'none', viaFolder: true };
+        }
+    }
+    return null;
+};
+/** The relative specifier from a file to a target, spelled in the given style. */
+export const specifierFor = (fromFileArg, targetArg, styleArg, viaFolderArg = false) => {
+    let target = targetArg;
+    if (styleArg === 'none' && viaFolderArg && /^index(\.d)?\.(ts|tsx)$/.test(baseOf(target))) {
+        target = dirOf(target);
+    }
+    else if (styleArg === 'none') {
+        target = target.replace(typeScriptExtension, '');
+    }
+    else if (styleArg === 'js') {
+        const emitted = { ts: '.js', tsx: '.jsx', mts: '.mjs', cts: '.cjs' };
+        target = target.replace(typeScriptExtension, (_matchArg, _declarationArg, extensionArg) => emitted[extensionArg]);
+    }
+    let relative = posix.relative(dirOf(fromFileArg), target);
+    if (!relative.startsWith('.')) {
+        relative = `./${relative}`;
+    }
+    return relative;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/index.d.ts

@@ -0,0 +1,14 @@
+export { initialBaselines, rekeyStandardConfig, updatedBaselines, type IBaselineRaise } from './baselines.js';
+export { checkStandard, describeStandardRules, detectFindings, rulesOfProfile, type IDetectedFinding } from './checker.js';
+export { GitRepo } from './classes.gitrepo.js';
+export { SourceEdits } from './classes.sourceedits.js';
+export { StandardFixer, type IStandardFixOptions } from './classes.standardfixer.js';
+export { StandardProject, loadStandardProject, type IStandardElement, type IStandardProperty } from './classes.standardproject.js';
+export { FixBatch, StandardTree } from './classes.standardtree.js';
+export { SmartconfigStandardConfigWriter, openStandardConfig, validateStandardConfig, wcctoolsConfigKey, type ILoadedStandardConfig, type IOpenedStandardConfig, type IStandardConfigWriter, } from './config.js';
+export { StandardConfigError, StandardUsageError } from './errors.js';
+export { isDemoFile, resolveSpecifier, specifierFor } from './helpers.paths.js';
+export { registerStandardCommands } from './cli.js';
+export { renderFixResult, renderStandardReport } from './output.js';
+export { initBaselines, updateBaselines, type IBaselineRunResult } from './ratchet.js';
+export { allowlistStaleRuleId, fixOrder, standardRules } from './rules/index.js';

package/dist_ts/standards/index.js

@@ -0,0 +1,15 @@
+export { initialBaselines, rekeyStandardConfig, updatedBaselines } from './baselines.js';
+export { checkStandard, describeStandardRules, detectFindings, rulesOfProfile } from './checker.js';
+export { GitRepo } from './classes.gitrepo.js';
+export { SourceEdits } from './classes.sourceedits.js';
+export { StandardFixer } from './classes.standardfixer.js';
+export { StandardProject, loadStandardProject } from './classes.standardproject.js';
+export { FixBatch, StandardTree } from './classes.standardtree.js';
+export { SmartconfigStandardConfigWriter, openStandardConfig, validateStandardConfig, wcctoolsConfigKey, } from './config.js';
+export { StandardConfigError, StandardUsageError } from './errors.js';
+export { isDemoFile, resolveSpecifier, specifierFor } from './helpers.paths.js';
+export { registerStandardCommands } from './cli.js';
+export { renderFixResult, renderStandardReport } from './output.js';
+export { initBaselines, updateBaselines } from './ratchet.js';
+export { allowlistStaleRuleId, fixOrder, standardRules } from './rules/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9zdGFuZGFyZHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLG1CQUFtQixFQUFFLGdCQUFnQixFQUF1QixNQUFNLGdCQUFnQixDQUFDO0FBQzlHLE9BQU8sRUFBRSxhQUFhLEVBQUUscUJBQXFCLEVBQUUsY0FBYyxFQUFFLGNBQWMsRUFBeUIsTUFBTSxjQUFjLENBQUM7QUFDM0gsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsYUFBYSxFQUE0QixNQUFNLDRCQUE0QixDQUFDO0FBQ3JGLE9BQU8sRUFBRSxlQUFlLEVBQUUsbUJBQW1CLEVBQWlELE1BQU0sOEJBQThCLENBQUM7QUFDbkksT0FBTyxFQUFFLFFBQVEsRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNuRSxPQUFPLEVBQ0wsK0JBQStCLEVBQy9CLGtCQUFrQixFQUNsQixzQkFBc0IsRUFDdEIsaUJBQWlCLEdBSWxCLE1BQU0sYUFBYSxDQUFDO0FBQ3JCLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUN0RSxPQUFPLEVBQUUsVUFBVSxFQUFFLGdCQUFnQixFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2hGLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUNwRCxPQUFPLEVBQUUsZUFBZSxFQUFFLG9CQUFvQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3BFLE9BQU8sRUFBRSxhQUFhLEVBQUUsZUFBZSxFQUEyQixNQUFNLGNBQWMsQ0FBQztBQUN2RixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDIn0=

package/dist_ts/standards/output.d.ts

@@ -0,0 +1,7 @@
+import * as plugins from '../plugins.js';
+type IStandardReport = plugins.interfaces.IStandardReport;
+/** The text form of a check report: findings grouped by file, then a summary. */
+export declare const renderStandardReport: (reportArg: IStandardReport, verboseArg: boolean) => string[];
+/** The text form of a fix result: the changes, then the check that remains. */
+export declare const renderFixResult: (resultArg: plugins.interfaces.IStandardFixResult, verboseArg: boolean) => string[];
+export {};

package/dist_ts/standards/output.js

@@ -0,0 +1,57 @@
+import * as plugins from '../plugins.js';
+const isShown = (findingArg, verboseArg) => verboseArg || (!findingArg.covered && findingArg.severity !== 'info');
+/** The text form of a check report: findings grouped by file, then a summary. */
+export const renderStandardReport = (reportArg, verboseArg) => {
+    const lines = [];
+    let currentFile = null;
+    for (const finding of reportArg.findings.filter((findingArg) => isShown(findingArg, verboseArg))) {
+        if (finding.file !== currentFile) {
+            if (currentFile !== null) {
+                lines.push('');
+            }
+            lines.push(finding.file);
+            currentFile = finding.file;
+        }
+        const notes = [finding.fixable ? 'fixable' : '', finding.covered ? `covered by the ${finding.covered}` : ''].filter(Boolean);
+        lines.push(`  ${finding.line}:${finding.column}  ${finding.severity}  ${finding.ruleId}  ${finding.message}${notes.length ? ` (${notes.join(', ')})` : ''}`);
+    }
+    if (verboseArg && reportArg.baselineSlack.length > 0) {
+        lines.push('', 'Below their baseline:');
+        for (const slack of reportArg.baselineSlack) {
+            lines.push(`  ${slack.ruleId}  ${slack.file}  ${slack.baseline} → ${slack.current}`);
+        }
+    }
+    const count = (predicateArg) => reportArg.findings.filter(predicateArg).length;
+    const failing = count((findingArg) => findingArg.severity === 'error' && !findingArg.covered);
+    const warnings = count((findingArg) => findingArg.severity === 'warn' && !findingArg.covered);
+    const infos = count((findingArg) => findingArg.severity === 'info' && !findingArg.covered);
+    const allowlisted = count((findingArg) => findingArg.covered === 'allowlist');
+    const baselined = count((findingArg) => findingArg.covered === 'baseline');
+    if (lines.length > 0) {
+        lines.push('');
+    }
+    lines.push(`wcctools check (${reportArg.profile}): ${failing} error(s), ${warnings} warning(s), ${infos} info; `
+        + `${allowlisted} allowlisted, ${baselined} within baselines, ${reportArg.baselineSlack.length} file(s) below their baseline — ${reportArg.ok ? 'ok' : 'failed'}`);
+    return lines;
+};
+/** The text form of a fix result: the changes, then the check that remains. */
+export const renderFixResult = (resultArg, verboseArg) => {
+    const { plan } = resultArg;
+    const lines = [resultArg.dryRun ? 'wcctools fix --dry-run would make these changes:' : 'wcctools fix made these changes:'];
+    for (const move of plan.moves) {
+        lines.push(`  git mv ${move.from} ${move.to}`);
+    }
+    for (const file of plan.created) {
+        lines.push(`  create ${file}`);
+    }
+    for (const edited of plan.edited) {
+        lines.push(`  edit ${edited.file} (${edited.ruleIds.join(', ')})`);
+    }
+    if (plan.moves.length + plan.created.length + plan.edited.length === 0) {
+        lines.push('  nothing to fix');
+    }
+    lines.push('', resultArg.dryRun ? 'Remaining after the fix:' : 'Remaining:');
+    lines.push(...renderStandardReport(resultArg.remaining, verboseArg));
+    return lines;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0cHV0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvc3RhbmRhcmRzL291dHB1dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGVBQWUsQ0FBQztBQUt6QyxNQUFNLE9BQU8sR0FBRyxDQUFDLFVBQTRCLEVBQUUsVUFBbUIsRUFBVyxFQUFFLENBQzdFLFVBQVUsSUFBSSxDQUFDLENBQUMsVUFBVSxDQUFDLE9BQU8sSUFBSSxVQUFVLENBQUMsUUFBUSxLQUFLLE1BQU0sQ0FBQyxDQUFDO0FBRXhFLGlGQUFpRjtBQUNqRixNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxDQUFDLFNBQTBCLEVBQUUsVUFBbUIsRUFBWSxFQUFFO0lBQ2hHLE1BQU0sS0FBSyxHQUFhLEVBQUUsQ0FBQztJQUMzQixJQUFJLFdBQVcsR0FBa0IsSUFBSSxDQUFDO0lBQ3RDLEtBQUssTUFBTSxPQUFPLElBQUksU0FBUyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQ2pHLElBQUksT0FBTyxDQUFDLElBQUksS0FBSyxXQUFXLEVBQUUsQ0FBQztZQUNqQyxJQUFJLFdBQVcsS0FBSyxJQUFJLEVBQUUsQ0FBQztnQkFDekIsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUNqQixDQUFDO1lBQ0QsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDekIsV0FBVyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUM7UUFDN0IsQ0FBQztRQUNELE1BQU0sS0FBSyxHQUFHLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsa0JBQWtCLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzdILEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxPQUFPLENBQUMsSUFBSSxJQUFJLE9BQU8sQ0FBQyxNQUFNLEtBQUssT0FBTyxDQUFDLFFBQVEsS0FBSyxPQUFPLENBQUMsTUFBTSxLQUFLLE9BQU8sQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsS0FBSyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDL0osQ0FBQztJQUNELElBQUksVUFBVSxJQUFJLFNBQVMsQ0FBQyxhQUFhLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ3JELEtBQUssQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLHVCQUF1QixDQUFDLENBQUM7UUFDeEMsS0FBSyxNQUFNLEtBQUssSUFBSSxTQUFTLENBQUMsYUFBYSxFQUFFLENBQUM7WUFDNUMsS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLEtBQUssQ0FBQyxNQUFNLEtBQUssS0FBSyxDQUFDLElBQUksS0FBSyxLQUFLLENBQUMsUUFBUSxNQUFNLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ3ZGLENBQUM7SUFDSCxDQUFDO0lBQ0QsTUFBTSxLQUFLLEdBQUcsQ0FBQyxZQUF1RCxFQUFVLEVBQUUsQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQyxNQUFNLENBQUM7SUFDbEksTUFBTSxPQUFPLEdBQUcsS0FBSyxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsUUFBUSxLQUFLLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM5RixNQUFNLFFBQVEsR0FBRyxLQUFLLENBQUMsQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLEtBQUssTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzlGLE1BQU0sS0FBSyxHQUFHLEtBQUssQ0FBQyxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLFFBQVEsS0FBSyxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDM0YsTUFBTSxXQUFXLEdBQUcsS0FBSyxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsT0FBTyxLQUFLLFdBQVcsQ0FBQyxDQUFDO0lBQzlFLE1BQU0sU0FBUyxHQUFHLEtBQUssQ0FBQyxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sS0FBSyxVQUFVLENBQUMsQ0FBQztJQUMzRSxJQUFJLEtBQUssQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDckIsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNqQixDQUFDO0lBQ0QsS0FBSyxDQUFDLElBQUksQ0FDUixtQkFBbUIsU0FBUyxDQUFDLE9BQU8sTUFBTSxPQUFPLGNBQWMsUUFBUSxnQkFBZ0IsS0FBSyxTQUFTO1VBQ25HLEdBQUcsV0FBVyxpQkFBaUIsU0FBUyxzQkFBc0IsU0FBUyxDQUFDLGFBQWEsQ0FBQyxNQUFNLG1DQUFtQyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUNsSyxDQUFDO0lBQ0YsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDLENBQUM7QUFFRiwrRUFBK0U7QUFDL0UsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLENBQUMsU0FBZ0QsRUFBRSxVQUFtQixFQUFZLEVBQUU7SUFDakgsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLFNBQVMsQ0FBQztJQUMzQixNQUFNLEtBQUssR0FBYSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLGtEQUFrRCxDQUFDLENBQUMsQ0FBQyxrQ0FBa0MsQ0FBQyxDQUFDO0lBQ3JJLEtBQUssTUFBTSxJQUFJLElBQUksSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQzlCLEtBQUssQ0FBQyxJQUFJLENBQUMsWUFBWSxJQUFJLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ2pELENBQUM7SUFDRCxLQUFLLE1BQU0sSUFBSSxJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNoQyxLQUFLLENBQUMsSUFBSSxDQUFDLFlBQVksSUFBSSxFQUFFLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBQ0QsS0FBSyxNQUFNLE1BQU0sSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDakMsS0FBSyxDQUFDLElBQUksQ0FBQyxVQUFVLE1BQU0sQ0FBQyxJQUFJLEtBQUssTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3JFLENBQUM7SUFDRCxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3ZFLEtBQUssQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBQ0QsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsMEJBQTBCLENBQUMsQ0FBQyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzdFLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxvQkFBb0IsQ0FBQyxTQUFTLENBQUMsU0FBUyxFQUFFLFVBQVUsQ0FBQyxDQUFDLENBQUM7SUFDckUsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDLENBQUMifQ==

package/dist_ts/standards/ratchet.d.ts

@@ -0,0 +1,15 @@
+import * as plugins from '../plugins.js';
+import { type IBaselineRaise } from './baselines.js';
+import type { IOpenedStandardConfig } from './config.js';
+export interface IBaselineRunResult {
+    /** The check with the configuration as it is after the run. */
+    report: plugins.interfaces.IStandardReport;
+    /** Files per rule written to the baselines; 0 when nothing was written. */
+    writtenFiles: number;
+    /** For --update-baseline: counts that would have to grow; the update was refused when not empty. */
+    raised: IBaselineRaise[];
+}
+/** `wcctools check --init-baseline`: records the current error counts; only while no baseline exists. */
+export declare const initBaselines: (rootDirArg: string, openedArg: IOpenedStandardConfig) => Promise<IBaselineRunResult>;
+/** `wcctools check --update-baseline`: lowers counts to the current ones, removes zeros, refuses to raise any. */
+export declare const updateBaselines: (rootDirArg: string, openedArg: IOpenedStandardConfig) => Promise<IBaselineRunResult>;

package/dist_ts/standards/ratchet.js

@@ -0,0 +1,45 @@
+import * as plugins from '../plugins.js';
+import { initialBaselines, updatedBaselines } from './baselines.js';
+import { checkStandard } from './checker.js';
+import { loadStandardProject } from './classes.standardproject.js';
+import { StandardUsageError } from './errors.js';
+const hasBaselines = (configArg) => Object.values(configArg.baselines ?? {}).some((countsArg) => Object.keys(countsArg).length > 0);
+const withBaselines = (configArg, baselinesArg) => {
+    const config = { ...configArg };
+    delete config.baselines;
+    return Object.keys(baselinesArg).length > 0 ? { ...config, baselines: baselinesArg } : config;
+};
+const countFiles = (baselinesArg) => Object.values(baselinesArg).reduce((sumArg, countsArg) => sumArg + Object.keys(countsArg).length, 0);
+/** `wcctools check --init-baseline`: records the current error counts; only while no baseline exists. */
+export const initBaselines = async (rootDirArg, openedArg) => {
+    const { loaded, writer } = openedArg;
+    if (hasBaselines(loaded.config)) {
+        throw new StandardUsageError('standard.baselines already exist; lower them with --update-baseline');
+    }
+    const project = await loadStandardProject(rootDirArg);
+    const baselines = initialBaselines(checkStandard(project, loaded));
+    const config = withBaselines(loaded.config, baselines);
+    if (countFiles(baselines) > 0) {
+        await writer.writeStandardConfig(config);
+    }
+    return { report: checkStandard(project, { ...loaded, config }), writtenFiles: countFiles(baselines), raised: [] };
+};
+/** `wcctools check --update-baseline`: lowers counts to the current ones, removes zeros, refuses to raise any. */
+export const updateBaselines = async (rootDirArg, openedArg) => {
+    const { loaded, writer } = openedArg;
+    if (!hasBaselines(loaded.config)) {
+        throw new StandardUsageError('standard.baselines do not exist; record them with --init-baseline');
+    }
+    const project = await loadStandardProject(rootDirArg);
+    const report = checkStandard(project, loaded);
+    const { baselines, raised } = updatedBaselines(report, loaded.config.baselines);
+    if (raised.length > 0) {
+        return { report, writtenFiles: 0, raised };
+    }
+    const config = withBaselines(loaded.config, baselines);
+    if (JSON.stringify(config) !== JSON.stringify(loaded.config)) {
+        await writer.writeStandardConfig(config);
+    }
+    return { report: checkStandard(project, { ...loaded, config }), writtenFiles: countFiles(baselines), raised };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/rule.d.ts

@@ -0,0 +1,50 @@
+import * as plugins from '../plugins.js';
+import type { StandardProject } from './classes.standardproject.js';
+type TStandardProfile = plugins.interfaces.TStandardProfile;
+type TStandardSeverity = plugins.interfaces.TStandardSeverity;
+/** Collects the changes of one fix run of one rule; the fixer applies them to its in-memory tree. */
+export interface IFixBuilder {
+    /** Replaces the span [start, end) of a file's current text. Identical edits are applied once. */
+    edit(fileArg: string, startArg: number, endArg: number, textArg: string): void;
+    /** Creates a file; skipped when the path exists. */
+    create(fileArg: string, textArg: string): void;
+    /** Moves a file (`git mv`) and rewrites every relative module specifier that resolves to it. */
+    move(fromArg: string, toArg: string): void;
+    /**
+     * In this run's moves, `export … from` declarations of barrels (index.ts) that resolve to `targetArg`
+     * point at `barrelTargetArg` instead, e.g. at the new element folder's index.ts.
+     */
+    redirectBarrelExports(targetArg: string, barrelTargetArg: string): void;
+}
+export type TFixAction = (builderArg: IFixBuilder) => void;
+export interface IRuleFinding {
+    file: string;
+    /** Offset in the file's text; 0 for file-level findings and for files that do not exist. */
+    position: number;
+    message: string;
+    /** Allowlist key: '<file>#<member>' or '<file>'. */
+    key: string;
+    /** Set when `wcctools fix` resolves the finding. */
+    fix?: TFixAction;
+}
+export interface IRuleContext {
+    project: StandardProject;
+    config: plugins.interfaces.IStandardConfig;
+    profile: TStandardProfile;
+}
+/** One rule of docs/standard.md. */
+export interface IStandardRule {
+    id: string;
+    /** Severity per profile; a rule without a `base` severity belongs to `dees` only. `dees` falls back to `base`. */
+    severity: {
+        base?: TStandardSeverity;
+        dees?: TStandardSeverity;
+    };
+    fixMode: plugins.interfaces.TStandardFixMode;
+    /** Categories an allowlist entry may use; absent when the rule takes no allowlist. */
+    allowlistCategories?: readonly string[];
+    detect(contextArg: IRuleContext): IRuleFinding[];
+}
+/** The rule's severity in a profile, or null when the rule is not part of it. */
+export declare const severityIn: (ruleArg: IStandardRule, profileArg: TStandardProfile) => TStandardSeverity | null;
+export {};

package/dist_ts/standards/rule.js

@@ -0,0 +1,9 @@
+import * as plugins from '../plugins.js';
+/** The rule's severity in a profile, or null when the rule is not part of it. */
+export const severityIn = (ruleArg, profileArg) => {
+    if (profileArg === 'dees') {
+        return ruleArg.severity.dees ?? ruleArg.severity.base ?? null;
+    }
+    return ruleArg.severity.base ?? null;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL3N0YW5kYXJkcy9ydWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sZUFBZSxDQUFDO0FBbUR6QyxpRkFBaUY7QUFDakYsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLENBQUMsT0FBc0IsRUFBRSxVQUE0QixFQUE0QixFQUFFO0lBQzNHLElBQUksVUFBVSxLQUFLLE1BQU0sRUFBRSxDQUFDO1FBQzFCLE9BQU8sT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDO0lBQ2hFLENBQUM7SUFDRCxPQUFPLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQztBQUN2QyxDQUFDLENBQUMifQ==

package/dist_ts/standards/rules/barrel.element-index.d.ts

@@ -0,0 +1,7 @@
+import type { IStandardRule } from '../rule.js';
+/**
+ * An element folder has `index.ts` re-exporting the entry file (and `types.ts`); a group folder's
+ * `index.ts` re-exports each element folder's `index.ts`; `ts_web/elements/index.ts` re-exports each
+ * group or element folder.
+ */
+export declare const barrelElementIndexRule: IStandardRule;