knip 5.69.0 → 5.70.0

package/dist/CatalogCounselor.d.ts

@@ -14,5 +14,5 @@ export declare class CatalogCounselor {
     constructor(options: MainOptions);
     private addReferencedCatalogEntry;
     addWorkspace(manifest: PackageJson): void;
-    settleCatalogIssues(): Promise<Issue[]>;
+    settleCatalogIssues(options: MainOptions): Promise<Issue[]>;
 }

package/dist/CatalogCounselor.js

@@ -23,7 +23,7 @@ export class CatalogCounselor {
         for (const catalogEntryName of catalogReferences)
             this.addReferencedCatalogEntry(catalogEntryName);
     }
-    async settleCatalogIssues() {
+    async settleCatalogIssues(options) {
         if (this.entries.size === 0)
             return [];
         const filePath = this.filePath;
@@ -38,7 +38,10 @@ export class CatalogCounselor {
                 if (!this.referencedEntries.has(entry)) {
                     const [parentSymbol, symbol] = entry.split(':');
                     const pos = peeker.getLocation(parentSymbol, symbol);
-                    catalogIssues.push({ type: 'catalog', filePath, workspace, symbol, parentSymbol, ...pos });
+                    const fixes = [];
+                    if (options.isFix && isYaml && pos)
+                        fixes.push([pos.line, 0, 0]);
+                    catalogIssues.push({ type: 'catalog', filePath, workspace, symbol, parentSymbol, fixes, ...pos });
                 }
             }
         }

package/dist/ConfigurationChief.d.ts

@@ -537,6 +537,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        taskfile?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         travis?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -758,6 +763,7 @@ export declare class ConfigurationChief {
         svgo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         syncpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tailwind?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        taskfile?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         travis?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "ts-node"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tsdown?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.js

@@ -213,15 +213,22 @@ export class DependencyDeputy {
             const isNotReferencedDependency = (dependency) => !isReferencedDependency(dependency, false);
             for (const symbol of this.getProductionDependencies(workspace).filter(isNotReferencedDependency)) {
                 const position = peeker.getLocation('dependencies', symbol);
-                dependencyIssues.push({ type: 'dependencies', workspace, filePath, symbol, ...position });
+                dependencyIssues.push({ type: 'dependencies', workspace, filePath, symbol, fixes: [], ...position });
             }
             for (const symbol of this.getDevDependencies(workspace).filter(isNotReferencedDependency)) {
                 const position = peeker.getLocation('devDependencies', symbol);
-                devDependencyIssues.push({ type: 'devDependencies', filePath, workspace, symbol, ...position });
+                devDependencyIssues.push({ type: 'devDependencies', filePath, workspace, symbol, fixes: [], ...position });
             }
             for (const symbol of this.getOptionalPeerDependencies(workspace).filter(d => isReferencedDependency(d))) {
                 const pos = peeker.getLocation('optionalPeerDependencies', symbol);
-                optionalPeerDependencyIssues.push({ type: 'optionalPeerDependencies', filePath, workspace, symbol, ...pos });
+                optionalPeerDependencyIssues.push({
+                    type: 'optionalPeerDependencies',
+                    filePath,
+                    workspace,
+                    symbol,
+                    fixes: [],
+                    ...pos,
+                });
             }
         }
         return { dependencyIssues, devDependencyIssues, optionalPeerDependencyIssues };

package/dist/IssueFixer.d.ts

@@ -1,15 +1,9 @@
-import type { Fix, Fixes } from './types/exports.js';
 import type { Issues } from './types/issues.js';
 import type { MainOptions } from './util/create-options.js';
 export declare class IssueFixer {
     options: MainOptions;
-    unusedTypeNodes: Map<string, Set<Fix>>;
-    unusedExportNodes: Map<string, Set<Fix>>;
     constructor(options: MainOptions);
-    addUnusedTypeNode(filePath: string, fixes: Fixes | undefined): void;
-    addUnusedExportNode(filePath: string, fixes: Fixes | undefined): void;
     fixIssues(issues: Issues): Promise<Set<string>>;
-    private markExportIssuesFixed;
     private removeUnusedFiles;
     private removeUnusedExports;
     private removeUnusedDependencies;

package/dist/IssueFixer.js

@@ -1,33 +1,13 @@
 import { readFile, rm, writeFile } from 'node:fs/promises';
 import { DEFAULT_CATALOG } from './util/catalog.js';
 import { load, save } from './util/package-json.js';
-import { extname, join, relative } from './util/path.js';
+import { extname, join } from './util/path.js';
 import { removeExport } from './util/remove-export.js';
 export class IssueFixer {
     options;
-    unusedTypeNodes = new Map();
-    unusedExportNodes = new Map();
     constructor(options) {
         this.options = options;
     }
-    addUnusedTypeNode(filePath, fixes) {
-        if (!fixes || fixes.length === 0)
-            return;
-        if (this.unusedTypeNodes.has(filePath))
-            for (const fix of fixes)
-                this.unusedTypeNodes.get(filePath)?.add(fix);
-        else
-            this.unusedTypeNodes.set(filePath, new Set(fixes));
-    }
-    addUnusedExportNode(filePath, fixes) {
-        if (!fixes || fixes.length === 0)
-            return;
-        if (this.unusedExportNodes.has(filePath))
-            for (const fix of fixes)
-                this.unusedExportNodes.get(filePath)?.add(fix);
-        else
-            this.unusedExportNodes.set(filePath, new Set(fixes));
-    }
     async fixIssues(issues) {
         const touchedFiles = new Set();
         await this.removeUnusedFiles(issues);
@@ -39,18 +19,6 @@ export class IssueFixer {
             touchedFiles.add(filePath);
         return touchedFiles;
     }
-    markExportIssuesFixed(issues, filePath) {
-        const relPath = relative(this.options.cwd, filePath);
-        const types = [
-            ...(this.options.isFixUnusedTypes ? ['types', 'nsTypes', 'classMembers', 'enumMembers'] : []),
-            ...(this.options.isFixUnusedExports ? ['exports', 'nsExports'] : []),
-        ];
-        for (const type of types) {
-            for (const id in issues[type][relPath]) {
-                issues[type][relPath][id].isFixed = true;
-            }
-        }
-    }
     async removeUnusedFiles(issues) {
         if (!this.options.isFixFiles)
             return;
@@ -61,18 +29,33 @@ export class IssueFixer {
     }
     async removeUnusedExports(issues) {
         const touchedFiles = new Set();
-        const filePaths = new Set([...this.unusedTypeNodes.keys(), ...this.unusedExportNodes.keys()]);
-        for (const filePath of filePaths) {
-            const types = (this.options.isFixUnusedTypes && this.unusedTypeNodes.get(filePath)) || [];
-            const exports = (this.options.isFixUnusedExports && this.unusedExportNodes.get(filePath)) || [];
-            const exportPositions = [...types, ...exports]
-                .filter((fix) => fix !== undefined)
-                .sort((a, b) => b[0] - a[0]);
-            if (exportPositions.length > 0) {
-                const sourceFileText = exportPositions.reduce((text, [start, end, flags]) => removeExport({ text, start, end, flags }), await readFile(filePath, 'utf-8'));
-                await writeFile(filePath, sourceFileText);
-                touchedFiles.add(filePath);
-                this.markExportIssuesFixed(issues, filePath);
+        const types = [
+            ...(this.options.isFixUnusedTypes ? ['types', 'nsTypes', 'classMembers', 'enumMembers'] : []),
+            ...(this.options.isFixUnusedExports ? ['exports', 'nsExports'] : []),
+        ];
+        if (types.length === 0)
+            return touchedFiles;
+        const allFixes = new Map();
+        for (const type of types) {
+            for (const [filePath, issueMap] of Object.entries(issues[type])) {
+                const fixes = allFixes.get(filePath) ?? [];
+                for (const issue of Object.values(issueMap))
+                    fixes.push(...issue.fixes);
+                allFixes.set(filePath, fixes);
+            }
+        }
+        for (const [filePath, fixes] of allFixes) {
+            const absFilePath = join(this.options.cwd, filePath);
+            const sourceFileText = fixes
+                .sort((a, b) => b[0] - a[0])
+                .reduce((text, [start, end, flags]) => removeExport({ text, start, end, flags }), await readFile(absFilePath, 'utf-8'));
+            await writeFile(absFilePath, sourceFileText);
+            touchedFiles.add(absFilePath);
+            for (const type of types) {
+                const issueMap = issues[type]?.[filePath];
+                if (issueMap)
+                    for (const issue of Object.values(issueMap))
+                        issue.isFixed = true;
             }
         }
         return touchedFiles;
@@ -102,7 +85,7 @@ export class IssueFixer {
                 }
             }
             await save(absFilePath, pkg);
-            touchedFiles.add(filePath);
+            touchedFiles.add(absFilePath);
         }
         return touchedFiles;
     }
@@ -115,15 +98,13 @@ export class IssueFixer {
             if (['.yml', '.yaml'].includes(extname(filePath))) {
                 const absFilePath = join(this.options.cwd, filePath);
                 const fileContent = await readFile(absFilePath, 'utf-8');
-                const remove = new Set();
-                const isRemove = (_, i) => !remove.has(i);
-                for (const [key, issue] of Object.entries(issues.catalog[filePath])) {
-                    if (issue.line) {
-                        remove.add(issue.line - 1);
-                        issues.catalog[filePath][key].isFixed = true;
-                    }
-                }
-                await writeFile(absFilePath, fileContent.split('\n').filter(isRemove).join('\n'));
+                const issuesForFile = Object.values(issues.catalog[filePath]);
+                const takeLine = (issue) => issue.fixes.map(fix => fix[0]);
+                const remove = new Set(issuesForFile.flatMap(takeLine));
+                const keep = (_, i) => !remove.has(i + 1);
+                await writeFile(absFilePath, fileContent.split('\n').filter(keep).join('\n'));
+                for (const issue of issuesForFile)
+                    issue.isFixed = true;
                 touchedFiles.add(filePath);
             }
             else {
@@ -146,7 +127,7 @@ export class IssueFixer {
                     }
                 }
                 await save(absFilePath, pkg);
-                touchedFiles.add(filePath);
+                touchedFiles.add(absFilePath);
             }
         }
         return touchedFiles;

package/dist/binaries/package-manager/yarn.js

@@ -21,6 +21,7 @@ const commands = [
     'patch-commit',
     'patch',
     'plugin',
+    'publish',
     'rebuild',
     'remove',
     'search',

package/dist/binaries/plugins.js

@@ -9,13 +9,13 @@ const isGlobLikeMatch = /(^!|[*+\\(|{^$])/;
 const isGlobLike = (value) => isGlobLikeMatch.test(value);
 const nodeLoadersArgs = { import: ['r', 'experimental-loader', 'require', 'loader'] };
 export const resolve = (binary, _args, options) => {
-    const { fromArgs, containingFilePath } = options;
+    const { cwd, fromArgs, containingFilePath } = options;
     const [pluginName, pluginArgs] = pluginArgsMap.get(binary) ?? [];
     if (!pluginArgs)
         return fallbackResolve(binary, _args, options);
     const inputOpts = {};
-    if (options.cwd && dirname(containingFilePath) !== options.cwd)
-        Object.assign(inputOpts, { dir: options.cwd });
+    if (cwd && dirname(containingFilePath) !== cwd)
+        Object.assign(inputOpts, { dir: cwd });
     const args = typeof pluginArgs.args === 'function' ? pluginArgs.args(_args) : _args;
     const parsed = parseArgs(args, {
         string: [
@@ -58,7 +58,7 @@ export const resolve = (binary, _args, options) => {
         return parsed[id] && pluginName ? [toConfig(pluginName, fn(parsed[id]), inputOpts)] : [];
     };
     const configFilePaths = config.flatMap(mapToConfigPattern);
-    const inputs = pluginArgs.resolveInputs?.(parsed, args) ?? [];
+    const inputs = pluginArgs.resolveInputs?.(parsed, { args, cwd }) ?? [];
     return [
         toBinary(binary, inputOpts),
         ...positionals,

package/dist/compilers/index.d.ts

@@ -489,6 +489,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    taskfile?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     travis?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1080,6 +1085,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        taskfile?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         travis?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/compilers/index.js

@@ -1,6 +1,7 @@
 import Astro from './astro.js';
 import AstroMDX from './astro-mdx.js';
 import MDX from './mdx.js';
+import Prisma from './prisma.js';
 import Svelte from './svelte.js';
 import CSS from './tailwind.js';
 import Vue from './vue.js';
@@ -31,6 +32,7 @@ const compilers = new Map([
     ['.astro', Astro],
     ['.css', CSS],
     ['.mdx', MDX],
+    ['.prisma', Prisma],
     ['.svelte', Svelte],
     ['.vue', Vue],
 ]);

package/dist/compilers/prisma.d.ts

@@ -0,0 +1,6 @@
+import type { HasDependency } from './types.js';
+declare const _default: {
+    condition: (hasDependency: HasDependency) => boolean;
+    compiler: (text: string) => string;
+};
+export default _default;

package/dist/compilers/prisma.js

@@ -0,0 +1,13 @@
+const condition = (hasDependency) => hasDependency('prisma');
+const directiveMatcher = /generator\s+(?!client)\w+\s*\{\s*provider\s*=\s*"([^"]+)"[^}]*\}/g;
+const compiler = (text) => {
+    const imports = [];
+    let match;
+    while ((match = directiveMatcher.exec(text))) {
+        if (match[1]) {
+            imports.push(`import '${match[1]}';`);
+        }
+    }
+    return imports.join('\n');
+};
+export default { condition, compiler };

package/dist/constants.d.ts

@@ -50,10 +50,14 @@ export declare const FIX_FLAGS: {
     readonly EMPTY_DECLARATION: number;
     readonly WITH_NEWLINE: number;
 };
+export declare const SIDE_EFFECTS = "__side-effects";
+export declare const OPAQUE = "__opaque";
 export declare const IMPORT_MODIFIERS: {
     readonly NONE: 0;
     readonly RE_EXPORT: number;
     readonly TYPE_ONLY: number;
     readonly ENTRY: number;
     readonly OPTIONAL: number;
+    readonly SIDE_EFFECTS: number;
+    readonly OPAQUE: number;
 };

package/dist/constants.js

@@ -208,10 +208,14 @@ export const FIX_FLAGS = {
     EMPTY_DECLARATION: 1 << 1,
     WITH_NEWLINE: 1 << 2,
 };
+export const SIDE_EFFECTS = '__side-effects';
+export const OPAQUE = '__opaque';
 export const IMPORT_MODIFIERS = {
     NONE: 0,
     RE_EXPORT: 1 << 0,
     TYPE_ONLY: 1 << 1,
     ENTRY: 1 << 2,
     OPTIONAL: 1 << 3,
+    SIDE_EFFECTS: 1 << 4,
+    OPAQUE: 1 << 5,
 };

package/dist/graph/analyze.d.ts

@@ -21,5 +21,5 @@ interface AnalyzeOptions {
     unreferencedFiles: Set<string>;
     options: MainOptions;
 }
-export declare const analyze: ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, fixer, graph, streamer, unreferencedFiles, options, }: AnalyzeOptions) => Promise<() => Promise<void>>;
+export declare const analyze: ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, graph, streamer, unreferencedFiles, options, }: AnalyzeOptions) => Promise<() => Promise<void>>;
 export {};

package/dist/graph/analyze.js

@@ -4,7 +4,7 @@ import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
 import { createAndPrintTrace, printTrace } from '../util/trace.js';
-export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, fixer, graph, streamer, unreferencedFiles, options, }) => {
+export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
     const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths, options.isTrace);
@@ -75,7 +75,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             if (!isReferenced) {
                                                 if (isIgnored)
                                                     continue;
-                                                const isIssueAdded = collector.addIssue({
+                                                collector.addIssue({
                                                     type: 'enumMembers',
                                                     filePath,
                                                     workspace: workspace.name,
@@ -84,9 +84,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                                     pos: member.pos,
                                                     line: member.line,
                                                     col: member.col,
+                                                    fixes: member.fix ? [member.fix] : [],
                                                 });
-                                                if (options.isFix && isIssueAdded && member.fix)
-                                                    fixer.addUnusedTypeNode(filePath, [member.fix]);
                                             }
                                             else if (isIgnored) {
                                                 for (const tagName of exportedItem.jsDocTags) {
@@ -110,7 +109,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             }
                                             continue;
                                         }
-                                        const isIssueAdded = collector.addIssue({
+                                        collector.addIssue({
                                             type: 'classMembers',
                                             filePath,
                                             workspace: workspace.name,
@@ -119,9 +118,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             pos: member.pos,
                                             line: member.line,
                                             col: member.col,
+                                            fixes: member.fix ? [member.fix] : [],
                                         });
-                                        if (options.isFix && isIssueAdded && member.fix)
-                                            fixer.addUnusedTypeNode(filePath, [member.fix]);
                                     }
                                 }
                                 continue;
@@ -138,7 +136,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             if (!options.isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
                                 continue;
                             const type = getType(hasStrictlyNsRefs, isType);
-                            const isIssueAdded = collector.addIssue({
+                            collector.addIssue({
                                 type,
                                 filePath,
                                 workspace: workspace.name,
@@ -148,13 +146,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 pos: exportedItem.pos,
                                 line: exportedItem.line,
                                 col: exportedItem.col,
+                                fixes: exportedItem.fixes,
                             });
-                            if (options.isFix && isIssueAdded) {
-                                if (isType)
-                                    fixer.addUnusedTypeNode(filePath, exportedItem.fixes);
-                                else
-                                    fixer.addUnusedExportNode(filePath, exportedItem.fixes);
-                            }
                         }
                     }
                 }
@@ -167,7 +160,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     for (const symbols of file.duplicates) {
                         if (symbols.length > 1) {
                             const symbol = symbols.map(s => s.symbol).join('|');
-                            collector.addIssue({ type: 'duplicates', filePath, workspace: ws.name, symbol, symbols });
+                            collector.addIssue({ type: 'duplicates', filePath, workspace: ws.name, symbol, symbols, fixes: [] });
                         }
                     }
                 }
@@ -185,13 +178,23 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 pos: extImport.pos,
                                 line: extImport.line,
                                 col: extImport.col,
+                                fixes: [],
                             });
                     }
                 }
                 if (file.imports?.unresolved) {
                     for (const unresolvedImport of file.imports.unresolved) {
                         const { specifier, pos, line, col } = unresolvedImport;
-                        collector.addIssue({ type: 'unresolved', filePath, workspace: ws.name, symbol: specifier, pos, line, col });
+                        collector.addIssue({
+                            type: 'unresolved',
+                            filePath,
+                            workspace: ws.name,
+                            symbol: specifier,
+                            pos,
+                            line,
+                            col,
+                            fixes: [],
+                        });
                     }
                 }
             }
@@ -213,7 +216,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
             for (const hint of configurationHints)
                 collector.addConfigurationHint(hint);
         }
-        const catalogIssues = await counselor.settleCatalogIssues();
+        const catalogIssues = await counselor.settleCatalogIssues(options);
         for (const issue of catalogIssues)
             collector.addIssue(issue);
         const unusedIgnoredWorkspaces = chief.getUnusedIgnoredWorkspaces();

package/dist/graph/build.js

@@ -294,10 +294,10 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 if (!isIgnored)
                     principal.addEntryPath(filePath, { skipExportsAnalysis: true });
             }
