sadrazam 0.1.10 → 0.1.12

package/dist/plugins.js

@@ -1,98 +1,76 @@
-import { access } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import path from "node:path";
+import fg from "fast-glob";
 const COMMAND_SPLIT_RE = /\s*(?:&&|\|\||;)\s*/;
 const TOKEN_RE = /"[^"]*"|'[^']*'|`[^`]*`|[^\s]+/g;
-function createConfigEntryPlugin(name, commands, flags) {
-    return {
-        name,
-        supports(command) {
-            return commands.includes(command);
-        },
-        async resolve(tokens, packageDir) {
-            const fileEntries = new Set();
-            for (let index = 0; index < tokens.length; index += 1) {
-                const token = stripQuotes(tokens[index] ?? "");
-                const next = stripQuotes(tokens[index + 1] ?? "");
-                if (!flags.includes(token) || !next) {
-                    continue;
-                }
-                const configPath = path.resolve(packageDir, next);
-                if (await fileExists(configPath)) {
-                    fileEntries.add(configPath);
-                }
-                index += 1;
-            }
-            return fileEntries.size > 0
-                ? {
-                    fileEntries: [...fileEntries],
-                }
-                : null;
-        },
-    };
-}
+const CONFIG_EXTENSIONS = "{js,cjs,mjs,ts,cts,mts,json,jsonc}";
+const CONFIG_FLAG_ALIASES = ["--config", "-c"];
 const PLUGINS = [
-    createConfigEntryPlugin("vite", ["vite"], ["--config"]),
-    createConfigEntryPlugin("vitest", ["vitest"], ["--config"]),
-    createConfigEntryPlugin("jest", ["jest"], ["--config"]),
+    createToolPlugin("vite", ["vite"], ["vite"], [`vite.config.${CONFIG_EXTENSIONS}`]),
+    createToolPlugin("vitest", ["vitest"], ["vitest"], [`vitest.config.${CONFIG_EXTENSIONS}`]),
+    createToolPlugin("jest", ["jest"], ["jest"], [
+        `jest.config.${CONFIG_EXTENSIONS}`,
+        "package.json",
+    ]),
+    createToolPlugin("playwright", ["playwright"], ["@playwright/test", "playwright"], [
+        `playwright.config.${CONFIG_EXTENSIONS}`,
+    ], ["tests/**", "e2e/**"]),
+    createToolPlugin("cypress", ["cypress"], ["cypress"], [
+        `cypress.config.${CONFIG_EXTENSIONS}`,
+    ], ["cypress/**"]),
+    createToolPlugin("storybook", ["storybook", "start-storybook", "build-storybook"], ["storybook", "@storybook/cli"], [
+        ".storybook/main.{js,cjs,mjs,ts,cts,mts}",
+        ".storybook/preview.{js,cjs,mjs,ts,cts,mts}",
+    ], [".storybook/**", "src/**/*.stories.{js,jsx,ts,tsx,mdx}"]),
+    createToolPlugin("next", ["next"], ["next"], [
+        "next.config.{js,cjs,mjs,ts}",
+    ], ["pages/**/*.{js,jsx,ts,tsx}", "app/**/*.{js,jsx,ts,tsx}", "src/pages/**/*.{js,jsx,ts,tsx}", "src/app/**/*.{js,jsx,ts,tsx}"]),
+    createToolPlugin("astro", ["astro"], ["astro"], [
+        "astro.config.{js,cjs,mjs,ts}",
+    ], ["src/pages/**/*.astro", "src/content/**/*.{md,mdx}"]),
+    createToolPlugin("sveltekit", ["svelte-kit"], ["@sveltejs/kit"], [
+        "svelte.config.{js,cjs,mjs,ts}",
+        "vite.config.{js,cjs,mjs,ts}",
+    ], ["src/routes/**/*.{js,ts,svelte}", "src/hooks.{js,ts}"]),
+    createToolPlugin("webpack", ["webpack", "webpack-cli"], ["webpack", "webpack-cli"], [
+        `webpack.config.${CONFIG_EXTENSIONS}`,
+    ]),
+    createToolPlugin("rollup", ["rollup"], ["rollup"], [
+        `rollup.config.${CONFIG_EXTENSIONS}`,
+    ]),
     {
-        name: "prettier",
-        supports(command) {
-            return command === "prettier";
-        },
-        async resolve(tokens, packageDir) {
-            const packages = new Set();
-            const fileEntries = new Set();
-            for (let index = 0; index < tokens.length; index += 1) {
-                const token = stripQuotes(tokens[index] ?? "");
-                const next = stripQuotes(tokens[index + 1] ?? "");
-                if (token === "--plugin" && next) {
-                    packages.add(next);
-                    index += 1;
-                    continue;
-                }
-                if (token === "--config" && next) {
-                    const configPath = path.resolve(packageDir, next);
-                    if (await fileExists(configPath)) {
-                        fileEntries.add(configPath);
-                    }
-                    index += 1;
-                }
-            }
-            if (packages.size === 0 && fileEntries.size === 0) {
-                return null;
-            }
-            return {
-                packages: [...packages],
-                fileEntries: [...fileEntries],
-            };
-        },
+        ...createToolPlugin("eslint", ["eslint"], ["eslint"], [
+            ".eslintrc",
+            `.eslintrc.${CONFIG_EXTENSIONS}`,
+            `eslint.config.${CONFIG_EXTENSIONS}`,
+        ]),
+        packageFlags: [
+            { flag: "--parser" },
+            { flag: "--plugin", normalize: normalizeEslintPlugin },
+        ],
+        analyzeConfig: analyzeEslintConfig,
     },
     {
-        name: "eslint",
-        supports(command) {
-            return command === "eslint";
-        },
-        async resolve(tokens) {
-            const packages = new Set();
-            for (let index = 0; index < tokens.length; index += 1) {
-                const token = stripQuotes(tokens[index] ?? "");
-                const next = stripQuotes(tokens[index + 1] ?? "");
-                if (token === "--parser" && next) {
-                    packages.add(next);
-                    index += 1;
-                    continue;
-                }
-                if (token === "--plugin" && next) {
-                    packages.add(normalizeEslintPlugin(next));
-                    index += 1;
-                }
-            }
-            return packages.size > 0
-                ? {
-                    packages: [...packages],
-                }
-                : null;
-        },
+        ...createToolPlugin("prettier", ["prettier"], ["prettier"], [
+            `.prettierrc.${CONFIG_EXTENSIONS}`,
+            "prettier.config.{js,cjs,mjs,ts,cts,mts}",
+            ".prettierrc",
+        ]),
+        packageFlags: [{ flag: "--plugin" }],
+        analyzePackageJson: analyzePrettierPackageJson,
+    },
+    {
+        ...createToolPlugin("tailwind", ["tailwindcss"], ["tailwindcss"], [
+            "tailwind.config.{js,cjs,mjs,ts}",
+            "postcss.config.{js,cjs,mjs,ts}",
+        ]),
+    },
+    {
+        ...createToolPlugin("typescript", ["tsc", "tsserver"], ["typescript"], [
+            "tsconfig.json",
+            "tsconfig.*.json",
+        ]),
+        analyzeConfig: analyzeTsConfig,
     },
 ];
 export async function analyzePlugins(context) {
@@ -100,63 +78,331 @@ export async function analyzePlugins(context) {
     const commandPackages = new Set();
     const fileEntries = new Set();
     const commandUsage = new Map();
-    for (const [scriptName, script] of Object.entries(context.scripts)) {
-        const segments = script.split(COMMAND_SPLIT_RE);
-        for (const segment of segments) {
-            const tokens = tokenize(segment);
-            if (tokens.length === 0) {
-                continue;
-            }
-            const command = resolveCommandName(tokens);
-            if (!command) {
-                continue;
-            }
-            for (const plugin of PLUGINS) {
-                if (!plugin.supports(command)) {
-                    continue;
-                }
-                const contribution = await plugin.resolve(tokens, context.packageDir);
-                if (!contribution) {
-                    continue;
-                }
-                activePlugins.add(plugin.name);
-                for (const packageName of contribution.packages ?? []) {
-                    commandPackages.add(packageName);
-                    addUsage(commandUsage, packageName, `script:${scriptName}`);
-                }
-                for (const filePath of contribution.fileEntries ?? []) {
-                    fileEntries.add(filePath);
-                }
-                for (const [packageName, sources] of Object.entries(contribution.packageUsage ?? {})) {
-                    commandPackages.add(packageName);
-                    for (const source of sources) {
-                        addUsage(commandUsage, packageName, source);
-                    }
-                }
-            }
+    const details = [];
+    const scripts = collectScriptInvocations(context.scripts);
+    for (const plugin of PLUGINS) {
+        const override = context.config?.[plugin.name];
+        if (override === false) {
+            continue;
+        }
+        const scriptInvocations = scripts.filter((script) => plugin.commands.includes(script.command));
+        const isForced = override === true || isPluginConfigObject(override);
+        const isDeclared = plugin.packages.some((packageName) => context.dependencyNames.has(packageName));
+        if (!isForced && !isDeclared && scriptInvocations.length === 0) {
+            continue;
+        }
+        const contribution = await collectPluginContribution(plugin, context, scriptInvocations, override);
+        if (!hasContribution(contribution) && !isDeclared && !isForced) {
+            continue;
         }
+        activePlugins.add(plugin.name);
+        mergeContribution(contribution, commandPackages, fileEntries, commandUsage);
+        details.push({
+            name: plugin.name,
+            activation: [
+                isDeclared ? "dependency" : null,
+                scriptInvocations.length > 0 ? "script" : null,
+                isForced ? "config" : null,
+            ].filter((value) => Boolean(value)),
+            packages: contribution.packages ?? [],
+            fileEntries: contribution.fileEntries ?? [],
+        });
     }
     return {
         activePlugins: [...activePlugins].sort(),
         commandPackages: [...commandPackages].sort(),
         fileEntries: [...fileEntries].sort(),
+        details: details.sort((left, right) => left.name.localeCompare(right.name)),
         commandUsage: Object.fromEntries([...commandUsage.entries()]
             .map(([packageName, sources]) => [packageName, [...sources].sort()])
             .sort(([left], [right]) => left.localeCompare(right))),
     };
 }
+export async function analyzePluginInputs(packageDir, config) {
+    const commandPackages = new Set();
+    const fileEntries = new Set();
+    const commandUsage = new Map();
+    for (const packageName of config?.packageNames ?? []) {
+        commandPackages.add(packageName);
+        addUsage(commandUsage, packageName, "config:inputs.packageNames");
+    }
+    for (const entry of config?.entryFiles ?? []) {
+        const filePath = path.resolve(packageDir, entry);
+        if (await fileExists(filePath)) {
+            fileEntries.add(filePath);
+        }
+    }
+    return {
+        activePlugins: commandPackages.size > 0 || fileEntries.size > 0 ? ["inputs"] : [],
+        commandPackages: [...commandPackages].sort(),
+        fileEntries: [...fileEntries].sort(),
+        details: commandPackages.size > 0 || fileEntries.size > 0
+            ? [{
+                    name: "inputs",
+                    activation: ["config"],
+                    packages: [...commandPackages].sort(),
+                    fileEntries: [...fileEntries].sort(),
+                }]
+            : [],
+        commandUsage: Object.fromEntries([...commandUsage.entries()]
+            .map(([packageName, sources]) => [packageName, [...sources].sort()])
+            .sort(([left], [right]) => left.localeCompare(right))),
+    };
+}
+function createToolPlugin(name, commands, packages, configPatterns = [], entryPatterns = []) {
+    return {
+        name,
+        commands,
+        packages,
+        configPatterns,
+        entryPatterns,
+        configFlags: CONFIG_FLAG_ALIASES,
+    };
+}
+async function collectPluginContribution(plugin, context, scriptInvocations, override) {
+    const packages = new Set();
+    const fileEntries = new Set();
+    const packageUsage = new Map();
+    for (const invocation of scriptInvocations) {
+        if (plugin.packages[0]) {
+            packages.add(plugin.packages[0]);
+            addUsage(packageUsage, plugin.packages[0], `script:${invocation.scriptName}`);
+        }
+        for (const packageName of collectPackagesFromFlags(invocation.tokens, plugin.packageFlags ?? [])) {
+            packages.add(packageName.name);
+            addUsage(packageUsage, packageName.name, `script:${invocation.scriptName}`);
+        }
+        for (const filePath of await collectFilesFromFlags(context.packageDir, invocation.tokens, plugin.configFlags ?? [])) {
+            fileEntries.add(filePath);
+        }
+        for (const filePath of await collectPositionalFiles(context.packageDir, invocation.tokens.slice(1))) {
+            fileEntries.add(filePath);
+        }
+    }
+    const configPatterns = isPluginConfigObject(override)
+        ? toArray(override.config ?? plugin.configPatterns ?? [])
+        : plugin.configPatterns ?? [];
+    const entryPatterns = isPluginConfigObject(override)
+        ? toArray(override.entry ?? plugin.entryPatterns ?? [])
+        : plugin.entryPatterns ?? [];
+    for (const filePath of await collectFilesFromPatterns(context.packageDir, configPatterns)) {
+        fileEntries.add(filePath);
+        const configContribution = plugin.analyzeConfig ? await plugin.analyzeConfig(filePath) : null;
+        mergeContribution(configContribution, packages, fileEntries, packageUsage);
+    }
+    for (const filePath of await collectFilesFromPatterns(context.packageDir, entryPatterns)) {
+        fileEntries.add(filePath);
+    }
+    mergeContribution(plugin.analyzePackageJson?.(context) ?? null, packages, fileEntries, packageUsage);
+    return {
+        packages: [...packages].sort(),
+        fileEntries: [...fileEntries].sort(),
+        packageUsage: Object.fromEntries([...packageUsage.entries()].map(([packageName, sources]) => [packageName, [...sources].sort()])),
+    };
+}
+function collectScriptInvocations(scripts) {
+    const invocations = [];
+    for (const [scriptName, script] of Object.entries(scripts)) {
+        for (const segment of script.split(COMMAND_SPLIT_RE)) {
+            const tokens = tokenize(segment);
+            const command = resolveCommandName(tokens);
+            if (command) {
+                invocations.push({ scriptName, command, tokens });
+            }
+        }
+    }
+    return invocations;
+}
+function collectPackagesFromFlags(tokens, flags) {
+    const packages = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = stripQuotes(tokens[index] ?? "");
+        const flag = flags.find((candidate) => candidate.flag === token);
+        const next = stripQuotes(tokens[index + 1] ?? "");
+        if (!flag || !next) {
+            continue;
+        }
+        packages.push({ name: flag.normalize ? flag.normalize(next) : next });
+        index += 1;
+    }
+    return packages;
+}
+async function collectFilesFromFlags(packageDir, tokens, flags) {
+    const fileEntries = new Set();
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = stripQuotes(tokens[index] ?? "");
+        const next = stripQuotes(tokens[index + 1] ?? "");
+        if (!flags.includes(token) || !next) {
+            continue;
+        }
+        for (const filePath of await resolveEntryPattern(packageDir, next)) {
+            fileEntries.add(filePath);
+        }
+        index += 1;
+    }
+    return [...fileEntries];
+}
+async function collectPositionalFiles(packageDir, tokens) {
+    const entries = new Set();
+    for (const rawToken of tokens) {
+        const token = stripQuotes(rawToken);
+        if (!token || token.startsWith("-") || looksLikePackageSpecifier(token)) {
+            continue;
+        }
+        for (const filePath of await resolveEntryPattern(packageDir, token)) {
+            entries.add(filePath);
+        }
+    }
+    return [...entries];
+}
+async function collectFilesFromPatterns(packageDir, patterns) {
+    const entries = new Set();
+    for (const pattern of patterns) {
+        for (const filePath of await resolveEntryPattern(packageDir, pattern)) {
+            entries.add(filePath);
+        }
+    }
+    return [...entries];
+}
+async function resolveEntryPattern(packageDir, pattern) {
+    const cleanPattern = stripQuotes(pattern);
+    const absolutePath = path.resolve(packageDir, cleanPattern);
+    if (!hasGlobMagic(cleanPattern) && await fileExists(absolutePath)) {
+        return [absolutePath];
+    }
+    return fg(cleanPattern, {
+        cwd: packageDir,
+        absolute: true,
+        dot: true,
+        onlyFiles: true,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
+    });
+}
+async function analyzeEslintConfig(filePath) {
+    if (!filePath.endsWith(".json") && !filePath.endsWith(".eslintrc")) {
+        return null;
+    }
+    const config = await readJsonFile(filePath);
+    if (!isRecord(config)) {
+        return null;
+    }
+    const packages = new Set();
+    for (const value of toArray(config.extends)) {
+        if (typeof value === "string" && !value.startsWith(".") && !path.isAbsolute(value)) {
+            packages.add(normalizeEslintConfig(value));
+        }
+    }
+    if (typeof config.parser === "string") {
+        packages.add(config.parser);
+    }
+    for (const value of toArray(config.plugins)) {
+        if (typeof value === "string") {
+            packages.add(normalizeEslintPlugin(value));
+        }
+    }
+    return packages.size > 0 ? { packages: [...packages] } : null;
+}
+function analyzePrettierPackageJson(context) {
+    const prettierConfig = context.packageJson.prettier;
+    if (!prettierConfig) {
+        return null;
+    }
+    if (typeof prettierConfig === "string") {
+        return {
+            fileEntries: [path.resolve(context.packageDir, prettierConfig)],
+        };
+    }
+    return {
+        packages: [...new Set(prettierConfig.plugins ?? [])],
+    };
+}
+async function analyzeTsConfig(filePath) {
+    const config = await readJsonFile(filePath);
+    if (!isRecord(config)) {
+        return null;
+    }
+    const fileEntries = new Set();
+    const packages = new Set();
+    const baseDir = path.dirname(filePath);
+    if (typeof config.extends === "string") {
+        if (config.extends.startsWith(".") || config.extends.startsWith("/")) {
+            const extendedPath = resolveTsConfigReference(baseDir, config.extends);
+            if (await fileExists(extendedPath)) {
+                fileEntries.add(extendedPath);
+            }
+        }
+        else {
+            packages.add(getPackageName(config.extends));
+        }
+    }
+    for (const reference of toUnknownArray(config.references)) {
+        if (!isRecord(reference) || typeof reference.path !== "string") {
+            continue;
+        }
+        const referencePath = resolveTsConfigReference(baseDir, reference.path);
+        if (await fileExists(referencePath)) {
+            fileEntries.add(referencePath);
+        }
+    }
+    const compilerOptions = isRecord(config.compilerOptions) ? config.compilerOptions : {};
+    for (const plugin of toUnknownArray(compilerOptions.plugins)) {
+        if (isRecord(plugin) && typeof plugin.name === "string") {
+            packages.add(plugin.name);
+        }
+    }
+    return fileEntries.size > 0 || packages.size > 0
+        ? { fileEntries: [...fileEntries], packages: [...packages] }
+        : null;
+}
+function resolveTsConfigReference(baseDir, value) {
+    const resolved = path.resolve(baseDir, value);
+    return path.extname(resolved) ? resolved : path.join(resolved, "tsconfig.json");
+}
+async function readJsonFile(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function mergeContribution(contribution, packages, fileEntries, packageUsage) {
+    if (!contribution) {
+        return;
+    }
+    for (const packageName of contribution.packages ?? []) {
+        packages.add(packageName);
+    }
+    for (const filePath of contribution.fileEntries ?? []) {
+        fileEntries.add(filePath);
+    }
+    for (const [packageName, sources] of Object.entries(contribution.packageUsage ?? {})) {
+        packages.add(packageName);
+        for (const source of sources) {
+            addUsage(packageUsage, packageName, source);
+        }
+    }
+}
+function hasContribution(contribution) {
+    return Boolean((contribution.packages?.length ?? 0) > 0
+        || (contribution.fileEntries?.length ?? 0) > 0
+        || Object.keys(contribution.packageUsage ?? {}).length > 0);
+}
 function tokenize(command) {
     return command.match(TOKEN_RE)?.map((token) => token.trim()).filter(Boolean) ?? [];
 }
 function resolveCommandName(tokens) {
-    const [first, second] = tokens;
+    const [first, second, third] = tokens;
     const command = stripQuotes(first ?? "");
     if (!command) {
         return null;
     }
-    if (command === "npx" || command === "pnpx") {
+    if (command === "npx" || command === "pnpx" || command === "bunx") {
         return stripQuotes(second ?? "") || null;
     }
+    if ((command === "npm" || command === "pnpm" || command === "yarn") && stripQuotes(second ?? "") === "exec") {
+        return stripQuotes(third ?? "") || null;
+    }
     return command;
 }
 function normalizeEslintPlugin(value) {
@@ -169,9 +415,52 @@ function normalizeEslintPlugin(value) {
     }
     return value.startsWith("eslint-plugin-") ? value : `eslint-plugin-${value}`;
 }
+function normalizeEslintConfig(value) {
+    if (value.startsWith("@")) {
+        if (value.includes("/eslint-config")) {
+            return value;
+        }
+        const [scope, name] = value.split("/");
+        return name ? `${scope}/eslint-config-${name}` : value;
+    }
+    return value.startsWith("eslint-config-") ? value : `eslint-config-${value}`;
+}
+function getPackageName(specifier) {
+    if (specifier.startsWith("@")) {
+        const [scope, name] = specifier.split("/");
+        return name ? `${scope}/${name}` : specifier;
+    }
+    return specifier.split("/")[0] ?? specifier;
+}
+function addUsage(usage, packageName, source) {
+    const sources = usage.get(packageName) ?? new Set();
+    sources.add(source);
+    usage.set(packageName, sources);
+}
+function isPluginConfigObject(value) {
+    return isRecord(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toArray(value) {
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === "string");
+    }
+    return typeof value === "string" ? [value] : [];
+}
+function toUnknownArray(value) {
+    return Array.isArray(value) ? value : [];
+}
 function stripQuotes(value) {
     return value.replace(/^['"`]|['"`]$/g, "");
 }
+function hasGlobMagic(value) {
+    return /[*?[\]{}()!+@]/.test(value);
+}
+function looksLikePackageSpecifier(value) {
+    return !value.startsWith(".") && !value.startsWith("/") && !value.includes("*") && !/\.[cm]?[jt]sx?$/.test(value);
+}
 async function fileExists(filePath) {
     try {
         await access(filePath);
@@ -181,33 +470,4 @@ async function fileExists(filePath) {
         return false;
     }
 }
-function addUsage(usageMap, packageName, source) {
-    const entries = usageMap.get(packageName) ?? new Set();
-    entries.add(source);
-    usageMap.set(packageName, entries);
-}
-export async function analyzePluginInputs(packageDir, inputs) {
-    const entryFiles = new Set();
-    const commandPackages = new Set();
-    const commandUsage = new Map();
-    for (const entryFile of inputs?.entryFiles ?? []) {
-        const absolutePath = path.resolve(packageDir, entryFile);
-        if (await fileExists(absolutePath)) {
-            entryFiles.add(absolutePath);
-        }
-    }
-    for (const packageName of inputs?.packageNames ?? []) {
-        commandPackages.add(packageName);
-        addUsage(commandUsage, packageName, "input:config");
-    }
-    const activePlugins = entryFiles.size > 0 || commandPackages.size > 0 ? ["inputs"] : [];
-    return {
-        activePlugins,
-        commandPackages: [...commandPackages].sort(),
-        fileEntries: [...entryFiles].sort(),
-        commandUsage: Object.fromEntries([...commandUsage.entries()]
-            .map(([packageName, sources]) => [packageName, [...sources].sort()])
-            .sort(([left], [right]) => left.localeCompare(right))),
-    };
-}
 //# sourceMappingURL=plugins.js.map