@design.estate/wcctools 6.0.0 → 6.2.0

package/dist_ts/standards/classes.standardproject.js

@@ -0,0 +1,195 @@
+import * as plugins from '../plugins.js';
+import * as ast from './helpers.ast.js';
+import { isDemoFile, isTypeScriptSource, resolveSpecifier, toPosix } from './helpers.paths.js';
+const ts = plugins.typescript;
+/** The root barrel every reachability check starts from. */
+export const rootBarrel = 'ts_web/index.ts';
+export const elementsBarrel = 'ts_web/elements/index.ts';
+/**
+ * The syntax-only model of a catalog the rules read: its files, elements, reactive properties and
+ * barrel graph. Built from a map of repository paths to file texts, so the same model serves a
+ * repository on disk and the fixer's in-memory tree.
+ */
+export class StandardProject {
+    files;
+    existsOnDisk;
+    parseCache;
+    elementsCache = null;
+    propertiesCache = null;
+    reexportsCache = new Map();
+    constructor(filesArg, existsOnDiskArg, parseCacheArg = new Map()) {
+        this.files = filesArg;
+        this.existsOnDisk = existsOnDiskArg;
+        this.parseCache = parseCacheArg;
+    }
+    /** True when the file is part of the model or exists in the repository. */
+    exists(fileArg) {
+        return this.files.has(fileArg) || this.existsOnDisk(fileArg);
+    }
+    /** The `ts_web/**\/*.ts` sources, sorted. */
+    get webFiles() {
+        return [...this.files.keys()].filter((fileArg) => fileArg.startsWith('ts_web/') && fileArg.endsWith('.ts') && isTypeScriptSource(fileArg)).sort();
+    }
+    sourceFile(fileArg) {
+        const text = this.files.get(fileArg);
+        if (text === undefined) {
+            throw new Error(`Not a known file: ${fileArg}`);
+        }
+        const cached = this.parseCache.get(fileArg);
+        if (cached && cached.text === text) {
+            return cached.sourceFile;
+        }
+        const sourceFile = ast.parseSource(fileArg, text);
+        this.parseCache.set(fileArg, { text, sourceFile });
+        return sourceFile;
+    }
+    /** `compilerOptions.experimentalDecorators` of tsconfig.json (its `extends` chain is not followed). */
+    get experimentalDecorators() {
+        const text = this.files.get('tsconfig.json');
+        if (!text) {
+            return false;
+        }
+        const parsed = ts.parseConfigFileTextToJson('tsconfig.json', text);
+        return parsed.config?.compilerOptions?.experimentalDecorators === true;
+    }
+    get elements() {
+        if (!this.elementsCache) {
+            this.elementsCache = [];
+            for (const file of this.webFiles) {
+                const sourceFile = this.sourceFile(file);
+                const visit = (nodeArg) => {
+                    if (ts.isClassDeclaration(nodeArg)) {
+                        const decorator = ast.findDecoratorCall(nodeArg, ['customElement']);
+                        if (decorator) {
+                            const tagArgument = decorator.call.arguments[0];
+                            this.elementsCache.push({
+                                file,
+                                sourceFile,
+                                classNode: nodeArg,
+                                className: nodeArg.name?.text ?? null,
+                                decoratorCall: decorator.call,
+                                tag: decorator.call.arguments.length === 1 && ast.isStringLiteralLike(tagArgument) ? tagArgument.text : null,
+                                exported: ast.hasModifier(nodeArg, ts.SyntaxKind.ExportKeyword),
+                                inDemoFile: isDemoFile(file),
+                            });
+                        }
+                    }
+                    ts.forEachChild(nodeArg, visit);
+                };
+                visit(sourceFile);
+            }
+        }
+        return this.elementsCache;
+    }
+    get properties() {
+        if (!this.propertiesCache) {
+            this.propertiesCache = [];
+            for (const file of this.webFiles) {
+                const sourceFile = this.sourceFile(file);
+                const visit = (nodeArg) => {
+                    if (ts.isClassDeclaration(nodeArg) || ts.isClassExpression(nodeArg)) {
+                        for (const member of nodeArg.members) {
+                            const decorator = ast.findDecoratorCall(member, ['property', 'state']);
+                            const name = ast.memberNameText(member);
+                            if (!decorator || name === null) {
+                                continue;
+                            }
+                            const firstArgument = decorator.call.arguments[0];
+                            const isPrivateName = !!member.name && ts.isPrivateIdentifier(member.name);
+                            this.propertiesCache.push({
+                                file,
+                                sourceFile,
+                                classNode: nodeArg,
+                                member,
+                                name: isPrivateName && !name.startsWith('#') ? `#${name}` : name,
+                                decorator: decorator.name,
+                                call: decorator.call,
+                                options: firstArgument && ts.isObjectLiteralExpression(firstArgument) ? firstArgument : null,
+                                dynamicOptions: !!firstArgument && !ts.isObjectLiteralExpression(firstArgument),
+                                isPublic: !isPrivateName
+                                    && !ast.hasModifier(member, ts.SyntaxKind.PrivateKeyword)
+                                    && !ast.hasModifier(member, ts.SyntaxKind.ProtectedKeyword),
+                                inDemoFile: isDemoFile(file),
+                            });
+                        }
+                    }
+                    ts.forEachChild(nodeArg, visit);
+                };
+                visit(sourceFile);
+            }
+        }
+        return this.propertiesCache;
+    }
+    /** The `export … from` declarations of a file with relative specifiers. */
+    reexports(fileArg) {
+        let reexports = this.reexportsCache.get(fileArg);
+        if (!reexports) {
+            reexports = [];
+            if (this.files.has(fileArg)) {
+                for (const statement of this.sourceFile(fileArg).statements) {
+                    if (ts.isExportDeclaration(statement) && statement.moduleSpecifier && ast.isStringLiteralLike(statement.moduleSpecifier)) {
+                        const specifier = statement.moduleSpecifier.text;
+                        if (!specifier.startsWith('.')) {
+                            continue;
+                        }
+                        const resolved = resolveSpecifier(fileArg, specifier, (candidateArg) => this.files.has(candidateArg));
+                        reexports.push({ file: fileArg, statement, specifier, target: resolved?.target ?? null });
+                    }
+                }
+            }
+            this.reexportsCache.set(fileArg, reexports);
+        }
+        return reexports;
+    }
+    /** Every file reached from a barrel by following `export … from` declarations. */
+    reachableFrom(fileArg) {
+        const reached = new Set();
+        const queue = this.files.has(fileArg) ? [fileArg] : [];
+        while (queue.length > 0) {
+            const file = queue.shift();
+            if (reached.has(file)) {
+                continue;
+            }
+            reached.add(file);
+            for (const reexport of this.reexports(file)) {
+                if (reexport.target && !reached.has(reexport.target)) {
+                    queue.push(reexport.target);
+                }
+            }
+        }
+        return reached;
+    }
+    lineAndColumn(fileArg, positionArg) {
+        return ast.lineAndColumn(this.sourceFile(fileArg), positionArg);
+    }
+}
+/** The files besides `ts_web/**` a check reads. */
+export const standardSideFiles = ['html/index.ts', 'html/index.html', 'tsconfig.json', 'readme.md'];
+/** Reads the files the standard covers from a repository on disk. */
+export const loadStandardProject = async (rootDirArg) => {
+    const files = new Map();
+    const webDir = plugins.path.join(rootDirArg, 'ts_web');
+    if (plugins.fsSync.existsSync(webDir)) {
+        const entries = await plugins.fs.readdir(webDir, { recursive: true, withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile()) {
+                continue;
+            }
+            const relative = toPosix(plugins.path.relative(rootDirArg, plugins.path.join(entry.parentPath, entry.name)));
+            if (relative.split('/').some((segmentArg) => segmentArg === 'node_modules')) {
+                continue;
+            }
+            if (relative.endsWith('.ts') && isTypeScriptSource(relative)) {
+                files.set(relative, await plugins.fs.readFile(plugins.path.join(rootDirArg, relative), 'utf8'));
+            }
+        }
+    }
+    for (const sideFile of standardSideFiles) {
+        const absolute = plugins.path.join(rootDirArg, sideFile);
+        if (plugins.fsSync.existsSync(absolute)) {
+            files.set(sideFile, await plugins.fs.readFile(absolute, 'utf8'));
+        }
+    }
+    return new StandardProject(files, (fileArg) => plugins.fsSync.existsSync(plugins.path.join(rootDirArg, fileArg)));
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.standardproject.js","sourceRoot":"","sources":["../../../ts/standards/classes.standardproject.ts"],"names":[],"mappings":"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"}

package/dist_ts/standards/classes.standardtree.d.ts

@@ -0,0 +1,56 @@
+import * as plugins from '../plugins.js';
+import * as ast from './helpers.ast.js';
+import { StandardProject } from './classes.standardproject.js';
+import type { IFixBuilder } from './rule.js';
+/** The changes one rule run collected. */
+export declare class FixBatch implements IFixBuilder {
+    readonly edits: Map<string, ast.ITextEdit[]>;
+    readonly creates: Map<string, string>;
+    readonly moves: Map<string, string>;
+    readonly redirects: Map<string, string>;
+    edit(fileArg: string, startArg: number, endArg: number, textArg: string): void;
+    create(fileArg: string, textArg: string): void;
+    move(fromArg: string, toArg: string): void;
+    redirectBarrelExports(targetArg: string, barrelTargetArg: string): void;
+}
+/**
+ * The fixer's in-memory copy of a repository: the tracked TypeScript sources and the side files the
+ * standard reads, with the moves and edits applied so far. Nothing touches the disk until the
+ * fixer commits the tree. Every path a batch names must be a repository path (see isRepoPath);
+ * a batch with any other path is rejected before it changes the tree.
+ */
+export declare class StandardTree {
+    readonly files: Map<string, string>;
+    private readonly originalTexts;
+    /** Current path → original path, for moved files. */
+    private readonly originOf;
+    /** Original paths that were moved away. */
+    private readonly vacated;
+    readonly created: Set<string>;
+    /** Current path → ids of the rules that changed the file. */
+    private readonly changedBy;
+    private readonly parseCache;
+    /** Every tracked file of the repository, including those the tree holds no text for (`.json`, `.css`, `.d.ts`, …). */
+    private readonly trackedFiles;
+    private readonly existsOnDisk;
+    constructor(filesArg: Map<string, string>, trackedFilesArg: Iterable<string>, existsOnDiskArg: (fileArg: string) => boolean);
+    exists(fileArg: string): boolean;
+    /** The model of the tree's current state. */
+    project(): StandardProject;
+    private markChanged;
+    /**
+     * Applies a batch: edits, then new files, then moves with import rewriting. Returns the number of
+     * applied changes. Throws without changing the tree when the batch names a path that is not a
+     * repository path.
+     */
+    apply(ruleIdArg: string, batchArg: FixBatch): number;
+    /**
+     * Rewrites every relative module specifier whose importing file or target moves, keeping its
+     * extension style. A specifier resolves to any tracked file (sources, `.d.ts`, `.json`, `.css`, …),
+     * so a moved file's imports of files that stay keep pointing at them. Barrel re-exports of a
+     * redirected target point at the redirect instead.
+     */
+    private rewriteSpecifiers;
+    /** The tree's changes against the repository it was read from. */
+    plan(): plugins.interfaces.IStandardFixPlan;
+}

package/dist_ts/standards/classes.standardtree.js

@@ -0,0 +1,207 @@
+import * as plugins from '../plugins.js';
+import * as ast from './helpers.ast.js';
+import { baseOf, isRepoPath, isTypeScriptSource, resolveSpecifier, specifierFor } from './helpers.paths.js';
+import { SourceEdits } from './classes.sourceedits.js';
+import { StandardProject } from './classes.standardproject.js';
+const ts = plugins.typescript;
+/** The changes one rule run collected. */
+export class FixBatch {
+    edits = new Map();
+    creates = new Map();
+    moves = new Map();
+    redirects = new Map();
+    edit(fileArg, startArg, endArg, textArg) {
+        this.edits.set(fileArg, [...(this.edits.get(fileArg) ?? []), { start: startArg, end: endArg, text: textArg }]);
+    }
+    create(fileArg, textArg) {
+        if (!this.creates.has(fileArg)) {
+            this.creates.set(fileArg, textArg);
+        }
+    }
+    move(fromArg, toArg) {
+        if (!this.moves.has(fromArg)) {
+            this.moves.set(fromArg, toArg);
+        }
+    }
+    redirectBarrelExports(targetArg, barrelTargetArg) {
+        this.redirects.set(targetArg, barrelTargetArg);
+    }
+}
+/**
+ * The fixer's in-memory copy of a repository: the tracked TypeScript sources and the side files the
+ * standard reads, with the moves and edits applied so far. Nothing touches the disk until the
+ * fixer commits the tree. Every path a batch names must be a repository path (see isRepoPath);
+ * a batch with any other path is rejected before it changes the tree.
+ */
+export class StandardTree {
+    files;
+    originalTexts = new Map();
+    /** Current path → original path, for moved files. */
+    originOf = new Map();
+    /** Original paths that were moved away. */
+    vacated = new Set();
+    created = new Set();
+    /** Current path → ids of the rules that changed the file. */
+    changedBy = new Map();
+    parseCache = new Map();
+    /** Every tracked file of the repository, including those the tree holds no text for (`.json`, `.css`, `.d.ts`, …). */
+    trackedFiles;
+    existsOnDisk;
+    constructor(filesArg, trackedFilesArg, existsOnDiskArg) {
+        this.files = new Map(filesArg);
+        for (const [file, text] of filesArg) {
+            this.originalTexts.set(file, text);
+        }
+        this.trackedFiles = new Set(trackedFilesArg);
+        this.existsOnDisk = existsOnDiskArg;
+    }
+    exists(fileArg) {
+        return this.files.has(fileArg) || (!this.vacated.has(fileArg) && this.existsOnDisk(fileArg));
+    }
+    /** The model of the tree's current state. */
+    project() {
+        return new StandardProject(this.files, (fileArg) => this.exists(fileArg), this.parseCache);
+    }
+    markChanged(fileArg, ruleIdArg) {
+        this.changedBy.set(fileArg, new Set([...(this.changedBy.get(fileArg) ?? []), ruleIdArg]));
+    }
+    /**
+     * Applies a batch: edits, then new files, then moves with import rewriting. Returns the number of
+     * applied changes. Throws without changing the tree when the batch names a path that is not a
+     * repository path.
+     */
+    apply(ruleIdArg, batchArg) {
+        const outside = [
+            ...batchArg.edits.keys(),
+            ...batchArg.creates.keys(),
+            ...[...batchArg.moves].flat(),
+            ...[...batchArg.redirects].flat(),
+        ].filter((pathArg) => !isRepoPath(pathArg));
+        if (outside.length > 0) {
+            throw new Error(`The fix of ${ruleIdArg} names paths outside the repository root: ${[...new Set(outside)].join(', ')}`);
+        }
+        let applied = 0;
+        for (const [file, edits] of batchArg.edits) {
+            const text = this.files.get(file);
+            if (text === undefined) {
+                continue;
+            }
+            const sourceEdits = new SourceEdits();
+            edits.forEach((editArg) => sourceEdits.add(editArg));
+            const next = sourceEdits.apply(text);
+            if (next !== text) {
+                this.files.set(file, next);
+                this.markChanged(file, ruleIdArg);
+                applied += sourceEdits.size;
+            }
+        }
+        for (const [file, text] of batchArg.creates) {
+            if (this.exists(file)) {
+                continue;
+            }
+            this.files.set(file, text);
+            this.created.add(file);
+            this.markChanged(file, ruleIdArg);
+            applied++;
+        }
+        const moves = new Map();
+        const targets = new Set();
+        for (const [from, to] of batchArg.moves) {
+            if (from === to || !this.files.has(from) || targets.has(to) || (this.exists(to) && !batchArg.moves.has(to))) {
+                continue;
+            }
+            moves.set(from, to);
+            targets.add(to);
+        }
+        if (moves.size > 0) {
+            this.rewriteSpecifiers(ruleIdArg, moves, batchArg.redirects);
+            const texts = new Map([...moves.keys()].map((fromArg) => [fromArg, this.files.get(fromArg)]));
+            for (const [from, to] of moves) {
+                this.files.delete(from);
+                if (this.created.delete(from)) {
+                    this.created.add(to);
+                }
+                else {
+                    const origin = this.originOf.get(from) ?? from;
+                    this.originOf.delete(from);
+                    if (origin !== to) {
+                        this.originOf.set(to, origin);
+                    }
+                    if (origin === from) {
+                        this.vacated.add(from);
+                    }
+                }
+                const changed = this.changedBy.get(from);
+                this.changedBy.delete(from);
+                if (changed) {
+                    this.changedBy.set(to, changed);
+                }
+            }
+            for (const [from, to] of moves) {
+                this.files.set(to, texts.get(from));
+                this.vacated.delete(to);
+            }
+            applied += moves.size;
+        }
+        return applied;
+    }
+    /**
+     * Rewrites every relative module specifier whose importing file or target moves, keeping its
+     * extension style. A specifier resolves to any tracked file (sources, `.d.ts`, `.json`, `.css`, …),
+     * so a moved file's imports of files that stay keep pointing at them. Barrel re-exports of a
+     * redirected target point at the redirect instead.
+     */
+    rewriteSpecifiers(ruleIdArg, movesArg, redirectsArg) {
+        const known = (fileArg) => this.files.has(fileArg) || (this.trackedFiles.has(fileArg) && !this.vacated.has(fileArg));
+        const project = this.project();
+        for (const [file, text] of [...this.files]) {
+            if (!isTypeScriptSource(file)) {
+                continue;
+            }
+            const newFile = movesArg.get(file) ?? file;
+            const sourceFile = project.sourceFile(file);
+            const edits = new SourceEdits();
+            for (const literal of ast.moduleSpecifierLiterals(sourceFile)) {
+                const resolved = resolveSpecifier(file, literal.text, known);
+                if (!resolved) {
+                    continue;
+                }
+                let target = movesArg.get(resolved.target) ?? resolved.target;
+                let viaFolder = resolved.viaFolder;
+                const redirect = redirectsArg.get(resolved.target);
+                if (redirect && redirect !== newFile && ts.isExportDeclaration(literal.parent) && baseOf(newFile) === 'index.ts') {
+                    target = redirect;
+                    viaFolder = true;
+                }
+                if (newFile === file && target === resolved.target) {
+                    continue;
+                }
+                const specifier = specifierFor(newFile, target, resolved.style, viaFolder);
+                if (specifier !== literal.text) {
+                    edits.add({ start: literal.getStart() + 1, end: literal.end - 1, text: specifier });
+                }
+            }
+            if (edits.size > 0) {
+                this.files.set(file, edits.apply(text));
+                this.markChanged(file, ruleIdArg);
+            }
+        }
+    }
+    /** The tree's changes against the repository it was read from. */
+    plan() {
+        const moves = [...this.originOf].map(([to, from]) => ({ from, to })).sort((a, b) => a.from.localeCompare(b.from));
+        const created = [...this.created].sort();
+        const edited = [];
+        for (const [file, ruleIds] of [...this.changedBy].sort(([a], [b]) => a.localeCompare(b))) {
+            if (this.created.has(file)) {
+                continue;
+            }
+            const origin = this.originOf.get(file) ?? file;
+            if (this.files.get(file) !== this.originalTexts.get(origin)) {
+                edited.push({ file, ruleIds: [...ruleIds].sort() });
+            }
+        }
+        return { moves, created, edited };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.standardtree.js","sourceRoot":"","sources":["../../../ts/standards/classes.standardtree.ts"],"names":[],"mappings":"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"}

package/dist_ts/standards/cli.d.ts

@@ -0,0 +1,7 @@
+import * as plugins from '../plugins.js';
+/**
+ * Registers `wcctools check` and `wcctools fix`. Both work on the current directory, the
+ * repository root that holds `.smartconfig.json`. Exit codes: 0 ok, 1 failing findings or a
+ * refused baseline update, 2 configuration or usage error (StandardConfigError/StandardUsageError).
+ */
+export declare const registerStandardCommands: (out: plugins.smartconsole.SmartConsole) => void;

package/dist_ts/standards/cli.js

@@ -0,0 +1,89 @@
+import * as plugins from '../plugins.js';
+import { checkStandard } from './checker.js';
+import { loadStandardProject } from './classes.standardproject.js';
+import { StandardFixer } from './classes.standardfixer.js';
+import { openStandardConfig } from './config.js';
+import { StandardUsageError } from './errors.js';
+import { renderFixResult, renderStandardReport } from './output.js';
+import { initBaselines, updateBaselines } from './ratchet.js';
+/**
+ * Registers `wcctools check` and `wcctools fix`. Both work on the current directory, the
+ * repository root that holds `.smartconfig.json`. Exit codes: 0 ok, 1 failing findings or a
+ * refused baseline update, 2 configuration or usage error (StandardConfigError/StandardUsageError).
+ */
+export const registerStandardCommands = (out) => {
+    out.cli.command({
+        name: 'check',
+        description: 'Check the catalog against the wcctools component standard (https://code.foss.global/design.estate/wcctools/src/branch/main/docs/standard.md)',
+        options: {
+            json: { type: 'boolean', description: 'Print the report as one JSON document (IStandardReport) and nothing else' },
+            verbose: { type: 'boolean', description: 'Also list info findings, findings covered by the allowlist or baselines, and baseline slack' },
+            initBaseline: { type: 'boolean', description: 'Record the current error counts as standard.baselines (only while none exist)' },
+            updateBaseline: { type: 'boolean', description: 'Lower standard.baselines to the current counts; refuses to raise any count' },
+        },
+    }, async ({ options }) => {
+        if (options.initBaseline && options.updateBaseline) {
+            throw new StandardUsageError('--init-baseline and --update-baseline exclude each other');
+        }
+        const rootDir = process.cwd();
+        const opened = openStandardConfig(rootDir);
+        const notes = [];
+        let report;
+        let refused = false;
+        if (options.initBaseline || options.updateBaseline) {
+            const result = options.initBaseline ? await initBaselines(rootDir, opened) : await updateBaselines(rootDir, opened);
+            report = result.report;
+            if (result.raised.length > 0) {
+                refused = true;
+                for (const raise of result.raised) {
+                    await out.error(`refusing to raise the ${raise.ruleId} baseline of ${raise.file}: ${raise.baseline} → ${raise.current}`);
+                }
+            }
+            else {
+                notes.push(`standard.baselines written: ${result.writtenFiles} file(s)`);
+            }
+        }
+        else {
+            report = checkStandard(await loadStandardProject(rootDir), opened.loaded);
+        }
+        if (options.json) {
+            await out.log(JSON.stringify(report));
+        }
+        else {
+            for (const line of [...renderStandardReport(report, !!options.verbose), ...notes]) {
+                await out.log(line);
+            }
+        }
+        process.exitCode = report.ok && !refused ? 0 : 1;
+    });
+    out.cli.command({
+        name: 'fix',
+        description: 'Fix findings of the wcctools component standard with span edits and git mv; needs a clean work tree, never commits',
+        options: {
+            rule: { type: 'strings', description: 'Fix only this rule (repeatable); opt-in rules run only when named' },
+            dryRun: { type: 'boolean', description: 'Show the changes without writing anything' },
+            json: { type: 'boolean', description: 'Print the result as one JSON document (IStandardFixResult) and nothing else' },
+            verbose: { type: 'boolean', description: 'Also list info and covered findings of the remaining check' },
+        },
+    }, async ({ options }) => {
+        const rootDir = process.cwd();
+        const opened = openStandardConfig(rootDir);
+        const result = await new StandardFixer({
+            rootDir,
+            loaded: opened.loaded,
+            rules: options.rule,
+            dryRun: !!options.dryRun,
+            configWriter: opened.writer,
+        }).run();
+        if (options.json) {
+            await out.log(JSON.stringify(result));
+        }
+        else {
+            for (const line of renderFixResult(result, !!options.verbose)) {
+                await out.log(line);
+            }
+        }
+        process.exitCode = result.remaining.ok ? 0 : 1;
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/config.d.ts

@@ -0,0 +1,33 @@
+import * as plugins from '../plugins.js';
+type IStandardConfig = plugins.interfaces.IStandardConfig;
+type TStandardProfile = plugins.interfaces.TStandardProfile;
+/** The key of wcctools' configuration in `.smartconfig.json`. */
+export declare const wcctoolsConfigKey = "@design.estate/wcctools";
+/** Persists the `standard` configuration of the repository it was read from. */
+export interface IStandardConfigWriter {
+    writeStandardConfig(configArg: IStandardConfig): Promise<void>;
+}
+export interface ILoadedStandardConfig {
+    config: IStandardConfig;
+    profile: TStandardProfile;
+}
+/** A validated configuration together with the writer bound to the `.smartconfig.json` it was read from. */
+export interface IOpenedStandardConfig {
+    loaded: ILoadedStandardConfig;
+    writer: IStandardConfigWriter;
+}
+/**
+ * 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 declare class SmartconfigStandardConfigWriter implements IStandardConfigWriter {
+    private readonly smartconfig;
+    constructor(smartconfigArg: plugins.smartconfig.Smartconfig);
+    writeStandardConfig(configArg: IStandardConfig): Promise<void>;
+}
+/** Validates the `standard` object; collects every problem into one StandardConfigError. */
+export declare const validateStandardConfig: (valueArg: unknown) => ILoadedStandardConfig;
+/** Reads and validates `.smartconfig.json` → `@design.estate/wcctools` → `standard` of a repository. */
+export declare const openStandardConfig: (rootDirArg: string) => IOpenedStandardConfig;
+export {};