sloth-d2c-mcp 1.0.4-beta70 → 1.0.4-beta71

package/dist/build/component-mapping/adapters/ios-adapter.js

@@ -0,0 +1,697 @@
+/**
+ * iOS平台适配器 - 支持SwiftUI/UIKit
+ */
+import { BasePlatformAdapter } from './base-adapter.js';
+import * as path from 'path';
+export class IOSPlatformAdapter extends BasePlatformAdapter {
+    platform = 'ios';
+    async scanComponents(projectPath, options) {
+        const components = [];
+        // 扫描SwiftUI组件
+        const swiftUIComponents = await this.scanSwiftUIComponents(projectPath, options);
+        components.push(...swiftUIComponents);
+        // 扫描UIKit组件
+        const uiKitComponents = await this.scanUIKitComponents(projectPath, options);
+        components.push(...uiKitComponents);
+        // 扫描Objective-C组件
+        const objcComponents = await this.scanObjectiveCComponents(projectPath, options);
+        components.push(...objcComponents);
+        return this.deduplicateComponents(components);
+    }
+    /**
+     * 扫描SwiftUI组件
+     */
+    async scanSwiftUIComponents(projectPath, options) {
+        const components = [];
+        const files = await this.findFiles(projectPath, ['.swift'], options);
+        console.log(`[scanSwiftUIComponents] 找到 ${files.length} 个 Swift 文件`);
+        // 只扫描路径中包含 "component" 或 "view" 的文件（不区分大小写）
+        const componentFiles = files.filter((file) => {
+            const normalizedPath = file.toLowerCase();
+            return (normalizedPath.includes('component') ||
+                normalizedPath.includes('view') ||
+                normalizedPath.includes('screen'));
+        });
+        console.log(`[scanSwiftUIComponents] 过滤后，${componentFiles.length} 个文件在相关目录中`);
+        for (const file of componentFiles) {
+            try {
+                const content = await this.readFile(file);
+                const extractedComponents = this.extractSwiftUIComponents(file, content, projectPath);
+                console.log(`[scanSwiftUIComponents] 文件 ${file} 提取到 ${extractedComponents.length} 个组件`);
+                components.push(...extractedComponents);
+            }
+            catch (error) {
+                console.warn(`解析SwiftUI组件失败 ${file}:`, error);
+            }
+        }
+        return components;
+    }
+    /**
+     * 从文件内容中提取SwiftUI组件
+     */
+    extractSwiftUIComponents(filePath, content, projectPath) {
+        const relativePath = path.relative(projectPath, filePath).replace(/\\/g, '/');
+        const components = [];
+        // 匹配SwiftUI View结构体:
+        // struct ComponentName: View { ... }
+        // public struct ComponentName: View { ... }
+        // struct ComponentName: View, SomeProtocol { ... }
+        const swiftUIViewRegex = /(?:public\s+|private\s+|internal\s+)?struct\s+([A-Z][a-zA-Z0-9]*)\s*:\s*View(?:\s*,\s*[^{]+)?\s*\{/g;
+        // 匹配PreviewProvider (用于预览)
+        const previewProviderRegex = /struct\s+([A-Z][a-zA-Z0-9]*)Preview\s*:\s*PreviewProvider\s*\{/g;
+        let match;
+        // 提取SwiftUI View组件
+        while ((match = swiftUIViewRegex.exec(content)) !== null) {
+            const componentName = match[1];
+            const props = this.extractSwiftProps(content, componentName);
+            const metadata = this.extractSwiftMetadata(content, componentName);
+            components.push({
+                id: this.generateComponentId(filePath, componentName),
+                name: componentName,
+                path: relativePath,
+                platform: 'ios',
+                type: this.inferComponentType(componentName),
+                props,
+                metadata: {
+                    ...metadata,
+                    framework: 'SwiftUI',
+                },
+            });
+        }
+        // 提取PreviewProvider (通常包含主组件的引用)
+        while ((match = previewProviderRegex.exec(content)) !== null) {
+            const previewName = match[1];
+            // 尝试从Preview中找到实际组件名
+            const previewContent = this.extractPreviewContent(content, previewName);
+            if (previewContent) {
+                const actualComponentName = previewContent;
+                // 检查是否已经添加过
+                if (!components.find((c) => c.name === actualComponentName)) {
+                    const props = this.extractSwiftProps(content, actualComponentName);
+                    const metadata = this.extractSwiftMetadata(content, actualComponentName);
+                    components.push({
+                        id: this.generateComponentId(filePath, actualComponentName),
+                        name: actualComponentName,
+                        path: relativePath,
+                        platform: 'ios',
+                        type: this.inferComponentType(actualComponentName),
+                        props,
+                        metadata: {
+                            ...metadata,
+                            framework: 'SwiftUI',
+                        },
+                    });
+                }
+            }
+        }
+        console.log(`[extractSwiftUIComponents] 从 ${filePath} 提取到 ${components.length} 个组件:`, components.map((c) => c.name));
+        return components;
+    }
+    /**
+     * 扫描UIKit组件
+     */
+    async scanUIKitComponents(projectPath, options) {
+        const components = [];
+        const files = await this.findFiles(projectPath, ['.swift'], options);
+        // 扫描UIKit相关的文件
+        const uiKitFiles = files.filter((file) => {
+            const normalizedPath = file.toLowerCase();
+            return (normalizedPath.includes('uiview') ||
+                normalizedPath.includes('uiviewcontroller') ||
+                normalizedPath.includes('uicontrol'));
+        });
+        console.log(`[scanUIKitComponents] 过滤后，${uiKitFiles.length} 个UIKit相关文件`);
+        for (const file of uiKitFiles) {
+            try {
+                const content = await this.readFile(file);
+                const extractedComponents = this.extractUIKitComponents(file, content, projectPath);
+                components.push(...extractedComponents);
+            }
+            catch (error) {
+                console.warn(`解析UIKit组件失败 ${file}:`, error);
+            }
+        }
+        return components;
+    }
+    /**
+     * 从文件内容中提取UIKit组件
+     */
+    extractUIKitComponents(filePath, content, projectPath) {
+        const relativePath = path.relative(projectPath, filePath).replace(/\\/g, '/');
+        const components = [];
+        // 匹配UIKit类:
+        // class ComponentName: UIView { ... }
+        // class ComponentName: UIViewController { ... }
+        // class ComponentName: UIControl { ... }
+        const uiKitClassRegex = /(?:public\s+|private\s+|internal\s+)?class\s+([A-Z][a-zA-Z0-9]*)\s*:\s*(UIView|UIViewController|UIControl|UIButton|UILabel|UITextField|UITextView)(?:\s*,\s*[^{]+)?\s*\{/g;
+        let match;
+        while ((match = uiKitClassRegex.exec(content)) !== null) {
+            const componentName = match[1];
+            const baseClass = match[2];
+            const props = this.extractSwiftProps(content, componentName);
+            const metadata = this.extractSwiftMetadata(content, componentName);
+            components.push({
+                id: this.generateComponentId(filePath, componentName),
+                name: componentName,
+                path: relativePath,
+                platform: 'ios',
+                type: this.inferComponentType(componentName),
+                props,
+                metadata: {
+                    ...metadata,
+                    framework: 'UIKit',
+                    // baseClass stored in description or tags if needed
+                    description: metadata.description || `${baseClass} component`,
+                },
+            });
+        }
+        return components;
+    }
+    /**
+     * 扫描Objective-C组件
+     */
+    async scanObjectiveCComponents(projectPath, options) {
+        const components = [];
+        const headerFiles = await this.findFiles(projectPath, ['.h'], options);
+        const implFiles = await this.findFiles(projectPath, ['.m'], options);
+        console.log(`[scanObjectiveCComponents] 找到 ${headerFiles.length} 个 .h 文件和 ${implFiles.length} 个 .m 文件`);
+        // 创建文件映射：.h 和 .m 文件配对
+        const fileMap = new Map();
+        // 处理头文件
+        for (const headerFile of headerFiles) {
+            const baseName = path.basename(headerFile, '.h');
+            const dir = path.dirname(headerFile);
+            const implFile = path.join(dir, `${baseName}.m`);
+            if (!fileMap.has(baseName)) {
+                fileMap.set(baseName, {});
+            }
+            fileMap.get(baseName).header = headerFile;
+        }
+        // 处理实现文件
+        for (const implFile of implFiles) {
+            const baseName = path.basename(implFile, '.m');
+            const dir = path.dirname(implFile);
+            const headerFile = path.join(dir, `${baseName}.h`);
+            if (!fileMap.has(baseName)) {
+                fileMap.set(baseName, {});
+            }
+            fileMap.get(baseName).impl = implFile;
+        }
+        // 只扫描路径中包含 "component"、"view"、"cell" 的文件（不区分大小写）
+        const componentFiles = Array.from(fileMap.entries()).filter(([baseName, files]) => {
+            const normalizedName = baseName.toLowerCase();
+            const normalizedPath = (files.header || files.impl || '').toLowerCase();
+            return (normalizedName.includes('component') ||
+                normalizedName.includes('view') ||
+                normalizedName.includes('cell') ||
+                normalizedName.includes('controller') ||
+                normalizedPath.includes('view') ||
+                normalizedPath.includes('cell') ||
+                normalizedPath.includes('component'));
+        });
+        console.log(`[scanObjectiveCComponents] 过滤后，${componentFiles.length} 个相关文件`);
+        for (const [baseName, files] of componentFiles) {
+            try {
+                const headerContent = files.header ? await this.readFile(files.header) : '';
+                const implContent = files.impl ? await this.readFile(files.impl) : '';
+                const combinedContent = `${headerContent}\n${implContent}`;
+                const extractedComponents = this.extractObjectiveCComponents(files.header || files.impl || '', headerContent, implContent, combinedContent, projectPath);
+                console.log(`[scanObjectiveCComponents] 文件 ${baseName} 提取到 ${extractedComponents.length} 个组件`);
+                components.push(...extractedComponents);
+            }
+            catch (error) {
+                console.warn(`解析Objective-C组件失败 ${baseName}:`, error);
+            }
+        }
+        return components;
+    }
+    /**
+     * 从文件内容中提取Objective-C组件
+     */
+    extractObjectiveCComponents(filePath, headerContent, implContent, combinedContent, projectPath) {
+        const relativePath = path.relative(projectPath, filePath).replace(/\\/g, '/');
+        const components = [];
+        // 匹配 @interface 声明:
+        // @interface ComponentName : SuperClass
+        // @interface ComponentName (Category)
+        const interfaceRegex = /@interface\s+([A-Z][a-zA-Z0-9]*)\s*(?::\s*([A-Z][a-zA-Z0-9_]*))?/g;
+        let match;
+        while ((match = interfaceRegex.exec(headerContent)) !== null) {
+            const componentName = match[1];
+            const superClass = match[2] || 'NSObject';
+            // 跳过分类（Category）和扩展（Extension）
+            if (headerContent.includes(`@interface ${componentName} (`)) {
+                continue;
+            }
+            const props = this.extractObjCProps(headerContent, componentName);
+            const metadata = this.extractObjCMetadata(headerContent, implContent, componentName, superClass);
+            components.push({
+                id: this.generateComponentId(filePath, componentName),
+                name: componentName,
+                path: relativePath,
+                platform: 'ios',
+                type: this.inferComponentType(componentName),
+                props,
+                metadata: {
+                    ...metadata,
+                    framework: 'UIKit',
+                },
+            });
+        }
+        return components;
+    }
+    /**
+     * 提取Objective-C组件的属性
+     */
+    extractObjCProps(content, componentName) {
+        const props = [];
+        // 匹配 @property 声明:
+        // @property (nonatomic, strong) Type *propertyName;
+        // @property (nonatomic, weak) id<Protocol> propertyName;
+        // @property (nonatomic, assign) NSInteger propertyName;
+        const propertyRegex = /@property\s*\([^)]+\)\s+(?:IBOutlet\s+)?(?:IBAction\s+)?(?:[\w<>,\s*]+)?\s*(\w+)\s*;/g;
+        let match;
+        while ((match = propertyRegex.exec(content)) !== null) {
+            const propName = match[1];
+            // 跳过私有属性（以_开头）和系统属性
+            if (propName.startsWith('_') || propName === 'delegate' || propName === 'dataSource') {
+                continue;
+            }
+            // 尝试提取类型信息
+            const propertyLine = this.extractPropertyLine(content, propName);
+            const typeInfo = this.parseObjCPropertyType(propertyLine);
+            props.push({
+                name: propName,
+                type: typeInfo.type,
+                required: typeInfo.required,
+                description: typeInfo.description,
+            });
+        }
+        return props;
+    }
+    /**
+     * 提取属性声明行
+     */
+    extractPropertyLine(content, propName) {
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(`@property`) && lines[i].includes(propName)) {
+                // 可能跨多行
+                let fullLine = lines[i];
+                let j = i + 1;
+                while (j < lines.length && !lines[j].includes(';')) {
+                    fullLine += ' ' + lines[j].trim();
+                    j++;
+                }
+                if (fullLine.includes(';')) {
+                    return fullLine;
+                }
+            }
+        }
+        return '';
+    }
+    /**
+     * 解析Objective-C属性类型
+     */
+    parseObjCPropertyType(propertyLine) {
+        // 提取类型
+        let type = 'id';
+        // 匹配 strong/retain/weak/assign/copy
+        const isStrong = propertyLine.includes('strong') || propertyLine.includes('retain');
+        const isWeak = propertyLine.includes('weak');
+        const isCopy = propertyLine.includes('copy');
+        const isAssign = propertyLine.includes('assign');
+        // 尝试提取具体类型
+        const typeMatch = propertyLine.match(/@property\s*\([^)]+\)\s+(?:IBOutlet\s+)?(?:IBAction\s+)?([\w<>,\s*]+?)\s+\w+\s*;/);
+        if (typeMatch) {
+            type = typeMatch[1].trim();
+            // 清理类型字符串
+            type = type.replace(/\s+/g, ' ');
+            // 处理指针类型
+            if (type.includes('*')) {
+                type = type.replace(/\s*\*\s*/g, ' *');
+            }
+        }
+        // 提取注释
+        const commentMatch = propertyLine.match(/\/\/\s*(.+)/);
+        const description = commentMatch ? commentMatch[1].trim() : undefined;
+        return {
+            type: type || 'id',
+            required: isStrong || isCopy, // strong/copy 通常表示必需
+            description,
+        };
+    }
+    /**
+     * 提取Objective-C组件元数据
+     */
+    extractObjCMetadata(headerContent, implContent, componentName, superClass) {
+        const metadata = {
+            tags: [],
+            dependencies: [],
+            styleProps: {},
+        };
+        const combinedContent = `${headerContent}\n${implContent}`;
+        // 提取文档注释
+        const docCommentRegex = new RegExp(`//\\s*([^\\n]+)|/\\*\\*([^*]|\\*(?!/))*\\*/\\s*@interface\\s+${componentName}`, 's');
+        const docCommentMatch = combinedContent.match(docCommentRegex);
+        if (docCommentMatch) {
+            const docText = docCommentMatch[0];
+            const descMatch = docText.match(/(?:\/\/\s*|\/\*\*\s*)([^@\n*]+)/);
+            if (descMatch) {
+                metadata.description = descMatch[1].trim();
+            }
+        }
+        // 提取 #import 依赖
+        const importRegex = /#import\s+[<"]([^>"]+)[>"]/g;
+        let importMatch;
+        while ((importMatch = importRegex.exec(combinedContent)) !== null) {
+            metadata.dependencies.push(importMatch[1]);
+        }
+        // 提取样式相关的属性（UIView相关）
+        metadata.styleProps = this.extractObjCStyleProps(combinedContent);
+        // 添加基类信息到描述
+        if (superClass && superClass !== 'NSObject') {
+            metadata.description = metadata.description
+                ? `${metadata.description} (继承自 ${superClass})`
+                : `继承自 ${superClass}`;
+        }
+        return metadata;
+    }
+    /**
+     * 提取Objective-C样式属性
+     */
+    extractObjCStyleProps(content) {
+        const styleProps = {};
+        // 查找常见的样式属性设置
+        const stylePatterns = [
+            { key: 'width', pattern: /\.width\s*=\s*(\d+(?:\.\d+)?)/i },
+            { key: 'height', pattern: /\.height\s*=\s*(\d+(?:\.\d+)?)/i },
+            { key: 'frame', pattern: /CGRectMake\(([^)]+)\)/i },
+            { key: 'backgroundColor', pattern: /\.backgroundColor\s*=\s*\[UIColor\s+(\w+)\]/i },
+            { key: 'fontSize', pattern: /fontWithSize:(\d+(?:\.\d+)?)/i },
+        ];
+        for (const { key, pattern } of stylePatterns) {
+            const match = content.match(pattern);
+            if (match) {
+                styleProps[key] = match[1] || 'defined';
+            }
+        }
+        return styleProps;
+    }
+    /**
+     * 提取Swift组件的属性
+     */
+    extractSwiftProps(content, componentName) {
+        const props = [];
+        // 匹配Swift属性:
+        // @State var propertyName: Type
+        // @Binding var propertyName: Type
+        // @Published var propertyName: Type
+        // var propertyName: Type
+        // let propertyName: Type
+        const propertyRegex = new RegExp(`(?:@(?:State|Binding|Published|ObservedObject|Environment|EnvironmentObject)\\s+)?(?:var|let)\\s+(\\w+)\\??\\s*:\\s*([^=\\n]+?)(?:\\s*=|\\s*\\{|\\s*\\()`, 'g');
+        // 匹配初始化参数:
+        // init(propertyName: Type, ...)
+        const initRegex = new RegExp(`(?:public\\s+|private\\s+|internal\\s+)?init\\s*\\(([^)]+)\\)`, 's');
+        let match;
+        // 提取属性
+        while ((match = propertyRegex.exec(content)) !== null) {
+            const propName = match[1];
+            const propType = match[2].trim();
+            const isOptional = propType.includes('?');
+            const cleanType = propType.replace(/\?/g, '').trim();
+            // 跳过私有属性（以_开头）
+            if (propName.startsWith('_'))
+                continue;
+            props.push({
+                name: propName,
+                type: cleanType,
+                required: !isOptional,
+            });
+        }
+        // 提取初始化参数
+        const initMatch = content.match(initRegex);
+        if (initMatch) {
+            const paramsStr = initMatch[1];
+            const paramRegex = /(\w+)(\??)\s*:\s*([^,)]+)/g;
+            let paramMatch;
+            while ((paramMatch = paramRegex.exec(paramsStr)) !== null) {
+                const paramName = paramMatch[1];
+                const isOptional = paramMatch[2] === '?';
+                const paramType = paramMatch[3].trim().replace(/\?/g, '');
+                // 检查是否已经存在（避免重复）
+                if (!props.find((p) => p.name === paramName)) {
+                    props.push({
+                        name: paramName,
+                        type: paramType,
+                        required: !isOptional,
+                    });
+                }
+            }
+        }
+        return props;
+    }
+    /**
+     * 提取Swift组件元数据
+     */
+    extractSwiftMetadata(content, componentName) {
+        const metadata = {
+            tags: [],
+            dependencies: [],
+            styleProps: {},
+        };
+        // 提取文档注释
+        const docCommentRegex = new RegExp(`///\\s*([^\\n]+)|/\\*\\*([^*]|\\*(?!/))*\\*/\\s*struct\\s+${componentName}|/\\*\\*([^*]|\\*(?!/))*\\*/\\s*class\\s+${componentName}`, 's');
+        const docCommentMatch = content.match(docCommentRegex);
+        if (docCommentMatch) {
+            const docText = docCommentMatch[0];
+            // Match single-line comment (///) or multi-line comment (/**)
+            const descMatch = docText.match(/(?:\/\/\/\s*|\/\*\*\s*)([^@\n*]+)/);
+            if (descMatch) {
+                metadata.description = descMatch[1].trim();
+            }
+            // 提取@标签
+            const tagRegex = /@(\w+)\s+([^\n]*)/g;
+            let tagMatch;
+            while ((tagMatch = tagRegex.exec(docText)) !== null) {
+                metadata.tags.push(tagMatch[1]);
+            }
+        }
+        // 提取import依赖
+        const importRegex = /import\s+([^\n]+)/g;
+        let importMatch;
+        while ((importMatch = importRegex.exec(content)) !== null) {
+            metadata.dependencies.push(importMatch[1].trim());
+        }
+        // 提取样式相关的属性
+        metadata.styleProps = this.extractSwiftStyleProps(content);
+        return metadata;
+    }
+    /**
+     * 提取Swift样式属性
+     */
+    extractSwiftStyleProps(content) {
+        const styleProps = {};
+        // 查找常见的样式属性（SwiftUI modifier）
+        const stylePatterns = [
+            { key: 'width', pattern: /\.frame\([^)]*width:\s*(\d+(?:\.\d+)?)/i },
+            { key: 'height', pattern: /\.frame\([^)]*height:\s*(\d+(?:\.\d+)?)/i },
+            { key: 'padding', pattern: /\.padding\(([^)]+)\)/i },
+            { key: 'backgroundColor', pattern: /\.background\([^)]*Color\([^)]*\)/i },
+            { key: 'borderRadius', pattern: /\.cornerRadius\((\d+(?:\.\d+)?)/i },
+            { key: 'fontSize', pattern: /\.font\([^)]*\.system\(size:\s*(\d+(?:\.\d+)?)/i },
+            { key: 'fontWeight', pattern: /\.fontWeight\(\.(\w+)\)/i },
+            { key: 'color', pattern: /\.foregroundColor\([^)]*Color\([^)]*\)/i },
+        ];
+        for (const { key, pattern } of stylePatterns) {
+            const match = content.match(pattern);
+            if (match) {
+                styleProps[key] = match[1] || 'defined';
+            }
+        }
+        return styleProps;
+    }
+    /**
+     * 从Preview中提取实际组件名
+     */
+    extractPreviewContent(content, previewName) {
+        const previewRegex = new RegExp(`struct\\s+${previewName}Preview[\\s\\S]*?static\\s+var\\s+previews[\\s\\S]*?return\\s+([A-Z][a-zA-Z0-9]*)\\(`, 's');
+        const match = content.match(previewRegex);
+        return match ? match[1] : null;
+    }
+    async parseComponentMetadata(filePath) {
+        const content = await this.readFile(filePath);
+        // 尝试提取Swift组件名
+        const structMatch = content.match(/struct\s+([A-Z][a-zA-Z0-9]*)\s*:\s*View/);
+        const classMatch = content.match(/class\s+([A-Z][a-zA-Z0-9]*)\s*:\s*(UIView|UIViewController)/);
+        if (structMatch || classMatch) {
+            const componentName = structMatch?.[1] || classMatch?.[1] || '';
+            if (componentName) {
+                return this.extractSwiftMetadata(content, componentName);
+            }
+        }
+        // 尝试提取Objective-C组件名
+        if (filePath.endsWith('.h') || filePath.endsWith('.m')) {
+            const interfaceMatch = content.match(/@interface\s+([A-Z][a-zA-Z0-9]*)\s*(?::\s*([A-Z][a-zA-Z0-9_]*))?/);
+            if (interfaceMatch) {
+                const componentName = interfaceMatch[1];
+                const superClass = interfaceMatch[2] || 'NSObject';
+                // 对于 .h 文件，需要读取对应的 .m 文件
+                let implContent = '';
+                if (filePath.endsWith('.h')) {
+                    const implPath = filePath.replace(/\.h$/, '.m');
+                    try {
+                        implContent = await this.readFile(implPath);
+                    }
+                    catch {
+                        // .m 文件不存在，只使用 .h 文件
+                    }
+                }
+                else {
+                    implContent = content;
+                }
+                return this.extractObjCMetadata(content, implContent, componentName, superClass);
+            }
+        }
+        return {
+            tags: [],
+            dependencies: [],
+            styleProps: {},
+        };
+    }
+    generateImportCode(component, targetPath) {
+        // Objective-C使用#import
+        if (component.path.endsWith('.h') || component.path.endsWith('.m')) {
+            if (!targetPath) {
+                const headerName = component.path.endsWith('.h')
+                    ? path.basename(component.path)
+                    : path.basename(component.path, '.m') + '.h';
+                return `#import "${headerName}"`;
+            }
+            // 计算相对路径
+            const targetDir = path.dirname(targetPath);
+            const componentDir = path.dirname(component.path);
+            const headerName = component.path.endsWith('.h')
+                ? path.basename(component.path)
+                : path.basename(component.path, '.m') + '.h';
+            // 如果在同一目录，直接导入文件名
+            if (targetDir === componentDir) {
+                return `#import "${headerName}"`;
+            }
+            // 否则使用相对路径（指向头文件）
+            const headerPath = component.path.endsWith('.h')
+                ? component.path
+                : component.path.replace(/\.m$/, '.h');
+            const relativePath = this.getRelativePath(targetPath, headerPath);
+            return `#import "${relativePath}"`;
+        }
+        // Swift使用import语句，但通常不需要相对路径导入
+        // 如果组件在同一个模块中，不需要import
+        // 如果组件在不同模块中，使用模块名
+        if (!targetPath) {
+            return `// 确保已导入组件所在模块\n// import ${component.metadata.framework || 'Foundation'}`;
+        }
+        // 检查是否在同一目录
+        const targetDir = path.dirname(targetPath);
+        const componentDir = path.dirname(component.path);
+        if (targetDir === componentDir) {
+            return `// 组件在同一文件中，无需导入`;
+        }
+        // 不同模块需要import（这里简化处理）
+        const moduleName = component.metadata.framework || 'Foundation';
+        return `import ${moduleName}`;
+    }
+    generateUsageCode(component, props, styles) {
+        // SwiftUI使用方式
+        if (component.metadata.framework === 'SwiftUI') {
+            const propsStr = Object.entries(props)
+                .map(([key, value]) => {
+                if (typeof value === 'string') {
+                    return `${key}: "${value}"`;
+                }
+                else if (typeof value === 'boolean') {
+                    return `${key}: ${value}`;
+                }
+                else if (typeof value === 'number') {
+                    return `${key}: ${value}`;
+                }
+                else {
+                    return `${key}: ${JSON.stringify(value)}`;
+                }
+            })
+                .join(', ');
+            // SwiftUI样式通过modifier应用
+            const styleModifiers = [];
+            if (styles.width)
+                styleModifiers.push(`.frame(width: ${styles.width})`);
+            if (styles.height)
+                styleModifiers.push(`.frame(height: ${styles.height})`);
+            if (styles.padding)
+                styleModifiers.push(`.padding(${styles.padding})`);
+            if (styles.backgroundColor)
+                styleModifiers.push(`.background(Color(${styles.backgroundColor}))`);
+            if (styles.borderRadius)
+                styleModifiers.push(`.cornerRadius(${styles.borderRadius})`);
+            if (styles.fontSize)
+                styleModifiers.push(`.font(.system(size: ${styles.fontSize}))`);
+            if (styles.color)
+                styleModifiers.push(`.foregroundColor(Color(${styles.color}))`);
+            const modifiersStr = styleModifiers.length > 0 ? '\n    ' + styleModifiers.join('\n    ') : '';
+            return propsStr
+                ? `${component.name}(${propsStr})${modifiersStr}`
+                : `${component.name}()${modifiersStr}`;
+        }
+        // UIKit Swift使用方式
+        if (component.metadata.framework === 'UIKit' && !component.path.endsWith('.h') && !component.path.endsWith('.m')) {
+            const propsStr = Object.entries(props)
+                .map(([key, value]) => {
+                if (typeof value === 'string') {
+                    return `\n    ${key} = "${value}"`;
+                }
+                else if (typeof value === 'boolean') {
+                    return `\n    ${key} = ${value}`;
+                }
+                else if (typeof value === 'number') {
+                    return `\n    ${key} = ${value}`;
+                }
+                else {
+                    return `\n    ${key} = ${JSON.stringify(value)}`;
+                }
+            })
+                .join(',');
+            return `let ${component.name.toLowerCase()} = ${component.name}()${propsStr}`;
+        }
+        // Objective-C使用方式
+        if (component.path.endsWith('.h') || component.path.endsWith('.m')) {
+            const varName = component.name.charAt(0).toLowerCase() + component.name.slice(1);
+            const propsStr = Object.entries(props)
+                .map(([key, value]) => {
+                if (typeof value === 'string') {
+                    return `\n    ${varName}.${key} = @"${value}";`;
+                }
+                else if (typeof value === 'boolean') {
+                    return `\n    ${varName}.${key} = ${value ? 'YES' : 'NO'};`;
+                }
+                else if (typeof value === 'number') {
+                    return `\n    ${varName}.${key} = ${value};`;
+                }
+                else {
+                    return `\n    ${varName}.${key} = ${JSON.stringify(value)};`;
+                }
+            })
+                .join('');
+            // 检查是否是UITableViewCell
+            if (component.name.includes('Cell')) {
+                return `${component.name} *${varName} = [[${component.name} alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"${varName}"];${propsStr}`;
+            }
+            // 检查是否是UIViewController
+            if (component.name.includes('Controller')) {
+                return `${component.name} *${varName} = [[${component.name} alloc] init];${propsStr}`;
+            }
+            // 默认UIView
+            return `${component.name} *${varName} = [[${component.name} alloc] init];${propsStr}`;
+        }
+        // 默认SwiftUI格式
+        return `${component.name}()`;
+    }
+}