knip 6.37.0 → 6.39.0

package/dist/plugins/mdx/index.js

@@ -1,25 +1,35 @@
-import { toDependency } from '../../util/input.js';
+import { toDeferResolveProductionEntry, toDependency } from '../../util/input.js';
+import { isInternal } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'MDX';
 const enablers = ['astro', 'mdxlint'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['tsconfig.json'];
-const takeDependencies = (config) => {
+const takeDependencies = (plugins) => {
     const inputs = [];
-    if (Array.isArray(config.plugins)) {
-        for (const plugin of config.plugins) {
+    if (Array.isArray(plugins)) {
+        for (const plugin of plugins) {
             if (typeof plugin === 'string')
                 inputs.push(toDependency(plugin));
-            else if (typeof plugin[0] === 'string')
+            else if (Array.isArray(plugin) && typeof plugin[0] === 'string')
                 inputs.push(toDependency(plugin[0]));
         }
     }
     return inputs;
 };
+export const contentMappers = ['mdx-content-mapper', '@mdx-js/content-mapper'];
+const bundledPlugins = ['remark-mdx-frontmatter'];
+export const resolveContentMapperOptions = (options) => {
+    const inputs = takeDependencies(options.remarkPlugins).filter(input => !bundledPlugins.includes(input.specifier));
+    const provider = options.providerImportSource;
+    if (typeof provider === 'string' && isInternal(provider))
+        inputs.push(toDeferResolveProductionEntry(provider));
+    return inputs;
+};
 const resolveConfig = async (config, options) => {
     const { configFileName } = options;
     if (configFileName === 'tsconfig.json' && 'mdx' in config)
-        return takeDependencies(config.mdx);
+        return takeDependencies(config.mdx.plugins);
     return [];
 };
 const plugin = {

package/dist/plugins/mocha/index.js

@@ -1,4 +1,4 @@
-import { toDeferResolve, toEntry } from '../../util/input.js';
+import { toDeferResolve, toDeferResolveEntry, toEntry } from '../../util/input.js';
 import { isDirectory } from '../../util/fs.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Mocha';
@@ -9,9 +9,11 @@ const entry = ['**/test/*.{js,cjs,mjs}'];
 const defaultExtensions = ['js', 'cjs', 'mjs'];
 const resolveConfig = localConfig => {
     const entryPatterns = localConfig.spec ? [localConfig.spec].flat() : entry;
+    const files = localConfig.file ? [localConfig.file].flat() : [];
     const require = localConfig.require ? [localConfig.require].flat() : [];
     const inputs = [];
     inputs.push(...entryPatterns.map(id => toEntry(id)));
+    inputs.push(...files.map(id => toDeferResolveEntry(id)));
     inputs.push(...require.map(id => toDeferResolve(id)));
     return inputs;
 };

package/dist/plugins/mocha/types.d.ts

@@ -1,4 +1,5 @@
 export interface MochaConfig {
+    file?: string | string[];
     require?: string | string[];
     spec?: string | string[];
 }

package/dist/plugins/oxlint/index.js

@@ -1,7 +1,7 @@
 import { Visitor } from 'oxc-parser';
 import { findProperty, getPropertyValues } from '../../typescript/ast-helpers.js';
-import { toDependency, toEntry } from '../../util/input.js';
-import { isInternal } from '../../util/path.js';
+import { toConfig, toDependency, toEntry } from '../../util/input.js';
+import { dirname, isInternal, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getInputsFromSettings } from '../eslint/helpers.js';
 import { getInputsFromSettingsAST } from '../eslint/resolveFromAST.js';
@@ -13,28 +13,42 @@ const isViteConfig = (configFileName) => configFileName.startsWith('vite.config.
 const args = {
     config: true,
 };
-const resolveJsPlugins = (jsPlugins) => {
+const resolveJsPlugins = (jsPlugins, configFilePath) => {
     const inputs = [];
+    const dir = dirname(configFilePath);
     for (const plugin of jsPlugins ?? []) {
         const specifier = typeof plugin === 'string' ? plugin : plugin.specifier;
         if (!isInternal(specifier))
             inputs.push(toDependency(specifier));
         else
-            inputs.push(toEntry(specifier));
+            inputs.push(toEntry(toAbsolute(specifier, dir)));
     }
     return inputs;
 };
 const isLoadConfig = ({ configFileName }) => !isViteConfig(configFileName);
-const resolveConfig = config => {
-    const inputs = resolveJsPlugins(config.jsPlugins);
+const resolveExtendedConfig = (config, configFilePath) => {
+    const inputs = [];
+    for (const entry of config.extends ?? []) {
+        if (typeof entry === 'string') {
+            const filePath = toAbsolute(entry, dirname(configFilePath));
+            inputs.push(toConfig('oxlint', filePath, { containingFilePath: configFilePath }));
+        }
+        else {
+            for (const input of resolveExtendedConfig(entry, configFilePath))
+                inputs.push(input);
+        }
+    }
+    for (const input of resolveJsPlugins(config.jsPlugins, configFilePath))
+        inputs.push(input);
     for (const override of config.overrides ?? []) {
-        for (const input of resolveJsPlugins(override.jsPlugins))
+        for (const input of resolveJsPlugins(override.jsPlugins, configFilePath))
             inputs.push(input);
     }
     for (const input of getInputsFromSettings(config.settings))
         inputs.push(input);
     return inputs;
 };
+const resolveConfig = (config, options) => resolveExtendedConfig(config, options.configFilePath);
 const resolveFromAST = (program, options) => {
     if (!isViteConfig(options.configFileName))
         return [];
@@ -55,8 +69,9 @@ const resolveFromAST = (program, options) => {
         },
     });
     visitor.visit(program);
-    return [...resolveJsPlugins([...jsPlugins]), ...getInputsFromSettingsAST(program)];
+    return [...resolveJsPlugins([...jsPlugins], options.configFilePath), ...getInputsFromSettingsAST(program)];
 };
+const isFilterTransitiveDependencies = true;
 const plugin = {
     title,
     enablers,
@@ -65,6 +80,7 @@ const plugin = {
     isLoadConfig,
     resolveConfig,
     resolveFromAST,
+    isFilterTransitiveDependencies,
     args,
 };
 export default plugin;

package/dist/plugins/oxlint/types.d.ts

@@ -7,6 +7,7 @@ type Override = {
     jsPlugins?: JsPlugin[];
 };
 export type OxlintConfig = {
+    extends?: (string | OxlintConfig)[];
     jsPlugins?: JsPlugin[];
     overrides?: Override[];
     settings?: Settings;

package/dist/plugins/playwright/index.js

@@ -1,6 +1,6 @@
 import { arrayify } from '../../util/array.js';
 import { toDeferResolve, toEntry } from '../../util/input.js';
-import { join, relative } from '../../util/path.js';
+import { join, relative, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Playwright';
 const enablers = ['@playwright/test'];
@@ -18,9 +18,9 @@ export const resolveConfig = async (localConfig, options) => {
     const { cwd, configFileDir } = options;
     const inputs = [];
     for (const id of arrayify(localConfig.globalSetup))
-        inputs.push(toEntry(id));
+        inputs.push(toEntry(toAbsolute(id, configFileDir)));
     for (const id of arrayify(localConfig.globalTeardown))
-        inputs.push(toEntry(id));
+        inputs.push(toEntry(toAbsolute(id, configFileDir)));
     const projects = localConfig.projects ? [localConfig, ...localConfig.projects] : [localConfig];
     const reporters = [localConfig.reporter].flat().flatMap(reporter => {
         const name = typeof reporter === 'string' ? reporter : reporter?.[0];

package/dist/plugins/plop/index.js

@@ -2,11 +2,11 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'Plop';
 const enablers = ['plop'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['plopfile.{cjs,mjs,js,ts}'];
+const entry = ['plopfile.{cjs,mjs,js,ts}'];
 const plugin = {
     title,
     enablers,
     isEnabled,
-    config,
+    entry,
 };
 export default plugin;

package/dist/plugins/railway/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/railway/index.js

@@ -0,0 +1,129 @@
+import { Visitor } from 'oxc-parser';
+import { findProperty, getFirstPropertyValue, getStringValues } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
+import { getGitRemoteUrls } from '../../util/git.js';
+import { isEntry } from '../../util/input.js';
+import { join, toAbsolute } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Railway';
+const enablers = ['railway'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['.railway/railway.ts'];
+const args = {
+    config: ['file'],
+    resolve: ['runner'],
+};
+const getCommands = (node) => {
+    const command = getStringValue(node);
+    return command ? [command] : [...getStringValues(node)];
+};
+const isExternalSourceType = (type) => type === 'github' || type === 'image' || type === 'template';
+const getGitHubRepository = (value) => {
+    const normalized = value
+        ?.trim()
+        .replace(/^git\+/, '')
+        .replace(/\.git\/?$/, '')
+        .replace(/\/$/, '');
+    return normalized?.match(/(?:^|github(?:\.com)?[/:])([^/:]+\/[^/]+)$/i)?.[1].toLowerCase();
+};
+const resolveFromAST = (program, options) => {
+    const serviceNames = new Set();
+    const sourceTypes = new Map();
+    const bindings = new Map();
+    const localRepositories = new Set();
+    for (const repository of [options.manifest.repository, options.rootManifest?.repository]) {
+        const name = getGitHubRepository(typeof repository === 'string' ? repository : repository?.url);
+        if (name)
+            localRepositories.add(name);
+    }
+    for (const url of getGitRemoteUrls(options.rootCwd)) {
+        const name = getGitHubRepository(url);
+        if (name)
+            localRepositories.add(name);
+    }
+    for (const node of program.body) {
+        if (node.type === 'ImportDeclaration' && getStringValue(node.source) === 'railway/iac') {
+            for (const specifier of node.specifiers) {
+                if (specifier.type !== 'ImportSpecifier' || specifier.imported.type !== 'Identifier')
+                    continue;
+                if (specifier.imported.name === 'service')
+                    serviceNames.add(specifier.local.name);
+                if (isExternalSourceType(specifier.imported.name)) {
+                    sourceTypes.set(specifier.local.name, specifier.imported.name);
+                }
+            }
+        }
+        else if (node.type === 'VariableDeclaration') {
+            for (const declaration of node.declarations) {
+                if (declaration.id.type === 'Identifier' && declaration.init)
+                    bindings.set(declaration.id.name, declaration.init);
+            }
+        }
+    }
+    const resolveBinding = (node) => {
+        const seen = new Set();
+        while (node?.type === 'Identifier' && bindings.has(node.name) && !seen.has(node.name)) {
+            seen.add(node.name);
+            node = bindings.get(node.name);
+        }
+        return node;
+    };
+    const inputs = [];
+    const visitor = new Visitor({
+        CallExpression(node) {
+            if (node.callee.type !== 'Identifier' || !serviceNames.has(node.callee.name))
+                return;
+            const serviceConfig = node.arguments[1];
+            if (serviceConfig?.type !== 'ObjectExpression')
+                return;
+            const source = resolveBinding(findProperty(serviceConfig, 'source'));
+            const repository = getFirstPropertyValue(source, 'repo');
+            const image = getFirstPropertyValue(source, 'image');
+            const template = getFirstPropertyValue(source, 'template');
+            const sourceType = (source?.type === 'CallExpression' && source.callee.type === 'Identifier'
+                ? sourceTypes.get(source.callee.name)
+                : undefined) ??
+                getFirstPropertyValue(source, 'type') ??
+                (repository ? 'github' : image ? 'image' : template ? 'template' : undefined);
+            const sourceRepository = getGitHubRepository(source?.type === 'CallExpression' ? getStringValue(source.arguments[0]) : repository);
+            if (sourceType === 'image' ||
+                sourceType === 'template' ||
+                (sourceType === 'github' &&
+                    sourceRepository !== undefined &&
+                    localRepositories.size > 0 &&
+                    !localRepositories.has(sourceRepository))) {
+                return;
+            }
+            const sourceConfig = source?.type === 'CallExpression' ? source.arguments[1] : source;
+            const rootDirectory = getFirstPropertyValue(sourceConfig, 'rootDirectory') ??
+                getFirstPropertyValue(serviceConfig, 'root') ??
+                getFirstPropertyValue(serviceConfig, 'rootDirectory');
+            const cwd = rootDirectory ? join(options.cwd, rootDirectory) : options.cwd;
+            const manifest = options.getManifest(cwd) ?? options.manifest;
+            const build = findProperty(serviceConfig, 'build');
+            const commands = [
+                ...getCommands(build),
+                ...getCommands(findProperty(build, 'buildCommand')),
+                ...getCommands(findProperty(serviceConfig, 'start')),
+                ...getCommands(findProperty(serviceConfig, 'preDeploy')),
+                ...getCommands(findProperty(findProperty(serviceConfig, 'deploy'), 'preDeployCommand')),
+            ];
+            for (const input of options.getInputsFromScripts(commands, { optionalBinaries: true, cwd, manifest })) {
+                if (isEntry(input))
+                    input.specifier = toAbsolute(input.specifier, cwd);
+                inputs.push({ ...input, dir: cwd });
+            }
+        },
+    });
+    visitor.visit(program);
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    args,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/rstest/index.js

@@ -1,31 +1,130 @@
-import { toDeferResolve, toEntry } from '../../util/input.js';
-import { hasDependency } from '../../util/plugin.js';
+import { arrayify } from '../../util/array.js';
+import { findFileWithExtensions } from '../../util/fs.js';
+import { _dirGlob, _glob, negate } from '../../util/glob.js';
+import { toAlias, toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
+import { dirname, join, relative, toAbsolute } from '../../util/path.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { createRstestMockVisitor } from './visitors/mock.js';
 const title = 'Rstest';
 const enablers = ['@rstest/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const configExtensions = ['.mts', '.mjs', '.ts', '.js', '.cjs', '.cts'];
 const config = ['rstest.config.{js,cjs,mjs,ts,cts,mts}'];
 const mocks = ['**/__mocks__/**/*.?(c|m)[jt]s?(x)'];
-const entry = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
-function testEnvironment(config) {
-    const environment = typeof config.testEnvironment === 'string' ? config.testEnvironment : config.testEnvironment?.name;
-    if (!environment || environment === 'node')
-        return [];
-    return [environment];
-}
-const resolveConfig = async (config) => {
-    const entries = (config.include ?? entry)
-        .concat(...mocks)
-        .map(toEntry)
-        .concat(...(config.exclude ?? []).map(id => toEntry(`!${id}`)));
-    const environments = testEnvironment(config);
-    const setupFiles = config.setupFiles ?? [];
-    return [...environments, ...setupFiles, ...entries].map(id => (typeof id === 'string' ? toDeferResolve(id) : id));
+const testEntry = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
+const entry = [...testEntry, ...mocks];
+const getEnvironmentDependency = (name) => (name && name !== 'node' ? [toDependency(name)] : []);
+const replaceRootDir = (path, root) => path.replace('<rootDir>', root);
+const configParams = { env: 'test', command: 'run', envMode: 'test' };
+const getConfig = async (config) => typeof config === 'function' ? await config(configParams) : config;
+const resolveConfig = async (localConfig, options) => {
+    const { cwd, configFileDir, configFilePath, getManifest, isResolvedConfigFile } = options;
+    const cfg = await getConfig(localConfig);
+    const runnerRoot = toAbsolute(cfg.root ?? '.', isResolvedConfigFile ? configFileDir : cwd);
+    const manifest = getManifest(cwd);
+    const seen = new Set([configFilePath]);
+    const inputs = [];
+    const addProject = async (project, projectRoot) => {
+        const toPattern = (pattern) => relative(cwd, toAbsolute(replaceRootDir(pattern, projectRoot), projectRoot));
+        if (!options.config.entry) {
+            const include = [];
+            const exclude = [...(Array.isArray(project.exclude) ? project.exclude : (project.exclude?.patterns ?? []))];
+            for (const pattern of [...(project.include ?? testEntry), ...mocks]) {
+                if (pattern.startsWith('!'))
+                    exclude.push(pattern.slice(1));
+                else
+                    include.push(toPattern(pattern));
+            }
+            const entries = exclude.length === 0
+                ? include
+                : await _glob({ cwd, patterns: [...include, ...exclude.map(pattern => negate(toPattern(pattern)))] });
+            for (const entry of entries)
+                inputs.push(toEntry(entry));
+        }
+        const env = project.testEnvironment;
+        inputs.push(...getEnvironmentDependency(typeof env === 'string' ? env : env?.name));
+        for (const specifier of [project.setupFiles ?? [], project.globalSetup ?? []].flat()) {
+            inputs.push(toDeferResolve(replaceRootDir(specifier, projectRoot), { dir: projectRoot }));
+        }
+        if (project.browser?.enabled) {
+            inputs.push(toDependency('@rstest/browser'), toDependency('playwright'));
+        }
+        for (const [name, value] of Object.entries(project.resolve?.alias ?? {})) {
+            const prefixes = [];
+            for (const target of arrayify(value))
+                prefixes.push(target.startsWith('.') ? join(runnerRoot, target) : target);
+            if (name.endsWith('$')) {
+                inputs.push(toAlias(name.slice(0, -1), prefixes));
+            }
+            else {
+                inputs.push(toAlias(name, prefixes), toAlias(`${name}/*`, prefixes.map(prefix => `${prefix}/*`)));
+            }
+        }
+    };
+    const addProjects = async (projects, projectsRoot) => {
+        const patterns = [];
+        for (const project of projects) {
+            if (typeof project === 'string')
+                patterns.push(replaceRootDir(project, projectsRoot));
+            else
+                await addProject(project, toAbsolute(replaceRootDir(project.root ?? projectsRoot, projectsRoot), runnerRoot));
+        }
+        const [files, dirs] = await Promise.all([
+            _glob({ cwd: projectsRoot, patterns, gitignore: false }),
+            _dirGlob({ cwd: projectsRoot, patterns, gitignore: false }),
+        ]);
+        for (const dir of dirs) {
+            const projectRoot = toAbsolute(dir, projectsRoot);
+            const filePath = findFileWithExtensions(join(projectRoot, 'rstest.config'), configExtensions);
+            if (filePath)
+                files.push(filePath);
+            else
+                await addProject({}, projectRoot);
+        }
+        for (const filePath of files) {
+            if (seen.has(filePath))
+                continue;
+            seen.add(filePath);
+            const project = getManifest(dirname(filePath)) === manifest
+                ? await load(filePath)
+                    .then(getConfig)
+                    .catch(() => undefined)
+                : undefined;
+            if (!project) {
+                inputs.push(toConfig('rstest', filePath, { containingFilePath: configFilePath }));
+                continue;
+            }
+            inputs.push(toEntry(filePath));
+            if (project.projects)
+                await addProjects(project.projects, dirname(filePath));
+            else
+                await addProject(project, toAbsolute(project.root ?? dirname(filePath), runnerRoot));
+        }
+    };
+    if (cfg.projects)
+        await addProjects(cfg.projects, runnerRoot);
+    else
+        await addProject(cfg, runnerRoot);
+    if (!isResolvedConfigFile) {
+        inputs.push(toDependency(`@rstest/coverage-${cfg.coverage?.provider ?? 'istanbul'}`, { optional: true }));
+    }
+    return inputs;
+};
+const args = {
+    config: true,
+    resolveInputs: parsed => getEnvironmentDependency(parsed.testEnvironment),
+};
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createRstestMockVisitor(ctx));
 };
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
+    entry,
     resolveConfig,
+    args,
+    registerVisitors,
 };
 export default plugin;

package/dist/plugins/rstest/types.d.ts

@@ -1,8 +1,32 @@
-export type RstestConfig = {
+type TestEnvironment = 'node' | 'jsdom' | 'happy-dom';
+export type RstestProjectConfig = {
+    root?: string;
     include?: string[];
-    exclude?: string[];
-    testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | {
-        name: 'node' | 'jsdom' | 'happy-dom';
+    exclude?: string[] | {
+        patterns: string[];
     };
-    setupFiles?: string[];
+    testEnvironment?: TestEnvironment | {
+        name: TestEnvironment;
+    };
+    setupFiles?: string | string[];
+    globalSetup?: string | string[];
+    browser?: {
+        enabled?: boolean;
+    };
+    resolve?: {
+        alias?: Record<string, string | false | (string | false)[]>;
+    };
+};
+type RstestConfig = RstestProjectConfig & {
+    projects?: (string | RstestProjectConfig)[];
+    coverage?: {
+        provider?: 'istanbul' | 'v8';
+    };
+};
+type ConfigParams = {
+    env: string;
+    command: string;
+    envMode: string;
 };
+export type RstestConfigOrFn = RstestConfig | ((params: ConfigParams) => RstestConfig | Promise<RstestConfig>);
+export {};

package/dist/plugins/rstest/visitors/mock.d.ts

@@ -0,0 +1,2 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../../types/config.ts';
+export declare function createRstestMockVisitor(ctx: PluginVisitorContext): PluginVisitorObject;

package/dist/plugins/rstest/visitors/mock.js

@@ -0,0 +1,52 @@
+import { IMPORT_FLAGS } from '../../../constants.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+import { isShadowed } from '../../../typescript/visitors/walk.js';
+const rstestApiNames = new Set(['rs', 'rstest']);
+const mockMethods = new Set(['mock', 'doMock']);
+export function createRstestMockVisitor(ctx) {
+    const rsNames = new Set();
+    return {
+        Program(node) {
+            rsNames.clear();
+            for (const statement of node.body) {
+                if (statement.type !== 'ImportDeclaration' ||
+                    !isStringLiteral(statement.source) ||
+                    getStringValue(statement.source) !== '@rstest/core')
+                    continue;
+                for (const specifier of statement.specifiers ?? []) {
+                    if (specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.type === 'Identifier' &&
+                        rstestApiNames.has(specifier.imported.name)) {
+                        rsNames.add(specifier.local.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            const argument = node.arguments[0];
+            const factory = node.arguments[1];
+            const factoryBody = factory?.type === 'ArrowFunctionExpression' &&
+                factory.body.type === 'ParenthesizedExpression' &&
+                factory.body.expression.type === 'ObjectExpression'
+                ? factory.body.expression
+                : undefined;
+            if (argument?.type !== 'ImportExpression' ||
+                !isStringLiteral(argument.source) ||
+                factory?.type !== 'ArrowFunctionExpression' ||
+                !factoryBody ||
+                factory.async ||
+                factory.params.length > 0 ||
+                factoryBody.properties.some(property => property.type === 'SpreadElement') ||
+                node.callee.type !== 'MemberExpression' ||
+                node.callee.computed ||
+                node.callee.object.type !== 'Identifier' ||
+                !rsNames.has(node.callee.object.name) ||
+                isShadowed(node.callee.object.name, node.callee.object.start) ||
+                node.callee.property.type !== 'Identifier' ||
+                !mockMethods.has(node.callee.property.name))
+                return;
+            ctx.markImportExpressionHandled(argument.start);
+            ctx.addImport(getStringValue(argument.source), argument.source.start, IMPORT_FLAGS.SIDE_EFFECTS);
+        },
+    };
+}

package/dist/plugins/turbo/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/turbo/index.js

@@ -0,0 +1,23 @@
+import { toEntry } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Turborepo';
+const enablers = ['turbo', '@turbo/gen'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const extensions = '{ts,js,cjs,mts,mjs}';
+const entry = [`turbo/generators/config.${extensions}`];
+const resolve = ({ cwd, rootCwd }) => (cwd === rootCwd ? [toEntry(`plopfile.${extensions}`)] : []);
+const args = {
+    string: ['config'],
+    resolveInputs: parsed => (parsed._[0] === 'gen' || parsed._[0] === 'generate') && typeof parsed.config === 'string'
+        ? [toEntry(parsed.config)]
+        : [],
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    entry,
+    resolve,
+    args,
+};
+export default plugin;

package/dist/plugins/typescript/content-mappers.d.ts

@@ -0,0 +1,4 @@
+import type { Input } from '../../util/input.ts';
+type ResolveContentMapperOptions = (options: Record<string, unknown>) => Input[];
+export declare const contentMapperResolvers: Map<string, ResolveContentMapperOptions>;
+export {};

package/dist/plugins/typescript/content-mappers.js

@@ -0,0 +1,4 @@
+import { contentMappers as mdxContentMappers, resolveContentMapperOptions as resolveMdxOptions } from '../mdx/index.js';
+export const contentMapperResolvers = new Map();
+for (const name of mdxContentMappers)
+    contentMapperResolvers.set(name, resolveMdxOptions);