knip 6.26.0 → 6.27.0

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

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

package/dist/plugins/temporal/index.js

@@ -0,0 +1,12 @@
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Temporal.io';
+const enablers = ['@temporalio/worker'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const production = ['src/workflows{,/index}.{js,cjs,mjs,ts,cts,mts}'];
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    production,
+};
+export default plugin;

package/dist/plugins/tsdown/index.js

@@ -1,5 +1,5 @@
 import { collectPropertyValues } from '../../typescript/ast-helpers.js';
-import { toProductionEntry } from '../../util/input.js';
+import { toDependency, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'tsdown';
 const enablers = ['tsdown'];
@@ -17,6 +17,11 @@ const normalizeEntry = (entry) => {
     }
     return Object.values(entry).flatMap(value => (Array.isArray(value) ? value : [value]));
 };
+const getExternalDependencies = (options) => {
+    const neverBundle = options.deps?.neverBundle;
+    const values = Array.isArray(neverBundle) ? neverBundle : [neverBundle];
+    return values.filter(value => typeof value === 'string');
+};
 const resolveConfig = async (config) => {
     if (typeof config === 'function')
         config = await config({});
@@ -24,9 +29,16 @@ const resolveConfig = async (config) => {
         .flat()
         .flatMap(config => normalizeEntry(config.entry))
         .map(id => toProductionEntry(id, { allowIncludeExports: true }));
-    return entryPatterns;
+    const externalDependencies = [config]
+        .flat()
+        .flatMap(getExternalDependencies)
+        .map(id => toDependency(id, { optional: true }));
+    return [...entryPatterns, ...externalDependencies];
 };
-const resolveFromAST = program => [...collectPropertyValues(program, 'entry')].map(id => toProductionEntry(id, { allowIncludeExports: true }));
+const resolveFromAST = program => [
+    ...[...collectPropertyValues(program, 'entry')].map(id => toProductionEntry(id, { allowIncludeExports: true })),
+    ...[...collectPropertyValues(program, 'neverBundle')].map(id => toDependency(id, { optional: true })),
+];
 const args = {
     config: true,
 };

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

@@ -1,6 +1,9 @@
 export type Entry = (string | Record<string, string[] | string>)[] | string | Record<string, string[] | string>;
-type Options = {
+export type Options = {
     entry?: Entry;
+    deps?: {
+        neverBundle?: unknown;
+    };
 };
 type MaybePromise<T> = T | Promise<T>;
 export type TsdownConfig = Options | Options[] | ((overrideOptions: Options) => MaybePromise<Options | Options[]>);

package/dist/plugins/vitest/index.js

@@ -30,6 +30,10 @@ const findConfigDependencies = (localConfig, options, vitestRoot) => {
     const setupFiles = [testConfig.setupFiles ?? []]
         .flat()
         .map(specifier => ({ ...toDeferResolve(specifier), dir: vitestRoot }));
+    const snapshotSerializers = (testConfig.snapshotSerializers ?? []).map(specifier => ({
+        ...toDeferResolve(specifier),
+        dir: vitestRoot,
+    }));
     const globalSetup = [testConfig.globalSetup ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
     const workspaceDependencies = [];
     if (testConfig.workspace !== undefined) {
@@ -50,6 +54,7 @@ const findConfigDependencies = (localConfig, options, vitestRoot) => {
         ...reporters.map(id => toDependency(id)),
         ...coverage.map(id => toDependency(id)),
         ...setupFiles,
+        ...snapshotSerializers,
         ...globalSetup,
         ...workspaceDependencies,
         ...projectsDependencies,
@@ -110,6 +115,9 @@ export const resolveConfig = async (localConfig, options) => {
                         inputs.add(toConfig('vitest', projectFile, { containingFilePath: options.configFilePath }));
                     }
                 }
+                else if (typeof project.extends === 'string') {
+                    inputs.add(toConfig('vitest', project.extends, { containingFilePath: options.configFilePath }));
+                }
             }
         }
     }
@@ -153,6 +161,13 @@ export const resolveConfig = async (localConfig, options) => {
             if (packageName)
                 inputs.add(toDependency(packageName, { optional: true }));
         }
+        const ssrExternal = cfg.ssr?.external;
+        if (Array.isArray(ssrExternal)) {
+            for (const dependency of ssrExternal) {
+                if (typeof dependency === 'string')
+                    inputs.add(toDependency(dependency, { optional: true }));
+            }
+        }
         if (cfg.resolve?.extensions) {
             const customExtensions = cfg.resolve.extensions.filter(ext => ext.startsWith('.') && !DEFAULT_EXTENSIONS.has(ext));
             for (const ext of customExtensions) {

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

@@ -21,6 +21,7 @@ interface VitestConfig {
         globalSetup?: string | string[];
         reporters?: (string | [string, unknown] | unknown)[];
         setupFiles?: string | string[];
+        snapshotSerializers?: string[];
         workspace?: (ViteConfig & {
             test: VitestConfig['test'] & {
                 workspace: never;
@@ -35,6 +36,7 @@ interface VitestConfig {
     };
 }
 export interface ViteConfig extends VitestConfig {
+    extends?: string | true;
     root?: string;
     plugins?: unknown[];
     build?: {
@@ -47,6 +49,9 @@ export interface ViteConfig extends VitestConfig {
     optimizeDeps?: {
         include?: string[];
     };
+    ssr?: {
+        external?: (string | RegExp)[] | true;
+    };
     resolve?: {
         alias?: AliasOptions;
         dedupe?: string[];

package/dist/run.js

@@ -12,7 +12,7 @@ import { debugLogObject } from './util/debug.js';
 import { flushGitignoreCache, initGitignoreCache } from './util/gitignore-cache.js';
 import { flushGlobCache, initGlobCache } from './util/glob-cache.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
-import { getModuleSourcePathHandler, getWorkspaceManifestHandler } from './util/to-source-path.js';
+import { getModuleSourcePathHandler, getWorkspacePackageTargetHandler } from './util/to-source-path.js';
 import { getSessionHandler } from './util/watch.js';
 export const run = async (options) => {
     debugLogObject('*', 'Unresolved configuration', options);
@@ -30,8 +30,8 @@ export const run = async (options) => {
     const workspaces = await chief.getWorkspaces();
     const isGitIgnored = await getGitIgnoredHandler(options, new Set(workspaces.map(w => w.dir)));
     const toSourceFilePath = getModuleSourcePathHandler(chief);
-    const findWorkspaceManifestImports = getWorkspaceManifestHandler(chief);
-    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspaceManifestImports);
+    const findWorkspacePackageTarget = getWorkspacePackageTargetHandler(chief);
+    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspacePackageTarget);
     collector.setWorkspaceFilter(chief.workspaceFilePathFilter);
     collector.setSelectedWorkspaces(chief.selectedWorkspaces);
     collector.setIgnoreIssues(chief.getIgnoreIssues());

package/dist/schema/configuration.d.ts

@@ -701,6 +701,11 @@ export declare const workspaceConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    temporal: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     travis: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1597,6 +1602,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    temporal: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     travis: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -2511,6 +2521,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         }, z.core.$strip>]>>;
+        temporal: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+            config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        }, z.core.$strip>]>>;
         travis: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
             config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.d.ts

@@ -706,6 +706,11 @@ export declare const pluginsSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>;
+    temporal: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>;
     travis: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.js

@@ -150,6 +150,7 @@ export const pluginsSchema = z.object({
     'tanstack-router': pluginSchema,
     taskfile: pluginSchema,
     tauri: pluginSchema,
+    temporal: pluginSchema,
     travis: pluginSchema,
     'ts-node': pluginSchema,
     tsdown: pluginSchema,

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-markdoc' | 'astro-og-canvas' | 'ava' | 'babel' | 'biome' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'catalyst' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'electron-vite' | 'eleventy' | 'esbuild' | 'eslint' | 'eve' | 'execa' | 'expo' | 'expressive-code' | 'fast' | 'fumadocs' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'knex' | 'ladle' | 'laravel-vite-plugin' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lit' | 'lockfile-lint' | 'lost-pixel' | 'lunaria' | 'markdownlint' | 'mdx' | 'mdxlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-spawn' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nuxtjs-i18n' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'orval' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'quasar' | 'qwik' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltejs-package' | 'sveltekit' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'tauri' | 'travis' | 'ts-node' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'unplugin-auto-import' | 'unplugin-icons' | 'unplugin-vue-components' | 'unplugin-vue-i18n' | 'unplugin-vue-markdown' | 'unplugin-vue-router' | 'vercel' | 'vercel-og' | 'vike' | 'vite' | 'vite-plugin-pages' | 'vite-plugin-pwa' | 'vite-plugin-vue-layouts-next' | 'vite-plus' | 'vite-pwa-assets-generator' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'wxt' | 'xo' | 'yarn' | 'yorkie' | 'zx';
-export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-markdoc', 'astro-og-canvas', 'ava', 'babel', 'biome', 'bumpp', 'bun', 'c8', 'capacitor', 'catalyst', 'changelogen', 'changelogithub', 'changesets', 'commitizen', 'commitlint', 'convex', 'create-typescript-app', 'cspell', 'cucumber', 'cypress', 'danger', 'dependency-cruiser', 'docusaurus', 'dotenv', 'drizzle', 'electron-vite', 'eleventy', 'esbuild', 'eslint', 'eve', 'execa', 'expo', 'expressive-code', 'fast', 'fumadocs', 'gatsby', 'github-action', 'github-actions', 'glob', 'graphql-codegen', 'hardhat', 'husky', 'i18next-parser', 'jest', 'karma', 'knex', 'ladle', 'laravel-vite-plugin', 'lefthook', 'lint-staged', 'linthtml', 'lit', 'lockfile-lint', 'lost-pixel', 'lunaria', 'markdownlint', 'mdx', 'mdxlint', 'metro', 'mocha', 'moonrepo', 'msw', 'nano-spawn', 'nano-staged', 'nest', 'netlify', 'next', 'next-intl', 'next-mdx', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nuxtjs-i18n', 'nx', 'nyc', 'oclif', 'openapi-ts', 'orval', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'preconstruct', 'prettier', 'prisma', 'quasar', 'qwik', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltejs-package', 'sveltekit', 'svgo', 'svgr', 'swc', 'syncpack', 'tailwind', 'tanstack-router', 'taskfile', 'tauri', 'travis', 'ts-node', 'tsdown', 'tsup', 'tsx', 'typedoc', 'typescript', 'unbuild', 'unocss', 'unplugin-auto-import', 'unplugin-icons', 'unplugin-vue-components', 'unplugin-vue-i18n', 'unplugin-vue-markdown', 'unplugin-vue-router', 'vercel', 'vercel-og', 'vike', 'vite', 'vite-plugin-pages', 'vite-plugin-pwa', 'vite-plugin-vue-layouts-next', 'vite-plus', 'vite-pwa-assets-generator', 'vitepress', 'vitest', 'vue', 'webdriver-io', 'webpack', 'wireit', 'wrangler', 'wxt', 'xo', 'yarn', 'yorkie', 'zx'];
+export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-markdoc' | 'astro-og-canvas' | 'ava' | 'babel' | 'biome' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'catalyst' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'electron-vite' | 'eleventy' | 'esbuild' | 'eslint' | 'eve' | 'execa' | 'expo' | 'expressive-code' | 'fast' | 'fumadocs' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'knex' | 'ladle' | 'laravel-vite-plugin' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lit' | 'lockfile-lint' | 'lost-pixel' | 'lunaria' | 'markdownlint' | 'mdx' | 'mdxlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-spawn' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nuxtjs-i18n' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'orval' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'quasar' | 'qwik' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltejs-package' | 'sveltekit' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'tauri' | 'temporal' | 'travis' | 'ts-node' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'unplugin-auto-import' | 'unplugin-icons' | 'unplugin-vue-components' | 'unplugin-vue-i18n' | 'unplugin-vue-markdown' | 'unplugin-vue-router' | 'vercel' | 'vercel-og' | 'vike' | 'vite' | 'vite-plugin-pages' | 'vite-plugin-pwa' | 'vite-plugin-vue-layouts-next' | 'vite-plus' | 'vite-pwa-assets-generator' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'wxt' | 'xo' | 'yarn' | 'yorkie' | 'zx';
+export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-markdoc', 'astro-og-canvas', 'ava', 'babel', 'biome', 'bumpp', 'bun', 'c8', 'capacitor', 'catalyst', 'changelogen', 'changelogithub', 'changesets', 'commitizen', 'commitlint', 'convex', 'create-typescript-app', 'cspell', 'cucumber', 'cypress', 'danger', 'dependency-cruiser', 'docusaurus', 'dotenv', 'drizzle', 'electron-vite', 'eleventy', 'esbuild', 'eslint', 'eve', 'execa', 'expo', 'expressive-code', 'fast', 'fumadocs', 'gatsby', 'github-action', 'github-actions', 'glob', 'graphql-codegen', 'hardhat', 'husky', 'i18next-parser', 'jest', 'karma', 'knex', 'ladle', 'laravel-vite-plugin', 'lefthook', 'lint-staged', 'linthtml', 'lit', 'lockfile-lint', 'lost-pixel', 'lunaria', 'markdownlint', 'mdx', 'mdxlint', 'metro', 'mocha', 'moonrepo', 'msw', 'nano-spawn', 'nano-staged', 'nest', 'netlify', 'next', 'next-intl', 'next-mdx', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nuxtjs-i18n', 'nx', 'nyc', 'oclif', 'openapi-ts', 'orval', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'preconstruct', 'prettier', 'prisma', 'quasar', 'qwik', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltejs-package', 'sveltekit', 'svgo', 'svgr', 'swc', 'syncpack', 'tailwind', 'tanstack-router', 'taskfile', 'tauri', 'temporal', 'travis', 'ts-node', 'tsdown', 'tsup', 'tsx', 'typedoc', 'typescript', 'unbuild', 'unocss', 'unplugin-auto-import', 'unplugin-icons', 'unplugin-vue-components', 'unplugin-vue-i18n', 'unplugin-vue-markdown', 'unplugin-vue-router', 'vercel', 'vercel-og', 'vike', 'vite', 'vite-plugin-pages', 'vite-plugin-pwa', 'vite-plugin-vue-layouts-next', 'vite-plus', 'vite-pwa-assets-generator', 'vitepress', 'vitest', 'vue', 'webdriver-io', 'webpack', 'wireit', 'wrangler', 'wxt', 'xo', 'yarn', 'yorkie', 'zx'];

package/dist/types/PluginNames.js

@@ -139,6 +139,7 @@ export const pluginNames = [
     'tanstack-router',
     'taskfile',
     'tauri',
+    'temporal',
     'travis',
     'ts-node',
     'tsdown',

package/dist/types/config.d.ts

@@ -14,6 +14,7 @@ import type { PackageJson } from './package-json.ts';
 export interface GetInputsFromScriptsOptions extends BaseOptions {
     knownBinsOnly?: boolean;
     containingFilePath: string;
+    expandedScripts?: Set<string>;
 }
 export type GetInputsFromScripts<T = GetInputsFromScriptsOptions> = (npmScripts: string | string[] | Set<string>, options: T) => Input[];
 export type GetInputsFromScriptsPartial = (npmScripts: string | string[] | Set<string>, options?: Partial<GetInputsFromScriptsOptions>) => Input[];

package/dist/typescript/ast-nodes.d.ts

@@ -8,6 +8,7 @@ export type ResolveModule = (specifier: string, containingFile: string) => Resol
 export interface ResolvedModule {
     resolvedFileName: string;
     isExternalLibraryImport: boolean;
+    packageName?: string;
 }
 export declare const buildLineStarts: (sourceText: string) => number[];
 export declare const getLineAndCol: (lineStarts: number[], pos: number) => {

package/dist/typescript/get-imports-and-exports.js

@@ -1,7 +1,7 @@
 import { isBuiltin } from 'node:module';
 import { IMPORT_FLAGS, IMPORT_STAR, OPAQUE, PROTOCOL_VIRTUAL, SIDE_EFFECTS } from '../constants.js';
 import { addNsValue, addValue, createImports } from '../util/module-graph.js';
-import { getPackageNameFromFilePath, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier, } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { dirname, isInNodeModules, resolve } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
@@ -125,9 +125,12 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                 if (module.isExternalLibraryImport) {
                     if (options.skipTypeOnly && modifiers & IMPORT_FLAGS.TYPE_ONLY)
                         return;
-                    const sanitizedSpecifier = sanitizeSpecifier(isInNodeModules(resolvedFileName) || isInNodeModules(specifier)
-                        ? getPackageNameFromFilePath(specifier)
-                        : specifier);
+                    let sanitizedSpecifier = sanitizeSpecifier(isInNodeModules(specifier) ? getPackageNameFromFilePath(specifier) : specifier);
+                    if (module.packageName &&
+                        isStartsLikePackageName(module.packageName) &&
+                        getPackageNameFromModuleSpecifier(sanitizedSpecifier) !== module.packageName) {
+                        sanitizedSpecifier = module.packageName;
+                    }
                     if (!isStartsLikePackageName(sanitizedSpecifier))
                         return;
                     const ePos = specifierPos ?? pos;
@@ -277,7 +280,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, filter: opts?.filter });
         pluginCtx.markExportRegistered = (name) => registeredCustomElements.add(name);
     }
-    const localRefs = _walkAST(result.program, sourceText, filePath, {
+    const localRefs = _walkAST(result.program, sourceText, filePath, result.module.hasModuleSyntax, {
         lineStarts,
         skipExports,
         options,

package/dist/typescript/resolve-module-names.d.ts

@@ -1,4 +1,4 @@
-import type { ToSourceFilePath, WorkspaceManifestHandler } from '../util/to-source-path.ts';
+import type { ToSourceFilePath, WorkspacePackageTargetHandler } from '../util/to-source-path.ts';
 import type { ResolveModule } from './ast-nodes.ts';
 type ScopedPaths = Array<{
     scope: string;
@@ -14,5 +14,5 @@ export declare function createGlobAliasResolver(scopedPaths: ScopedPaths | undef
 export declare function createCustomModuleResolver(compilerOptions: {
     scopedPaths?: ScopedPaths;
     scopedRootDirs?: ScopedRootDirs;
-}, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler, tsConfigFile?: string): ResolveModule;
+}, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, findWorkspacePackageTarget?: WorkspacePackageTargetHandler, tsConfigFile?: string): ResolveModule;
 export {};

package/dist/typescript/resolve-module-names.js

@@ -1,7 +1,8 @@
-import { existsSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
 import { isBuiltin } from 'node:module';
-import { DEFAULT_EXTENSIONS, DTS_EXTENSIONS } from '../constants.js';
-import { sanitizeSpecifier } from '../util/modules.js';
+import { DEFAULT_EXTENSIONS, DTS_EXTENSIONS, IS_DTS } from '../constants.js';
+import { isFile } from '../util/fs.js';
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier, sanitizeSpecifier } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { dirname, extname, isAbsolute, isInNodeModules, join, toPosix } from '../util/path.js';
 import { _createSyncModuleResolver, _resolveModuleSync } from '../util/resolve.js';
@@ -22,10 +23,81 @@ function pickStringTarget(value) {
             return s;
     }
 }
+const invalidSegments = /(^|\\|\/)((\.|%2e)(\.|%2e)?|node_modules)(\\|\/|$)/i;
+const expandPackageTarget = (target, patternMatch) => {
+    if (!target?.startsWith('./') || invalidSegments.test(target.slice(2)))
+        return;
+    if (!target.includes('*'))
+        return target;
+    if (patternMatch === undefined || invalidSegments.test(patternMatch))
+        return;
+    return target.replaceAll('*', patternMatch);
+};
+const toPackagePath = (dir, target) => {
+    const candidate = join(dir, target);
+    return candidate.startsWith(`${dir}/`) ? candidate : undefined;
+};
+function pickExistingPackageTarget(value, dir, patternMatch, moduleExtensions) {
+    if (typeof value === 'string') {
+        const target = expandPackageTarget(value, patternMatch);
+        if (!target || IS_DTS.test(target) || !moduleExtensions.has(extname(target)))
+            return;
+        const candidate = toPackagePath(dir, target);
+        return candidate && isFile(candidate) ? candidate : undefined;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const target = pickExistingPackageTarget(item, dir, patternMatch, moduleExtensions);
+            if (target)
+                return target;
+        }
+        return;
+    }
+    for (const [condition, child] of Object.entries(value)) {
+        if (condition === 'types')
+            continue;
+        const target = pickExistingPackageTarget(child, dir, patternMatch, moduleExtensions);
+        if (target)
+            return target;
+    }
+}
 const moduleResolutionCaches = [];
+const installedPackageRootCache = new Map();
 export function clearModuleResolutionCaches() {
     for (const cache of moduleResolutionCaches)
         cache.clear();
+    installedPackageRootCache.clear();
+}
+function getInstalledPackageRoot(candidate) {
+    if (installedPackageRootCache.has(candidate))
+        return installedPackageRootCache.get(candidate);
+    let packageRoot;
+    try {
+        packageRoot = toPosix(realpathSync(candidate));
+    }
+    catch { }
+    installedPackageRootCache.set(candidate, packageRoot);
+    return packageRoot;
+}
+function getAttributedPackageName(specifier, containingFile, resolvedFileName) {
+    const packageName = getPackageNameFromFilePath(resolvedFileName);
+    const specifierPackageName = getPackageNameFromModuleSpecifier(specifier);
+    if (!specifierPackageName || specifierPackageName === packageName)
+        return packageName;
+    let dir = dirname(containingFile);
+    while (true) {
+        const packageRoot = getInstalledPackageRoot(join(dir, 'node_modules', specifierPackageName));
+        if (packageRoot) {
+            const isResolvedInstall = resolvedFileName === packageRoot || resolvedFileName.startsWith(`${packageRoot}/`);
+            return isResolvedInstall ? specifierPackageName : packageName;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return packageName;
+        dir = parent;
+    }
 }
 function compilePathMappings(scopedPaths) {
     if (!scopedPaths)
@@ -90,8 +162,9 @@ export function createGlobAliasResolver(scopedPaths) {
         return resolved;
     };
 }
-export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, findWorkspaceManifestImports, tsConfigFile) {
+export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, findWorkspacePackageTarget, tsConfigFile) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
+    const moduleExtensions = new Set([...DEFAULT_EXTENSIONS, ...customCompilerExtensions, '.json', '.jsonc']);
     const hasCustomExts = customCompilerExtensionsSet.size > 0;
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions, ...DTS_EXTENSIONS, '.json', '.jsonc'];
     const resolveSync = hasCustomExts || tsConfigFile ? _createSyncModuleResolver(extensions, tsConfigFile) : _resolveModuleSync;
@@ -103,11 +176,15 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
         }
         return resolvedFileName;
     }
-    function toResult(resolvedFileName) {
+    function toResult(specifier, containingFile, resolvedFileName) {
         const mapped = toSourcePath(resolvedFileName);
+        const isExternalLibraryImport = mapped === resolvedFileName && isInNodeModules(resolvedFileName);
         return {
             resolvedFileName: mapped,
-            isExternalLibraryImport: mapped === resolvedFileName && isInNodeModules(resolvedFileName),
+            isExternalLibraryImport,
+            packageName: isExternalLibraryImport
+                ? getAttributedPackageName(specifier, containingFile, resolvedFileName)
+                : undefined,
         };
     }
     const cache = new Map();
@@ -133,7 +210,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
             return undefined;
         const resolvedFileName = resolveSync(specifier, containingFile);
         if (resolvedFileName)
-            return toResult(resolvedFileName);
+            return toResult(specifier, containingFile, resolvedFileName);
         if (pathMappings) {
             const dir = dirname(containingFile);
             for (const { prefix, wildcard, values, scope } of pathMappings) {
@@ -146,7 +223,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                         const mapped = starIdx >= 0 ? value.slice(0, starIdx) + captured + value.slice(starIdx + 1) : value;
                         const resolved = resolveSync(mapped, containingFile);
                         if (resolved)
-                            return toResult(resolved);
+                            return toResult(specifier, containingFile, resolved);
                     }
                 }
             }
@@ -165,21 +242,23 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                             continue;
                         const resolved = resolveSync(join(targetRoot, relPath, specifier), containingFile);
                         if (resolved)
-                            return toResult(resolved);
+                            return toResult(specifier, containingFile, resolved);
                     }
                 }
             }
         }
-        if (specifier.startsWith('#') && findWorkspaceManifestImports) {
-            const ws = findWorkspaceManifestImports(containingFile);
-            if (ws) {
-                const target = pickStringTarget(ws.imports[specifier]);
-                if (target?.startsWith('.')) {
-                    const sourcePath = toSourceFilePath(join(ws.dir, target));
-                    if (sourcePath)
-                        return toResult(sourcePath);
-                }
+        const workspaceTarget = findWorkspacePackageTarget?.(specifier, containingFile);
+        if (workspaceTarget) {
+            const target = expandPackageTarget(pickStringTarget(workspaceTarget.target), workspaceTarget.patternMatch);
+            if (target) {
+                const targetPath = toPackagePath(workspaceTarget.dir, target);
+                const sourcePath = targetPath && toSourceFilePath(targetPath);
+                if (sourcePath)
+                    return toResult(specifier, containingFile, sourcePath);
             }
+            const existingTarget = pickExistingPackageTarget(workspaceTarget.target, workspaceTarget.dir, workspaceTarget.patternMatch, moduleExtensions);
+            if (existingTarget)
+                return toResult(specifier, containingFile, existingTarget);
         }
         const candidate = isAbsolute(specifier) ? specifier : join(dirname(containingFile), specifier);
         if (existsSync(candidate)) {

package/dist/typescript/visitors/walk.d.ts

@@ -50,6 +50,7 @@ export interface WalkState extends WalkContext {
     filePath: string;
     sourceText: string;
     isJS: boolean;
+    isModuleFile: boolean;
     handledImportExpressions: Set<number>;
     bareExprRefs: Set<string>;
     accessedAliases: Set<string>;
@@ -88,6 +89,6 @@ export interface WalkState extends WalkContext {
 }
 export declare const isShadowed: (name: string, pos: number) => boolean;
 export declare function buildVisitor(pluginVisitorObjects: PluginVisitorObject[], includeLocalRefs?: boolean): Visitor;
-declare function walkAST(program: Program, sourceText: string, filePath: string, ctx: WalkContext): Set<string> | undefined;
+declare function walkAST(program: Program, sourceText: string, filePath: string, hasModuleSyntax: boolean, ctx: WalkContext): Set<string> | undefined;
 export declare const _walkAST: typeof walkAST;
 export {};

package/dist/typescript/visitors/walk.js

@@ -211,7 +211,7 @@ const coreVisitorObject = {
     },
     TSModuleDeclaration(node) {
         state.nsRanges.push([node.start, node.end]);
-        if (node.kind !== 'global' && isStringLiteral(node.id)) {
+        if (node.kind !== 'global' && state.isModuleFile && isStringLiteral(node.id)) {
             const specifier = getStringValue(node.id);
             for (const name of collectAugmentationRefs(node))
                 state.addImport(specifier, name, undefined, undefined, node.id.start, IMPORT_FLAGS.TYPE_ONLY | IMPORT_FLAGS.AUGMENT);
@@ -704,13 +704,24 @@ export function buildVisitor(pluginVisitorObjects, includeLocalRefs) {
     }
     return new Visitor(merged);
 }
-function walkAST(program, sourceText, filePath, ctx) {
+const isExternalModule = (program, hasModuleSyntax) => {
+    if (hasModuleSyntax)
+        return true;
+    for (const node of program.body) {
+        if (node.type === 'TSImportEqualsDeclaration' && node.moduleReference.type === 'TSExternalModuleReference') {
+            return true;
+        }
+    }
+    return false;
+};
+function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
     const isJS = filePath.endsWith('.js') || filePath.endsWith('.mjs') || filePath.endsWith('.cjs') || filePath.endsWith('.jsx');
     state = {
         ...ctx,
         filePath,
         sourceText,
         isJS,
+        isModuleFile: isExternalModule(program, hasModuleSyntax),
         handledImportExpressions: new Set(),
         bareExprRefs: new Set(),
         accessedAliases: new Set(),

package/dist/util/create-input-handler.js

@@ -55,7 +55,14 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         const isWorkspace = chief.workspacesByPkgName.has(packageName);
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         if (inputWorkspace) {
-            const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName, isConfig(input), input.isTypeOnly);
+            let isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName, isConfig(input), input.isTypeOnly);
+            if (input.isTypeOnly && input.containingFilePath) {
+                const owningWorkspace = chief.findWorkspaceByFilePath(input.containingFilePath);
+                if (owningWorkspace && owningWorkspace !== inputWorkspace) {
+                    const isOwnerHandled = deputy.maybeAddReferencedExternalDependency(owningWorkspace, packageName, isConfig(input), input.isTypeOnly);
+                    isHandled = isHandled || isOwnerHandled;
+                }
+            }
             if (externalRefs && !isWorkspace) {
                 addExternalRef(externalRefs, containingFilePath, { specifier: packageName, identifier: undefined });
             }

package/dist/util/create-options.d.ts

@@ -745,6 +745,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        temporal?: 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;
@@ -1653,6 +1658,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            temporal?: 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/util/package-json.d.ts

@@ -5,6 +5,13 @@ interface ExtendedPackageJson extends PackageJson {
     [INDENT]?: string;
     [NEWLINE]?: string;
 }
+export declare const getPackageMapTarget: (map: unknown, key: string) => {
+    target: any;
+    patternMatch?: undefined;
+} | {
+    target: unknown;
+    patternMatch: string;
+} | undefined;
 export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
 export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
 export declare const getEntrySpecifiersFromManifest: (manifest: PackageJson) => Set<string>;