@adamhl8/configs 0.17.0 → 0.17.2

package/dist/ts-import-fix/index

@@ -38,7 +38,7 @@ async function checkExports(filePaths) {
 			visit(sourceFile);
 			if (exportDeclarations.length === 0) return;
 			const exportDeclarationText = exportDeclarations.map((declaration) => declaration.getText()).join("\n");
-			EXPORT_ERRORS.push(`${pc.redBright("✗")} ${filePath}\n${pc.dim(exportDeclarationText)}\n`);
+			EXPORT_ERRORS.push(`${pc.redBright("✗")} ${pc.blue(filePath)}\n${pc.dim(exportDeclarationText)}\n`);
 		});
 		return Promise.all(filePromises);
 	});
@@ -53,34 +53,64 @@ function getPathsMap() {
 	for (let [alias, [aliasDir]] of Object.entries(tsconfig.config.compilerOptions?.paths ?? {})) {
 		if (!alias.endsWith("/*")) continue;
 		if (!aliasDir?.endsWith("/*")) continue;
-		aliasDir = aliasDir.slice(0, -2);
 		alias = alias.slice(0, -2);
+		aliasDir = aliasDir.slice(0, -2);
 		pathsMap[alias] = aliasDir;
 	}
 	return pathsMap;
 }
-function changeExtension(parsedPath, newExtension) {
+function resolveImportPath(importPath, filePath, pathsMap) {
+	const fileDir = path.dirname(filePath);
+	const sortedAliases = Object.keys(pathsMap).sort((a, b) => b.length - a.length);
+	for (const alias of sortedAliases) {
+		if (!importPath.startsWith(alias)) continue;
+		const aliasDir = pathsMap[alias];
+		if (!aliasDir) continue;
+		const relativePath = importPath.slice(alias.length + 1);
+		return path.resolve(aliasDir, relativePath);
+	}
+	return path.resolve(fileDir, importPath);
+}
+function changeExtension(importParts, newExtension) {
 	return {
-		...parsedPath,
+		...importParts,
 		ext: newExtension,
 		base: ""
 	};
 }
-function transformExtension(filePath) {
-	const pathParts = path.parse(filePath);
-	if (!(pathParts.ext === ".js" || pathParts.ext === "")) return filePath;
-	return path.format(changeExtension(pathParts, ".ts"));
+const ALLOWED_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".d.ts"
+];
+function getNewExtensionPathParts(importParts) {
+	const tsExtensionLookups = [
+		"",
+		".js",
+		".jsx",
+		".ts",
+		".tsx"
+	];
+	if (!tsExtensionLookups.includes(importParts.ext)) return {
+		ext: importParts.ext,
+		base: importParts.base
+	};
+	if (tsExtensionLookups.includes(importParts.ext)) for (const allowedExtension of ALLOWED_EXTENSIONS) {
+		const targetPathParts = changeExtension(importParts, allowedExtension);
+		const targetPath = path.format(targetPathParts);
+		if (fss.existsSync(targetPath)) return {
+			ext: targetPathParts.ext,
+			base: targetPathParts.base
+		};
+	}
 }
-function transformRelativeImport(filePath, importPath, pathsMap) {
-	const currentDir = path.dirname(filePath);
-	const absoluteImportPath = path.resolve(currentDir, importPath);
-	if (!fss.existsSync(absoluteImportPath)) return err(`skipped transform of '${importPath}': target file does not exist`, void 0);
+function getAliasPathParts(importParts, pathsMap) {
+	const importPath = path.format(importParts);
 	for (const [alias, aliasDir] of Object.entries(pathsMap)) {
-		const relativeToAliasDir = path.relative(aliasDir, absoluteImportPath);
+		const relativeToAliasDir = path.relative(aliasDir, importPath);
 		if (relativeToAliasDir.startsWith("..")) continue;
-		return `${alias}/${relativeToAliasDir}`;
+		return { dir: path.parse(`${alias}/${relativeToAliasDir}`).dir };
 	}
-	return err(`could not find alias for '${importPath}'`, void 0);
 }
 async function fixImports(filePaths, { write, importIgnoreStrings, skipAlias }) {
 	const IMPORT_ERRORS = [];
@@ -97,23 +127,37 @@ async function fixImports(filePaths, { write, importIgnoreStrings, skipAlias })
 				const isAliasImport = Object.keys(pathsMap).some((alias) => importPath.startsWith(alias));
 				if (!(isRelativeImport || isAliasImport)) return match;
 				if (importIgnoreStrings.some((ignoreString) => importPath.includes(ignoreString))) return match;
-				let newImportPath = transformExtension(importPath);
+				let newImportParts = path.parse(importPath);
+				const resolvedImportPath = resolveImportPath(importPath, filePath, pathsMap);
+				const resolvedImportParts = path.parse(resolvedImportPath);
+				const transformExtensionResult = getNewExtensionPathParts(resolvedImportParts);
+				if (transformExtensionResult) newImportParts = {
+					...newImportParts,
+					...transformExtensionResult
+				};
+				else {
+					const targetFilePath = `${path.format(changeExtension(resolvedImportParts, ""))}.{${ALLOWED_EXTENSIONS.map((ext) => ext.replace(".", "")).join()}}`;
+					importErrorsForFile.push(`skipped extension transform of '${importPath}': target file not found (looking for '${targetFilePath}')`);
+				}
 				if (isRelativeImport && !skipAlias) {
-					const transformedRelativeImport = transformRelativeImport(filePath, newImportPath, pathsMap);
-					if (isErr(transformedRelativeImport)) importErrorsForFile.push(transformedRelativeImport.messageChain);
-					else newImportPath = transformedRelativeImport;
+					const transformToAliasImportResult = getAliasPathParts(resolvedImportParts, pathsMap);
+					if (transformToAliasImportResult) newImportParts = {
+						...newImportParts,
+						...transformToAliasImportResult
+					};
+					else importErrorsForFile.push(`skipped transforming relative import path '${importPath}': could not find appropriate alias`);
 				}
+				const newImportPath = path.format(newImportParts);
 				if (newImportPath === importPath) return match;
 				const { ext: originalExt } = path.parse(importPath);
-				const newPathParts = path.parse(newImportPath);
-				const { ext: newExt } = newPathParts;
+				const { ext: newExt } = newImportParts;
 				let newImportPathString = newImportPath;
-				if (newExt !== originalExt) newImportPathString = `${path.format(changeExtension(newPathParts, ""))}${pc.greenBright(newExt)}`;
+				if (newExt !== originalExt) newImportPathString = `${path.format(changeExtension(newImportParts, ""))}${pc.greenBright(newExt)}`;
 				transformedImportsForFile.push(`'${importPath}' -> '${newImportPathString}'`);
 				return match.replace(importPath, newImportPath);
 			});
-			if (importErrorsForFile.length > 0) IMPORT_ERRORS.push(`${pc.redBright("✗")} ${filePath}\n${importErrorsForFile.join("\n")}\n`);
-			if (transformedImportsForFile.length > 0) TRANSFORMED_IMPORTS.push(`${pc.greenBright("✓")} ${filePath}\n${transformedImportsForFile.join("\n")}\n`);
+			if (importErrorsForFile.length > 0) IMPORT_ERRORS.push(`${pc.redBright("✗")} ${pc.blue(filePath)}\n${importErrorsForFile.join("\n")}\n`);
+			if (transformedImportsForFile.length > 0) TRANSFORMED_IMPORTS.push(`${pc.greenBright("✓")} ${pc.blue(filePath)}\n${transformedImportsForFile.join("\n")}\n`);
 			if (transformedContent === content) return;
 			if (write) await fs.writeFile(filePath, transformedContent);
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adamhl8/configs",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "type": "module",
   "repository": {
     "type": "git",