@design.estate/wcctools 6.0.0 → 6.2.0

package/dist_ts/standards/output.js

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

package/dist_ts/standards/ratchet.d.ts

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

package/dist_ts/standards/ratchet.js

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

package/dist_ts/standards/rule.d.ts

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

package/dist_ts/standards/rule.js

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

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

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

package/dist_ts/standards/rules/barrel.element-index.js

@@ -0,0 +1,108 @@
+import { baseOf, dirOf, specifierFor } from '../helpers.paths.js';
+import { addReexport, catalogElements, elementsDir, isInElementFolder } from './shared.js';
+/**
+ * An element folder has `index.ts` re-exporting the entry file (and `types.ts`); a group folder's
+ * `index.ts` re-exports each element folder's `index.ts`; `ts_web/elements/index.ts` re-exports each
+ * group or element folder.
+ */
+export const barrelElementIndexRule = {
+    id: 'barrel/element-index',
+    severity: { base: 'warn' },
+    fixMode: 'auto',
+    detect: ({ project }) => {
+        const findings = new Map();
+        const add = (findingArg) => {
+            const id = `${findingArg.file}|${findingArg.message}`;
+            if (!findings.has(id)) {
+                findings.set(id, findingArg);
+            }
+        };
+        const folderElements = catalogElements(project).filter(isInElementFolder);
+        const folders = [...new Set(folderElements.map((elementArg) => dirOf(elementArg.file)))].sort();
+        const groupsWithFolders = new Set();
+        for (const element of folderElements) {
+            const folder = dirOf(element.file);
+            const index = `${folder}/index.ts`;
+            const types = `${folder}/types.ts`;
+            if (!project.files.has(index)) {
+                const exported = [element.file, ...(project.files.has(types) ? [types] : [])];
+                add({
+                    file: index,
+                    position: 0,
+                    key: index,
+                    message: `${folder}/ has no index.ts`,
+                    fix: (builderArg) => builderArg.create(index, exported.map((fileArg) => `export * from '${specifierFor(index, fileArg, 'js')}';\n`).join('')),
+                });
+                continue;
+            }
+            for (const required of [element.file, types]) {
+                if (!project.files.has(required) || project.reexports(index).some((reexportArg) => reexportArg.target === required)) {
+                    continue;
+                }
+                add({
+                    file: index,
+                    position: 0,
+                    key: index,
+                    message: `${index} does not re-export ./${baseOf(required)}`,
+                    fix: (builderArg) => addReexport(builderArg, project, index, required),
+                });
+            }
+            const parent = dirOf(folder);
+            const parentIndex = `${parent}/index.ts`;
+            if (parent !== elementsDir) {
+                groupsWithFolders.add(parent);
+            }
+            if (!project.files.has(parentIndex)) {
+                if (parent === elementsDir) {
+                    continue;
+                }
+                const groupFolders = folders.filter((folderArg) => dirOf(folderArg) === parent);
+                add({
+                    file: parentIndex,
+                    position: 0,
+                    key: parentIndex,
+                    message: `${parent}/ has no index.ts`,
+                    fix: (builderArg) => builderArg.create(parentIndex, groupFolders.map((folderArg) => `export * from '${specifierFor(parentIndex, `${folderArg}/index.ts`, 'js')}';\n`).join('')),
+                });
+                continue;
+            }
+            const parentReexports = project.reexports(parentIndex);
+            if (parentReexports.some((reexportArg) => reexportArg.target === index)) {
+                continue;
+            }
+            const inside = parentReexports.filter((reexportArg) => reexportArg.target?.startsWith(`${folder}/`));
+            const finding = {
+                file: parentIndex,
+                position: inside[0]?.statement.getStart() ?? 0,
+                key: parentIndex,
+                message: `${parentIndex} does not re-export ${baseOf(folder)}/index.ts`,
+            };
+            if (inside.length === 0) {
+                finding.fix = (builderArg) => addReexport(builderArg, project, parentIndex, index);
+            }
+            else if (inside.length === 1) {
+                const literal = inside[0].statement.moduleSpecifier;
+                finding.fix = (builderArg) => builderArg.edit(parentIndex, literal.getStart() + 1, literal.end - 1, specifierFor(parentIndex, index, 'js'));
+            }
+            add(finding);
+        }
+        const elementsIndex = `${elementsDir}/index.ts`;
+        if (project.files.has(elementsIndex)) {
+            for (const group of [...groupsWithFolders].sort()) {
+                const groupIndex = `${group}/index.ts`;
+                if (!project.files.has(groupIndex) || project.reexports(elementsIndex).some((reexportArg) => reexportArg.target === groupIndex)) {
+                    continue;
+                }
+                add({
+                    file: elementsIndex,
+                    position: 0,
+                    key: elementsIndex,
+                    message: `${elementsIndex} does not re-export ${baseOf(group)}/index.ts`,
+                    fix: (builderArg) => addReexport(builderArg, project, elementsIndex, groupIndex),
+                });
+            }
+        }
+        return [...findings.values()];
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/rules/barrel.no-demo-export.d.ts

@@ -0,0 +1,3 @@
+import type { IStandardRule } from '../rule.js';
+/** No barrel exports a demo file. */
+export declare const barrelNoDemoExportRule: IStandardRule;

package/dist_ts/standards/rules/barrel.no-demo-export.js

@@ -0,0 +1,29 @@
+import { baseOf, isDemoFile } from '../helpers.paths.js';
+import { removeStatement } from './shared.js';
+/** No barrel exports a demo file. */
+export const barrelNoDemoExportRule = {
+    id: 'barrel/no-demo-export',
+    severity: { base: 'error' },
+    fixMode: 'auto',
+    detect: ({ project }) => {
+        const findings = [];
+        for (const file of project.webFiles) {
+            if (baseOf(file) !== 'index.ts') {
+                continue;
+            }
+            for (const reexport of project.reexports(file)) {
+                if (reexport.target && isDemoFile(reexport.target)) {
+                    findings.push({
+                        file,
+                        position: reexport.statement.getStart(),
+                        key: file,
+                        message: `${file} exports the demo file ${reexport.target}`,
+                        fix: (builderArg) => removeStatement(builderArg, file, reexport.statement),
+                    });
+                }
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFycmVsLm5vLWRlbW8tZXhwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvc3RhbmRhcmRzL3J1bGVzL2JhcnJlbC5uby1kZW1vLWV4cG9ydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRXpELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFOUMscUNBQXFDO0FBQ3JDLE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFrQjtJQUNuRCxFQUFFLEVBQUUsdUJBQXVCO0lBQzNCLFFBQVEsRUFBRSxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUU7SUFDM0IsT0FBTyxFQUFFLE1BQU07SUFDZixNQUFNLEVBQUUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUU7UUFDdEIsTUFBTSxRQUFRLEdBQW1CLEVBQUUsQ0FBQztRQUNwQyxLQUFLLE1BQU0sSUFBSSxJQUFJLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUNwQyxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxVQUFVLEVBQUUsQ0FBQztnQkFDaEMsU0FBUztZQUNYLENBQUM7WUFDRCxLQUFLLE1BQU0sUUFBUSxJQUFJLE9BQU8sQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztnQkFDL0MsSUFBSSxRQUFRLENBQUMsTUFBTSxJQUFJLFVBQVUsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztvQkFDbkQsUUFBUSxDQUFDLElBQUksQ0FBQzt3QkFDWixJQUFJO3dCQUNKLFFBQVEsRUFBRSxRQUFRLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRTt3QkFDdkMsR0FBRyxFQUFFLElBQUk7d0JBQ1QsT0FBTyxFQUFFLEdBQUcsSUFBSSwwQkFBMEIsUUFBUSxDQUFDLE1BQU0sRUFBRTt3QkFDM0QsR0FBRyxFQUFFLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxlQUFlLENBQUMsVUFBVSxFQUFFLElBQUksRUFBRSxRQUFRLENBQUMsU0FBUyxDQUFDO3FCQUMzRSxDQUFDLENBQUM7Z0JBQ0wsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQztDQUNGLENBQUMifQ==

package/dist_ts/standards/rules/demo.fixture-not-exported.d.ts

@@ -0,0 +1,3 @@
+import type { IStandardRule } from '../rule.js';
+/** Elements declared in demo files are not reachable from `ts_web/elements/index.ts`. */
+export declare const demoFixtureNotExportedRule: IStandardRule;

package/dist_ts/standards/rules/demo.fixture-not-exported.js

@@ -0,0 +1,29 @@
+import { elementsBarrel } from '../classes.standardproject.js';
+import { elementKey, removeStatement } from './shared.js';
+/** Elements declared in demo files are not reachable from `ts_web/elements/index.ts`. */
+export const demoFixtureNotExportedRule = {
+    id: 'demo/fixture-not-exported',
+    severity: { base: 'warn' },
+    fixMode: 'auto',
+    detect: ({ project }) => {
+        const findings = [];
+        const reached = project.reachableFrom(elementsBarrel);
+        for (const element of project.elements) {
+            if (!element.inDemoFile || !reached.has(element.file)) {
+                continue;
+            }
+            const exporters = [...reached].flatMap((fileArg) => project.reexports(fileArg)).filter((reexportArg) => reexportArg.target === element.file);
+            findings.push({
+                file: element.file,
+                position: element.decoratorCall.getStart(),
+                key: elementKey(element),
+                message: `fixture element <${element.tag ?? '?'}> in a demo file is reachable from ${elementsBarrel}`,
+                fix: exporters.length > 0
+                    ? (builderArg) => exporters.forEach((reexportArg) => removeStatement(builderArg, reexportArg.file, reexportArg.statement))
+                    : undefined,
+            });
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVtby5maXh0dXJlLW5vdC1leHBvcnRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3N0YW5kYXJkcy9ydWxlcy9kZW1vLmZpeHR1cmUtbm90LWV4cG9ydGVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUUvRCxPQUFPLEVBQUUsVUFBVSxFQUFFLGVBQWUsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUUxRCx5RkFBeUY7QUFDekYsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQWtCO0lBQ3ZELEVBQUUsRUFBRSwyQkFBMkI7SUFDL0IsUUFBUSxFQUFFLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRTtJQUMxQixPQUFPLEVBQUUsTUFBTTtJQUNmLE1BQU0sRUFBRSxDQUFDLEVBQUUsT0FBTyxFQUFFLEVBQUUsRUFBRTtRQUN0QixNQUFNLFFBQVEsR0FBbUIsRUFBRSxDQUFDO1FBQ3BDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxhQUFhLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDdEQsS0FBSyxNQUFNLE9BQU8sSUFBSSxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDdkMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO2dCQUN0RCxTQUFTO1lBQ1gsQ0FBQztZQUNELE1BQU0sU0FBUyxHQUFHLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEtBQUssT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzdJLFFBQVEsQ0FBQyxJQUFJLENBQUM7Z0JBQ1osSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJO2dCQUNsQixRQUFRLEVBQUUsT0FBTyxDQUFDLGFBQWEsQ0FBQyxRQUFRLEVBQUU7Z0JBQzFDLEdBQUcsRUFBRSxVQUFVLENBQUMsT0FBTyxDQUFDO2dCQUN4QixPQUFPLEVBQUUsb0JBQW9CLE9BQU8sQ0FBQyxHQUFHLElBQUksR0FBRyxzQ0FBc0MsY0FBYyxFQUFFO2dCQUNyRyxHQUFHLEVBQUUsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDO29CQUN2QixDQUFDLENBQUMsQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLGVBQWUsQ0FBQyxVQUFVLEVBQUUsV0FBVyxDQUFDLElBQUksRUFBRSxXQUFXLENBQUMsU0FBUyxDQUFDLENBQUM7b0JBQzFILENBQUMsQ0FBQyxTQUFTO2FBQ2QsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUNELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7Q0FDRixDQUFDIn0=

package/dist_ts/standards/rules/demo.groups.d.ts

@@ -0,0 +1,6 @@
+import type { IStandardRule } from '../rule.js';
+/**
+ * An element with a demo declares `static demoGroups`, a non-empty string or array of non-empty strings.
+ * dees: the first entry is `standard.groupNames[<area>]` of the element's `00group-<area>`.
+ */
+export declare const demoGroupsRule: IStandardRule;

package/dist_ts/standards/rules/demo.groups.js

@@ -0,0 +1,72 @@
+import * as plugins from '../../plugins.js';
+import * as ast from '../helpers.ast.js';
+import { catalogElements, elementKey, groupAreaOf, nextLineStart } from './shared.js';
+const ts = plugins.typescript;
+const quote = (textArg) => `'${textArg.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+/**
+ * An element with a demo declares `static demoGroups`, a non-empty string or array of non-empty strings.
+ * dees: the first entry is `standard.groupNames[<area>]` of the element's `00group-<area>`.
+ */
+export const demoGroupsRule = {
+    id: 'demo/groups',
+    severity: { base: 'warn' },
+    fixMode: 'auto',
+    detect: ({ project, config, profile }) => {
+        const findings = [];
+        for (const element of catalogElements(project)) {
+            const demo = ast.findStaticProperty(element.classNode, 'demo');
+            if (!demo) {
+                continue;
+            }
+            const area = profile === 'dees' ? groupAreaOf(element.file) : null;
+            const expected = area ? config.groupNames?.[area] ?? null : null;
+            const base = { file: element.file, key: elementKey(element) };
+            const member = ast.findStaticProperty(element.classNode, 'demoGroups');
+            const text = element.sourceFile.text;
+            if (!member) {
+                const finding = { ...base, position: demo.getStart(), message: `${element.className ?? '?'} has a demo but no static demoGroups` };
+                if (expected) {
+                    const at = nextLineStart(text, demo.end);
+                    finding.fix = (builderArg) => builderArg.edit(element.file, at, at, `${ast.indentationAt(text, demo.getStart())}public static demoGroups = [${quote(expected)}];\n`);
+                }
+                findings.push(finding);
+                continue;
+            }
+            const initializer = member.initializer;
+            let entries = null;
+            if (initializer && ast.isStringLiteralLike(initializer)) {
+                entries = [initializer.text];
+            }
+            else if (initializer && ts.isArrayLiteralExpression(initializer) && initializer.elements.every(ast.isStringLiteralLike)) {
+                entries = initializer.elements.map((entryArg) => entryArg.text);
+            }
+            else if (!initializer || ts.isArrayLiteralExpression(initializer) || ts.isLiteralExpression(initializer)) {
+                findings.push({ ...base, position: member.getStart(), message: `static demoGroups of ${element.className ?? '?'} is not a string or an array of strings` });
+                continue;
+            }
+            if (entries && (entries.length === 0 || entries.some((entryArg) => entryArg.length === 0))) {
+                findings.push({ ...base, position: member.getStart(), message: `static demoGroups of ${element.className ?? '?'} is empty or has an empty entry` });
+                continue;
+            }
+            if (profile !== 'dees' || !area || !entries) {
+                continue;
+            }
+            if (!expected) {
+                findings.push({ ...base, position: member.getStart(), message: `standard.groupNames has no display name for the area '${area}'` });
+                continue;
+            }
+            if (entries[0] !== expected) {
+                const target = initializer;
+                const reordered = [expected, ...entries.filter((entryArg) => entryArg !== expected)];
+                findings.push({
+                    ...base,
+                    position: member.getStart(),
+                    message: `the first demo group of ${element.className ?? '?'} is ${quote(entries[0])}; expected ${quote(expected)} (00group-${area})`,
+                    fix: (builderArg) => builderArg.edit(element.file, target.getStart(), target.end, `[${reordered.map(quote).join(', ')}]`),
+                });
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/rules/demo.required.d.ts

@@ -0,0 +1,3 @@
+import type { IStandardRule } from '../rule.js';
+/** Every exported element has `static demo`. The opt-in fix writes a stub that renders the bare tag. */
+export declare const demoRequiredRule: IStandardRule;

package/dist_ts/standards/rules/demo.required.js

@@ -0,0 +1,48 @@
+import * as ast from '../helpers.ast.js';
+import { dirOf } from '../helpers.paths.js';
+import { catalogElements, elementKey, isCustomElementName } from './shared.js';
+/** Every exported element has `static demo`. The opt-in fix writes a stub that renders the bare tag. */
+export const demoRequiredRule = {
+    id: 'demo/required',
+    severity: { base: 'warn' },
+    fixMode: 'opt-in',
+    allowlistCategories: ['subcomponent', 'base'],
+    detect: ({ project }) => {
+        const findings = [];
+        const elements = catalogElements(project);
+        for (const element of elements) {
+            if (!element.exported || ast.findStaticProperty(element.classNode, 'demo')) {
+                continue;
+            }
+            const finding = {
+                file: element.file,
+                position: element.decoratorCall.getStart(),
+                key: elementKey(element),
+                message: `${element.className ?? '?'} (<${element.tag ?? '?'}>) has no static demo`,
+            };
+            const sourceFile = element.sourceFile;
+            // The stub's file name and markup come from the tag: only a valid custom element name is usable.
+            const usableTag = element.tag && isCustomElementName(element.tag) ? element.tag : null;
+            const demoFile = usableTag ? `${dirOf(element.file)}/${usableTag}.demo.ts` : null;
+            const firstMember = element.classNode.members[0];
+            const alone = elements.filter((otherArg) => otherArg.file === element.file).length === 1;
+            if (usableTag && demoFile && element.className && firstMember && alone && !project.exists(demoFile) && !/\bdemoFunc\b/.test(sourceFile.text)) {
+                const tag = usableTag;
+                const customElementSource = ast.importSourceOf(sourceFile, 'customElement');
+                const htmlSource = ast.importSourceOf(sourceFile, 'html')
+                    ?? (customElementSource && customElementSource !== 'lit/decorators.js' ? customElementSource : 'lit');
+                const text = sourceFile.text;
+                const importAt = ast.afterLastImport(sourceFile);
+                finding.fix = (builderArg) => {
+                    builderArg.create(demoFile, `import { html } from '${htmlSource}';\n\nexport const demoFunc = () => html\`<${tag}></${tag}>\`;\n`);
+                    builderArg.edit(element.file, importAt, importAt, `import { demoFunc } from './${tag}.demo.js';\n`);
+                    const lineStart = text.lastIndexOf('\n', firstMember.getStart() - 1) + 1;
+                    builderArg.edit(element.file, lineStart, lineStart, `${ast.indentationAt(text, firstMember.getStart())}public static demo = demoFunc;\n`);
+                };
+            }
+            findings.push(finding);
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/rules/demo.separate-file.d.ts

@@ -0,0 +1,3 @@
+import type { IStandardRule } from '../rule.js';
+/** `static demo` refers to an export of the element's demo file. Report-only in 6.1. */
+export declare const demoSeparateFileRule: IStandardRule;

package/dist_ts/standards/rules/demo.separate-file.js

@@ -0,0 +1,38 @@
+import * as plugins from '../../plugins.js';
+import * as ast from '../helpers.ast.js';
+import { isDemoFile, resolveSpecifier } from '../helpers.paths.js';
+import { catalogElements, elementKey, rootIdentifier } from './shared.js';
+const ts = plugins.typescript;
+/** `static demo` refers to an export of the element's demo file. Report-only in 6.1. */
+export const demoSeparateFileRule = {
+    id: 'demo/separate-file',
+    severity: { base: 'warn', dees: 'error' },
+    fixMode: 'none',
+    detect: ({ project }) => {
+        const findings = [];
+        for (const element of catalogElements(project)) {
+            const member = ast.findStaticProperty(element.classNode, 'demo');
+            if (!member?.initializer) {
+                continue;
+            }
+            const initializer = member.initializer;
+            const references = ts.isArrayLiteralExpression(initializer) ? [...initializer.elements] : [initializer];
+            const separate = references.length > 0 && references.every((referenceArg) => {
+                const identifier = rootIdentifier(referenceArg);
+                const source = identifier ? ast.importSourceOf(element.sourceFile, identifier) : null;
+                const resolved = source ? resolveSpecifier(element.file, source, (fileArg) => project.files.has(fileArg)) : null;
+                return !!resolved && isDemoFile(resolved.target);
+            });
+            if (!separate) {
+                findings.push({
+                    file: element.file,
+                    position: member.getStart(),
+                    key: elementKey(element),
+                    message: `static demo of ${element.className ?? '?'} is not imported from its demo file (${element.tag ?? '<tag>'}.demo.ts)`,
+                });
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/rules/demo.shape.d.ts

@@ -0,0 +1,3 @@
+import type { IStandardRule } from '../rule.js';
+/** `static demo` is a function or a non-empty array of functions. */
+export declare const demoShapeRule: IStandardRule;