@adamhl8/configs 0.17.0 → 0.17.1

package/dist/configs/tsdown.d.ts

@@ -8,6 +8,7 @@ import * as hookable0 from "hookable";
 //#region src/configs/tsdown.d.ts
 declare const tsdownConfig: MergeConfigFn<{
   entry?: rolldown0.InputOption;
+  exports?: boolean | tsdown0.ExportsOptions;
   external?: rolldown0.ExternalOption;
   noExternal?: (string | RegExp | (string | RegExp)[]) | ((id: string, importer: string | undefined) => boolean | null | undefined | void);
   skipNodeModulesBundle?: boolean;
@@ -58,7 +59,6 @@ declare const tsdownConfig: MergeConfigFn<{
   attw?: boolean | tsdown0.AttwOptions;
   report?: boolean | tsdown0.ReportOptions;
   globImport?: boolean;
-  exports?: boolean | tsdown0.ExportsOptions;
   publicDir?: tsdown0.CopyOptions | tsdown0.CopyOptionsFn;
   copy?: tsdown0.CopyOptions | tsdown0.CopyOptionsFn;
   hooks?: Partial<tsdown0.TsdownHooks> | ((hooks: hookable0.Hookable<tsdown0.TsdownHooks>) => void | Promise<void>);

package/dist/configs/tsdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tsdown.d.ts","names":[],"sources":["../../src/configs/tsdown.ts"],"sourcesContent":[],"mappings":";;;;;;;;cAyCa;UAAyF,SAAA,CAAA;;;;;;;EAAzF,GAAA,CAAA,QAAA,CAAA,MAAyF,EAAA,GAAA,CAAA;EAAA,MAAA,CAAA,QAAA,CAAA,MAAA,EAAA,MAAA,CAAA;OAAA,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA7E,SAAA,MAAA,EAAA,KAAA;EACZ,SAAA,QAAA,EAAwF,SAAA;EAAA,SAAA,MAAA,EAAA,UAAA;WAAA,SAAzE,EAAA,IAAA;WAAA,IAAA,EAAA,KAAA;WAAA,GAAA,EAAA;IAAA,SAAA,UAAA,EAAA,IAAA;;;;;;;;;;cAAf,iBAAe,sBAAA,KAAyE,OAAA,CAAzE,OAAA"}
+{"version":3,"file":"tsdown.d.ts","names":[],"sources":["../../src/configs/tsdown.ts"],"sourcesContent":[],"mappings":";;;;;;;;cAyCa;UAAyF,SAAA,CAAA;;;;;;;EAAzF,MAAA,CAAA,EAAA,MAAyF,GAAA,MAAA,EAAA,GAAA,KAAA;EAAA,GAAA,CAAA,QAAA,CAAA,MAAA,EAAA,GAAA,CAAA;QAAA,CAAA,QAAA,CAAA,MAAA,EAAA,MAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA7E,SAAA,MAAA,EAAA,KAAA;EACZ,SAAA,QAAA,EAAwF,SAAA;EAAA,SAAA,MAAA,EAAA,UAAA;WAAA,SAAzE,EAAA,IAAA;WAAA,IAAA,EAAA,KAAA;WAAA,GAAA,EAAA;IAAA,SAAA,UAAA,EAAA,IAAA;;;;;;;;;;cAAf,iBAAe,sBAAA,KAAyE,OAAA,CAAzE,OAAA"}

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,61 @@ 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);
+	for (const [alias, aliasDir] of Object.entries(pathsMap)) {
+		if (!importPath.startsWith(alias)) 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"));
+function getNewExtensionPathParts(importParts) {
+	const tsExtensionLookups = [
+		"",
+		".js",
+		".jsx",
+		".ts",
+		".tsx"
+	];
+	const allowedExtensions = [
+		".ts",
+		".tsx",
+		".d.ts"
+	];
+	if (!tsExtensionLookups.includes(importParts.ext)) return {
+		ext: importParts.ext,
+		base: importParts.base
+	};
+	if (tsExtensionLookups.includes(importParts.ext)) for (const allowedExtension of allowedExtensions) {
+		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 +124,34 @@ 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 importErrorsForFile.push(`skipped extension transform of '${importPath}': target file not found`);
 				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.1",
   "type": "module",
   "repository": {
     "type": "git",