knip 6.35.1 → 6.37.0

package/dist/graph-explorer/operations/resolve-export-origins.js

@@ -0,0 +1,255 @@
+import { isBuiltin } from 'node:module';
+import { IMPORT_FLAGS, IMPORT_STAR } from '../../constants.js';
+import { getCachedExportTable, setCachedExportTable } from '../cache.js';
+import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from '../visitors.js';
+const originKey = (origin) => origin.filePath + '\0' + origin.identifier;
+const isExplicit = (info, name) => info.node?.exports.has(name) || info.terminals.has(name);
+export const createExportResolver = (graph) => {
+    const infos = new Map();
+    const getInfo = (filePath) => {
+        const cached = infos.get(filePath);
+        if (cached)
+            return cached;
+        const node = graph.get(filePath);
+        const info = { node, references: new Map(), terminals: new Map(), stars: [] };
+        infos.set(filePath, info);
+        if (!node)
+            return info;
+        const add = (map, name, origin) => {
+            const list = map.get(name);
+            if (list)
+                list.push(origin);
+            else
+                map.set(name, [origin]);
+        };
+        for (const [sourcePath, imports] of node.imports.internal) {
+            if (getStarReExportSources(imports))
+                info.stars.push(sourcePath);
+            forEachNamespaceReExport(imports, name => {
+                const exp = node.exports.get(name);
+                if (!exp || exp.isBindingReExport)
+                    add(info.terminals, name, { filePath: sourcePath, identifier: IMPORT_STAR });
+            });
+            forEachPassThroughReExport(imports, name => {
+                if (node.exports.get(name)?.isBindingReExport)
+                    add(info.references, name, { filePath: sourcePath, identifier: name });
+            });
+            forEachAliasReExport(imports, (identifier, alias) => {
+                if (node.exports.get(alias)?.isBindingReExport)
+                    add(info.references, alias, { filePath: sourcePath, identifier });
+            });
+        }
+        const addExternal = (record) => {
+            if (!(record.modifiers & IMPORT_FLAGS.RE_EXPORT) || !record.identifier)
+                return;
+            const name = record.alias ?? record.identifier;
+            const exp = node.exports.get(name);
+            if ((!exp && !(record.identifier === IMPORT_STAR && record.alias)) ||
+                (record.isTypeOnly && exp && !exp.isBindingReExport) ||
+                info.references.has(name))
+                return;
+            add(info.terminals, name, { filePath: record.specifier, identifier: record.identifier });
+        };
+        for (const record of node.imports.external)
+            addExternal(record);
+        for (const record of node.imports.imports)
+            if (isBuiltin(record.specifier))
+                addExternal(record);
+        return info;
+    };
+    const build = (filePath, identifier) => {
+        const states = new Map();
+        const discovery = [];
+        const updates = [];
+        const request = (path, name) => {
+            let state = states.get(path);
+            if (!state) {
+                state = {
+                    filePath: path,
+                    info: getInfo(path),
+                    names: new Set(),
+                    all: false,
+                    entries: new Map(),
+                    dependents: new Map(),
+                    pending: new Set(),
+                };
+                states.set(path, state);
+            }
+            if (state.all || (name !== undefined && state.names.has(name)))
+                return state;
+            if (name === undefined)
+                state.all = true;
+            else
+                state.names.add(name);
+            discovery.push([state, name]);
+            return state;
+        };
+        const merge = (state, name, origins) => {
+            let entry = state.entries.get(name);
+            let changed = false;
+            if (!entry) {
+                entry = { origins, hasExplicitExport: !!isExplicit(state.info, name) };
+                state.entries.set(name, entry);
+                changed = origins.size > 0;
+            }
+            else if (entry.origins.size === 0) {
+                entry.origins = origins;
+                changed = origins.size > 0;
+            }
+            else {
+                let merged;
+                for (const [key, origin] of origins) {
+                    if (!entry.origins.has(key))
+                        (merged ??= new Map(entry.origins)).set(key, origin);
+                }
+                if (merged) {
+                    entry.origins = merged;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                if (state.pending.size === 0)
+                    updates.push(state);
+                state.pending.add(name);
+            }
+        };
+        const connect = (source, target, sourceName, targetName) => {
+            let edge = source.dependents.get(target);
+            if (!edge)
+                source.dependents.set(target, (edge = { star: false, aliases: new Map() }));
+            if (sourceName === undefined || targetName === undefined)
+                edge.star = true;
+            else {
+                let aliases = edge.aliases.get(sourceName);
+                if (!aliases)
+                    edge.aliases.set(sourceName, (aliases = new Set()));
+                aliases.add(targetName);
+            }
+        };
+        request(filePath, identifier);
+        for (let index = 0; index < discovery.length; index++) {
+            const [state, name] = discovery[index];
+            const cached = getCachedExportTable(graph, state.filePath);
+            if (name === undefined && cached?.complete) {
+                for (const [id, entry] of cached.entries)
+                    merge(state, id, entry.origins);
+                continue;
+            }
+            const seed = (id) => {
+                const entry = cached?.entries.get(id);
+                if (entry) {
+                    merge(state, id, entry.origins);
+                    return;
+                }
+                const terminals = state.info.terminals.get(id);
+                const references = state.info.references.get(id);
+                const exp = state.info.node?.exports.get(id);
+                if (terminals || exp) {
+                    const origins = new Map();
+                    if (terminals)
+                        for (const origin of terminals)
+                            origins.set(originKey(origin), origin);
+                    else if (exp && !exp.isBindingReExport) {
+                        const origin = { filePath: state.filePath, identifier: exp.binding };
+                        origins.set(originKey(origin), origin);
+                    }
+                    merge(state, id, origins);
+                }
+                if (references)
+                    for (const source of references)
+                        connect(request(source.filePath, source.identifier), state, source.identifier, id);
+            };
+            if (name === undefined) {
+                if (state.info.node)
+                    for (const id of state.info.node.exports.keys())
+                        seed(id);
+                for (const id of state.info.terminals.keys())
+                    if (!state.info.node?.exports.has(id))
+                        seed(id);
+                for (const source of state.info.stars)
+                    connect(request(source), state);
+            }
+            else {
+                seed(name);
+                if (cached?.complete || cached?.entries.has(name) || isExplicit(state.info, name) || name === 'default')
+                    continue;
+                for (const source of state.info.stars)
+                    connect(request(source, name), state);
+            }
+        }
+        for (let index = 0; index < updates.length; index++) {
+            const state = updates[index];
+            const names = state.pending;
+            state.pending = new Set();
+            for (const [target, edge] of state.dependents) {
+                for (const name of names) {
+                    const entry = state.entries.get(name);
+                    if (!entry)
+                        continue;
+                    if (edge.star &&
+                        name !== 'default' &&
+                        !isExplicit(target.info, name) &&
+                        (target.all || target.names.has(name)))
+                        merge(target, name, entry.origins);
+                    const aliases = edge.aliases.get(name);
+                    if (aliases)
+                        for (const alias of aliases)
+                            merge(target, alias, entry.origins);
+                }
+            }
+        }
+        for (const state of states.values()) {
+            const cached = getCachedExportTable(graph, state.filePath);
+            if (cached && !state.all) {
+                for (const [name, entry] of state.entries)
+                    cached.entries.set(name, entry);
+            }
+            else
+                setCachedExportTable(graph, state.filePath, { entries: state.entries, complete: state.all });
+        }
+    };
+    const getTable = (filePath) => {
+        if (!getCachedExportTable(graph, filePath)?.complete)
+            build(filePath);
+        return getCachedExportTable(graph, filePath)?.entries ?? new Map();
+    };
+    const resolve = (filePath, identifier) => {
+        const cached = getCachedExportTable(graph, filePath);
+        if (!cached?.complete && !cached?.entries.has(identifier))
+            build(filePath, identifier);
+        return getCachedExportTable(graph, filePath)?.entries.get(identifier);
+    };
+    const getSources = (filePath, identifier) => {
+        const info = getInfo(filePath);
+        if (isExplicit(info, identifier))
+            return info.references.get(identifier) ?? [];
+        return identifier === 'default' ? [] : info.stars.map(source => ({ filePath: source, identifier }));
+    };
+    const reachesOrigin = (source, origin, site) => {
+        const visited = new Set([originKey(site)]);
+        const queue = [source];
+        const key = originKey(origin);
+        for (let index = 0; index < queue.length; index++) {
+            const current = queue[index];
+            const currentKey = originKey(current);
+            if (visited.has(currentKey))
+                continue;
+            visited.add(currentKey);
+            if (current.identifier === IMPORT_STAR && currentKey === key)
+                return true;
+            const info = getInfo(current.filePath);
+            const exp = info.node?.exports.get(current.identifier);
+            if (info.terminals.get(current.identifier)?.some(value => originKey(value) === key))
+                return true;
+            if (exp && !exp.isBindingReExport && originKey({ filePath: current.filePath, identifier: exp.binding }) === key)
+                return true;
+            queue.push(...getSources(current.filePath, current.identifier));
+        }
+        return false;
+    };
+    return { getTable, resolve, getInfo, reachesOrigin };
+};
+export const resolveExportOrigins = (graph, filePath, identifier) => {
+    const entry = createExportResolver(graph).resolve(filePath, identifier);
+    return { origins: entry ? [...entry.origins.values()] : [], hasExplicitExport: entry?.hasExplicitExport ?? false };
+};

package/dist/graph-explorer/utils.js

@@ -27,6 +27,14 @@ export const getExportedIdentifiers = (graph, filePath, visited = new Set()) =>
             continue;
         addIdentifier(identifier);
     }