-            for (const [import_, specifierFilePath] of file.imports.specifiers) {
-                const packageName = getPackageNameFromModuleSpecifier(import_.specifier);
+            for (const [_import, specifierFilePath] of file.imports.imports) {
+                const packageName = getPackageNameFromModuleSpecifier(_import.specifier);
                 if (packageName && isInternalWorkspace(packageName)) {
-                    file.imports.external.add({ ...import_, specifier: packageName });
+                    file.imports.external.add({ ..._import, specifier: packageName });
                     const principal = getPrincipalByFilePath(specifierFilePath);
                     if (principal && !isGitIgnored(specifierFilePath)) {
                         principal.addNonEntryPath(specifierFilePath);

package/dist/index.js

@@ -14,7 +14,6 @@ import { debugLogArray, debugLogObject } from './util/debug.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { getWatchHandler } from './util/watch.js';
 export const main = async (options) => {
-    const { cwd } = options;
     debugLogObject('*', 'Unresolved configuration', options);
     debugLogObject('*', 'Included issue types', options.includedIssueTypes);
     const chief = new ConfigurationChief(options);
@@ -78,7 +77,7 @@ export const main = async (options) => {
     if (options.isFix) {
         const touchedFiles = await fixer.fixIssues(issues);
         if (options.isFormat) {
-            const report = await formatly(Array.from(touchedFiles), { cwd });
+            const report = await formatly(Array.from(touchedFiles));
             if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
                 debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
             }

package/dist/plugins/index.d.ts

@@ -96,6 +96,7 @@ export declare const Plugins: {
     svgo: import("../types/config.js").Plugin;
     syncpack: import("../types/config.js").Plugin;
     tailwind: import("../types/config.js").Plugin;
+    taskfile: import("../types/config.js").Plugin;
     travis: import("../types/config.js").Plugin;
     'ts-node': import("../types/config.js").Plugin;
     tsdown: import("../types/config.js").Plugin;

package/dist/plugins/index.js

@@ -95,6 +95,7 @@ import { default as svelte } from './svelte/index.js';
 import { default as svgo } from './svgo/index.js';
 import { default as syncpack } from './syncpack/index.js';
 import { default as tailwind } from './tailwind/index.js';
+import { default as taskfile } from './taskfile/index.js';
 import { default as travis } from './travis/index.js';
 import { default as tsNode } from './ts-node/index.js';
 import { default as tsdown } from './tsdown/index.js';
@@ -214,6 +215,7 @@ export const Plugins = {
     svgo,
     syncpack,
     tailwind,
+    taskfile,
     travis,
     'ts-node': tsNode,
     tsdown,

package/dist/plugins/next/index.js

@@ -8,9 +8,6 @@ const config = ['next.config.{js,ts,cjs,mjs}'];
 const defaultPageExtensions = ['{js,jsx,ts,tsx}'];
 const productionEntryFilePatterns = [
     '{instrumentation,instrumentation-client,middleware,proxy}.{js,ts}',
-    'app/global-{error,not-found}.{js,jsx,ts,tsx}',
-    'app/**/{error,layout,loading,not-found,page,template,default,forbidden,unauthorized}.{js,jsx,ts,tsx}',
-    'app/**/route.{js,jsx,ts,tsx}',
     'app/{manifest,robots}.{js,ts}',
     'app/**/sitemap.{js,ts}',
     'app/**/{icon,apple-icon}.{js,jsx,ts,tsx}',
@@ -18,8 +15,10 @@ const productionEntryFilePatterns = [
     'mdx-components.{js,jsx,ts,tsx}',
 ];
 const getEntryFilePatterns = (pageExtensions = defaultPageExtensions) => {
-    const pages = pageExtensions.map(ext => `pages/**/*.${ext}`);
-    const patterns = [...productionEntryFilePatterns, ...pages];
+    const patterns = [...productionEntryFilePatterns];
+    for (const ext of pageExtensions) {
+        patterns.push(`app/global-{error,not-found}.${ext}`, `app/**/{error,layout,loading,not-found,page,template,default,forbidden,unauthorized}.${ext}`, `app/**/route.${ext}`, `pages/**/*.${ext}`);
+    }
     return [...patterns, ...patterns.map(pattern => `src/${pattern}`)];
 };
 const production = getEntryFilePatterns();

package/dist/plugins/prisma/index.js

@@ -1,28 +1,50 @@
+import { isDirectory } from '../../util/fs.js';
+import { toEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Prisma';
 const enablers = ['prisma', /^@prisma\/.*/];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const entry = ['prisma/schema.prisma', 'schema.prisma'];
 const config = [
     'prisma.config.{js,ts,mjs,cjs,mts,cts}',
     '.config/prisma.{js,ts,mjs,cjs,mts,cts}',
     'package.json',
 ];
+const resolveSchema = (path, cwd) => {
+    if (!isDirectory(join(cwd, path))) {
+        return toEntry(path);
+    }
+    return toEntry(join(path, '**/*.prisma'));
+};
 const resolveConfig = async (config, options) => {
-    if (options.configFileName === 'package.json' && config.seed) {
-        return options.getInputsFromScripts(config.seed);
+    const inputs = [];
+    if (config.seed) {
+        inputs.push(...options.getInputsFromScripts(config.seed));
+    }
+    else if (config.migrations?.seed) {
+        inputs.push(...options.getInputsFromScripts(config.migrations.seed));
     }
-    if (config.migrations?.seed) {
-        return options.getInputsFromScripts(config.migrations.seed);
+    if (config.schema) {
+        inputs.push(resolveSchema(config.schema, options.cwd));
     }
-    return [];
+    return inputs;
 };
 const args = {
     config: true,
+    resolveInputs: (parsed, { cwd }) => {
+        const inputs = [];
+        if (parsed['schema']) {
+            inputs.push(resolveSchema(parsed['schema'], cwd));
+        }
+        return inputs;
+    },
 };
 const plugin = {
     title,
     enablers,
     isEnabled,
+    entry,
     config,
     args,
     resolveConfig,

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

@@ -3,4 +3,5 @@ export type PrismaConfig = {
     migrations?: {
         seed?: string;
     };
+    schema?: string;
 };

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

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