autosnippet 1.1.15 → 1.1.17

package/bin/asnip.js

@@ -176,10 +176,17 @@ commander
 commander
 	.command('i')
 	.description('add the shared Snippet to the Xcode environment')
-	.action(() => {
-		getSpecFile(function (specFile) {
-			install.addCodeSnippets(specFile);
-		});
+	.action(async () => {
+		// ✅ 使用异步版本查找配置文件
+		const specFile = await findPath.findASSpecPathAsync(CMD_PATH);
+		if (!specFile) {
+			console.error('未找到 AutoSnippet.boxspec.json 配置文件');
+			return;
+		}
+		// ✅ 先聚合子模块配置到主配置文件
+		await init.mergeSubSpecs(specFile);
+		// 然后安装 snippets
+		install.addCodeSnippets(specFile);
 	});
 
 commander

package/bin/cache.js

@@ -41,11 +41,12 @@ async function updateCache(specFile, content) {
 						linkCache[key] = element['{readme}'];
 					}
 
+					// ✅ SPM 模块：headName 已经包含相对路径，不需要 specHeadPath
 					if (element['{headName}']
-						&& element['{specHeadPath}']
 						&& element['{language}'] !== 'Xcode.SourceCodeLanguage.Swift') {
-
-						headCache[element['{headName}']] = element['{specHeadPath}'];
+						// headName 本身已经是相对路径，直接使用
+						const headerFileName = path.basename(element['{headName}']);
+						headCache[headerFileName] = element['{headName}'];
 					}
 				}
 			});

package/bin/create.js

