More consistent naming

webpro · webpro · commit bae87d968b8c · 2024-10-24T08:03:24.000+02:00
diff --git a/packages/knip/src/WorkspaceWorker.ts b/packages/knip/src/WorkspaceWorker.ts
@@ -1,5 +1,5 @@
 import { CacheConsultant } from './CacheConsultant.js';
-import { _getDependenciesFromScripts } from './binaries/index.js';
+import { _getInputsFromScripts } from './binaries/index.js';
 import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
 import type { PluginName } from './types/PluginNames.js';
@@ -254,14 +254,14 @@ export class WorkspaceWorker {
     // Get dependencies from package.json#scripts
     const baseScriptOptions = { ...baseOptions, manifest, isProduction, enabledPlugins: this.enabledPlugins };
     const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
-    const inputsFromManifest = _getDependenciesFromScripts(Object.values(developmentScripts), baseOptions);
-    const productionInputsFromManifest = _getDependenciesFromScripts(Object.values(productionScripts), baseOptions);
+    const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);
+    const productionInputsFromManifest = _getInputsFromScripts(Object.values(productionScripts), baseOptions);
 
     const hasProductionInput = (input: Input) =>
       productionInputsFromManifest.find(d => d.specifier === input.specifier && d.type === input.type);
 
-    const getDependenciesFromScripts: GetInputsFromScriptsPartial = (scripts, options) =>
-      _getDependenciesFromScripts(scripts, { ...baseScriptOptions, ...options });
+    const getInputsFromScripts: GetInputsFromScriptsPartial = (scripts, options) =>
+      _getInputsFromScripts(scripts, { ...baseScriptOptions, ...options });
 
     const inputs: Input[] = [];
     const configFiles = new Map<PluginName, Set<string>>();
@@ -311,7 +311,7 @@ export class WorkspaceWorker {
         configFilePath: containingFilePath,
         configFileDir: cwd,
         configFileName: '',
-        getDependenciesFromScripts,
+        getInputsFromScripts,
       };
 
       const configEntryPaths: Input[] = [];
