dependency-cruiser 18.6.0 → 18.8.0-beta-1

package/configs/rules/no-duplicate-dependency-types.cjs

@@ -2,7 +2,7 @@ module.exports = {
 	name: "no-duplicate-dep-types",
 	comment:
 		"Likely this module depends on an external ('npm') package that occurs more " +
-		"than once in your package.json i.e. bot as a devDependencies and in dependencies. " +
+		"than once in your package.json i.e. both as a devDependencies and in dependencies. " +
 		"This will cause maintenance problems later on. If it's intentional, you can " +
 		"disable this rule by adding this override as a rule in the 'forbidden' section " +
 		"of your dependency-cruiser configuration: " +

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dependency-cruiser",
-	"version": "18.6.0",
+	"version": "18.8.0-beta-1",
 	"description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
 	"keywords": [
 		"static analysis",

package/src/analyze/summarize/index.mjs

@@ -1,4 +1,3 @@
-import { EOL } from "node:os";
 import addRuleSetUsed from "./add-rule-set-used.mjs";
 import summarizeModules from "./summarize-modules.mjs";
 import summarizeFolders from "./summarize-folders.mjs";
@@ -11,6 +10,7 @@ import {
 } from "./get-stats.mjs";
 import { compareViolations } from "#graph-utl/compare.mjs";
 import { getEnvironmentInfo } from "#environment.mjs";
+import { determineEnvironmentIssues } from "./verify-environment.mjs";
 
 /**
  * @import { IOptions, IEnvironmentIssue, ISummary, IModule, IFolder } from "../../../types/cruise-result.mjs"
@@ -18,107 +18,6 @@ import { getEnvironmentInfo } from "#environment.mjs";
  * @import { IStrictCruiseOptions } from "../../../types/strict-options.mjs"
  */
 
-/**
- * @param { IOptions } pOptions
- * @param { IAvailableTranspiler[] } pAvailableTranspilers
- * @returns { boolean }
- */
-function swcIsConsistent(pOptions, pAvailableTranspilers) {
-	const lSWCNeeded = (pOptions?.parser ?? "acorn") === "swc";
-	return lSWCNeeded
-		? pAvailableTranspilers.some(
-				(pTranspiler) => pTranspiler.name === "swc" && pTranspiler.available,
-			)
-		: true;
-}
-
-/**
- * @param { IOptions } pOptions
- * @param { IAvailableTranspiler[] } pAvailableTranspilers
- * @returns { boolean }
- */
-function typescriptIsConsistent(pOptions, pAvailableTranspilers) {
-	const lTypeScriptNeeded =
-		Boolean(pOptions?.tsConfig) ||
-		Boolean(pOptions?.tsPreCompilationDeps) ||
-		Boolean(pOptions?.detectJSDocImports) ||
-		(pOptions?.parser ?? "acorn") === "tsc";
-	return lTypeScriptNeeded
-		? pAvailableTranspilers.some(
-				(pTranspiler) =>
-					pTranspiler.name === "typescript" && pTranspiler.available,
-			)
-		: true;
-}
-/**
- * @param { IOptions } pOptions
- * @param { IAvailableTranspiler[] } pAvailableTranspilers
- * @returns { boolean }
- */
-function babelIsConsistent(pOptions, pAvailableTranspilers) {
-	return Boolean(pOptions?.babelConfig)
-		? pAvailableTranspilers.some(
-				(pTranspiler) => pTranspiler.name === "babel" && pTranspiler.available,
-			)
-		: true;
-}
-
-/**
- * @param {IOptions} pOptions
- * @param {IAvailableTranspiler[]} pAvailableTranspilers
- * @returns {{issues?: IEnvironmentIssue[]}}
- */
-function determineEnvironmentIssues(pOptions, pAvailableTranspilers) {
-	const lIssues = [];
-	if (!typescriptIsConsistent(pOptions, pAvailableTranspilers)) {
-		const tsTranspiler = pAvailableTranspilers.find(
-			(pTranspiler) => pTranspiler.name === "typescript",
-		);
-
-		lIssues.push({
-			severity: "warn",
-			name: "missing-typescript-transpiler",
-			description:
-				`dependency-cruiser detected a TypeScript environment,${EOL}` +
-				`    but not a compatible TypeScript compiler (${tsTranspiler.name}: ${tsTranspiler.version}). This means${EOL}` +
-				`    it's likely to have missed TypeScript sources and dependencies.${EOL}${EOL}` +
-				`    Install typescript to get better results (e.g. npm i -D typescript@^6).${EOL}${EOL}` +
-				`    => Support for typescript@>=7 will follow when its API is published and stable.${EOL}`,
-		});
-	}
-	if (!swcIsConsistent(pOptions, pAvailableTranspilers)) {
-		const swcTranspiler = pAvailableTranspilers.find(
-			(pTranspiler) => pTranspiler.name === "swc",
-		);
-
-		lIssues.push({
-			severity: "warn",
-			name: "missing-swc-transpiler",
-			description:
-				`dependency-cruiser found swc configured as parser, but ${EOL}` +
-				`    it did not find a compatible version of swc (${swcTranspiler.name}: ${swcTranspiler.version}).${EOL}` +
-				`    dependency-cruiser might have missed some sources or dependencies.${EOL}${EOL}` +
-				`    Install swc (e.g. npm i -D @swc/core) to get better results.${EOL}`,
-		});
-	}
-	if (!babelIsConsistent(pOptions, pAvailableTranspilers)) {
-		const babelTranspiler = pAvailableTranspilers.find(
-			(pTranspiler) => pTranspiler.name === "babel",
-		);
-
-		lIssues.push({
-			severity: "warn",
-			name: "missing-babel-transpiler",
-			description:
-				`dependency-cruiser detected a babel configuration, but not a${EOL}` +
-				`    compatible babel transpiler (${babelTranspiler.name}: ${babelTranspiler.version}). If you indeed use babel,${EOL}` +
-				`    dependency-cruiser might have missed some sources or dependencies.${EOL}${EOL}` +
-				`    Install babel (e.g. npm i -D @babel/core@^7) to get better results.${EOL}`,
-		});
-	}
-	return lIssues.length > 0 ? { issues: lIssues } : {};
-}
-
 function getAdvisedExitCode(
 	pErrorCount,
 	pBaselineStaleCount,

package/src/analyze/summarize/verify-environment.mjs

@@ -0,0 +1,146 @@
+import { EOL } from "node:os";
+/**
+ * @import { IOptions, IEnvironmentIssue } from "../../../types/cruise-result.mjs"
+ * @import { IAvailableTranspiler } from "../../../types/environment.mjs"
+ */
+
+/**
+ * @param { IOptions } pOptions
+ * @param { IAvailableTranspiler[] } pAvailableTranspilers
+ * @returns { boolean }
+ */
+function swcIsConsistent(pOptions, pAvailableTranspilers) {
+	const lSWCNeeded = (pOptions?.parser ?? "acorn") === "swc";
+	return lSWCNeeded
+		? pAvailableTranspilers.some(
+				(pTranspiler) => pTranspiler.name === "swc" && pTranspiler.available,
+			)
+		: true;
+}
+
+/**
+ * @param { IOptions } pOptions
+ * @param { IAvailableTranspiler[] } pAvailableTranspilers
+ * @returns { boolean }
+ */
+function tscIsConsistent(pOptions, pAvailableTranspilers) {
+	const lTSCNeeded =
+		Boolean(pOptions?.tsPreCompilationDeps) ||
+		Boolean(pOptions?.detectJSDocImports) ||
+		(pOptions?.parser ?? "acorn") === "tsc";
+	return lTSCNeeded
+		? pAvailableTranspilers.some(
+				(pTranspiler) =>
+					pTranspiler.name === "typescript" && pTranspiler.available,
+			)
+		: true;
+}
+
+function typeScriptIsConsistent(pOptions, pAvailableTranspilers) {
+	const lTypeScriptNeeded =
+		Boolean(pOptions?.tsConfig) &&
+		!(
+			// these two options require tsc (covered in tscIsConsistent), so
+			// to prevent typeScriptIsConsistent from also firing (and printing
+			// two messages) we exclude them here
+			Boolean(pOptions?.tsPreCompilationDeps) ||
+			Boolean(pOptions?.detectJSDocImports)
+		);
+	return lTypeScriptNeeded
+		? pAvailableTranspilers.some(
+				(pTranspiler) =>
+					(pTranspiler.name === "typescript" ||
+						(pTranspiler.name === "swc" && pOptions?.parser === "swc")) &&
+					pTranspiler.available,
+			)
+		: true;
+}
+
+/**
+ * @param { IOptions } pOptions
+ * @param { IAvailableTranspiler[] } pAvailableTranspilers
+ * @returns { boolean }
+ */
+function babelIsConsistent(pOptions, pAvailableTranspilers) {
+	return Boolean(pOptions?.babelConfig)
+		? pAvailableTranspilers.some(
+				(pTranspiler) => pTranspiler.name === "babel" && pTranspiler.available,
+			)
+		: true;
+}
+
+/**
+ * @param {IOptions} pOptions
+ * @param {IAvailableTranspiler[]} pAvailableTranspilers
+ * @returns {{issues?: IEnvironmentIssue[]}}
+ */
+export function determineEnvironmentIssues(pOptions, pAvailableTranspilers) {
+	const lIssues = [];
+	if (!tscIsConsistent(pOptions, pAvailableTranspilers)) {
+		const tsTranspiler = pAvailableTranspilers.find(
+			(pTranspiler) => pTranspiler.name === "typescript",
+		);
+
+		lIssues.push({
+			severity: "warn",
+			name: "missing-tsc-transpiler",
+			description:
+				`dependency-cruiser detected a TypeScript environment,${EOL}` +
+				`    but not a compatible TypeScript compiler (${tsTranspiler.name}: ${tsTranspiler.version}). This means${EOL}` +
+				`    it's likely to have missed TypeScript sources and dependencies.${EOL}${EOL}` +
+				`    Install typescript to get better results (e.g. npm i -D typescript@^6 or typescript@^7.1).${EOL}${EOL}` +
+				`    => typescript@7.0 is not supported as its API lacks what dependency-cruiser needs.${EOL}`,
+		});
+	}
+	if (!typeScriptIsConsistent(pOptions, pAvailableTranspilers)) {
+		const tsTranspilersString = pAvailableTranspilers
+			.filter(
+				(pTranspiler) =>
+					pTranspiler.name === "typescript" || pTranspiler.name === "swc",
+			)
+			.map((pTranspiler) => `${pTranspiler.name}: ${pTranspiler.version}`)
+			.join(", ");
+		lIssues.push({
+			severity: "warn",
+			name: "missing-typescript-transpiler",
+			description:
+				`dependency-cruiser detected an environment that needs a TypeScript compiler of some sort,${EOL}` +
+				`    but did not find one of the supported ones (${tsTranspilersString}).${EOL}` +
+				`    This means it's likely to have missed TypeScript sources and dependencies.${EOL}${EOL}` +
+				`    Install one of the above for better results.${EOL}${EOL}` +
+				`    => if you choose to use swc don't forget to set the "parser" option to "swc"${EOL}` +
+				`    => typescript@7.0 is not supported as its API lacks what dependency-cruiser needs.${EOL}`,
+		});
+	}
+	if (!swcIsConsistent(pOptions, pAvailableTranspilers)) {
+		const swcTranspiler = pAvailableTranspilers.find(
+			(pTranspiler) => pTranspiler.name === "swc",
+		);
+
+		lIssues.push({
+			severity: "warn",
+			name: "missing-swc-transpiler",
+			description:
+				`dependency-cruiser found swc configured as compiler, but ${EOL}` +
+				`    it did not find a compatible version of swc (${swcTranspiler.name}: ${swcTranspiler.version}).${EOL}` +
+				`    dependency-cruiser might have missed some sources or dependencies.${EOL}${EOL}` +
+				`    Install swc (e.g. npm i -D @swc/core) to get better results.${EOL}`,
+		});
+	}
+	if (!babelIsConsistent(pOptions, pAvailableTranspilers)) {
+		const babelTranspiler = pAvailableTranspilers.find(
+			(pTranspiler) => pTranspiler.name === "babel",
+		);
+
+		lIssues.push({
+			severity: "warn",
+			name: "missing-babel-transpiler",
+			description:
+				`dependency-cruiser detected a babel configuration, but not a${EOL}` +
+				`    compatible babel transpiler (${babelTranspiler.name}: ${babelTranspiler.version}). If you indeed use babel,${EOL}` +
+				`    dependency-cruiser might have missed some sources or dependencies.${EOL}${EOL}` +
+				`    Install babel (e.g. npm i -D @babel/core@^7) to get better results.${EOL}`,
+		});
+	}
+	return lIssues.length > 0 ? { issues: lIssues } : {};
+}

package/src/cli/init-config/config-template.mjs

@@ -112,7 +112,7 @@ module.exports = {
       name: 'no-duplicate-dep-types',
       comment:
         "Likely this module depends on an external ('npm') package that occurs more than once " +
-        "in your package.json i.e. bot as a devDependencies and in dependencies. This will cause " +
+        "in your package.json i.e. both as a devDependencies and in dependencies. This will cause " +
         "maintenance problems later on.",
       severity: 'warn',
       from: {},

package/src/config-utl/extract-ts-config.mjs

@@ -1,31 +1,4 @@
-import { dirname, resolve } from "node:path";
-import tryImport from "#utl/try-import.mjs";
-import meta from "#meta.cjs";
-
-const typescript = await tryImport(
-	"typescript",
-	meta.supportedTranspilers.typescript,
-);
-
-const FORMAT_DIAGNOSTICS_HOST = {
-	getCanonicalFileName(pFileName) {
-		let lReturnValue = pFileName.toLowerCase();
-
-		// depends on the platform which branch is taken, hence the c8 ignore
-		/* c8 ignore start */
-		if (typescript?.sys?.useCaseSensitiveFileNames ?? false) {
-			lReturnValue = pFileName;
-		}
-		/* c8 ignore stop */
-		return lReturnValue;
-	},
-	getCurrentDirectory() {
-		return process.cwd();
-	},
-	getNewLine() {
-		return "\n";
-	},
-};
+import typescript from "#utl/typescript-facade.mjs";
 
 /**
  * Reads the file with name `pTSConfigFileName` and returns its parsed
@@ -42,31 +15,18 @@ export default function extractTSConfig(pTSConfigFileName) {
 	let lReturnValue = {};
 
 	if (typescript) {
-		const lConfig = typescript.readConfigFile(
-			pTSConfigFileName,
-			typescript.sys.readFile,
-		);
+		const lConfig = typescript.readConfigFile(pTSConfigFileName);
 
 		if (typeof lConfig.error !== "undefined") {
-			throw new TypeError(
-				typescript.formatDiagnostics([lConfig.error], FORMAT_DIAGNOSTICS_HOST),
-			);
+			throw new TypeError(typescript.formatDiagnostics([lConfig.error]));
 		}
 		lReturnValue = typescript.parseJsonConfigFileContent(
 			lConfig.config,
-			typescript.sys,
-			dirname(resolve(pTSConfigFileName)),
-			{},
 			pTSConfigFileName,
 		);
 
 		if (lReturnValue.errors.length > 0) {
-			throw new Error(
-				typescript.formatDiagnostics(
-					lReturnValue.errors,
-					FORMAT_DIAGNOSTICS_HOST,
-				),
-			);
+			throw new Error(typescript.formatDiagnostics(lReturnValue.errors));
 		}
 	}
 

package/src/extract/resolve/determine-dependency-types.mjs

@@ -22,7 +22,9 @@ function dependencyKeyHasModuleName(
 	pPrefix,
 ) {
 	return (pKey) =>
-		pKey.includes("ependencies") &&
+		// dependencies, devDependencies, peerDependencies, optionalDependencies, bundleDependencies, bundledDependencies.
+		// But not peerDependenciesMeta. Or dependenciesIDoNotWantToTalkabout.
+		pKey.endsWith("ependencies") &&
 		Object.hasOwn(pPackageDependencies[pKey], join(pPrefix, pModuleName));
 }
 

package/src/extract/swc/dependency-visitor.mjs

@@ -123,7 +123,7 @@ function nodeIsTypeOnly(pNode) {
 		return true;
 	}
 	return (
-		pNode?.specifiers.length > 0 &&
+		pNode?.specifiers?.length > 0 &&
 		pNode.specifiers.every((pSpecifier) => pSpecifier.isTypeOnly)
 	);
 }
@@ -144,7 +144,9 @@ export default Visitor
 						module: pNode.source.value,
 						moduleSystem: "es6",
 						exoticallyRequired: false,
-						dependencyTypes: ["export"],
+						dependencyTypes: nodeIsTypeOnly(pNode)
+							? ["export", "type-only"]
+							: ["export"],
 					});
 				}
 			}

package/src/extract/transpile/meta.mjs

@@ -55,10 +55,9 @@ const TRANSPILER2AVAILABLE = {
 		meta.supportedTranspilers.svelte,
 	),
 	swc: tryImportAvailable("@swc/core", meta.supportedTranspilers.swc),
-	typescript: tryImportAvailable(
-		"typescript",
-		meta.supportedTranspilers.typescript,
-	),
+	// not tryImportAvailable as for typescript >=7 being installed isn't
+	// enough - the native compiler needs to be able to run as well
+	typescript: typescriptWrap.isAvailable(),
 	"vue-template-compiler": tryImportAvailable(
 		"vue-template-compiler",
 		meta.supportedTranspilers["vue-template-compiler"],
@@ -109,7 +108,19 @@ export const EXTENSION2AVAILABLE = new Map([
 ]);
 
 const EXTENSIONS_PER_PARSER = {
-	swc: new Set([".js", ".cjs", ".mjs", ".jsx", ".ts", ".tsx", ".d.ts"]),
+	swc: new Set([
+		".js",
+		".cjs",
+		".mjs",
+		".jsx",
+		".ts",
+		".tsx",
+		".d.ts",
+		".cts",
+		".d.cts",
+		".mts",
+		".d.mts",
+	]),
 	// tsc: [".js", ".cjs", ".mjs", ".jsx", ".ts", ".tsx", ".d.ts"],
 	// acorn: [".js", ".cjs", ".mjs", ".jsx"],
 };

package/src/extract/transpile/typescript-wrap.mjs

@@ -1,32 +1,26 @@
-import tryImport from "#utl/try-import.mjs";
-import meta from "#meta.cjs";
-
-const typescript = await tryImport(
-	"typescript",
-	meta.supportedTranspilers.typescript,
-);
+import typescript from "#utl/typescript-facade.mjs";
 
 function getCompilerOptions(pFlavor, pTSConfig) {
 	const lCompilerOptions = {};
 
 	if (pFlavor === "tsx") {
-		lCompilerOptions.jsx = "react";
+		lCompilerOptions.jsx = typescript.JsxEmit.React;
 	}
 
 	if (pFlavor === "esm") {
 		// see https://www.typescriptlang.org/docs/handbook/esm-node.html
-		lCompilerOptions.module = "nodenext";
+		lCompilerOptions.module = typescript.ModuleKind.NodeNext;
 		// when we're doing something with esm (so cts, mts extensions) we can
 		// assume TypeScript >=4.7 - which supports target es2022 - which should
 		// be easier (and hence we assume faster) to transpile
-		lCompilerOptions.target = "es2022";
+		lCompilerOptions.target = typescript.ScriptTarget.ES2022;
 	}
 
 	return {
 		// target: "es2022" should also be OK - but we don't know which version of
 		// the TypeScript compiler we're using, so for we keep this for backwards
 		// compatibility.
-		target: "es2015",
+		target: typescript.ScriptTarget.ES2015,
 		...lCompilerOptions,
 		...(pTSConfig?.options ?? {}),
 	};

package/src/extract/tsc/extract-typescript-deps.mjs

@@ -2,19 +2,12 @@
 /* eslint-disable unicorn/prevent-abbreviations */
 /* eslint-disable max-lines */
 /* eslint-disable no-inline-comments */
-import tryImport from "#utl/try-import.mjs";
-import meta from "#meta.cjs";
+import typescript from "#utl/typescript-facade.mjs";
 
 /**
- * @import typescript, {Node} from "typescript"
+ * @import {Node} from "typescript"
  */
 
-/** @type {typescript} */
-const typescript = await tryImport(
-	"typescript",
-	meta.supportedTranspilers.typescript,
-);
-
 const INTERESTING_NODE_KINDS = typescript
 	? new Set([
 			typescript.SyntaxKind.CallExpression,
@@ -86,11 +79,17 @@ function getModuleBlock(pStatement) {
 }
 
 function getStatements(pAST, pDetectImportsInAmbientModules) {
+	// in javascript the native compiler adds statements it derived from jsdoc
+	// (e.g. from @import tags). Those are handled with the rest of the jsdoc.
+	const lStatements = (pAST.statements ?? []).filter(
+		(pStatement) => !typescript.isReparsed(pStatement),
+	);
+
 	if (!pDetectImportsInAmbientModules) {
-		return pAST.statements ?? [];
+		return lStatements;
 	}
 
-	return (pAST.statements ?? []).flatMap((pStatement) => {
+	return lStatements.flatMap((pStatement) => {
 		const lModuleBlock = getModuleBlock(pStatement);
 
 		return lModuleBlock
@@ -208,7 +207,9 @@ function extractTripleSlashDirectives(pAST) {
 			})),
 		)
 		.concat(
-			pAST.amdDependencies.map((pReference) => ({
+			// the native compiler doesn't support amd anymore, so it doesn't
+			// deliver amdDependencies either
+			(pAST.amdDependencies ?? []).map((pReference) => ({
 				module: pReference.path,
 				moduleSystem: "tsd",
 				exoticallyRequired: false,
@@ -237,19 +238,11 @@ function isRequireCallExpression(pASTNode) {
 		pASTNode.kind === typescript.SyntaxKind.CallExpression &&
 		pASTNode.expression
 	) {
-		/*
-		 * from typescript 5.0.0 the `originalKeywordKind` attribute is deprecated
-		 * and from 5.2.0 it will be gone. However, in typescript < 5.0.0 (still used
-		 * heavily IRL) it's the only way to get it - hence this test for the
-		 * existence of the * identifierToKeywordKind function
-		 */
-		const lSyntaxKind = typescript.identifierToKeywordKind
-			? typescript.SyntaxKind[
-					typescript.identifierToKeywordKind(pASTNode.expression)
-				]
-			: /* c8 ignore next 1 */
-				typescript.SyntaxKind[pASTNode.expression.originalKeywordKind];
-		return lSyntaxKind === "RequireKeyword" && firstArgumentIsAString(pASTNode);
+		return (
+			pASTNode.expression.kind === typescript.SyntaxKind.Identifier &&
+			pASTNode.expression.text === "require" &&
+			firstArgumentIsAString(pASTNode)
+		);
 	}
 	return false;
 }
@@ -272,10 +265,10 @@ function isCompositeExoticRequire(pASTNode, pObjectName, pPropertyName) {
 			typescript.SyntaxKind.PropertyAccessExpression &&
 		pASTNode.expression.expression &&
 		pASTNode.expression.expression.kind === typescript.SyntaxKind.Identifier &&
-		pASTNode.expression.expression.escapedText === pObjectName &&
+		pASTNode.expression.expression.text === pObjectName &&
 		pASTNode.expression.name &&
 		pASTNode.expression.name.kind === typescript.SyntaxKind.Identifier &&
-		pASTNode.expression.name.escapedText === pPropertyName &&
+		pASTNode.expression.name.text === pPropertyName &&
 		firstArgumentIsAString(pASTNode)
 	);
 }
@@ -298,15 +291,15 @@ function isTripleCursedCompositeExoticRequire(
 		pASTNode.expression.expression.expression &&
 		pASTNode.expression.expression.expression.kind ===
 			typescript.SyntaxKind.Identifier &&
-		pASTNode.expression.expression.expression.escapedText === pObjectName1 &&
+		pASTNode.expression.expression.expression.text === pObjectName1 &&
 		// process
 		pASTNode.expression.expression.name.kind ===
 			typescript.SyntaxKind.Identifier &&
-		pASTNode.expression.expression.name.escapedText === pObjectName2 &&
+		pASTNode.expression.expression.name.text === pObjectName2 &&
 		// getBuiltinModule
 		pASTNode.expression.name &&
 		pASTNode.expression.name.kind === typescript.SyntaxKind.Identifier &&
-		pASTNode.expression.name.escapedText === pPropertyName &&
+		pASTNode.expression.name.text === pPropertyName &&
 		firstArgumentIsAString(pASTNode)
 	);
 }
@@ -344,7 +337,7 @@ function extractJSDocImportTags(pJSDocTags) {
 	return pJSDocTags
 		.filter(
 			(pTag) =>
-				pTag.tagName.escapedText === "import" &&
+				pTag.tagName.text === "import" &&
 				pTag.moduleSpecifier &&
 				pTag.moduleSpecifier.kind === typescript.SyntaxKind.StringLiteral &&
 				pTag.moduleSpecifier.text,
@@ -367,33 +360,13 @@ function isJSDocImport(pTypeNode) {
 	);
 }
 
-const IGNORABLE_JSDOC_KEYS = new Set([
-	"parent",
-	"pos",
-	"end",
-	"flags",
-	"emitNode",
-	"modifierFlagsCache",
-	"transformFlags",
-	"id",
-	"flowNode",
-	"symbol",
-	"original",
-]);
-
-export function walkJSDoc(pObject, pCollection = new Set()) {
-	if (isJSDocImport(pObject)) {
-		pCollection.add(pObject.argument.literal.text);
-	} else if (Array.isArray(pObject)) {
-		for (const lValue of pObject) {
-			walkJSDoc(lValue, pCollection);
-		}
-	} else if (typeof pObject === "object") {
-		for (const lKey in pObject) {
-			if (!IGNORABLE_JSDOC_KEYS.has(lKey) && pObject[lKey]) {
-				walkJSDoc(pObject[lKey], pCollection);
-			}
-		}
+export function walkJSDoc(pNode, pCollection = new Set()) {
+	if (isJSDocImport(pNode)) {
+		pCollection.add(pNode.argument.literal.text);
+	} else {
+		typescript.forEachChild(pNode, (pChildNode) => {
+			walkJSDoc(pChildNode, pCollection);
+		});
 	}
 }
 
@@ -408,7 +381,7 @@ function extractJSDocBracketImports(pJSDocTags) {
 	return pJSDocTags
 		.filter(
 			(pTag) =>
-				pTag.tagName.escapedText !== "import" &&
+				pTag.tagName.text !== "import" &&
 				pTag.typeExpression?.kind === typescript.SyntaxKind.FirstJSDocNode,
 		)
 		.flatMap((pTag) => getJSDocImports(pTag))
@@ -534,6 +507,14 @@ function walk(
 	pDetectProcessBuiltinModuleCalls,
 ) {
 	return (pASTNode) => {
+		// in javascript the native compiler adds nodes it derived from jsdoc
+		// (e.g. for types in @type tags). Those are handled with the rest of the
+		// jsdoc. As only the native compiler has these, the c8 ignore.
+		/* c8 ignore start */
+		if (typescript.isReparsed(pASTNode)) {
+			return;
+		}
+		/* c8 ignore stop */
 		// /** @import thing from './module' */ etc
 		// /** @type {import('module').thing}*/ etc
 		if (pDetectJSDocImports && pASTNode.jsDoc) {

package/src/extract/tsc/parse.mjs

@@ -1,14 +1,8 @@
 import { readFileSync } from "node:fs";
 import transpile from "../transpile/index.mjs";
-import tryImport from "#utl/try-import.mjs";
-import meta from "#meta.cjs";
 import getExtension from "#utl/get-extension.mjs";
+import typescript from "#utl/typescript-facade.mjs";
 
-/** @type {import('typescript')} */
-const typescript = await tryImport(
-	"typescript",
-	meta.supportedTranspilers.typescript,
-);
 /** @type {Map<string, any>} */
 const CACHE = new Map();
 
@@ -29,8 +23,6 @@ export function getASTFromSource(pFileRecord, pTranspileOptions) {
 	return typescript.createSourceFile(
 		pFileRecord.filename || "$internal-file-name",
 		lSource,
-		typescript.ScriptTarget.Latest,
-		false,
 	);
 }
 

package/src/meta.cjs

@@ -1,6 +1,6 @@
 /* generated - don't edit */
 module.exports = {
-	version: "18.6.0",
+	version: "18.8.0-beta-1",
 	engines: {
 		node: "^22||^24||>=26",
 	},
@@ -11,7 +11,7 @@ module.exports = {
 		livescript: ">=1.0.0 <2.0.0",
 		svelte: ">=3.0.0 <6.0.0",
 		swc: ">=1.0.0 <2.0.0",
-		typescript: ">=2.0.0 <7.0.0",
+		typescript: ">=2.0.0 <7.0.0||>=7.1.0 <8.0.0",
 		"vue-template-compiler": ">=2.0.0 <3.0.0",
 		"@vue/compiler-sfc": ">=3.0.0 <4.0.0",
 	},

package/src/utl/typescript-facade.mjs

@@ -0,0 +1,238 @@
+/* eslint-disable security/detect-object-injection */
+import { dirname, resolve } from "node:path";
+import tryImport from "#utl/try-import.mjs";
+import meta from "#meta.cjs";
+
+/**
+ * One interface over the two flavors of the typescript compiler
+ * - typescript <7: the compiler written in typescript, with its API
+ *   available in-process on the module itself.
+ * - typescript >=7.1: the native compiler. Its API (typescript/sync and
+ *   typescript/ast) talks to a separate process running the compiler.
+ *
+ * @typedef {object} ITypeScriptFacade
+ * @property {boolean} isNative - true when this is the native (>=7.1) compiler
+ * @property {string} version - version of the typescript compiler
+ * @property {Record<string, any>} SyntaxKind - the compiler's SyntaxKind enum
+ * @property {Record<string, any>} ScriptTarget - the compiler's ScriptTarget enum
+ * @property {Record<string, any>} ModuleKind - the compiler's ModuleKind enum
+ * @property {Record<string, any>} JsxEmit - the compiler's JsxEmit enum
+ * @property {(pNode: any, pCallback: (pNode: any) => void) => void} forEachChild -
+ *           calls pCallback for each child node of pNode
+ * @property {(pNode: any) => boolean} isReparsed - true for nodes the
+ *           compiler synthesized from something else (e.g. jsdoc in javascript)
+ * @property {(pFileName: string, pSource: string) => any} createSourceFile -
+ *           parses pSource into an AST
+ * @property {(pSource: string, pOptions?: {compilerOptions?: Record<string, any>, fileName?: string}) => {outputText: string}} transpileModule -
+ *           transpiles pSource to javascript
+ * @property {(pFileName: string) => {config?: any, error?: any}} readConfigFile -
+ *           reads the tsconfig pFileName
+ * @property {(pConfig: any, pFileName: string) => import("typescript").ParsedCommandLine} parseJsonConfigFileContent -
+ *           parses (and flattens) the tsconfig pConfig that was read from pFileName
+ * @property {(pDiagnostics: readonly any[]) => string} formatDiagnostics -
+ *           formats pDiagnostics into a human readable string
+ */
+
+const FIRST_NATIVE_MAJOR_VERSION = 7;
+
+/**
+ * @param {typeof import("typescript")} pTypeScript
+ * @returns {ITypeScriptFacade}
+ */
+function getClassicFacade(pTypeScript) {
+	const lFormatDiagnosticsHost = {
+		getCanonicalFileName(pFileName) {
+			let lReturnValue = pFileName.toLowerCase();
+
+			// depends on the platform which branch is taken, hence the c8 ignore
+			/* c8 ignore start */
+			if (pTypeScript?.sys?.useCaseSensitiveFileNames ?? false) {
+				lReturnValue = pFileName;
+			}
+			/* c8 ignore stop */
+			return lReturnValue;
+		},
+		getCurrentDirectory() {
+			return process.cwd();
+		},
+		getNewLine() {
+			return "\n";
+		},
+	};
+
+	return {
+		isNative: false,
+		version: pTypeScript.version,
+		SyntaxKind: pTypeScript.SyntaxKind,
+		ScriptTarget: pTypeScript.ScriptTarget,
+		ModuleKind: pTypeScript.ModuleKind,
+		JsxEmit: pTypeScript.JsxEmit,
+		forEachChild: (pNode, pCallback) => {
+			pTypeScript.forEachChild(pNode, pCallback);
+		},
+		isReparsed: () => false,
+		createSourceFile: (pFileName, pSource) =>
+			pTypeScript.createSourceFile(
+				pFileName,
+				pSource,
+				pTypeScript.ScriptTarget.Latest,
+				false,
+			),
+		transpileModule: (pSource, pOptions) =>
+			pTypeScript.transpileModule(pSource, pOptions),
+		readConfigFile: (pFileName) =>
+			pTypeScript.readConfigFile(pFileName, pTypeScript.sys.readFile),
+		parseJsonConfigFileContent: (pConfig, pFileName) =>
+			pTypeScript.parseJsonConfigFileContent(
+				pConfig,
+				pTypeScript.sys,
+				dirname(resolve(pFileName)),
+				{},
+				pFileName,
+			),
+		formatDiagnostics: (pDiagnostics) =>
+			pTypeScript.formatDiagnostics(pDiagnostics, lFormatDiagnosticsHost),
+	};
+}
+
+// The code below only runs with the native compiler (or without any
+// typescript compiler). The regular test (& coverage) run uses the classic
+// one, so c8 can't see this is covered by the run against the native one.
+/* c8 ignore start */
+/**
+ * The classic compiler's transpileModule accepts both names ("commonjs") and
+ * values (1) for options that are enums. The native one only takes values,
+ * so this lets its own tsconfig parser translate any names into values.
+ * Options it doesn't recognize (anymore) are left out.
+ *
+ * @param {any} pAPI - instance of the native compiler's API
+ * @returns {(pCompilerOptions?: Record<string, any>) => Record<string, any>}
+ */
+function getCompilerOptionsNormalizer(pAPI) {
+	/** @type {Map<string, Record<string, any>>} */
+	const lCache = new Map();
+
+	return (pCompilerOptions = {}) => {
+		const lStringOptions = Object.fromEntries(
+			Object.entries(pCompilerOptions).filter(
+				([, pValue]) => typeof pValue === "string",
+			),
+		);
+		const lStringOptionKeys = Object.keys(lStringOptions);
+
+		if (lStringOptionKeys.length === 0) {
+			return pCompilerOptions;
+		}
+		const lCacheKey = JSON.stringify(lStringOptions);
+
+		if (!lCache.has(lCacheKey)) {
+			lCache.set(
+				lCacheKey,
+				pAPI.parseJsonConfigFileContent(
+					{ compilerOptions: lStringOptions, files: [] },
+					{ configDirectory: process.cwd() },
+				).options,
+			);
+		}
+		const lParsedOptions = lCache.get(lCacheKey);
+
+		return Object.fromEntries(
+			Object.entries(pCompilerOptions)
+				.map(([pKey, pValue]) =>
+					lStringOptionKeys.includes(pKey)
+						? [pKey, lParsedOptions[pKey]]
+						: [pKey, pValue],
+				)
+				.filter(([, pValue]) => pValue !== undefined),
+		);
+	};
+}
+
+/**
+ * @param {{version: string}} pTypeScript
+ * @returns {Promise<ITypeScriptFacade>}
+ * @throws {Error} when the native compiler's binary isn't available (e.g.
+ *         on unsupported platforms, or when optional dependencies weren't
+ *         installed)
+ */
+async function getNativeFacade(pTypeScript) {
+	const [lSync, lAST] = await Promise.all([
+		import("typescript/sync"),
+		import("typescript/ast"),
+	]);
+	// this starts the compiler process. That process doesn't keep node from
+	// exiting and stops when node does, so there's no need to close it.
+	const lAPI = new lSync.API({ cwd: process.cwd() });
+	const normalizeCompilerOptions = getCompilerOptionsNormalizer(lAPI);
+
+	return {
+		isNative: true,
+		version: pTypeScript.version,
+		SyntaxKind: lAST.SyntaxKind,
+		ScriptTarget: lAST.ScriptTarget,
+		ModuleKind: lSync.ModuleKind,
+		JsxEmit: lSync.JsxEmit,
+		// nodes created by anything else than the native compiler (e.g. ASTs
+		// from json) don't have the forEachChild method. They're treated as
+		// having no children.
+		forEachChild: (pNode, pCallback) => {
+			pNode.forEachChild?.(pCallback);
+		},
+		isReparsed: (pNode) =>
+			// flags is a bit field
+			// oxlint-disable-next-line no-bitwise
+			((pNode.flags ?? 0) & lAST.NodeFlags.Reparsed) !== 0,
+		createSourceFile: (pFileName, pSource) => {
+			const lRetainedSourceFile = lAPI.createSourceFile(pFileName, pSource);
+			// the source file is already copied over from the compiler process,
+			// so it stays usable after releasing it there
+			lRetainedSourceFile.dispose();
+			return lRetainedSourceFile.sourceFile;
+		},
+		transpileModule: (pSource, pOptions) =>
+			lAPI.transpileModule(pSource, {
+				compilerOptions: normalizeCompilerOptions(pOptions?.compilerOptions),
+				fileName: pOptions?.fileName,
+			}),
+		// The compiler process resolves relative paths against the directory it
+		// was started in - which can differ from the current one => resolve
+		// here
+		readConfigFile: (pFileName) => lAPI.readConfigFile(resolve(pFileName)),
+		parseJsonConfigFileContent: (pConfig, pFileName) =>
+			lAPI.parseJsonConfigFileContent(pConfig, {
+				configFileName: resolve(pFileName),
+			}),
+		formatDiagnostics: (pDiagnostics) =>
+			lSync.formatDiagnostics(pDiagnostics, lAPI),
+	};
+}
+
+/**
+ * @param {any} pTypeScript - the typescript module, or false if it isn't available
+ * @returns {Promise<ITypeScriptFacade|false>}
+ */
+async function getFacade(pTypeScript) {
+	if (!pTypeScript) {
+		return false;
+	}
+	if (Number.parseInt(pTypeScript.version, 10) >= FIRST_NATIVE_MAJOR_VERSION) {
+		try {
+			return await getNativeFacade(pTypeScript);
+		} catch {
+			return false;
+		}
+	}
+	/* c8 ignore stop */
+	return getClassicFacade(pTypeScript);
+}
+
+/**
+ * The typescript compiler behind a facade that hides the differences
+ * between the classic (<7) and the native (>=7.1) compiler, or false when
+ * no supported version of the typescript compiler is available.
+ *
+ * @type {ITypeScriptFacade|false}
+ */
+export default await getFacade(
+	await tryImport("typescript", meta.supportedTranspilers.typescript),
+);

package/types/config-utl/extract-ts-config.d.mts

@@ -1,4 +1,28 @@
-import type { ParsedCommandLine } from "typescript";
+/**
+ * A tsconfig as parsed by the typescript compiler. Declared here as from
+ * typescript 7 the package's main entry point doesn't export its
+ * ParsedCommandLine type anymore.
+ */
+export interface IParsedTSConfig {
+	/**
+	 * The compiler options. Options with an enum type (target, module,
+	 * moduleResolution, jsx, ...) have the enum's (numerical) value.
+	 */
+	options: Record<string, any>;
+	/**
+	 * The (absolute) names of the files the tsconfig includes
+	 */
+	fileNames: string[];
+	/**
+	 * Errors the typescript compiler encountered parsing the tsconfig
+	 */
+	errors: any[];
+	/**
+	 * The tsconfig as read from disk
+	 */
+	raw?: any;
+	[key: string]: any;
+}
 
 /**
  * Reads the file with name `pTSConfigFileName` and returns its parsed
@@ -13,4 +37,4 @@ import type { ParsedCommandLine } from "typescript";
  */
 export default function extractTSConfig(
 	pTSConfigFileName: string,
-): ParsedCommandLine;
+): IParsedTSConfig;