@design.estate/wcctools 5.1.0 → 6.1.0

package/dist_ts/standards/config.js

@@ -0,0 +1,139 @@
+import * as plugins from '../plugins.js';
+import { StandardConfigError } from './errors.js';
+import { severityIn } from './rule.js';
+import { standardRules } from './rules/index.js';
+/** The key of wcctools' configuration in `.smartconfig.json`. */
+export const wcctoolsConfigKey = '@design.estate/wcctools';
+/**
+ * Writes through the Smartconfig instance that read the configuration, so a write is refused
+ * (SmartconfigChangedError) when `.smartconfig.json` changed in between. Other keys of the
+ * `@design.estate/wcctools` block keep their values.
+ */
+export class SmartconfigStandardConfigWriter {
+    smartconfig;
+    constructor(smartconfigArg) {
+        this.smartconfig = smartconfigArg;
+    }
+    async writeStandardConfig(configArg) {
+        const block = this.smartconfig.dataFor(wcctoolsConfigKey, {});
+        await this.smartconfig.writeDataFor(wcctoolsConfigKey, { ...block, standard: configArg });
+    }
+}
+const isPlainObject = (valueArg) => typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+const knownKeys = ['profile', 'tagPrefix', 'groupNames', 'allowlist', 'baselines'];
+/** Validates the `standard` object; collects every problem into one StandardConfigError. */
+export const validateStandardConfig = (valueArg) => {
+    const problems = [];
+    if (valueArg === undefined) {
+        throw new StandardConfigError([`"${wcctoolsConfigKey}".standard is missing`]);
+    }
+    if (!isPlainObject(valueArg)) {
+        throw new StandardConfigError([`"${wcctoolsConfigKey}".standard must be an object`]);
+    }
+    for (const key of Object.keys(valueArg)) {
+        if (!knownKeys.includes(key)) {
+            problems.push(`standard.${key} is not a known key (${knownKeys.join(', ')})`);
+        }
+    }
+    const profile = valueArg.profile ?? 'base';
+    if (profile !== 'base' && profile !== 'dees') {
+        problems.push(`standard.profile must be 'base' or 'dees'`);
+    }
+    if (valueArg.tagPrefix === undefined) {
+        problems.push('standard.tagPrefix is missing');
+    }
+    else if (typeof valueArg.tagPrefix !== 'string' || !/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(valueArg.tagPrefix)) {
+        problems.push('standard.tagPrefix must be a lowercase tag prefix without the trailing hyphen, e.g. "dees"');
+    }
+    if (valueArg.groupNames !== undefined) {
+        if (!isPlainObject(valueArg.groupNames)) {
+            problems.push('standard.groupNames must be an object of area → display name');
+        }
+        else {
+            for (const [area, name] of Object.entries(valueArg.groupNames)) {
+                if (typeof name !== 'string' || name.length === 0) {
+                    problems.push(`standard.groupNames.${area} must be a non-empty string`);
+                }
+            }
+        }
+    }
+    const rulesById = new Map(standardRules.map((ruleArg) => [ruleArg.id, ruleArg]));
+    if (valueArg.allowlist !== undefined) {
+        if (!isPlainObject(valueArg.allowlist)) {
+            problems.push('standard.allowlist must be an object of rule id → entries');
+        }
+        else {
+            for (const [ruleId, entries] of Object.entries(valueArg.allowlist)) {
+                const rule = rulesById.get(ruleId);
+                if (!rule) {
+                    problems.push(`standard.allowlist: unknown rule '${ruleId}'`);
+                    continue;
+                }
+                if (!rule.allowlistCategories) {
+                    problems.push(`standard.allowlist: rule '${ruleId}' takes no allowlist entries`);
+                    continue;
+                }
+                if (!isPlainObject(entries)) {
+                    problems.push(`standard.allowlist['${ruleId}'] must be an object of '<file>#<member>' → '<category>: <reason>'`);
+                    continue;
+                }
+                for (const [key, value] of Object.entries(entries)) {
+                    const match = typeof value === 'string' ? /^([a-z-]+):\s*(\S.*)$/.exec(value) : null;
+                    if (!match) {
+                        problems.push(`standard.allowlist['${ruleId}']['${key}'] must be '<category>: <reason>'`);
+                    }
+                    else if (!rule.allowlistCategories.includes(match[1])) {
+                        problems.push(`standard.allowlist['${ruleId}']['${key}']: unknown category '${match[1]}' (${rule.allowlistCategories.join(', ')})`);
+                    }
+                }
+            }
+        }
+    }
+    if (valueArg.baselines !== undefined) {
+        if (!isPlainObject(valueArg.baselines)) {
+            problems.push('standard.baselines must be an object of rule id → file → count');
+        }
+        else {
+            for (const [ruleId, counts] of Object.entries(valueArg.baselines)) {
+                const rule = rulesById.get(ruleId);
+                if (!rule) {
+                    problems.push(`standard.baselines: unknown rule '${ruleId}'`);
+                    continue;
+                }
+                if ((profile === 'base' || profile === 'dees') && severityIn(rule, profile) !== 'error') {
+                    problems.push(`standard.baselines: '${ruleId}' is not an error rule of the '${profile}' profile; baselines hold error rules only`);
+                    continue;
+                }
+                if (!isPlainObject(counts)) {
+                    problems.push(`standard.baselines['${ruleId}'] must be an object of file → count`);
+                    continue;
+                }
+                for (const [file, count] of Object.entries(counts)) {
+                    if (typeof count !== 'number' || !Number.isInteger(count) || count < 1) {
+                        problems.push(`standard.baselines['${ruleId}']['${file}'] must be an integer of at least 1`);
+                    }
+                }
+            }
+        }
+    }
+    if (problems.length > 0) {
+        throw new StandardConfigError(problems);
+    }
+    return { config: valueArg, profile: profile };
+};
+/** Reads and validates `.smartconfig.json` → `@design.estate/wcctools` → `standard` of a repository. */
+export const openStandardConfig = (rootDirArg) => {
+    let smartconfig;
+    try {
+        smartconfig = new plugins.smartconfig.Smartconfig(rootDirArg);
+    }
+    catch (error) {
+        throw new StandardConfigError([`.smartconfig.json cannot be read: ${error instanceof Error ? error.message : String(error)}`]);
+    }
+    if (!smartconfig.smartconfigJsonExists) {
+        throw new StandardConfigError([`${rootDirArg} has no .smartconfig.json`]);
+    }
+    const wcctoolsConfig = smartconfig.dataFor(wcctoolsConfigKey, {});
+    return { loaded: validateStandardConfig(wcctoolsConfig.standard), writer: new SmartconfigStandardConfigWriter(smartconfig) };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/errors.d.ts

@@ -0,0 +1,9 @@
+/** The `standard` configuration is missing or invalid; the CLI exits with code 2. */
+export declare class StandardConfigError extends Error {
+    readonly problems: string[];
+    constructor(problemsArg: string[]);
+}
+/** A precondition or argument of `check`/`fix` is not met; the CLI exits with code 2. */
+export declare class StandardUsageError extends Error {
+    constructor(messageArg: string);
+}

package/dist_ts/standards/errors.js

@@ -0,0 +1,17 @@
+/** The `standard` configuration is missing or invalid; the CLI exits with code 2. */
+export class StandardConfigError extends Error {
+    problems;
+    constructor(problemsArg) {
+        super(`Invalid wcctools standard configuration in .smartconfig.json:\n${problemsArg.map((problemArg) => `  - ${problemArg}`).join('\n')}`);
+        this.name = 'StandardConfigError';
+        this.problems = problemsArg;
+    }
+}
+/** A precondition or argument of `check`/`fix` is not met; the CLI exits with code 2. */
+export class StandardUsageError extends Error {
+    constructor(messageArg) {
+        super(messageArg);
+        this.name = 'StandardUsageError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvc3RhbmRhcmRzL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxxRkFBcUY7QUFDckYsTUFBTSxPQUFPLG1CQUFvQixTQUFRLEtBQUs7SUFDNUIsUUFBUSxDQUFXO0lBRW5DLFlBQVksV0FBcUI7UUFDL0IsS0FBSyxDQUFDLGtFQUFrRSxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxPQUFPLFVBQVUsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUMzSSxJQUFJLENBQUMsSUFBSSxHQUFHLHFCQUFxQixDQUFDO1FBQ2xDLElBQUksQ0FBQyxRQUFRLEdBQUcsV0FBVyxDQUFDO0lBQzlCLENBQUM7Q0FDRjtBQUVELHlGQUF5RjtBQUN6RixNQUFNLE9BQU8sa0JBQW1CLFNBQVEsS0FBSztJQUMzQyxZQUFZLFVBQWtCO1FBQzVCLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUNsQixJQUFJLENBQUMsSUFBSSxHQUFHLG9CQUFvQixDQUFDO0lBQ25DLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,56 @@
+import * as plugins from '../plugins.js';
+export type TNode = plugins.typescript.Node;
+export type TSourceFile = plugins.typescript.SourceFile;
+export type TClassDeclaration = plugins.typescript.ClassDeclaration;
+export type TClassElement = plugins.typescript.ClassElement;
+export type TPropertyDeclaration = plugins.typescript.PropertyDeclaration;
+export type TObjectLiteralExpression = plugins.typescript.ObjectLiteralExpression;
+export type TCallExpression = plugins.typescript.CallExpression;
+export type TExpression = plugins.typescript.Expression;
+export type TTypeNode = plugins.typescript.TypeNode;
+export type TStringLiteralLike = plugins.typescript.StringLiteralLike;
+export declare const parseSource: (fileArg: string, textArg: string) => TSourceFile;
+/** 1-based line and column of a position. */
+export declare const lineAndColumn: (sourceFileArg: TSourceFile, positionArg: number) => {
+    line: number;
+    column: number;
+};
+/** The called name of `name(...)` or `a.b.name(...)`. */
+export declare const calleeName: (expressionArg: TExpression) => string | null;
+/** The decorator call named `nameArg` on a node, e.g. `@customElement('x')`. */
+export declare const findDecoratorCall: (nodeArg: TNode, namesArg: readonly string[]) => {
+    name: string;
+    call: TCallExpression;
+} | null;
+export declare const hasModifier: (nodeArg: TNode, kindArg: plugins.typescript.SyntaxKind) => boolean;
+/** The text of a member name: identifier, private identifier (with '#'), string or numeric literal. */
+export declare const memberNameText: (memberArg: TClassElement) => string | null;
+export declare const isStatic: (memberArg: TNode) => boolean;
+/** The static property declaration `static <name> = …` of a class. */
+export declare const findStaticProperty: (classArg: TClassDeclaration, nameArg: string) => TPropertyDeclaration | null;
+export declare const isStringLiteralLike: (nodeArg: TNode | undefined) => nodeArg is TStringLiteralLike;
+/** A property assignment `key: value` of an object literal, by key. */
+export declare const objectProperty: (objectArg: TObjectLiteralExpression, keyArg: string) => plugins.typescript.PropertyAssignment | null;
+/** The source text of an object literal property's value, or null. */
+export declare const objectPropertyText: (objectArg: TObjectLiteralExpression, keyArg: string) => string | null;
+/** The indentation (leading whitespace) of the line a position is on. */
+export declare const indentationAt: (textArg: string, positionArg: number) => string;
+export interface ITextEdit {
+    start: number;
+    end: number;
+    text: string;
+}
+/**
+ * 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 declare const appendObjectPropertyEdit: (objectArg: TObjectLiteralExpression, propertyTextArg: string) => ITextEdit;
+/** The edit that adds `propertyTextArg` (e.g. `type: String`) as the first property of an object literal. */
+export declare const prependObjectPropertyEdit: (objectArg: TObjectLiteralExpression, propertyTextArg: string) => ITextEdit;
+/** The position after the last import declaration, at the start of the following line; 0 without imports. */
+export declare const afterLastImport: (sourceFileArg: TSourceFile) => number;
+/** The module an identifier is imported from in a file, e.g. `html` → `lit`. */
+export declare const importSourceOf: (sourceFileArg: TSourceFile, identifierArg: string) => string | null;
+/** Every relative-capable module specifier literal of a file: imports, re-exports, dynamic `import()` and `import('…')` types. */
+export declare const moduleSpecifierLiterals: (sourceFileArg: TSourceFile) => TStringLiteralLike[];

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 {};