@@ -336,18 +336,18 @@ export class WorkspaceWorker {
             const data: CacheItem = {};
             if (config) {
               if (hasResolveEntryPaths) {
-                const dependencies = (await plugin.resolveEntryPaths?.(config, opts)) ?? [];
-                for (const id of dependencies) configEntryPaths.push(id);
-                data.resolveEntryPaths = dependencies;
+                const entryPaths = (await plugin.resolveEntryPaths?.(config, opts)) ?? [];
+                for (const entryPath of entryPaths) configEntryPaths.push(entryPath);
+                data.resolveEntryPaths = entryPaths;
               }
               if (shouldRunConfigResolver) {
-                const dependencies = (await plugin.resolveConfig?.(config, opts)) ?? [];
-                for (const id of dependencies) {
-                  if (isConfigPattern(id))
-                    handleConfigInput(id.pluginName, { ...id, containingFilePath: configFilePath });
-                  addInput(id, configFilePath);
+                const inputs = (await plugin.resolveConfig?.(config, opts)) ?? [];
+                for (const input of inputs) {
+                  if (isConfigPattern(input))
+                    handleConfigInput(input.pluginName, { ...input, containingFilePath: configFilePath });
+                  addInput(input, configFilePath);
                 }
-                data.resolveConfig = dependencies;
+                data.resolveConfig = inputs;
               }
               if (!isManifest && fd?.changed && fd.meta) fd.meta.data = data;
             }
diff --git a/packages/knip/src/binaries/index.ts b/packages/knip/src/binaries/index.ts
@@ -17,4 +17,4 @@ const getInputsFromScripts: GetInputsFromScripts = (npmScripts, options) => {
   return Array.from(inputs);
 };
 
-export const _getDependenciesFromScripts = timerify(getInputsFromScripts);
+export const _getInputsFromScripts = timerify(getInputsFromScripts);
diff --git a/packages/knip/src/index.ts b/packages/knip/src/index.ts
@@ -7,7 +7,7 @@ import { IssueFixer } from './IssueFixer.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
 import type { ProjectPrincipal } from './ProjectPrincipal.js';
 import { WorkspaceWorker } from './WorkspaceWorker.js';
-import { _getDependenciesFromScripts } from './binaries/index.js';
+import { _getInputsFromScripts } from './binaries/index.js';
 import { getCompilerExtensions, getIncludedCompilers } from './compilers/index.js';
 import type { CommandLineOptions } from './types/cli.js';
 import type { DependencyGraph, Export, ExportMember } from './types/dependency-graph.js';
@@ -344,7 +344,7 @@ export const main = async (unresolvedConfiguration: CommandLineOptions) => {
           dependencies,
           manifestScriptNames,
         };
-        const specifiers = _getDependenciesFromScripts(scripts, options);
+        const specifiers = _getInputsFromScripts(scripts, options);
         for (const specifier of specifiers) {
           specifier.containingFilePath = filePath;
           specifier.dir = cwd;
diff --git a/packages/knip/src/plugins/ava/index.ts b/packages/knip/src/plugins/ava/index.ts
@@ -38,7 +38,7 @@ const resolveConfig: ResolveConfig<AvaConfig> = async (localConfig, options) =>
   const requireArgs = (localConfig.require ?? []).map(require => `--require ${require}`);
   const fakeCommand = `node ${nodeArgs.join(' ')} ${requireArgs.join(' ')}`;
 
-  return options.getDependenciesFromScripts(fakeCommand, { knownBinsOnly: true });
+  return options.getInputsFromScripts(fakeCommand, { knownBinsOnly: true });
 };
 
 export default {
diff --git a/packages/knip/src/plugins/github-actions/index.ts b/packages/knip/src/plugins/github-actions/index.ts
@@ -33,7 +33,7 @@ type Job = {
 };
 
 const resolveConfig: ResolveConfig = async (config, options) => {
-  const { configFileDir, configFileName, rootCwd, getDependenciesFromScripts } = options;
+  const { configFileDir, configFileName, rootCwd, getInputsFromScripts } = options;
 
   const inputs = new Set<Input>();
 
@@ -48,10 +48,10 @@ const resolveConfig: ResolveConfig = async (config, options) => {
       const workingDir = step['working-directory'];
       const dir = join(rootCwd, path && workingDir ? relative(workingDir, path) : workingDir ? workingDir : '.');
       if (step.run) {
-        for (const dependency of getDependenciesFromScripts([step.run], { knownBinsOnly: true })) {
-          if (isDeferResolveEntry(dependency) && path && !workingDir)
-            dependency.specifier = relative(join(dir, path), join(rootCwd, dependency.specifier));
-          inputs.add({ ...dependency, dir });
+        for (const input of getInputsFromScripts([step.run], { knownBinsOnly: true })) {
+          if (isDeferResolveEntry(input) && path && !workingDir)
+            input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
+          inputs.add({ ...input, dir });
         }
       }
     }
diff --git a/packages/knip/src/plugins/husky/index.ts b/packages/knip/src/plugins/husky/index.ts
@@ -24,11 +24,11 @@ const resolveConfig: ResolveConfig = (script, options) => {
     const hooks = script.hooks;
     if (hooks) {
       const scripts: string[] = Object.values(hooks);
-      return [toDependency('husky'), ...options.getDependenciesFromScripts(scripts, { ...options })];
+      return [toDependency('husky'), ...options.getInputsFromScripts(scripts, { ...options })];
     }
   }
 
-  return options.getDependenciesFromScripts(String(script), { knownBinsOnly: true });
+  return options.getInputsFromScripts(String(script), { knownBinsOnly: true });
 };
 
 export default {
diff --git a/packages/knip/src/plugins/lefthook/index.ts b/packages/knip/src/plugins/lefthook/index.ts
@@ -23,13 +23,13 @@ type Command = {
 };
 
 const resolveConfig: ResolveConfig = async (localConfig, options) => {
-  const { manifest, configFileName, cwd, getDependenciesFromScripts } = options;
+  const { manifest, configFileName, cwd, getInputsFromScripts } = options;
 
   const inputs = manifest.devDependencies ? Object.keys(manifest.devDependencies).map(toDependency) : [];
 
   if (extname(configFileName) === '.yml') {
     const scripts = findByKeyDeep<Command>(localConfig, 'run').flatMap(command => {
-      const deps = getDependenciesFromScripts([command.run], { ...options, knownBinsOnly: true });
+      const deps = getInputsFromScripts([command.run], { ...options, knownBinsOnly: true });
       const dir = command.root ?? cwd;
       return deps.flatMap(dependency => ({ ...dependency, dir }));
     });
@@ -45,7 +45,7 @@ const resolveConfig: ResolveConfig = async (localConfig, options) => {
 
   if (!script) return [];
 
-  const scriptInputs = getDependenciesFromScripts(script);
+  const scriptInputs = getInputsFromScripts(script);
   const matches = scriptInputs.find(dep => inputs.some(d => d.specifier === fromBinary(dep)));
   return matches ? [matches] : [];
 };
diff --git a/packages/knip/src/plugins/lint-staged/index.ts b/packages/knip/src/plugins/lint-staged/index.ts
@@ -31,7 +31,7 @@ const resolveConfig: ResolveConfig<LintStagedConfig> = async (config, options) =
 
   for (const entry of Object.values(config).flat()) {
     const scripts = [typeof entry === 'function' ? await entry([]) : entry].flat();
-    for (const id of options.getDependenciesFromScripts(scripts)) inputs.add(id);
+    for (const id of options.getInputsFromScripts(scripts)) inputs.add(id);
   }
 
   return Array.from(inputs);
diff --git a/packages/knip/src/plugins/moonrepo/index.ts b/packages/knip/src/plugins/moonrepo/index.ts
@@ -19,7 +19,7 @@ const resolveConfig: ResolveConfig<MoonConfiguration> = async (config, options)
     .filter(command => command)
     .map(command => command.replace('$workspaceRoot', options.rootCwd))
     .map(command => command.replace('$projectRoot', options.cwd))
-    .flatMap(command => options.getDependenciesFromScripts(command));
+    .flatMap(command => options.getInputsFromScripts(command));
   return [...inputs];
 };
 
diff --git a/packages/knip/src/plugins/nx/index.ts b/packages/knip/src/plugins/nx/index.ts
@@ -58,7 +58,7 @@ const resolveConfig: ResolveConfig<NxProjectConfiguration | NxConfigRoot> = asyn
     .filter(target => target.executor === 'nx:run-commands')
     .flatMap(target => target.options?.commands ?? (target.options?.command ? [target.options.command] : []));
 
-  const inputs = options.getDependenciesFromScripts(scripts);
+  const inputs = options.getInputsFromScripts(scripts);
 
   return compact([...executors, ...inputs]).map(id => (typeof id === 'string' ? toDependency(id) : id));
 };
diff --git a/packages/knip/src/plugins/release-it/index.ts b/packages/knip/src/plugins/release-it/index.ts
@@ -26,7 +26,7 @@ const resolveConfig: ResolveConfig<ReleaseItConfig> = (config, options) => {
   if (typeof config.gitlab?.releaseNotes === 'string') {
     scripts.push(config.gitlab.releaseNotes);
   }
-  const inputs = options.getDependenciesFromScripts(scripts);
+  const inputs = options.getInputsFromScripts(scripts);
 
   return [...plugins.map(toDependency), ...inputs];
 };
diff --git a/packages/knip/src/plugins/simple-git-hooks/index.ts b/packages/knip/src/plugins/simple-git-hooks/index.ts
@@ -29,7 +29,7 @@ const resolveConfig: ResolveConfig<PluginConfig> = async (config, options) => {
   const inputs = new Set<Input>();
 
   for (const hook of Object.values(config)) {
-    for (const id of options.getDependenciesFromScripts(hook)) inputs.add(id);
+    for (const id of options.getInputsFromScripts(hook)) inputs.add(id);
   }
 
   return Array.from(inputs);
diff --git a/packages/knip/src/plugins/travis/index.ts b/packages/knip/src/plugins/travis/index.ts
@@ -20,7 +20,7 @@ const resolveConfig: ResolveConfig = async (config, options) => {
 
   const scripts = [...beforeDeploy, ...beforeInstall, ...beforeScript];
 
-  return options.getDependenciesFromScripts(scripts, { knownBinsOnly: true });
+  return options.getInputsFromScripts(scripts, { knownBinsOnly: true });
 };
 
 export default {
diff --git a/packages/knip/src/plugins/wireit/index.ts b/packages/knip/src/plugins/wireit/index.ts
@@ -17,7 +17,7 @@ const config = ['package.json'];
 const resolveConfig: ResolveConfig<WireitConfig> = (localConfig, options) => {
   const scripts = Object.values(localConfig).flatMap(({ command: script }) => (script ? [script] : []));
 
-  const scriptDependencies = options.getDependenciesFromScripts(scripts);
+  const scriptDependencies = options.getInputsFromScripts(scripts);
 
   return scriptDependencies;
 };
diff --git a/packages/knip/src/plugins/yorkie/index.ts b/packages/knip/src/plugins/yorkie/index.ts
@@ -20,7 +20,7 @@ const resolveConfig: ResolveConfig<LintStagedConfig> = (config, options) => {
 
   for (const script of Object.values(config).flat()) {
     const scripts = [script].flat();
-    for (const identifier of options.getDependenciesFromScripts(scripts)) inputs.add(identifier);
+    for (const identifier of options.getInputsFromScripts(scripts)) inputs.add(identifier);
   }
 
   // Looks like the idea is to have lint-staged installed too, so there are no refs to yorkie
diff --git a/packages/knip/src/types/config.ts b/packages/knip/src/types/config.ts
@@ -112,7 +112,7 @@ export interface PluginOptions extends BaseOptions {
   configFilePath: string;
   isProduction: boolean;
   enabledPlugins: string[];
-  getDependenciesFromScripts: GetInputsFromScriptsPartial;
+  getInputsFromScripts: GetInputsFromScriptsPartial;
 }
 
 export type ResolveEntryPaths<T = any> = (config: T, options: PluginOptions) => Promise<Input[]> | Input[];
diff --git a/packages/knip/src/util/handle-referenced-dependency.ts b/packages/knip/src/util/handle-referenced-dependency.ts
@@ -20,13 +20,14 @@ export const getReferencedDependencyHandler =
     chief: ConfigurationChief,
     isGitIgnored: (s: string) => boolean
   ) =>
-  (dependency: Input, workspace: Workspace) => {
-    const { specifier, containingFilePath } = dependency;
+  (input: Input, workspace: Workspace) => {
+    const { specifier, containingFilePath } = input;
+
     if (!containingFilePath || IGNORED_RUNTIME_DEPENDENCIES.has(specifier)) return;
 
-    if (isBinary(dependency)) {
-      const binaryName = fromBinary(dependency);
-      const ws = (dependency.dir && chief.findWorkspaceByFilePath(`${dependency.dir}/`)) || workspace;
+    if (isBinary(input)) {
+      const binaryName = fromBinary(input);
+      const ws = (input.dir && chief.findWorkspaceByFilePath(`${input.dir}/`)) || workspace;
       const isHandled = deputy.maybeAddReferencedBinary(ws, binaryName);
       if (isHandled) return;
       collector.addIssue({
@@ -48,9 +49,9 @@ export const getReferencedDependencyHandler =
       if (specifierWorkspace) {
         const isHandled = deputy.maybeAddReferencedExternalDependency(specifierWorkspace, packageName);
 
-        if (isWorkspace || isDependency(dependency)) {
+        if (isWorkspace || isDependency(input)) {
           if (!isHandled) {
-            if ((deputy.isProduction && dependency.production) || !deputy.isProduction) {
+            if ((deputy.isProduction && input.production) || !deputy.isProduction) {
               // Unlisted dependency
               collector.addIssue({
                 type: 'unlisted',
@@ -71,11 +72,11 @@ export const getReferencedDependencyHandler =
       }
     }
 
-    if (!isConfigPattern(dependency) && deputy.isProduction && !dependency.production) {
+    if (!isConfigPattern(input) && deputy.isProduction && !input.production) {
       return;
     }
 
-    const baseDir = dependency.dir ?? dirname(containingFilePath);
+    const baseDir = input.dir ?? dirname(containingFilePath);
     const filePath = isAbsolute(specifier) ? specifier : join(baseDir, specifier);
     const resolvedFilePath = _resolveSync(filePath, baseDir);
 
diff --git a/packages/knip/test/util/get-references-from-scripts.test.ts b/packages/knip/test/util/get-references-from-scripts.test.ts
@@ -1,6 +1,6 @@
 import { test } from 'bun:test';
 import assert from 'node:assert/strict';
-import { _getDependenciesFromScripts } from '../../src/binaries/index.js';
+import { _getInputsFromScripts } from '../../src/binaries/index.js';
 import { type Input, toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toDependency, toEntry } from '../../src/util/input.js';
 import { resolve } from '../../src/util/path.js';
 
@@ -15,7 +15,7 @@ const req = toDeferResolve('./require.js');
 type T = (script: string | string[], dependencies: Input[], options?: { cwd: string }) => void;
 const t: T = (script, dependencies = [], options = { cwd }) =>
   assert.deepEqual(
-    _getDependenciesFromScripts(script, {
+    _getInputsFromScripts(script, {
       rootCwd: cwd,
       manifestScriptNames: new Set(),
       dependencies: new Set(),

Original file line number	Diff line number	Diff line change
`@@ -24,11 +24,11 @@ const resolveConfig: ResolveConfig = (script, options) => {`
`24`	`24`	`const hooks = script.hooks;`
`25`	`25`	`if (hooks) {`
`26`	`26`	`const scripts: string[] = Object.values(hooks);`
`27`		`- return [toDependency('husky'), ...options.getDependenciesFromScripts(scripts, { ...options })];`
	`27`	`+ return [toDependency('husky'), ...options.getInputsFromScripts(scripts, { ...options })];`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`		`- return options.getDependenciesFromScripts(String(script), { knownBinsOnly: true });`
	`31`	`+ return options.getInputsFromScripts(String(script), { knownBinsOnly: true });`
`32`	`32`	`};`
`33`	`33`
`34`	`34`	`export default {`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ const resolveConfig: ResolveConfig<LintStagedConfig> = async (config, options) =`
`31`	`31`
`32`	`32`	`for (const entry of Object.values(config).flat()) {`
`33`	`33`	`const scripts = [typeof entry === 'function' ? await entry([]) : entry].flat();`
`34`		`- for (const id of options.getDependenciesFromScripts(scripts)) inputs.add(id);`
	`34`	`+ for (const id of options.getInputsFromScripts(scripts)) inputs.add(id);`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`return Array.from(inputs);`