@linter-spec/cli 1.0.0

package/dist/commands/scan.js

@@ -0,0 +1,36 @@
+import ora from 'ora';
+import scan from '../actions/scan/index.js';
+import printReport from '../utils/print-report.js';
+import { hasLocalLintConfig, installProjectDepsIfMissing } from '../actions/init/install-deps.js';
+import { messages } from '../utils/messages.js';
+export function registerScan(program, cwd) {
+    program
+        .command('scan')
+        .description(messages.scanDescription)
+        .option('-q, --quiet', messages.optQuiet)
+        .option('-o, --output-report', messages.optOutputReport)
+        .option('-i, --include <dirpath>', messages.optInclude)
+        .option('--no-ignore', messages.optNoIgnore)
+        .action(async (cmd) => {
+        await installProjectDepsIfMissing(cwd, hasLocalLintConfig(cwd));
+        const checking = ora();
+        checking.start(messages.runChecking);
+        const { results, errorCount, warningCount, runErrors } = await scan({
+            cwd,
+            fix: false,
+            include: cmd.include || cwd,
+            quiet: Boolean(cmd.quiet),
+            outputReport: Boolean(cmd.outputReport),
+            ignore: cmd.ignore,
+        });
+        if (runErrors.length > 0 || errorCount > 0)
+            checking.fail();
+        else if (warningCount > 0)
+            checking.warn();
+        else
+            checking.succeed();
+        if (results.length > 0)
+            printReport(results, false);
+        runErrors.forEach((e) => console.log(e));
+    });
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerUpdate(program: Command): void;

package/dist/commands/update.js

@@ -0,0 +1,8 @@
+import update from '../actions/update.js';
+import { messages } from '../utils/messages.js';
+export function registerUpdate(program) {
+    program
+        .command('update')
+        .description(messages.updateDescription)
+        .action(() => update(true));
+}

package/dist/config/_editorconfig.ejs

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+quote_type = single
+
+[*.md]
+trim_trailing_whitespace = false

package/dist/config/_markdownlint-cli2.cjs.ejs

@@ -0,0 +1,13 @@
+<%_ if (enableMarkdownlint) { _%>
+// markdownlint-cli2 config. The shared rule set is an ESM-only package,
+// so we require its default export and pass it as cli2's `config` option.
+// Read by markdownlint-cli2 (CLI) and the VS Code markdownlint extension —
+// per the cli2 README, `.markdownlint-cli2.cjs` outranks `.markdownlint.cjs`,
+// so both tools pick up the `ignores` field here.
+const config = require('@linter-spec/markdownlint-config').default;
+
+module.exports = {
+  config,
+  ignores: [<%- markdownLintIgnores.map((txt) => `'${txt}'`).join(', ') %>],
+};
+<%_ } _%>

package/dist/config/_stylelintignore.ejs

@@ -0,0 +1,5 @@
+<%_ if (enableStylelint) { _%>
+<%_ stylelintIgnores.forEach((txt) => { _%>
+<%= txt %>
+<%_ }); _%>
+<%_ } _%>

package/dist/config/_vscode/extensions.json.ejs

@@ -0,0 +1,9 @@
+{
+  "recommendations": [
+    "dbaeumer.vscode-eslint",
+    "stylelint.vscode-stylelint",
+    "esbenp.prettier-vscode",
+    "DavidAnson.vscode-markdownlint",
+    "EditorConfig.EditorConfig"
+  ]
+}

package/dist/config/_vscode/settings.json.ejs

@@ -0,0 +1,26 @@
+<%
+const settings = {};
+if (enableESLint) {
+  settings['eslint.validate'] = [
+    'javascript', 'javascriptreact', 'typescript', 'typescriptreact', 'vue',
+  ];
+}
+if (enableStylelint) {
+  settings['stylelint.validate'] = stylelintExt.map((ext) => ext.replace(/^\./, ''));
+}
+settings['editor.codeActionsOnSave'] = {
+  'source.fixAll.eslint': 'explicit',
+  ...(enableStylelint ? { 'source.fixAll.stylelint': 'explicit' } : {}),
+  ...(enableMarkdownlint ? { 'source.fixAll.markdownlint': 'explicit' } : {}),
+};
+if (enablePrettier) {
+  settings['editor.defaultFormatter'] = 'esbenp.prettier-vscode';
+  for (const lang of [
+    'javascript', 'javascriptreact', 'typescript', 'typescriptreact', 'vue',
+    'css', 'less', 'scss', 'html', 'json', 'jsonc',
+  ]) {
+    settings[`[${lang}]`] = { 'editor.defaultFormatter': 'esbenp.prettier-vscode' };
+  }
+}
+settings['editor.formatOnSave'] = Boolean(enablePrettier);
+%><%- JSON.stringify(settings, null, 2) %>

package/dist/config/commitlint.config.mjs.ejs

@@ -0,0 +1,3 @@
+export default {
+  extends: ['@linter-spec/commitlint-config'],
+};

package/dist/config/eslint.config.mjs.ejs

@@ -0,0 +1,16 @@
+<%
+const spec = eslintType === 'index'
+  ? '@linter-spec/eslint-config'
+  : `@linter-spec/eslint-config/${eslintType}`;
+%>import config from '<%= spec %>';
+
+export default [
+  ...config,
+  {
+    ignores: [
+<%_ eslintIgnores.forEach((pattern) => { _%>
+      '<%= pattern %>',
+<%_ }); _%>
+    ],
+  },
+];

package/dist/config/linter-spec.config.mjs.ejs

@@ -0,0 +1,6 @@
+export default {
+  enableESLint: <%= enableESLint %>,
+  enableStylelint: <%= enableStylelint %>,
+  enableMarkdownlint: <%= enableMarkdownlint %>,
+  enablePrettier: <%= enablePrettier %>,
+};

package/dist/config/prettier.config.mjs.ejs

@@ -0,0 +1,10 @@
+<%_ if (enablePrettier) { _%>
+export default {
+  printWidth: 100,
+  tabWidth: 2,
+  semi: true,
+  singleQuote: true,
+  trailingComma: 'all',
+  arrowParens: 'always',
+};
+<%_ } _%>

package/dist/config/stylelint.config.mjs.ejs

@@ -0,0 +1,5 @@
+<%_ if (enableStylelint) { _%>
+export default {
+  extends: ['@linter-spec/stylelint-config'],
+};
+<%_ } _%>

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { InitOptions, ScanOptions, ScanReport } from './types.js';
+/** Programmatically initialise a project (never self-updates the CLI). */
+export declare const init: (options: Omit<InitOptions, "checkVersionUpdate">) => Promise<void>;
+/** Programmatically scan a project, printing a report. */
+export declare const scan: (options: ScanOptions) => Promise<ScanReport>;
+export type { Config, ScanOptions, ScanReport, ScanResult, ScanMessage, InitOptions, } from './types.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+import ora from 'ora';
+import scanAction from './actions/scan/index.js';
+import initAction from './actions/init/index.js';
+import printReport from './utils/print-report.js';
+import { messages } from './utils/messages.js';
+/** Programmatically initialise a project (never self-updates the CLI). */
+export const init = (options) => initAction({ ...options, checkVersionUpdate: false });
+/** Programmatically scan a project, printing a report. */
+export const scan = async (options) => {
+    const checking = ora();
+    checking.start(messages.runChecking);
+    const report = await scanAction(options);
+    const { results, errorCount, warningCount } = report;
+    if (errorCount > 0)
+        checking.fail();
+    else if (warningCount > 0)
+        checking.warn();
+    else
+        checking.succeed();
+    if (results.length > 0)
+        printReport(results, false);
+    return report;
+};

package/dist/lints/eslint/do-eslint.d.ts

@@ -0,0 +1,7 @@
+import type { Config, PKG, ScanOptions } from '../../types.js';
+import { formatESLintResults } from './format-results.js';
+export interface DoESLintOptions extends ScanOptions {
+    pkg: PKG;
+    config: Config;
+}
+export declare function doESLint(options: DoESLintOptions): Promise<ReturnType<typeof formatESLintResults>>;

package/dist/lints/eslint/do-eslint.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import { ESLint } from 'eslint';
+import { ESLINT_FILE_EXT } from '../../utils/constants.js';
+import { formatESLintResults } from './format-results.js';
+import { getESLintConfig } from './get-config.js';
+/** Glob (relative to cwd) covering every ESLint-handled extension. */
+function buildPattern(cwd, include) {
+    const exts = ESLINT_FILE_EXT.map((ext) => ext.replace(/^\./, '')).join(',');
+    const rel = path.relative(cwd, include).replace(/\\/g, '/');
+    const prefix = rel && rel !== '.' ? `${rel}/` : '';
+    return `${prefix}**/*.{${exts}}`;
+}
+export async function doESLint(options) {
+    let patterns;
+    if (options.files) {
+        const files = options.files.filter((name) => ESLINT_FILE_EXT.includes(path.extname(name)));
+        if (files.length === 0)
+            return [];
+        patterns = files;
+    }
+    else {
+        patterns = [buildPattern(options.cwd, options.include || options.cwd)];
+    }
+    const eslintOptions = await getESLintConfig(options, options.pkg, options.config);
+    const eslint = new ESLint(eslintOptions);
+    const reports = await eslint.lintFiles(patterns);
+    if (options.fix) {
+        await ESLint.outputFixes(reports);
+    }
+    return formatESLintResults(reports, options.quiet, eslint);
+}

package/dist/lints/eslint/format-results.d.ts

@@ -0,0 +1,6 @@
+import type { ESLint } from 'eslint';
+import type { ScanResult } from '../../types.js';
+/**
+ * Normalise ESLint results into the shared `ScanResult` shape.
+ */
+export declare function formatESLintResults(results: ESLint.LintResult[], quiet: boolean | undefined, eslint: ESLint): ScanResult[];

package/dist/lints/eslint/format-results.js

@@ -0,0 +1,25 @@
+/**
+ * Normalise ESLint results into the shared `ScanResult` shape.
+ */
+export function formatESLintResults(results, quiet, eslint) {
+    const rulesMeta = eslint.getRulesMetaForResults(results);
+    return results
+        .filter(({ warningCount, errorCount }) => errorCount || warningCount)
+        .map(({ filePath, messages, errorCount, warningCount, fixableErrorCount, fixableWarningCount, }) => ({
+        filePath,
+        errorCount,
+        warningCount: quiet ? 0 : warningCount,
+        fixableErrorCount,
+        fixableWarningCount: quiet ? 0 : fixableWarningCount,
+        messages: messages
+            .map(({ line = 0, column = 0, ruleId, message, fatal, severity }) => ({
+            line,
+            column,
+            rule: ruleId,
+            url: (ruleId && rulesMeta[ruleId]?.docs?.url) || '',
+            message: message.replace(/([^ ])\.$/u, '$1'),
+            errored: Boolean(fatal) || severity === 2,
+        }))
+            .filter(({ errored }) => (quiet ? errored : true)),
+    }));
+}

package/dist/lints/eslint/get-config-type.d.ts

@@ -0,0 +1,12 @@
+import type { PKG } from '../../types.js';
+/**
+ * Detect the project type from its files and dependencies.
+ * The returned value is a `PROJECT_TYPES` value (e.g. `index`, `typescript`,
+ * `typescript/react`) which maps directly onto a `@linter-spec/eslint-config`
+ * export subpath.
+ */
+export declare function getESLintConfigType(cwd: string, pkg: PKG): string;
+/**
+ * Resolve a project type to the `@linter-spec/eslint-config` import specifier.
+ */
+export declare function eslintConfigSpecifier(type: string): string;

package/dist/lints/eslint/get-config-type.js

@@ -0,0 +1,30 @@
+import fg from 'fast-glob';
+/**
+ * Detect the project type from its files and dependencies.
+ * The returned value is a `PROJECT_TYPES` value (e.g. `index`, `typescript`,
+ * `typescript/react`) which maps directly onto a `@linter-spec/eslint-config`
+ * export subpath.
+ */
+export function getESLintConfigType(cwd, pkg) {
+    const tsFiles = fg.sync('./!(node_modules)/**/*.@(ts|tsx)', { cwd });
+    const reactFiles = fg.sync('./!(node_modules)/**/*.@(jsx|tsx)', { cwd });
+    const vueFiles = fg.sync('./!(node_modules)/**/*.vue', { cwd });
+    const dependencies = Object.keys(pkg.dependencies || {});
+    const language = tsFiles.length > 0 ? 'typescript' : '';
+    let dsl = '';
+    if (reactFiles.length > 0 || dependencies.some((name) => /^react(-|$)/.test(name))) {
+        dsl = 'react';
+    }
+    else if (vueFiles.length > 0 || dependencies.some((name) => /^vue(-|$)/.test(name))) {
+        dsl = 'vue';
+    }
+    // `''` -> `index`, `typescript/` -> `typescript`, `/react` -> `react`, etc.
+    return `${language}/${dsl}`.replace(/\/$/, '').replace(/^\//, '') || 'index';
+}
+/**
+ * Resolve a project type to the `@linter-spec/eslint-config` import specifier.
+ */
+export function eslintConfigSpecifier(type) {
+    const base = '@linter-spec/eslint-config';
+    return type === 'index' ? base : `${base}/${type}`;
+}

package/dist/lints/eslint/get-config.d.ts

@@ -0,0 +1,10 @@
+import type { ESLint } from 'eslint';
+import type { Config, PKG, ScanOptions } from '../../types.js';
+/**
+ * Build the ESLint 9 constructor options.
+ *
+ * - If the project has its own flat config, let ESLint discover it.
+ * - Otherwise synthesise a `baseConfig` from the matching
+ *   `@linter-spec/eslint-config` export (resolved relative to this package).
+ */
+export declare function getESLintConfig(opts: ScanOptions, pkg: PKG, config: Config): Promise<ESLint.Options>;

package/dist/lints/eslint/get-config.js

@@ -0,0 +1,39 @@
+import fg from 'fast-glob';
+import { ESLINT_IGNORE_GLOBS } from '../../utils/constants.js';
+import { eslintConfigSpecifier, getESLintConfigType } from './get-config-type.js';
+/** True when the project ships its own ESLint flat config / inline config. */
+function hasUserConfig(cwd, pkg) {
+    const flatConfig = fg.sync('eslint.config.@(js|mjs|cjs|ts|mts|cts)', { cwd, dot: true });
+    return flatConfig.length > 0 || Boolean(pkg.eslintConfig);
+}
+/**
+ * Build the ESLint 9 constructor options.
+ *
+ * - If the project has its own flat config, let ESLint discover it.
+ * - Otherwise synthesise a `baseConfig` from the matching
+ *   `@linter-spec/eslint-config` export (resolved relative to this package).
+ */
+export async function getESLintConfig(opts, pkg, config) {
+    const { cwd, fix, ignore } = opts;
+    const lintConfig = {
+        cwd,
+        fix,
+        ignore: ignore !== false,
+        errorOnUnmatchedPattern: false,
+    };
+    if (config.eslintOptions) {
+        Object.assign(lintConfig, config.eslintOptions);
+        return lintConfig;
+    }
+    if (hasUserConfig(cwd, pkg)) {
+        // ESLint will auto-discover the project's own flat config.
+        return lintConfig;
+    }
+    const type = getESLintConfigType(cwd, pkg);
+    const specifier = eslintConfigSpecifier(type);
+    const mod = (await import(specifier));
+    const baseConfig = (mod.default ?? mod);
+    lintConfig.overrideConfigFile = true;
+    lintConfig.baseConfig = [...baseConfig, { ignores: ESLINT_IGNORE_GLOBS }];
+    return lintConfig;
+}

package/dist/lints/eslint/index.d.ts

@@ -0,0 +1,4 @@
+export * from './get-config-type.js';
+export * from './get-config.js';
+export * from './format-results.js';
+export * from './do-eslint.js';

package/dist/lints/eslint/index.js

@@ -0,0 +1,4 @@
+export * from './get-config-type.js';
+export * from './get-config.js';
+export * from './format-results.js';
+export * from './do-eslint.js';

package/dist/lints/index.d.ts

@@ -0,0 +1,4 @@
+export * from './eslint/index.js';
+export * from './stylelint/index.js';
+export * from './markdownlint/index.js';
+export * from './prettier/index.js';

package/dist/lints/index.js

@@ -0,0 +1,4 @@
+export * from './eslint/index.js';
+export * from './stylelint/index.js';
+export * from './markdownlint/index.js';
+export * from './prettier/index.js';

package/dist/lints/markdownlint/do-markdownlint.d.ts

@@ -0,0 +1,7 @@
+import type { Config, PKG, ScanOptions } from '../../types.js';
+import { formatMarkdownlintResults } from './format-results.js';
+export interface DoMarkdownlintOptions extends ScanOptions {
+    pkg: PKG;
+    config: Config;
+}
+export declare function doMarkdownlint(options: DoMarkdownlintOptions): Promise<ReturnType<typeof formatMarkdownlintResults>>;

package/dist/lints/markdownlint/do-markdownlint.js

@@ -0,0 +1,33 @@
+import fsExtra from 'fs-extra';
+import markdownlint from 'markdownlint';
+import { applyFixes } from 'markdownlint-rule-helpers';
+import { MARKDOWN_LINT_FILE_EXT, MARKDOWN_LINT_IGNORE_PATTERN } from '../../utils/constants.js';
+import { resolveScanFiles } from '../resolve-files.js';
+import { formatMarkdownlintResults } from './format-results.js';
+import { getMarkdownlintConfig } from './get-config.js';
+const { readFile, writeFile } = fsExtra;
+export async function doMarkdownlint(options) {
+    const files = await resolveScanFiles(options, MARKDOWN_LINT_FILE_EXT, MARKDOWN_LINT_IGNORE_PATTERN);
+    if (files.length === 0)
+        return [];
+    const results = await markdownlint.promises.markdownlint({
+        ...getMarkdownlintConfig(options, options.pkg, options.config),
+        files,
+    });
+    if (options.fix) {
+        await Promise.all(Object.keys(results).map((filename) => fixMarkdownFile(filename, results[filename] ?? [])));
+    }
+    return formatMarkdownlintResults(results, options.quiet);
+}
+async function fixMarkdownFile(filename, errors) {
+    const fixes = errors?.filter((error) => error.fixInfo);
+    if (fixes?.length > 0) {
+        const originalText = await readFile(filename, 'utf8');
+        const fixedText = applyFixes(originalText, fixes);
+        if (originalText !== fixedText) {
+            await writeFile(filename, fixedText, 'utf8');
+            return errors.filter((error) => !error.fixInfo);
+        }
+    }
+    return errors;
+}

package/dist/lints/markdownlint/format-results.d.ts

@@ -0,0 +1,7 @@
+import type markdownlint from 'markdownlint';
+import type { ScanResult } from '../../types.js';
+/**
+ * Normalise markdownlint results into the shared `ScanResult` shape.
+ * markdownlint findings are always warnings.
+ */
+export declare function formatMarkdownlintResults(results: markdownlint.LintResults, quiet: boolean | undefined): ScanResult[];

package/dist/lints/markdownlint/format-results.js

@@ -0,0 +1,38 @@
+/**
+ * Normalise markdownlint results into the shared `ScanResult` shape.
+ * markdownlint findings are always warnings.
+ */
+export function formatMarkdownlintResults(results, quiet) {
+    const parsedResults = [];
+    for (const file in results) {
+        if (!Object.prototype.hasOwnProperty.call(results, file) || quiet)
+            continue;
+        const fileErrors = results[file];
+        if (!fileErrors)
+            continue;
+        let warningCount = 0;
+        let fixableWarningCount = 0;
+        const messages = fileErrors.map(({ lineNumber, ruleNames, ruleDescription, ruleInformation, errorRange, fixInfo }) => {
+            if (fixInfo)
+                fixableWarningCount++;
+            warningCount++;
+            return {
+                line: lineNumber,
+                column: Array.isArray(errorRange) ? (errorRange[0] ?? 1) : 1,
+                rule: ruleNames[0] ?? null,
+                url: ruleInformation ?? '',
+                message: ruleDescription,
+                errored: false,
+            };
+        });
+        parsedResults.push({
+            filePath: file,
+            messages,
+            errorCount: 0,
+            warningCount,
+            fixableErrorCount: 0,
+            fixableWarningCount,
+        });
+    }
+    return parsedResults;
+}

package/dist/lints/markdownlint/get-config.d.ts

@@ -0,0 +1,10 @@
+import markdownlint from 'markdownlint';
+import type { Config, PKG, ScanOptions } from '../../types.js';
+export type MarkdownlintOptions = markdownlint.Options & {
+    fix?: boolean;
+};
+/**
+ * Build the markdownlint options. Uses the shared config unless the project
+ * provides its own `.markdownlint.*`.
+ */
+export declare function getMarkdownlintConfig(opts: ScanOptions, _pkg: PKG, config: Config): MarkdownlintOptions;

package/dist/lints/markdownlint/get-config.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import fg from 'fast-glob';
+import markdownlint from 'markdownlint';
+import markdownlintConfig from '@linter-spec/markdownlint-config';
+/**
+ * Build the markdownlint options. Uses the shared config unless the project
+ * provides its own `.markdownlint.*`.
+ */
+export function getMarkdownlintConfig(opts, _pkg, config) {
+    const { cwd } = opts;
+    const lintConfig = {
+        fix: Boolean(opts.fix),
+        resultVersion: 3,
+    };
+    if (config.markdownlintOptions) {
+        Object.assign(lintConfig, config.markdownlintOptions);
+        return lintConfig;
+    }
+    const userConfigFiles = fg.sync('.markdownlint?(-cli2).@(jsonc|json|yaml|yml)', {
+        cwd,
+        dot: true,
+    });
+    const [userConfigFile] = userConfigFiles;
+    if (!userConfigFile) {
+        lintConfig.config = markdownlintConfig;
+    }
+    else {
+        lintConfig.config = markdownlint.readConfigSync(path.resolve(cwd, userConfigFile));
+    }
+    return lintConfig;
+}

package/dist/lints/markdownlint/index.d.ts

@@ -0,0 +1,3 @@
+export * from './get-config.js';
+export * from './format-results.js';
+export * from './do-markdownlint.js';

package/dist/lints/markdownlint/index.js

@@ -0,0 +1,3 @@
+export * from './get-config.js';
+export * from './format-results.js';
+export * from './do-markdownlint.js';

package/dist/lints/prettier/do-prettier.d.ts

@@ -0,0 +1,2 @@
+import type { ScanOptions } from '../../types.js';
+export declare function doPrettier(options: ScanOptions): Promise<void>;

package/dist/lints/prettier/do-prettier.js

@@ -0,0 +1,31 @@
+import os from 'node:os';
+import fsExtra from 'fs-extra';
+import prettier from 'prettier';
+import { PRETTIER_FILE_EXT, PRETTIER_IGNORE_PATTERN } from '../../utils/constants.js';
+import { resolveScanFiles } from '../resolve-files.js';
+const { readFile, writeFile } = fsExtra;
+// Cap how many files Prettier formats at once: an unbounded `Promise.all` over
+// thousands of files would spawn that many concurrent reads + format passes and
+// can exhaust file handles / memory on large projects.
+const CONCURRENCY = Math.max(4, os.cpus().length);
+export async function doPrettier(options) {
+    const files = await resolveScanFiles(options, PRETTIER_FILE_EXT, PRETTIER_IGNORE_PATTERN);
+    for (let i = 0; i < files.length; i += CONCURRENCY) {
+        await Promise.all(files.slice(i, i + CONCURRENCY).map(formatFile));
+    }
+}
+async function formatFile(filepath) {
+    // Skip files Prettier can't parse / is configured to ignore.
+    const info = await prettier.getFileInfo(filepath, { resolveConfig: true });
+    if (info.ignored || !info.inferredParser)
+        return;
+    const text = await readFile(filepath, 'utf8');
+    const config = await prettier.resolveConfig(filepath);
+    // Prettier 3: `format` is async. Default `endOfLine` to `auto` so a file keeps
+    // its existing line endings (a CRLF file stays CRLF) when the user's resolved
+    // config doesn't pin `endOfLine`; their config still wins via the spread order.
+    const formatted = await prettier.format(text, { endOfLine: 'auto', ...config, filepath });
+    if (formatted !== text) {
+        await writeFile(filepath, formatted, 'utf8');
+    }
+}

package/dist/lints/prettier/index.d.ts

@@ -0,0 +1 @@
+export * from './do-prettier.js';

package/dist/lints/prettier/index.js

@@ -0,0 +1 @@
+export * from './do-prettier.js';

package/dist/lints/resolve-files.d.ts

@@ -0,0 +1,10 @@
+import type { ScanOptions } from '../types.js';
+/**
+ * Resolve the absolute file list a linter should process: either the explicitly
+ * passed `options.files` (filtered to `exts`, resolved against `cwd`) or a
+ * fast-glob sweep of `options.include` for those extensions, honoring `ignore`.
+ *
+ * ESLint does its own globbing and works in relative patterns, so it does not
+ * use this helper — see `do-eslint.ts`.
+ */
+export declare function resolveScanFiles(options: ScanOptions, exts: string[], ignore: string[]): Promise<string[]>;

package/dist/lints/resolve-files.js

@@ -0,0 +1,20 @@
+import path from 'node:path';
+import fg from 'fast-glob';
+/**
+ * Resolve the absolute file list a linter should process: either the explicitly
+ * passed `options.files` (filtered to `exts`, resolved against `cwd`) or a
+ * fast-glob sweep of `options.include` for those extensions, honoring `ignore`.
+ *
+ * ESLint does its own globbing and works in relative patterns, so it does not
+ * use this helper — see `do-eslint.ts`.
+ */
+export async function resolveScanFiles(options, exts, ignore) {
+    if (options.files) {
+        return options.files
+            .filter((name) => exts.includes(path.extname(name)))
+            .map((name) => path.resolve(options.cwd, name));
+    }
+    const globExts = exts.map((ext) => ext.replace(/^\./, '')).join(',');
+    const include = options.include || options.cwd;
+    return fg(`**/*.{${globExts}}`, { cwd: include, ignore, absolute: true });
+}

package/dist/lints/stylelint/do-stylelint.d.ts

@@ -0,0 +1,7 @@
+import type { Config, PKG, ScanOptions } from '../../types.js';
+import { formatStylelintResults } from './format-results.js';
+export interface DoStylelintOptions extends ScanOptions {
+    pkg: PKG;
+    config: Config;
+}
+export declare function doStylelint(options: DoStylelintOptions): Promise<ReturnType<typeof formatStylelintResults>>;