+    for (const _import of node.imports.imports) {
+        if (!_import.filePath &&
+            _import.modifiers & IMPORT_FLAGS.RE_EXPORT &&
+            _import.identifier === IMPORT_STAR &&
+            _import.alias) {
+            addIdentifier(_import.alias, true);
+        }
+    }
     if (node.imports?.internal) {
         for (const [importedPath, importDetails] of node.imports.internal) {
             forEachPassThroughReExport(importDetails, (id, _sources) => {

package/dist/manifest/index.js

@@ -17,10 +17,8 @@ const getMetaDataFromPackageJson = ({ dir, packageNames }) => {
         if (manifest) {
             const defaultBinaryName = packageName.replace(/^@[^/]+\//, '');
             const binaries = typeof manifest.bin === 'string' ? [defaultBinaryName] : Object.keys(manifest.bin ?? {});
-            for (const binaryName of binaries) {
+            for (const binaryName of binaries)
                 addBinary(binaryName, packageName);
-                addBinary(packageName, binaryName);
-            }
             const packagePeerDependencies = Object.keys(manifest.peerDependencies ?? {});
             for (const packagePeerDependency of packagePeerDependencies) {
                 const hostDependency = {

package/dist/plugins/ava/index.js

@@ -23,7 +23,7 @@ const resolveConfig = async (localConfig, options) => {
     const nodeArgs = localConfig.nodeArguments ?? [];
     const requireArgs = (localConfig.require ?? []).map(require => `--require ${require}`);
     const fakeCommand = `node ${nodeArgs.join(' ')} ${requireArgs.join(' ')}`;
-    return files.concat(options.getInputsFromScripts(fakeCommand, { knownBinsOnly: true }));
+    return files.concat(options.getInputsFromScripts(fakeCommand, { optionalBinaries: true }));
 };
 const plugin = {
     title,

package/dist/plugins/eslint/helpers.d.ts

@@ -1,7 +1,8 @@
 import type { PluginOptions } from '../../types/config.ts';
+import type { Manifest } from '../../util/package-json.ts';
 import { type ConfigInput, type Input } from '../../util/input.ts';
 import type { ESLintConfig, ESLintConfigDeprecated, OverrideConfigDeprecated, Settings } from './types.ts';
 export declare const isFlatConfig: (fileName: string) => boolean;
 export declare const getInputs: (config: ESLintConfigDeprecated | OverrideConfigDeprecated | ESLintConfig, options: PluginOptions) => (Input | ConfigInput)[];
 export declare const getInputsFromSettings: (settings?: Settings) => Input[];
-export declare const resolveFormatters: (formatters: string | string[]) => Set<Input>;
+export declare const resolveFormatters: (formatters: string | string[], manifest: Manifest) => Set<Input>;

package/dist/plugins/eslint/helpers.js

@@ -16,20 +16,36 @@ export const getInputs = (config, options) => {
     return compact(dependencies).map(id => toDeferResolve(id, { optional: true }));
 };
 const getInputsDeprecated = (config, options) => {
-    const extendsSpecifiers = config.extends ? compact([config.extends].flat().map(resolveExtendSpecifier)) : [];
+    const extendsList = config.extends ? [config.extends].flat() : [];
+    const extendsSpecifiers = compact(extendsList.map(resolveExtendSpecifier));
     if (extendsSpecifiers.some(specifier => specifier?.startsWith('eslint-plugin-prettier')))
         extendsSpecifiers.push('eslint-config-prettier');
-    const extendConfigs = extendsSpecifiers.map(specifier => toConfig('eslint', specifier, { containingFilePath: options.configFilePath }));
+    const extendConfigs = [...extendsList.filter(isInternal), ...extendsSpecifiers].map(specifier => toConfig('eslint', specifier, { containingFilePath: options.configFilePath }));
     const plugins = config.plugins ? config.plugins.map(resolvePluginSpecifier) : [];
-    const parser = config.parser ?? config.parserOptions?.parser;
+    const parsers = getParsers(config);
     const babelDependencies = config.parserOptions?.babelOptions
         ? getDependenciesFromConfig(config.parserOptions.babelOptions)
         : [];
     const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
     const rules = getDependenciesFromRules({});
     const overrides = config.overrides ? [config.overrides].flat().flatMap(d => getInputsDeprecated(d, options)) : [];
-    const deferred = compact([...extendsSpecifiers, ...plugins, parser, ...settings, ...rules]).map(id => toDeferResolve(id));
-    return [...extendConfigs, ...deferred, ...babelDependencies, ...overrides];
+    const deferred = compact([...extendsSpecifiers, ...plugins, ...settings, ...rules]).map(id => toDeferResolve(id));
+    return [...extendConfigs, ...deferred, ...parsers, ...babelDependencies, ...overrides];
+};
+const isParserObject = (value) => typeof value.parseForESLint === 'function' || typeof value.parse === 'function';
+const toParser = (name) => toDeferResolve(name, name === 'espree' ? { optional: true } : {});
+const getParsers = ({ parser, parserOptions }) => {
+    const inputs = [];
+    for (const value of [parser, parserOptions?.parser]) {
+        if (typeof value === 'string')
+            inputs.push(toParser(value));
+        else if (value && typeof value === 'object' && !isParserObject(value)) {
+            for (const name of Object.values(value))
+                if (typeof name === 'string')
+                    inputs.push(toParser(name));
+        }
+    }
+    return inputs;
 };
 const isQualifiedSpecifier = (specifier) => specifier === 'eslint' ||
     /\/eslint-(config|plugin)$/.test(specifier) ||
@@ -58,10 +74,19 @@ const resolveExtendSpecifier = (specifier) => {
     return resolveSpecifier(namespace, specifier);
 };
 const getDependenciesFromRules = (rules = {}) => Object.keys(rules).flatMap(ruleKey => ruleKey.includes('/') ? [resolveSpecifier('eslint-plugin', ruleKey.split('/').slice(0, -1).join('/'))] : []);
+const getResolverNames = (value) => {
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap(getResolverNames);
+    if (value && typeof value === 'object')
+        return Object.keys(value);
+    return [];
+};
 const getDependenciesFromSettings = (settings = {}) => {
     return Object.entries(settings).flatMap(([settingKey, settings]) => {
         if (settingKey === 'import/resolver') {
-            return (typeof settings === 'string' ? [settings] : Object.keys(settings))
+            return getResolverNames(settings)
                 .filter(key => key !== 'node')
                 .map(key => {
                 if (isInternal(key))
@@ -82,15 +107,35 @@ const getDependenciesFromSettings = (settings = {}) => {
 };
 export const getInputsFromSettings = (settings) => compact(getDependenciesFromSettings(settings)).map(id => toDeferResolve(id, { optional: true }));
 const builtinFormatters = new Set(['html', 'json-with-metadata', 'json', 'stylish']);
-export const resolveFormatters = (formatters) => {
+const builtinFormattersUntilV8 = new Set([
+    'checkstyle',
+    'compact',
+    'jslint-xml',
+    'junit',
+    'tap',
+    'unix',
+    'visualstudio',
+]);
+const normalizeFormatterName = (name) => {
+    if (!name.startsWith('@'))
+        return name.startsWith('eslint-formatter-') ? name : `eslint-formatter-${name}`;
+    const [scope, id] = name.split('/');
+    if (!id)
+        return `${scope}/eslint-formatter`;
+    return /^eslint-formatter(-|$)/.test(id) ? name : name.replace('/', '/eslint-formatter-');
+};
+export const resolveFormatters = (formatters, manifest) => {
     const inputs = new Set();
-    for (const formatter of [formatters].flat()) {
-        if (builtinFormatters.has(formatter))
-            continue;
-        else if (isInternal(formatter))
-            inputs.add(toDeferResolve(formatter));
-        else
-            inputs.add(toDependency(`eslint-formatter-${formatter}`));
+    const isBeforeV9 = (manifest.getMajor('eslint') ?? 9) < 9;
+    for (const rawFormatter of [formatters].flat()) {
+        const formatter = rawFormatter.replace(/\\/g, '/');
+        if (!formatter.startsWith('@') && formatter.includes('/')) {
+            inputs.add(toDeferResolve(isInternal(formatter) ? formatter : `./${formatter}`));
+        }
+        else {
+            const isBuiltin = builtinFormatters.has(formatter) || (isBeforeV9 && builtinFormattersUntilV8.has(formatter));
+            inputs.add(toDependency(normalizeFormatterName(formatter), isBuiltin ? { optional: true } : {}));
+        }
     }
     return inputs;
 };

package/dist/plugins/eslint/index.js

@@ -49,12 +49,12 @@ const args = {
     config: true,
     alias: { format: ['f'] },
     boolean: ['inspect-config'],
-    resolveInputs: (parsed) => {
+    resolveInputs: (parsed, { manifest }) => {
         const inputs = [];
         if (parsed['inspect-config'])
             inputs.push(toDependency('@eslint/config-inspector', { optional: true }));
         if (parsed['format'])
-            for (const input of resolveFormatters(parsed['format']))
+            for (const input of resolveFormatters(parsed['format'], manifest))
                 inputs.push(input);
         return inputs;
     },

package/dist/plugins/eslint/resolveFromAST.js

@@ -11,6 +11,21 @@ export const getInputsFromSettingsAST = (program) => {
         const dep = key === 'import/resolver' ? `eslint-import-resolver-${resolver}` : resolver;
         inputs.push(toDeferResolve(dep, { optional: true }));
     };
+    const addResolvers = (key, node) => {
+        if (node?.type === 'ArrayExpression') {
+            for (const element of node.elements)
+                addResolvers(key, element);
+        }
+        else if (node?.type === 'ObjectExpression') {
+            for (const prop of node.properties) {
+                if (prop.type === 'Property')
+                    addResolver(key, getPropertyKey(prop));
+            }
+        }
+        else {
+            addResolver(key, getStringValue(node));
+        }
+    };
     const visitor = new Visitor({
         ObjectExpression(node) {
             const settingsNode = findProperty(node, 'settings');
@@ -20,17 +35,8 @@ export const getInputsFromSettingsAST = (program) => {
                 if (prop.type !== 'Property')
                     continue;
                 const key = getPropertyKey(prop);
-                if (key !== 'import/resolver' && key !== 'import/parsers')
-                    continue;
-                if (prop.value?.type === 'ObjectExpression') {
-                    for (const p of prop.value.properties ?? []) {
-                        if (p.type === 'Property')
-                            addResolver(key, getPropertyKey(p));
-                    }
-                }
-                else {
-                    addResolver(key, getStringValue(prop.value));
-                }
+                if (key === 'import/resolver' || key === 'import/parsers')
+                    addResolvers(key, prop.value);
             }
         },
     });

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

@@ -1,14 +1,14 @@
 type ParserOptions = {
     project?: string;
-    parser?: string;
+    parser?: string | Record<string, unknown>;
     babelOptions?: {
         plugins: string[];
         presets: string[];
     };
 };
-export type Settings = Record<string, Record<string, unknown> | string>;
+export type Settings = Record<string, Record<string, unknown> | string | unknown[]>;
 type Rules = Record<string, string | number>;
-type BaseConfig = {
+export type BaseConfig = {
     extends?: string | string[];
     parser?: string;
     parserOptions?: ParserOptions;

package/dist/plugins/github-actions/index.js

@@ -34,7 +34,7 @@ const resolveConfig = async (config, options) => {
                 const manifest = getManifest(dir) ?? options.manifest;
                 const actionPath = relative(dir, configFileDir);
                 const run = step.run.replace(ACTION_PATH_VAR, actionPath ? `./${actionPath}` : '.');
-                for (const input of getInputsFromScripts([run], { knownBinsOnly: true, manifest })) {
+                for (const input of getInputsFromScripts([run], { optionalBinaries: true, manifest })) {
                     if (isDeferResolveEntry(input) && path && !workingDir) {
                         input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
                     }

package/dist/plugins/graphql-codegen/index.js

@@ -1,8 +1,8 @@
 import { toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { get } from '../../util/object.js';
-import { isInternal, join } from '../../util/path.js';
+import { isInternal, join, normalize } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
-import { isConfigurationOutput, isGraphqlConfigTypes, isGraphqlProjectsConfigTypes } from './types.js';
+import { isConfigurationOutput, isGraphqlConfigTypes, isGraphqlProjectsConfigTypes, isNearOperationFilePreset, } from './types.js';
 const title = 'GraphQL Codegen';
 const enablers = [/^@graphql-codegen\//, 'graphql-config'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -24,6 +24,17 @@ const getPluginPackageName = (name) => {
         return name;
     return `@graphql-codegen/${name}`;
 };
+const getOutputPattern = (output, outputConfig) => {
+    if (isConfigurationOutput(outputConfig) && isNearOperationFilePreset(outputConfig.preset)) {
+        const presetConfig = outputConfig.presetConfig ?? {};
+        const { folder = '', extension = '.generated.ts', fileName = '*', filePerOperation = false } = presetConfig;
+        const subfolder = normalize(folder)
+            .split('/')
+            .filter(segment => segment !== '' && segment !== '.' && segment !== '..');
+        return join(output, '**', ...subfolder, `${filePerOperation ? '*' : fileName}${extension}`);
+    }
+    return output.endsWith('/') ? `${output}**` : output;
+};
 const resolveConfig = (config, options) => {
     const codegenConfigs = isGraphqlProjectsConfigTypes(config)
         ? Object.values(config.projects).flatMap(project => project.extensions?.codegen ?? [])
@@ -33,8 +44,8 @@ const resolveConfig = (config, options) => {
     const generateConfigs = codegenConfigs.filter((config) => Boolean(config?.generates));
     const generateSet = generateConfigs.flatMap(config => Object.values(config.generates));
     const outputs = generateConfigs
-        .flatMap(config => Object.keys(config.generates))
-        .map(output => toProductionEntry(join(options.configFileDir, output.endsWith('/') ? `${output}**` : output)));
+        .flatMap(config => Object.entries(config.generates))
+        .map(([output, outputConfig]) => toProductionEntry(join(options.configFileDir, getOutputPattern(output, outputConfig))));
     const configurationOutput = generateSet.filter(isConfigurationOutput);
     const presets = configurationOutput
         .map(configOutput => (configOutput.preset ? configOutput.preset : undefined))

package/dist/plugins/graphql-codegen/types.d.ts

@@ -12,10 +12,20 @@ type OutputPreset = {
     buildGeneratesSection: (options: unknown) => Promise<unknown>;
     prepareDocuments?: (outputFilePath: string, outputSpecificDocuments: unknown) => Promise<unknown>;
 };
+export interface NearOperationFilePresetConfig {
+    baseTypesPath?: string;
+    extension?: string;
+    fileName?: string;
+    filePerOperation?: boolean;
+    folder?: string;
+    [key: string]: unknown;
+}
+export declare const isNearOperationFilePreset: (preset: ConfiguredOutput['preset']) => preset is PresetNames;
 export declare function isConfigurationOutput(config: ConfiguredOutput | ConfiguredPlugin[]): config is ConfiguredOutput;
-interface ConfiguredOutput {
+export interface ConfiguredOutput {
     plugins?: OutputConfig[];
     preset?: PresetNames | OutputPreset;
+    presetConfig?: NearOperationFilePresetConfig;
 }
 export interface GraphqlCodegenTypes {
     generates: {

package/dist/plugins/graphql-codegen/types.js

@@ -1,3 +1,9 @@
+const nearOperationFilePresetNames = new Set([
+    'near-operation-file',
+    'near-operation-file-preset',
+    '@graphql-codegen/near-operation-file-preset',
+]);
+export const isNearOperationFilePreset = (preset) => typeof preset === 'string' && nearOperationFilePresetNames.has(preset);
 export function isConfigurationOutput(config) {
     return 'preset' in config || 'plugins' in config;
 }

package/dist/plugins/husky/index.js

@@ -17,7 +17,7 @@ const resolveConfig = (script, options) => {
             return [toDependency('husky'), ...options.getInputsFromScripts(scripts, { ...options })];
         }
     }
-    return options.getInputsFromScripts(String(script), { knownBinsOnly: true });
+    return options.getInputsFromScripts(String(script), { optionalBinaries: true });
 };
 const plugin = {
     title,

package/dist/plugins/index.d.ts

@@ -150,6 +150,7 @@ export declare const Plugins: {
     taskfile: import("../types/config.ts").Plugin;
     tauri: import("../types/config.ts").Plugin;
     temporal: import("../types/config.ts").Plugin;
+    textlint: import("../types/config.ts").Plugin;
     travis: import("../types/config.ts").Plugin;
     'ts-node': import("../types/config.ts").Plugin;
     tsd: import("../types/config.ts").Plugin;
@@ -166,6 +167,7 @@ export declare const Plugins: {
     'unplugin-vue-i18n': import("../types/config.ts").Plugin;
     'unplugin-vue-markdown': import("../types/config.ts").Plugin;
     'unplugin-vue-router': import("../types/config.ts").Plugin;
+    varlock: import("../types/config.ts").Plugin;
     vercel: import("../types/config.ts").Plugin;
     'vercel-og': import("../types/config.ts").Plugin;
     vike: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -144,6 +144,7 @@ import { default as tanstackRouter } from './tanstack-router/index.js';
 import { default as taskfile } from './taskfile/index.js';
 import { default as tauri } from './tauri/index.js';
 import { default as temporal } from './temporal/index.js';
+import { default as textlint } from './textlint/index.js';
 import { default as travis } from './travis/index.js';
 import { default as tsNode } from './ts-node/index.js';
 import { default as tsd } from './tsd/index.js';
@@ -160,6 +161,7 @@ import { default as unpluginVueComponents } from './unplugin-vue-components/inde
 import { default as unpluginVueI18n } from './unplugin-vue-i18n/index.js';
 import { default as unpluginVueMarkdown } from './unplugin-vue-markdown/index.js';
 import { default as unpluginVueRouter } from './unplugin-vue-router/index.js';
+import { default as varlock } from './varlock/index.js';
 import { default as vercel } from './vercel/index.js';
 import { default as vercelOg } from './vercel-og/index.js';
 import { default as vike } from './vike/index.js';
@@ -328,6 +330,7 @@ export const Plugins = {
     taskfile,
     tauri,
     temporal,
+    textlint,
     travis,
     'ts-node': tsNode,
     tsd,
@@ -344,6 +347,7 @@ export const Plugins = {
     'unplugin-vue-i18n': unpluginVueI18n,
     'unplugin-vue-markdown': unpluginVueMarkdown,
     'unplugin-vue-router': unpluginVueRouter,
+    varlock,
     vercel,
     'vercel-og': vercelOg,
     vike,

package/dist/plugins/lefthook/index.js

@@ -21,7 +21,7 @@ const resolveConfig = async (localConfig, options) => {
     const inputs = manifest.devDependencies ? Object.keys(manifest.devDependencies).map(id => toDependency(id)) : [];
     if (extname(configFileName) !== '') {
         const scripts = findByKeyDeep(localConfig, 'run').flatMap(command => {
-            const deps = getInputsFromScripts([command.run], { ...options, knownBinsOnly: true });
+            const deps = getInputsFromScripts([command.run], { ...options, optionalBinaries: true });
             const dir = command.root ?? cwd;
             return deps.flatMap(dependency => ({ ...dependency, dir }));
         });