@design.estate/wcctools 6.0.0 → 6.1.0

package/dist_ts/standards/classes.standardfixer.js

@@ -0,0 +1,210 @@
+import * as plugins from '../plugins.js';
+import { rekeyStandardConfig } from './baselines.js';
+import { checkStandard, detectFindings, rulesOfProfile } from './checker.js';
+import { GitRepo } from './classes.gitrepo.js';
+import { loadStandardProject, standardSideFiles } from './classes.standardproject.js';
+import { FixBatch, StandardTree } from './classes.standardtree.js';
+import { StandardUsageError } from './errors.js';
+import { dirOf, isRepoPath, isTypeScriptSource } from './helpers.paths.js';
+import { fixOrder, standardRules } from './rules/index.js';
+/** How often one rule is re-run on the edited tree to apply edits that overlapped in an earlier run. */
+const maxRunsPerRule = 5;
+/**
+ * `wcctools fix`: applies the fixes of the selected rules to an in-memory copy of the repository,
+ * one rule after another on the re-parsed result, validates that every path of the resulting plan
+ * stays inside the repository root, then writes the configuration, moves files with `git mv`, writes
+ * the edited files and checks again. Refuses to run on a dirty work tree and never commits, so a
+ * failure part-way through the writes is undone with `git reset --hard` and `git clean -fd`.
+ */
+export class StandardFixer {
+    options;
+    constructor(optionsArg) {
+        this.options = optionsArg;
+    }
+    selectRules() {
+        const { profile } = this.options.loaded;
+        const inProfile = new Set(rulesOfProfile(profile).map((ruleArg) => ruleArg.id));
+        if (!this.options.rules || this.options.rules.length === 0) {
+            return fixOrder.filter((idArg) => inProfile.has(idArg) && standardRules.find((ruleArg) => ruleArg.id === idArg).fixMode === 'auto');
+        }
+        for (const id of this.options.rules) {
+            const rule = standardRules.find((ruleArg) => ruleArg.id === id);
+            if (!rule) {
+                throw new StandardUsageError(`Unknown rule '${id}'`);
+            }
+            if (!inProfile.has(id)) {
+                throw new StandardUsageError(`Rule '${id}' is not part of the '${profile}' profile`);
+            }
+            if (rule.fixMode === 'none') {
+                throw new StandardUsageError(`Rule '${id}' has no fix`);
+            }
+        }
+        return fixOrder.filter((idArg) => this.options.rules.includes(idArg));
+    }
+    async run() {
+        const { rootDir, loaded } = this.options;
+        const selected = this.selectRules();
+        const git = new GitRepo(rootDir);
+        const topLevel = await git.topLevel();
+        if (!topLevel || plugins.fsSync.realpathSync(topLevel) !== plugins.fsSync.realpathSync(rootDir)) {
+            throw new StandardUsageError(`wcctools fix runs at the root of a git repository; ${rootDir} is not one`);
+        }
+        const status = await git.statusLines();
+        if (status.length > 0) {
+            throw new StandardUsageError(`wcctools fix needs a clean work tree; git status reports ${status.length} change(s). Commit or stash them first.`);
+        }
+        const trackedFiles = await git.trackedFiles();
+        const files = new Map();
+        for (const file of trackedFiles) {
+            if (isTypeScriptSource(file) || standardSideFiles.includes(file)) {
+                files.set(file, await plugins.fs.readFile(plugins.path.join(rootDir, file), 'utf8'));
+            }
+        }
+        const tree = new StandardTree(files, trackedFiles, (fileArg) => plugins.fsSync.existsSync(plugins.path.join(rootDir, fileArg)));
+        for (const ruleId of selected) {
+            const rule = standardRules.find((ruleArg) => ruleArg.id === ruleId);
+            for (let run = 0; run < maxRunsPerRule; run++) {
+                const fixable = detectFindings(tree.project(), loaded, [rule]).filter((detectedArg) => !detectedArg.allowlisted && detectedArg.finding.fix);
+                if (fixable.length === 0) {
+                    break;
+                }
+                const batch = new FixBatch();
+                fixable.forEach((detectedArg) => detectedArg.finding.fix(batch));
+                if (tree.apply(rule.id, batch) === 0) {
+                    break;
+                }
+            }
+        }
+        const plan = tree.plan();
+        await this.assertInsideRoot(plan);
+        const rekeyed = rekeyStandardConfig(loaded.config, plan.moves);
+        if (rekeyed.changed.length > 0 && !this.options.configWriter) {
+            throw new StandardUsageError(`wcctools fix would move files that the standard configuration names (${rekeyed.changed.join(', ')}) but has no configuration writer`);
+        }
+        const loadedAfter = { ...loaded, config: rekeyed.config };
+        if (this.options.dryRun) {
+            return { dryRun: true, plan, remaining: checkStandard(tree.project(), loadedAfter) };
+        }
+        // Every path is validated above. The configuration goes first: a refused write (the file changed
+        // since it was read) leaves the tree untouched. A failure after it leaves a partial result that the
+        // clean work tree fix started from restores (`git reset --hard`, `git clean -fd`).
+        if (rekeyed.changed.length > 0) {
+            await this.options.configWriter.writeStandardConfig(rekeyed.config);
+        }
+        await this.commitMoves(git, plan.moves);
+        for (const file of [...plan.created, ...plan.edited.map((editedArg) => editedArg.file)]) {
+            await this.ensureDir(dirOf(file));
+            await plugins.fs.writeFile(plugins.path.join(rootDir, file), tree.files.get(file), 'utf8');
+        }
+        await this.removeEmptyDirs(plan.moves.map((moveArg) => dirOf(moveArg.from)));
+        return { dryRun: false, plan, remaining: checkStandard(await loadStandardProject(rootDir), loadedAfter) };
+    }
+    /**
+     * Refuses a plan with a path that leaves the repository root, lexically (an absolute path or a `..`
+     * segment) or physically (through a symbolic link that resolves outside the root or dangles).
+     * Runs before anything is written, so a refused plan leaves the repository and its surroundings as
+     * they were.
+     */
+    async assertInsideRoot(planArg) {
+        const realRoot = await plugins.fs.realpath(this.options.rootDir);
+        const paths = [
+            ...planArg.moves.flatMap((moveArg) => [moveArg.from, moveArg.to]),
+            ...planArg.created,
+            ...planArg.edited.map((editedArg) => editedArg.file),
+        ];
+        const outside = [];
+        for (const file of new Set(paths)) {
+            if (!isRepoPath(file) || !(await this.resolvesInside(realRoot, file))) {
+                outside.push(file);
+            }
+        }
+        if (outside.length > 0) {
+            throw new StandardUsageError(`wcctools fix refuses to write outside the repository root: ${outside.join(', ')}`);
+        }
+    }
+    /** True when the file, or its nearest existing ancestor, resolves to a path inside the real root. */
+    async resolvesInside(realRootArg, fileArg) {
+        let current = plugins.path.join(realRootArg, fileArg);
+        while (true) {
+            try {
+                const real = await plugins.fs.realpath(current);
+                return real === realRootArg || real.startsWith(`${realRootArg}${plugins.path.sep}`);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+                    throw error;
+                }
+            }
+            if (await this.isSymbolicLink(current)) {
+                // A dangling link: writing through it would create its target, wherever that is.
+                return false;
+            }
+            const parent = plugins.path.dirname(current);
+            if (parent === current) {
+                return false;
+            }
+            current = parent;
+        }
+    }
+    async isSymbolicLink(pathArg) {
+        try {
+            return (await plugins.fs.lstat(pathArg)).isSymbolicLink();
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT' || code === 'ENOTDIR') {
+                return false;
+            }
+            throw error;
+        }
+    }
+    /** `git mv` in an order where no move overwrites a file that has not moved away yet. */
+    async commitMoves(gitArg, movesArg) {
+        const pending = [...movesArg];
+        while (pending.length > 0) {
+            const index = pending.findIndex((moveArg) => !plugins.fsSync.existsSync(plugins.path.join(this.options.rootDir, moveArg.to)));
+            if (index === -1) {
+                throw new Error(`Cannot order the moves ${pending.map((moveArg) => `${moveArg.from} → ${moveArg.to}`).join(', ')}`);
+            }
+            const [move] = pending.splice(index, 1);
+            await this.ensureDir(dirOf(move.to));
+            await gitArg.move(move.from, move.to);
+        }
+    }
+    /** Creates a directory one path component at a time. */
+    async ensureDir(dirArg) {
+        let current = this.options.rootDir;
+        for (const segment of dirArg.split('/').filter((segmentArg) => segmentArg && segmentArg !== '.')) {
+            current = plugins.path.join(current, segment);
+            try {
+                await plugins.fs.mkdir(current);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST') {
+                    throw error;
+                }
+            }
+        }
+    }
+    /** Removes directories that moves left empty, walking up towards the repository root. */
+    async removeEmptyDirs(dirsArg) {
+        for (const start of [...new Set(dirsArg)].sort((a, b) => b.length - a.length)) {
+            let dir = start;
+            while (dir && dir !== '.') {
+                try {
+                    await plugins.fs.rmdir(plugins.path.join(this.options.rootDir, dir));
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (code === 'ENOTEMPTY' || code === 'EEXIST' || code === 'ENOENT') {
+                        break;
+                    }
+                    throw error;
+                }
+                dir = dirOf(dir);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.standardfixer.js","sourceRoot":"","sources":["../../../ts/standards/classes.standardfixer.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,80 @@
+import * as plugins from '../plugins.js';
+import * as ast from './helpers.ast.js';
+/** A class decorated with `@customElement(…)`. */
+export interface IStandardElement {
+    file: string;
+    sourceFile: ast.TSourceFile;
+    classNode: ast.TClassDeclaration;
+    className: string | null;
+    decoratorCall: ast.TCallExpression;
+    /** The literal tag, or null when the decorator argument is not a string literal. */
+    tag: string | null;
+    exported: boolean;
+    inDemoFile: boolean;
+}
+/** A class member decorated with `@property(…)` or `@state(…)`. */
+export interface IStandardProperty {
+    file: string;
+    sourceFile: ast.TSourceFile;
+    classNode: ast.TClassDeclaration;
+    member: ast.TClassElement;
+    name: string;
+    decorator: 'property' | 'state';
+    call: ast.TCallExpression;
+    /** The options object literal; null when the decorator has no argument or a non-literal one. */
+    options: ast.TObjectLiteralExpression | null;
+    /** True when the decorator has an argument that is not an object literal. */
+    dynamicOptions: boolean;
+    isPublic: boolean;
+    inDemoFile: boolean;
+}
+/** An `export … from '<relative>'` declaration. */
+export interface IStandardReexport {
+    file: string;
+    statement: plugins.typescript.ExportDeclaration;
+    specifier: string;
+    /** The resolved repository path, or null when it does not resolve to a known file. */
+    target: string | null;
+}
+export type TParseCache = Map<string, {
+    text: string;
+    sourceFile: ast.TSourceFile;
+}>;
+/** The root barrel every reachability check starts from. */
+export declare const rootBarrel = "ts_web/index.ts";
+export declare 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 declare class StandardProject {
+    readonly files: ReadonlyMap<string, string>;
+    private readonly existsOnDisk;
+    private readonly parseCache;
+    private elementsCache;
+    private propertiesCache;
+    private reexportsCache;
+    constructor(filesArg: ReadonlyMap<string, string>, existsOnDiskArg: (fileArg: string) => boolean, parseCacheArg?: TParseCache);
+    /** True when the file is part of the model or exists in the repository. */
+    exists(fileArg: string): boolean;
+    /** The `ts_web/**\/*.ts` sources, sorted. */
+    get webFiles(): string[];
+    sourceFile(fileArg: string): ast.TSourceFile;
+    /** `compilerOptions.experimentalDecorators` of tsconfig.json (its `extends` chain is not followed). */
+    get experimentalDecorators(): boolean;
+    get elements(): IStandardElement[];
+    get properties(): IStandardProperty[];
+    /** The `export … from` declarations of a file with relative specifiers. */
+    reexports(fileArg: string): IStandardReexport[];
+    /** Every file reached from a barrel by following `export … from` declarations. */
+    reachableFrom(fileArg: string): Set<string>;
+    lineAndColumn(fileArg: string, positionArg: number): {
+        line: number;
+        column: number;
+    };
+}
+/** The files besides `ts_web/**` a check reads. */
+export declare const standardSideFiles: string[];
+/** Reads the files the standard covers from a repository on disk. */
+export declare const loadStandardProject: (rootDirArg: string) => Promise<StandardProject>;

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":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,GAAG,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE/F,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;AA2C9B,4DAA4D;AAC5D,MAAM,CAAC,MAAM,UAAU,GAAG,iBAAiB,CAAC;AAC5C,MAAM,CAAC,MAAM,cAAc,GAAG,0BAA0B,CAAC;AAEzD;;;;GAIG;AACH,MAAM,OAAO,eAAe;IACV,KAAK,CAA8B;IAClC,YAAY,CAA+B;IAC3C,UAAU,CAAc;IACjC,aAAa,GAA8B,IAAI,CAAC;IAChD,eAAe,GAA+B,IAAI,CAAC;IACnD,cAAc,GAAG,IAAI,GAAG,EAA+B,CAAC;IAEhE,YAAY,QAAqC,EAAE,eAA6C,EAAE,gBAA6B,IAAI,GAAG,EAAE;QACtI,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,eAAe,CAAC;QACpC,IAAI,CAAC,UAAU,GAAG,aAAa,CAAC;IAClC,CAAC;IAED,2EAA2E;IACpE,MAAM,CAAC,OAAe;QAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAC/D,CAAC;IAED,6CAA6C;IAC7C,IAAW,QAAQ;QACjB,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACpJ,CAAC;IAEM,UAAU,CAAC,OAAe;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACrC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,qBAAqB,OAAO,EAAE,CAAC,CAAC;QAClD,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,MAAM,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACnC,OAAO,MAAM,CAAC,UAAU,CAAC;QAC3B,CAAC;QACD,MAAM,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAClD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;QACnD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,uGAAuG;IACvG,IAAW,sBAAsB;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,MAAM,GAAG,EAAE,CAAC,yBAAyB,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;QACnE,OAAO,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,sBAAsB,KAAK,IAAI,CAAC;IACzE,CAAC;IAED,IAAW,QAAQ;QACjB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;YACxB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACjC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBACzC,MAAM,KAAK,GAAG,CAAC,OAAkB,EAAQ,EAAE;oBACzC,IAAI,EAAE,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC;wBACnC,MAAM,SAAS,GAAG,GAAG,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC;wBACpE,IAAI,SAAS,EAAE,CAAC;4BACd,MAAM,WAAW,GAAG,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;4BAChD,IAAI,CAAC,aAAc,CAAC,IAAI,CAAC;gCACvB,IAAI;gCACJ,UAAU;gCACV,SAAS,EAAE,OAAO;gCAClB,SAAS,EAAE,OAAO,CAAC,IAAI,EAAE,IAAI,IAAI,IAAI;gCACrC,aAAa,EAAE,SAAS,CAAC,IAAI;gCAC7B,GAAG,EAAE,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,GAAG,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI;gCAC5G,QAAQ,EAAE,GAAG,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;gCAC/D,UAAU,EAAE,UAAU,CAAC,IAAI,CAAC;6BAC7B,CAAC,CAAC;wBACL,CAAC;oBACH,CAAC;oBACD,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;gBAClC,CAAC,CAAC;gBACF,KAAK,CAAC,UAAU,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,IAAW,UAAU;QACnB,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1B,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;YAC1B,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACjC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBACzC,MAAM,KAAK,GAAG,CAAC,OAAkB,EAAQ,EAAE;oBACzC,IAAI,EAAE,CAAC,kBAAkB,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAAE,CAAC;wBACpE,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;4BACrC,MAAM,SAAS,GAAG,GAAG,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;4BACvE,MAAM,IAAI,GAAG,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;4BACxC,IAAI,CAAC,SAAS,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;gCAChC,SAAS;4BACX,CAAC;4BACD,MAAM,aAAa,GAAG,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;4BAClD,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;4BAC3E,IAAI,CAAC,eAAgB,CAAC,IAAI,CAAC;gCACzB,IAAI;gCACJ,UAAU;gCACV,SAAS,EAAE,OAAgC;gCAC3C,MAAM;gCACN,IAAI,EAAE,aAAa,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI;gCAChE,SAAS,EAAE,SAAS,CAAC,IAA4B;gCACjD,IAAI,EAAE,SAAS,CAAC,IAAI;gCACpB,OAAO,EAAE,aAAa,IAAI,EAAE,CAAC,yBAAyB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI;gCAC5F,cAAc,EAAE,CAAC,CAAC,aAAa,IAAI,CAAC,EAAE,CAAC,yBAAyB,CAAC,aAAa,CAAC;gCAC/E,QAAQ,EAAE,CAAC,aAAa;uCACnB,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;uCACtD,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;gCAC7D,UAAU,EAAE,UAAU,CAAC,IAAI,CAAC;6BAC7B,CAAC,CAAC;wBACL,CAAC;oBACH,CAAC;oBACD,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;gBAClC,CAAC,CAAC;gBACF,KAAK,CAAC,UAAU,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED,2EAA2E;IACpE,SAAS,CAAC,OAAe;QAC9B,IAAI,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACjD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,SAAS,GAAG,EAAE,CAAC;YACf,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC5B,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,CAAC;oBAC5D,IAAI,EAAE,CAAC,mBAAmB,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,eAAe,IAAI,GAAG,CAAC,mBAAmB,CAAC,SAAS,CAAC,eAAe,CAAC,EAAE,CAAC;wBACzH,MAAM,SAAS,GAAG,SAAS,CAAC,eAAe,CAAC,IAAI,CAAC;wBACjD,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;4BAC/B,SAAS;wBACX,CAAC;wBACD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,YAAY,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC;wBACtG,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,IAAI,EAAE,CAAC,CAAC;oBAC5F,CAAC;gBACH,CAAC;YACH,CAAC;YACD,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAC9C,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,kFAAkF;IAC3E,aAAa,CAAC,OAAe;QAClC,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACvD,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,EAAG,CAAC;YAC5B,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACtB,SAAS;YACX,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAClB,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC5C,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;oBACrD,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAC9B,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAEM,aAAa,CAAC,OAAe,EAAE,WAAmB;QACvD,OAAO,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC;IAClE,CAAC;CACF;AAED,mDAAmD;AACnD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,WAAW,CAAC,CAAC;AAEpG,qEAAqE;AACrE,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,EAAE,UAAkB,EAA4B,EAAE;IACxF,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IACxC,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IACvD,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3F,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;gBACpB,SAAS;YACX,CAAC;YACD,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC7G,IAAI,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,KAAK,cAAc,CAAC,EAAE,CAAC;gBAC5E,SAAS;YACX,CAAC;YACD,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC7D,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;YAClG,CAAC;QACH,CAAC;IACH,CAAC;IACD,KAAK,MAAM,QAAQ,IAAI,iBAAiB,EAAE,CAAC;QACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QACzD,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACxC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IACD,OAAO,IAAI,eAAe,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AACpH,CAAC,CAAC"}

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