@@ -13,23 +13,32 @@ const CMD_PATH = process.cwd();
 
 /**
  * 根据文件路径确定模块名（SPM）
+ * 返回路径中最近的（最深的）target 名称
  */
 function determineModuleName(filePath, packageInfo) {
 	// 从路径中提取模块名
-	// 例如：Services/Services/BDNetworkControl/Code/... -> BDNetworkControl
+	// 例如：Business/BDNetworkAPI/Code/... -> BDNetworkAPI（不是 Business）
 	const packagePath = packageInfo.path;
 	const relativePath = path.relative(packagePath, filePath);
 	const segments = relativePath.split(path.sep);
 
-	// 查找匹配的 target
-	for (const segment of segments) {
+	// ✅ 从后向前查找匹配的 target（优先匹配路径中更深的 target）
+	// 这样可以避免匹配到聚合 target（如 Business），而匹配到实际的 target（如 BDNetworkAPI）
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const segment = segments[i];
 		if (packageInfo.targets.includes(segment)) {
 			return segment;
 		}
 	}
 
-	// 如果找不到，使用第一个 target
-	return packageInfo.targets[0] || packageInfo.name;
+	// 如果找不到，使用第一个 target（排除包名，如果包名也是 target）
+	const firstTarget = packageInfo.targets[0];
+	if (firstTarget && firstTarget !== packageInfo.name) {
+		return firstTarget;
+	}
+	
+	// 最后回退到包名
+	return packageInfo.name;
 }
 
 function updateCodeSnippets(specFile, word, key, value) {
@@ -234,7 +243,9 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 					if (!packagePath) {
 						console.log('未找到 Package.swift 文件，请检查路径。');
 						snippet['{content}'] = codeList;
-						saveFromFile(specFile, snippet);
+						// ✅ SPM 模块：.boxspec 文件位置在模块根目录（与 Package.swift 同级）
+						const moduleSpecFile = path.join(path.dirname(packagePath), 'AutoSnippet.boxspec.json');
+						saveFromFile(moduleSpecFile, snippet);
 						return;
 					}
 
@@ -242,41 +253,51 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 					const packageInfo = await findPath.parsePackageSwift(packagePath);
 					if (!packageInfo) {
 						snippet['{content}'] = codeList;
-						saveFromFile(specFile, snippet);
+						const moduleSpecFile = path.join(path.dirname(packagePath), 'AutoSnippet.boxspec.json');
+						saveFromFile(moduleSpecFile, snippet);
 						return;
 					}
 
 					// 根据当前文件路径确定模块名
 					const moduleName = determineModuleName(filePath, packageInfo);
-					const headerName = fileName.substring(0, fileName.length - 2); // 移除 .h
+					const headerNameWithoutExt = fileName.substring(0, fileName.length - 2); // 移除 .h
+
+					// ✅ 模块根目录就是 Package.swift 所在目录（packageInfo.path）
+					// .boxspec.json 文件将创建在这个目录下（与 Package.swift 同级）
+					const moduleRoot = packageInfo.path;
 
 					// ✅ 查找头文件（适配 SPM 的 include/ModuleName/ 结构）
-					const headerPath = await findPath.findSubHeaderPath(packageInfo.path, headerName, moduleName);
+					// 在 Package.swift 所在目录下查找（可能包含 Services/Services/... 这样的结构）
+					const headerPath = await findPath.findSubHeaderPath(moduleRoot, headerNameWithoutExt, moduleName);
 
 					snippet['{content}'] = codeList;
-					snippet['{specName}'] = moduleName;
-					snippet['{headName}'] = fileName;
+					snippet['{specName}'] = moduleName;  // ✅ specName 是 target 名称（如 BDNetworkAPI），不是包名（如 Business）
 
 					if (headerPath) {
-						// ✅ 使用 path.relative() 计算相对于配置文件的相对路径
-						const specFileDir = path.dirname(specFile);
-						const relativePath = path.relative(specFileDir, headerPath);
-						snippet['{specHeadPath}'] = encodeURI(relativePath);
+						// ✅ headName 存储相对于 Package.swift 所在目录的相对路径
+						// 例如：如果 Package.swift 在 Business/，头文件在 Business/Business/BDNetworkAPI/Code/xxx.h
+						// 则 headName = "Business/BDNetworkAPI/Code/xxx.h"
+						const headerRelativePath = path.relative(moduleRoot, headerPath);
+						snippet['{headName}'] = headerRelativePath;
+					} else {
+						// 如果找不到头文件，使用文件名
+						snippet['{headName}'] = fileName;
 					}
 
 					// 查找 README.md
 					try {
 						const readmePath = path.join(packageInfo.path, README_NAME);
 						await fs.promises.access(readmePath);
-						// ✅ 使用 path.relative() 计算相对于配置文件的相对路径
-						const specFileDir = path.dirname(specFile);
-						const readmeRelativePath = path.relative(specFileDir, readmePath);
+						const moduleRoot = packageInfo.path;
+						const readmeRelativePath = path.relative(moduleRoot, readmePath);
 						snippet['{readme}'] = encodeURI(readmeRelativePath);
 					} catch {
 						// README.md 不存在，跳过
 					}
 
-					saveFromFile(specFile, snippet);
+					// ✅ SPM 模块：.boxspec 文件位置在模块根目录（与 Package.swift 同级）
+					const moduleSpecFile = path.join(packageInfo.path, 'AutoSnippet.boxspec.json');
+					saveFromFile(moduleSpecFile, snippet);
 				}).catch(function (err) {
 					console.error('Error finding Package.swift:', err);
 					snippet['{content}'] = codeList;
@@ -304,7 +325,23 @@ function saveFromFile(specFile, snippet) {
 			placeholder = JSON.parse(data);
 		}
 	} catch (err) {
-		console.error(err);
+		// ✅ 文件不存在或读取失败，创建新的配置文件
+		if (err.code === 'ENOENT') {
+			// 确保目录存在
+			const specFileDir = path.dirname(specFile);
+			try {
+				fs.mkdirSync(specFileDir, { recursive: true });
+			} catch (mkdirErr) {
+				// 目录可能已存在，忽略错误
+			}
+			// 创建空的配置文件结构
+			placeholder = {
+				list: []
+			};
+		} else {
+			console.error(err);
+			return;
+		}
 	}
 
 	if (placeholder != null) {

package/bin/init.js

@@ -5,31 +5,29 @@ const path = require('path');
 const CMD_PATH = process.cwd();
 const findPath = require('./findPath.js');
 
-async function initSpec() {
-	const filePath = path.join(CMD_PATH, '/AutoSnippet.boxspec.json');
+/**
+ * 聚合子模块的 AutoSnippet.boxspec.json 到主配置文件
+ * @param {string} mainSpecFile - 主配置文件路径
+ * @returns {Promise<void>}
+ */
+async function mergeSubSpecs(mainSpecFile) {
 	let idsArray = [];
 	let specObj = {
 		list: []
 	};
 
-	try {
-		await fs.promises.access(filePath);
-	} catch (error) {
-		const content = JSON.stringify(specObj, null, 4);
-		fs.writeFileSync(filePath, content, 'utf8');
-	}
+	const specSlashIndex = mainSpecFile.lastIndexOf('/');
+	const specFilePath = mainSpecFile.substring(0, specSlashIndex + 1);
 
-	const specSlashIndex = filePath.lastIndexOf('/');
-	const specFilePath = filePath.substring(0, specSlashIndex + 1);
-
-	const array = await findPath.findSubASSpecPath(CMD_PATH);
+	// 从主配置文件所在目录向下查找子模块的 AutoSnippet.boxspec.json
+	const array = await findPath.findSubASSpecPath(path.dirname(mainSpecFile));
 
 	for (let i = 0; i < array.length; i++) {
 		const filename = array[i];
 
 		const slashIndex = filename.lastIndexOf('/');
 		let thePath = filename.substring(0, slashIndex + 1);
-		if (filename === filePath) {
+		if (filename === mainSpecFile) {
 			thePath = '';
 		} else {
 			thePath = thePath.replace(specFilePath, '');
@@ -38,41 +36,58 @@ async function initSpec() {
 		try {
 			// 读取AutoSnippet的占位配置
 			const data = fs.readFileSync(filename, 'utf8');
-            const config = JSON.parse(data);
+			const config = JSON.parse(data);
 			if (config && config.list) {
-
-                const arr = config.list.filter(function (item, index, array) {
-                    for (let i = 0; i < idsArray.length; i++) {
-                        if (item['{identifier}'] === idsArray[i]) {
-                            return false;
-                        }
-                    }
-					idsArray.push(item['{identifier}']);
-					// ✅ 头文件相对路径需要补齐（将子配置的相对路径转换为相对于主配置的路径）
-					if (item['{specHeadPath}']) {
-						// 解码原始路径，拼接子配置路径，再编码
-						const decodedPath = decodeURI(item['{specHeadPath}']);
-						const combinedPath = thePath ? path.join(thePath, decodedPath) : decodedPath;
-						// 规范化路径（处理 .. 和 .）
-						item['{specHeadPath}'] = encodeURI(path.normalize(combinedPath));
+				const arr = config.list.filter(function (item, index, array) {
+					for (let i = 0; i < idsArray.length; i++) {
+						if (item['{identifier}'] === idsArray[i]) {
+							return false;
+						}
 					}
-                    return true;
-                });
-                specObj.list = specObj.list.concat(arr);
+					idsArray.push(item['{identifier}']);
+					// ✅ SPM 模块：headName 已经是相对于模块根目录的相对路径
+					// headName 保持相对于各自模块根目录的路径（不需要转换）
+					return true;
+				});
+				specObj.list = specObj.list.concat(arr);
 			}
 		} catch (err) {
 			console.error(err);
 		}
 	}
 
-    try {
-        const content = JSON.stringify(specObj, null, 4);
-        if (content) {
-            fs.writeFileSync(filePath, content, 'utf8');
-        }
-    } catch (err) {
-        console.error(err);
-    }
+	try {
+		const content = JSON.stringify(specObj, null, 4);
+		if (content) {
+			fs.writeFileSync(mainSpecFile, content, 'utf8');
+		}
+	} catch (err) {
+		console.error(err);
+	}
+}
+
+async function initSpec() {
+	// ✅ 查找 Package.swift，在其同级目录创建 AutoSnippet.boxspec.json
+	let packagePath = await findPath.findPackageSwiftPath(CMD_PATH);
+	
+	// 如果找不到 Package.swift，使用当前目录
+	const configDir = packagePath ? path.dirname(packagePath) : CMD_PATH;
+	const filePath = path.join(configDir, 'AutoSnippet.boxspec.json');
+	
+	// 如果配置文件不存在，创建一个空的
+	try {
+		await fs.promises.access(filePath);
+	} catch (error) {
+		const specObj = {
+			list: []
+		};
+		const content = JSON.stringify(specObj, null, 4);
+		fs.writeFileSync(filePath, content, 'utf8');
+	}
+
+	// ✅ 聚合子模块配置到主配置文件
+	await mergeSubSpecs(filePath);
 }
 
-exports.initSpec = initSpec;
+exports.initSpec = initSpec;
+exports.mergeSubSpecs = mergeSubSpecs;

package/bin/injection.js

@@ -58,33 +58,117 @@ function handleHeaderLineSwift(specFile, updateFile, headerLine, importArray) {
 
 // specFile实际上是获取缓存的key，用来获取Snippet的模块空间信息，没有路径意义
 // updateFile是当前修改文件路径，用来获取当前模块空间信息
-function handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift) {
+async function handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift) {
     if (isSwift) {
         handleHeaderLineSwift(specFile, updateFile, headerLine, importArray);
         return;
     }
 	const header = createHeader(headerLine);
 
-	// 首先识别是否是组件内部修改，默认头文件间接等于模块名
-	cache.getHeadCache(specFile).then(function (headCache) {
-		if (headCache) {
-			const headPath = headCache[header.headerName];
+	// ✅ 重新设计：区分当前模块内部和外部
+	// 1. 获取当前文件所在的模块（通过 Package.swift）
+	// 2. 获取头文件所在的模块（从头文件路径查找 Package.swift，确定最近的 target 模块名）
+	// 3. 比较模块名：
+	//    - 相同模块 -> 使用相对路径 #import "Header.h"
+	//    - 不同模块 -> 使用 #import <ModuleName/Header.h>
+
+	// 获取当前文件所在的模块
+	const updateFileDir = path.dirname(updateFile);
+	const currentPackagePath = await findPath.findPackageSwiftPath(updateFileDir);
+	
+	if (!currentPackagePath) {
+		// 找不到当前模块的 Package.swift，默认使用 <> 格式
+		handleModuleHeader(specFile, updateFile, header, importArray, true);
+		return;
+	}
 
-			const dotIndex = headPath.lastIndexOf('.');
-			const slashIndex = headPath.lastIndexOf('/');
-			const currModuleName = headPath.substring(slashIndex + 1, dotIndex);
-			if (currModuleName === header.moduleName) {
-				handleModuleHeader(specFile, updateFile, header, importArray, false);
-			} else {
-				handleModuleHeader(specFile, updateFile, header, importArray, true);
-			}
+	const currentPackageInfo = await findPath.parsePackageSwift(currentPackagePath);
+	if (!currentPackageInfo) {
+		handleModuleHeader(specFile, updateFile, header, importArray, true);
+		return;
+	}
+
+	// 获取当前文件所在的模块名（通过路径判断）
+	const currentModuleName = determineCurrentModuleName(updateFile, currentPackageInfo);
+
+	// ✅ 获取头文件缓存，然后确定头文件所在的模块名
+	const headCache = await cache.getHeadCache(specFile);
+	const headerModuleName = await determineHeaderModuleName(specFile, header, headCache);
+
+	// ✅ 更新 header 中的模块名和 specName，确保使用正确的模块名（最近的 target 模块名）
+	header.moduleName = headerModuleName;
+	header.specName = '<' + headerModuleName + '/' + header.headerName + '>';
+
+	// ✅ 判断是否为同一模块
+	const isSameModule = currentModuleName === headerModuleName;
+
+	// 如果是同一模块，使用相对路径；否则使用 <> 格式
+	handleModuleHeader(specFile, updateFile, header, importArray, !isSameModule);
+}
+
+/**
+ * 根据文件路径确定当前模块名（SPM）
+ */
+function determineCurrentModuleName(filePath, packageInfo) {
+	const relativePath = path.relative(packageInfo.path, filePath);
+	const segments = relativePath.split(path.sep);
+
+	// 查找匹配的 target（最近的 target）
+	for (const segment of segments) {
+		if (packageInfo.targets.includes(segment)) {
+			return segment;
 		}
-	});
+	}
+
+	// 如果找不到，使用第一个 target
+	return packageInfo.targets[0] || packageInfo.name;
+}
+
+/**
+ * 确定头文件所在的模块名（SPM）
+ * 从头文件路径查找 Package.swift，确定最近的 target 模块名
+ */
+async function determineHeaderModuleName(specFile, header, headCache) {
+	if (!headCache) {
+		// 没有缓存，使用从 headerLine 解析的模块名（可能不准确）
+		return header.moduleName;
+	}
+
+	// 从头缓存中获取头文件的相对路径
+	const headRelativePath = headCache[header.headerName];
+	if (!headRelativePath) {
+		// 找不到头文件路径，使用从 headerLine 解析的模块名
+		return header.moduleName;
+	}
+
+	// ✅ specFile 位于模块根目录（如 ModuleRoot/AutoSnippet.boxspec.json）
+	const moduleRootDir = path.dirname(specFile);
+	const headPath = path.join(moduleRootDir, headRelativePath);
+
+	// 从头文件路径向上查找 Package.swift
+	const headerPackagePath = await findPath.findPackageSwiftPath(headPath);
+	if (!headerPackagePath) {
+		// 找不到 Package.swift，使用从 headerLine 解析的模块名
+		return header.moduleName;
+	}
+
+	// 解析 Package.swift 获取模块信息
+	const headerPackageInfo = await findPath.parsePackageSwift(headerPackagePath);
+	if (!headerPackageInfo) {
+		return header.moduleName;
+	}
+
+	// ✅ 根据头文件路径确定最近的 target 模块名
+	return determineCurrentModuleName(headPath, headerPackageInfo);
 }
 
 // isOuter区分模块内部引用""格式和模块外部引用<>格式
+// ✅ SPM 模块：
+//    - isOuter = false：同一模块内部，使用相对路径 #import "Header.h"
+//    - isOuter = true：不同模块之间，使用 #import <ModuleName/Header.h>
 function handleModuleHeader(specFile, updateFile, header, importArray, isOuter) {
-    const headName = isOuter ? header.name : header.headerStrName;
+	// ✅ 根据 isOuter 选择不同的引入格式
+	const headName = isOuter ? header.name : header.headerStrName;  // isOuter: <ModuleName/Header.h>, 否则: "Header.h"
 	const moduleName = isOuter ? header.specName : header.moduleStrName;
 
 	// 检查是否已经引入头文件
@@ -93,20 +177,21 @@ function handleModuleHeader(specFile, updateFile, header, importArray, isOuter)
 
 		if (importHeader === headName) {
 			// 已经引入头文件
-			handelAddHeaderStatus(specFile, updateFile, header, true, false);
+			handelAddHeaderStatus(specFile, updateFile, header, true, false, isOuter);
 			return;
 		} else if (importHeader === moduleName) {
-			// 已经引入spec头文件
-			handelAddHeaderStatus(specFile, updateFile, header, false, true);
+			// 已经引入模块头文件（如 <ModuleName/ModuleName.h>）
+			handelAddHeaderStatus(specFile, updateFile, header, false, true, isOuter);
 			return;
 		}
 	}
 
 	// 没有找到已引入的头文件，直接添加
-	addHeaderToFile(updateFile, header);
+	// addHeaderToFile 会根据 isOuter 使用不同的格式
+	addHeaderToFile(updateFile, header, isOuter);
 }
 
-function handelAddHeaderStatus(specFile, updateFile, header, isAddedHeader, isAddedSpecHeader) {
+function handelAddHeaderStatus(specFile, updateFile, header, isAddedHeader, isAddedSpecHeader, isOuter) {
 	if (isAddedHeader) {
 		// 已经引入头文件
 		removeMarkFromFile(updateFile, header, '依赖头文件已存在，不需要额外引入。');
@@ -117,22 +202,32 @@ function handelAddHeaderStatus(specFile, updateFile, header, isAddedHeader, isAd
 				// spec header足够了，不需要添加头文件
 				removeMarkFromFile(updateFile, header, '依赖模块头文件已存在，不需要额外引入。');
 			} else {
-				addHeaderToFile(updateFile, header);
+				// 使用传入的 isOuter 参数
+				addHeaderToFile(updateFile, header, isOuter);
 			}
 		});
 	} else {
 		// 都没找到，添加头文件
-		addHeaderToFile(updateFile, header);
+		// 使用传入的 isOuter 参数
+		addHeaderToFile(updateFile, header, isOuter);
 	}
 }
 
 function isAddedToSpecHeader(specFile, header, callback) {
 	cache.getHeadCache(specFile).then(function (headCache) {
 		if (headCache) {
-			// ✅ 使用 path.join() 正确拼接配置目录和相对路径
-			const specFileDir = path.dirname(specFile);
-			const relativePath = decodeURI(headCache[header.headerName]);
-			const headPath = path.join(specFileDir, relativePath);
+			// ✅ SPM 模块：headName 已经是相对于模块根目录的相对路径
+			// specFile 位于模块根目录（如 ModuleRoot/AutoSnippet.boxspec.json）
+			const moduleRootDir = path.dirname(specFile);
+			const headRelativePath = headCache[header.headerName];
+			
+			if (!headRelativePath) {
+				callback(false);
+				return;
+			}
+			
+			// 拼接头文件的完整路径
+			const headPath = path.join(moduleRootDir, headRelativePath);
 
 			try {
 				// 读取当前头文件所在工作空间里默认暴露的头文件
@@ -169,8 +264,15 @@ function removeMarkFromFile(updateFile, header, string) {
 	});
 }
 
-function addHeaderToFile(updateFile, header) {
-	readStream(updateFile, importMark + ' ' + header.name, importMark);
+function addHeaderToFile(updateFile, header, isOuter) {
+	// ✅ 根据 isOuter 选择不同的引入格式
+	// isOuter = true: 使用 <> 格式（#import <ModuleName/Header.h>）
+	// isOuter = false: 使用相对路径（#import "Header.h"）
+	const importLine = isOuter 
+		? importMark + ' ' + header.name  // <ModuleName/Header.h>
+		: importMark + ' ' + header.headerStrName;  // "Header.h"
+	
+	readStream(updateFile, importLine, importMark);
 	checkDependency(updateFile, header.moduleName, '自动注入头文件完成。').catch(err => {
 		console.error('Error checking dependency:', err);
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "autosnippet",
-    "version": "1.1.15",
+    "version": "1.1.17",
     "description": "A iOS module management tool.",
     "main": "index.js",
     "scripts": {