zcw-shared 1.46.2 → 1.47.2

package/dist/functions/platform/ios/integrateNativePlugin.js

@@ -0,0 +1,994 @@
+import { addFileToXcodeProject, addFileToEmbedFrameworks, } from "./integrateThirdPartyModule";
+async function extractPlugin(pluginPath, extractDir, deps) {
+    try {
+        if (deps.existsSync(pluginPath)) {
+            const stat = deps.statSync(pluginPath);
+            if (stat.isDirectory()) {
+                deps.log?.("插件是目录，直接使用");
+                return {
+                    success: true,
+                    extractedPath: pluginPath,
+                };
+            }
+        }
+        if (pluginPath.endsWith(".zip")) {
+            const pluginName = deps.basename(pluginPath, ".zip");
+            const targetDir = deps.join(extractDir, pluginName);
+            if (deps.existsSync(targetDir)) {
+                deps.log?.(`插件已解压过，使用现有目录: ${targetDir}`);
+                return {
+                    success: true,
+                    extractedPath: targetDir,
+                };
+            }
+            if (!deps.existsSync(extractDir)) {
+                deps.mkdirSync(extractDir, { recursive: true });
+            }
+            deps.log?.(`开始解压插件: ${pluginPath}`);
+            deps.log?.(`解压到目录: ${extractDir}`);
+            return new Promise((resolve) => {
+                let resolved = false;
+                let timeoutId;
+                const child = deps.exec(`unzip -q "${pluginPath}" -d "${extractDir}"`, (error, stdout, stderr) => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    if (timeoutId !== undefined) {
+                        deps.clearTimeout(timeoutId);
+                    }
+                    if (error) {
+                        deps.log?.(`解压失败: ${error.message}`);
+                        if (stderr)
+                            deps.log?.(`错误输出: ${stderr}`);
+                        resolve({
+                            success: false,
+                            error: `解压插件失败: ${error.message}`,
+                        });
+                        return;
+                    }
+                    deps.log?.("解压完成，查找解压后的目录...");
+                    const files = deps.readdirSync(extractDir);
+                    if (files.length === 0) {
+                        deps.log?.("解压后未找到任何文件");
+                        resolve({
+                            success: false,
+                            error: "解压后未找到插件文件",
+                        });
+                        return;
+                    }
+                    const extractedPath = deps.join(extractDir, files[0]);
+                    deps.log?.(`找到解压后的目录: ${extractedPath}`);
+                    resolve({
+                        success: true,
+                        extractedPath,
+                    });
+                });
+                timeoutId = deps.setTimeout(() => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    child.kill();
+                    deps.log?.("解压超时（30秒）");
+                    resolve({
+                        success: false,
+                        error: "解压插件超时",
+                    });
+                }, 30000);
+            });
+        }
+        return {
+            success: false,
+            error: `不支持的插件格式: ${pluginPath}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `解压插件异常: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function readPluginPackageJson(pluginDir, deps) {
+    try {
+        const packageJsonPath = deps.join(pluginDir, "package.json");
+        if (!deps.existsSync(packageJsonPath)) {
+            return {
+                success: false,
+                error: `插件 package.json 不存在: ${packageJsonPath}`,
+            };
+        }
+        const content = deps.readFileSync(packageJsonPath, "utf8");
+        const packageJson = deps.parse(content);
+        return {
+            success: true,
+            packageJson,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `读取插件 package.json 失败: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function extractIOSPluginConfig(packageJson) {
+    try {
+        const iosConfig = packageJson._dp_nativeplugin?.ios;
+        if (!iosConfig) {
+            return {
+                success: false,
+                error: "package.json 中未找到 _dp_nativeplugin.ios 配置",
+            };
+        }
+        const plugins = iosConfig.plugins;
+        if (!plugins || !Array.isArray(plugins) || plugins.length === 0) {
+            return {
+                success: false,
+                error: "package.json 中未找到有效的 plugins 配置",
+            };
+        }
+        const pluginItems = [];
+        for (const plugin of plugins) {
+            if (plugin.type && plugin.name && plugin.class) {
+                pluginItems.push({
+                    type: plugin.type,
+                    name: plugin.name,
+                    class: plugin.class,
+                });
+            }
+        }
+        if (pluginItems.length === 0) {
+            return {
+                success: false,
+                error: "package.json 中未找到有效的插件配置",
+            };
+        }
+        const hooksClass = iosConfig.hooksClass || "";
+        const frameworks = iosConfig.frameworks || [];
+        const embedFrameworks = iosConfig.embedFrameworks || [];
+        const resources = iosConfig.resources || [];
+        const privacies = iosConfig.privacies || [];
+        let parameters = undefined;
+        if (iosConfig.parameters && typeof iosConfig.parameters === "object") {
+            parameters = {};
+            for (const [paramName, paramConfig] of Object.entries(iosConfig.parameters)) {
+                if (paramConfig &&
+                    typeof paramConfig === "object" &&
+                    "key" in paramConfig) {
+                    parameters[paramName] = {
+                        key: paramConfig.key,
+                        des: paramConfig.des || "",
+                    };
+                }
+            }
+        }
+        return {
+            success: true,
+            plugins: pluginItems,
+            hooksClass,
+            frameworks,
+            embedFrameworks,
+            resources,
+            privacies,
+            parameters,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `提取插件配置失败: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function addPluginToInfoPlist(xmlDoc, pluginItems, hooksClass) {
+    const dictElement = xmlDoc.getElementsByTagName("dict")[0];
+    if (!dictElement)
+        return false;
+    let unipluginsKey = null;
+    let unipluginsArray = null;
+    const childNodes = Array.from(dictElement.childNodes || []).filter((node) => node.nodeType === 1);
+    for (let i = 0; i < childNodes.length; i++) {
+        const node = childNodes[i];
+        if (node.nodeName === "key" && node.textContent === "dcloud_uniplugins") {
+            unipluginsKey = node;
+            if (i + 1 < childNodes.length && childNodes[i + 1].nodeName === "array") {
+                unipluginsArray = childNodes[i + 1];
+                break;
+            }
+        }
+    }
+    if (!unipluginsArray) {
+        if (!unipluginsKey) {
+            unipluginsKey = xmlDoc.createElement("key");
+            unipluginsKey.textContent = "dcloud_uniplugins";
+            dictElement.appendChild(unipluginsKey);
+        }
+        unipluginsArray = xmlDoc.createElement("array");
+        dictElement.appendChild(unipluginsArray);
+    }
+    const pluginDict = xmlDoc.createElement("dict");
+    const hooksClassKey = xmlDoc.createElement("key");
+    hooksClassKey.textContent = "hooksClass";
+    const hooksClassValue = xmlDoc.createElement("string");
+    hooksClassValue.textContent = hooksClass;
+    pluginDict.appendChild(hooksClassKey);
+    pluginDict.appendChild(hooksClassValue);
+    const pluginsKey = xmlDoc.createElement("key");
+    pluginsKey.textContent = "plugins";
+    const pluginsArray = xmlDoc.createElement("array");
+    for (const plugin of pluginItems) {
+        const itemDict = xmlDoc.createElement("dict");
+        const typeKey = xmlDoc.createElement("key");
+        typeKey.textContent = "type";
+        const typeValue = xmlDoc.createElement("string");
+        typeValue.textContent = plugin.type;
+        itemDict.appendChild(typeKey);
+        itemDict.appendChild(typeValue);
+        const nameKey = xmlDoc.createElement("key");
+        nameKey.textContent = "name";
+        const nameValue = xmlDoc.createElement("string");
+        nameValue.textContent = plugin.name;
+        itemDict.appendChild(nameKey);
+        itemDict.appendChild(nameValue);
+        const classKey = xmlDoc.createElement("key");
+        classKey.textContent = "class";
+        const classValue = xmlDoc.createElement("string");
+        classValue.textContent = plugin.class;
+        itemDict.appendChild(classKey);
+        itemDict.appendChild(classValue);
+        pluginsArray.appendChild(itemDict);
+    }
+    pluginDict.appendChild(pluginsKey);
+    pluginDict.appendChild(pluginsArray);
+    unipluginsArray.appendChild(pluginDict);
+    return true;
+}
+function addPluginParametersToInfoPlist(xmlDoc, parameters, parameterValues) {
+    const dictElement = xmlDoc.getElementsByTagName("dict")[0];
+    if (!dictElement)
+        return false;
+    for (const [paramName, paramConfig] of Object.entries(parameters)) {
+        const value = parameterValues[paramName];
+        if (!value)
+            continue;
+        const key = paramConfig.key;
+        const keys = key.split(":");
+        if (keys.length === 1) {
+            const keyElement = xmlDoc.createElement("key");
+            keyElement.textContent = keys[0];
+            const valueElement = xmlDoc.createElement("string");
+            valueElement.textContent = value;
+            dictElement.appendChild(keyElement);
+            dictElement.appendChild(valueElement);
+        }
+        else {
+            const parentKey = keys[0];
+            const childKey = keys[1];
+            let parentDict = null;
+            const childNodes = Array.from(dictElement.childNodes || []).filter((node) => node.nodeType === 1);
+            for (let i = 0; i < childNodes.length; i++) {
+                const node = childNodes[i];
+                if (node.nodeName === "key" && node.textContent === parentKey) {
+                    if (i + 1 < childNodes.length &&
+                        childNodes[i + 1].nodeName === "dict") {
+                        parentDict = childNodes[i + 1];
+                        break;
+                    }
+                }
+            }
+            if (!parentDict) {
+                const parentKeyElement = xmlDoc.createElement("key");
+                parentKeyElement.textContent = parentKey;
+                parentDict = xmlDoc.createElement("dict");
+                dictElement.appendChild(parentKeyElement);
+                dictElement.appendChild(parentDict);
+            }
+            const childKeyElement = xmlDoc.createElement("key");
+            childKeyElement.textContent = childKey;
+            const childValueElement = xmlDoc.createElement("string");
+            childValueElement.textContent = value;
+            parentDict.appendChild(childKeyElement);
+            parentDict.appendChild(childValueElement);
+        }
+    }
+    return true;
+}
+function addPrivaciesToInfoPlist(xmlDoc, privacies) {
+    const dictElement = xmlDoc.getElementsByTagName("dict")[0];
+    if (!dictElement)
+        return false;
+    for (const privacy of privacies) {
+        const keyElements = xmlDoc.getElementsByTagName("key");
+        let found = false;
+        for (let i = 0; i < keyElements.length; i++) {
+            const keyElement = keyElements[i];
+            if (keyElement.textContent === privacy) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            const keyElement = xmlDoc.createElement("key");
+            keyElement.textContent = privacy;
+            const valueElement = xmlDoc.createElement("string");
+            valueElement.textContent = "应用需要使用此功能";
+            dictElement.appendChild(keyElement);
+            dictElement.appendChild(valueElement);
+        }
+    }
+    return true;
+}
+function findFilesRecursive(dir, extensions, deps, depth = 0) {
+    const result = [];
+    const maxDepth = 10;
+    if (!deps.existsSync(dir)) {
+        return result;
+    }
+    const bundleExtensions = [".framework", ".xcframework", ".app", ".bundle"];
+    if (depth > maxDepth) {
+        return result;
+    }
+    try {
+        const files = deps.readdirSync(dir);
+        for (const file of files) {
+            const filePath = deps.join(dir, file);
+            try {
+                const stat = deps.statSync(filePath);
+                if (stat.isDirectory()) {
+                    let matchesExtension = false;
+                    let isBundle = false;
+                    for (const ext of extensions) {
+                        if (file.endsWith(ext)) {
+                            matchesExtension = true;
+                            isBundle = bundleExtensions.includes(ext);
+                            result.push(filePath);
+                            break;
+                        }
+                    }
+                    if (!matchesExtension || !isBundle) {
+                        if (!matchesExtension) {
+                            result.push(...findFilesRecursive(filePath, extensions, deps, depth + 1));
+                        }
+                    }
+                }
+                else {
+                    for (const ext of extensions) {
+                        if (file.endsWith(ext)) {
+                            result.push(filePath);
+                            break;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                continue;
+            }
+        }
+    }
+    catch (error) {
+    }
+    return result;
+}
+async function copyFrameworkUsingArchive(sourcePath, targetPath, deps, logFn) {
+    const log = (msg) => {
+        const message = `[copyFramework] ${msg}`;
+        if (logFn)
+            logFn(message);
+    };
+    try {
+        log(`开始复制 framework: ${deps.basename(sourcePath)}`);
+        log(`  源路径: ${sourcePath}`);
+        log(`  目标路径: ${targetPath}`);
+        const targetDir = deps.dirname(targetPath);
+        const tempDir = deps.join(targetDir, ".temp_framework_copy");
+        log(`  临时目录: ${tempDir}`);
+        if (deps.existsSync(tempDir)) {
+            log(`  清理已存在的临时目录...`);
+            await new Promise((resolve) => {
+                deps.exec(`rm -rf "${tempDir}"`, (error) => {
+                    if (error) {
+                        log(`  警告: 清理临时目录失败: ${error.message}`);
+                    }
+                    else {
+                        log(`  临时目录已清理`);
+                    }
+                    resolve();
+                });
+            });
+        }
+        if (!deps.existsSync(tempDir)) {
+            log(`  创建临时目录...`);
+            deps.mkdirSync(tempDir, { recursive: true });
+        }
+        const frameworkName = deps.basename(sourcePath);
+        const archiveName = `${frameworkName}.tar.gz`;
+        const archivePath = deps.join(tempDir, archiveName);
+        log(`  压缩文件路径: ${archivePath}`);
+        const sourceDir = deps.dirname(sourcePath);
+        const sourceName = deps.basename(sourcePath);
+        log(`  开始压缩: ${sourceDir}/${sourceName} -> ${archivePath}`);
+        return new Promise((resolve) => {
+            const startTime = Date.now();
+            deps.exec(`cd "${sourceDir}" && tar -czf "${archivePath}" "${sourceName}"`, (error, stdout, stderr) => {
+                const compressTime = Date.now() - startTime;
+                log(`  压缩完成 (耗时: ${compressTime}ms)`);
+                if (error) {
+                    log(`  压缩失败: ${error.message}`);
+                    if (stderr)
+                        log(`  stderr: ${stderr}`);
+                    resolve({
+                        success: false,
+                        error: `压缩 framework 失败: ${error.message}`,
+                    });
+                    return;
+                }
+                const targetArchivePath = deps.join(targetDir, archiveName);
+                log(`  开始复制压缩文件: ${archivePath} -> ${targetArchivePath}`);
+                const copyStartTime = Date.now();
+                try {
+                    deps.copyFileSync(archivePath, targetArchivePath);
+                    const copyTime = Date.now() - copyStartTime;
+                    log(`  复制压缩文件完成 (耗时: ${copyTime}ms)`);
+                }
+                catch (copyError) {
+                    log(`  复制压缩文件失败: ${copyError.message || String(copyError)}`);
+                    resolve({
+                        success: false,
+                        error: `复制压缩文件失败: ${copyError.message || String(copyError)}`,
+                    });
+                    return;
+                }
+                log(`  开始解压: ${targetArchivePath} -> ${targetDir}`);
+                const extractStartTime = Date.now();
+                deps.exec(`cd "${targetDir}" && tar -xzf "${targetArchivePath}" && rm -f "${targetArchivePath}"`, (extractError, extractStdout, extractStderr) => {
+                    const extractTime = Date.now() - extractStartTime;
+                    log(`  解压完成 (耗时: ${extractTime}ms)`);
+                    try {
+                        if (deps.existsSync(archivePath)) {
+                            deps.exec(`rm -f "${archivePath}"`, () => { });
+                        }
+                    }
+                    catch { }
+                    if (extractError) {
+                        log(`  解压失败: ${extractError.message}`);
+                        if (extractStderr)
+                            log(`  stderr: ${extractStderr}`);
+                        resolve({
+                            success: false,
+                            error: `解压 framework 失败: ${extractError.message}`,
+                        });
+                    }
+                    else {
+                        const totalTime = Date.now() - startTime;
+                        log(`  framework 复制成功 (总耗时: ${totalTime}ms)`);
+                        resolve({ success: true });
+                    }
+                });
+            });
+        });
+    }
+    catch (error) {
+        log(`  复制 framework 异常: ${error.message || String(error)}`);
+        return {
+            success: false,
+            error: `复制 framework 失败: ${error.message || String(error)}`,
+        };
+    }
+}
+export async function integrateNativePluginIOS(projectPath, projectName, pluginPath, deps, parameters) {
+    try {
+        deps.log?.(`开始集成 UniApp 原生插件: ${pluginPath}`);
+        deps.log?.("步骤 1: 解压插件");
+        const tempDir = deps.join(projectPath, ".temp");
+        if (deps.existsSync(tempDir)) {
+            deps.log?.("清理已存在的临时目录...");
+            await new Promise((resolve) => {
+                deps.exec(`rm -rf "${tempDir}"`, (error) => {
+                    if (error) {
+                        deps.log?.(`警告: 清理临时目录失败: ${error.message}`);
+                    }
+                    else {
+                        deps.log?.("临时目录已清理");
+                    }
+                    resolve();
+                });
+            });
+        }
+        if (!deps.existsSync(tempDir)) {
+            deps.mkdirSync(tempDir, { recursive: true });
+            deps.log?.("已创建临时目录");
+        }
+        const extractResult = await extractPlugin(pluginPath, tempDir, {
+            existsSync: deps.existsSync,
+            readdirSync: deps.readdirSync,
+            statSync: deps.statSync,
+            join: deps.join,
+            exec: deps.exec,
+            basename: deps.basename,
+            dirname: deps.dirname,
+            mkdirSync: deps.mkdirSync,
+            log: deps.log,
+            setTimeout: deps.setTimeout,
+            clearTimeout: deps.clearTimeout,
+        });
+        if (!extractResult.success) {
+            return {
+                success: false,
+                error: extractResult.error,
+                logs: [],
+            };
+        }
+        const pluginDir = extractResult.extractedPath;
+        deps.log?.(`插件已解压到: ${pluginDir}`);
+        deps.log?.("步骤 2: 读取插件配置");
+        const packageJsonResult = readPluginPackageJson(pluginDir, {
+            existsSync: deps.existsSync,
+            readFileSync: deps.readFileSync,
+            join: deps.join,
+            parse: deps.parse,
+        });
+        if (!packageJsonResult.success) {
+            return {
+                success: false,
+                error: packageJsonResult.error,
+                logs: [],
+            };
+        }
+        const packageJson = packageJsonResult.packageJson;
+        deps.log?.(`插件名称: ${packageJson.name}`);
+        deps.log?.(`插件 ID: ${packageJson.id}`);
+        deps.log?.(`插件版本: ${packageJson.version}`);
+        deps.log?.("步骤 3: 提取 iOS 插件配置");
+        const configResult = extractIOSPluginConfig(packageJson);
+        if (!configResult.success) {
+            return {
+                success: false,
+                error: configResult.error,
+                logs: [],
+            };
+        }
+        const { plugins: pluginItems, hooksClass, frameworks, embedFrameworks, resources, privacies, parameters: pluginParameters, } = configResult;
+        deps.log?.(`找到 ${pluginItems.length} 个插件`);
+        if (hooksClass) {
+            deps.log?.(`Hooks 类: ${hooksClass}`);
+        }
+        deps.log?.("步骤 4: 复制插件文件");
+        const iosDir = deps.join(pluginDir, "ios");
+        deps.log?.(`  iosDir: ${iosDir}`);
+        deps.log?.(`  iosDir 存在: ${deps.existsSync(iosDir)}`);
+        if (!deps.existsSync(iosDir)) {
+            return {
+                success: false,
+                error: `插件 ios 目录不存在: ${iosDir}`,
+                logs: [],
+            };
+        }
+        deps.log?.("步骤 4.1: 查找静态库 (.a)");
+        const findLibStartTime = Date.now();
+        const staticLibs = findFilesRecursive(iosDir, [".a"], deps);
+        const findLibTime = Date.now() - findLibStartTime;
+        deps.log?.(`  找到 ${staticLibs.length} 个静态库 (查找耗时: ${findLibTime}ms)`);
+        const libsDir = deps.join(projectPath, "libs");
+        if (!deps.existsSync(libsDir)) {
+            deps.mkdirSync(libsDir, { recursive: true });
+        }
+        for (const libPath of staticLibs) {
+            const libName = deps.basename(libPath);
+            const targetPath = deps.join(libsDir, libName);
+            deps.copyFileSync(libPath, targetPath);
+            deps.log?.(`已复制静态库: ${libName}`);
+        }
+        deps.log?.("步骤 4.2: 查找 framework");
+        deps.log?.(`  搜索目录: ${iosDir}`);
+        const findFrameworkStartTime = Date.now();
+        const allFrameworks = findFilesRecursive(iosDir, [".framework"], deps);
+        const findFrameworkTime = Date.now() - findFrameworkStartTime;
+        deps.log?.(`找到 ${allFrameworks.length} 个 framework (查找耗时: ${findFrameworkTime}ms)`);
+        const frameworksDir = deps.join(projectPath, "Frameworks");
+        if (!deps.existsSync(frameworksDir)) {
+            deps.mkdirSync(frameworksDir, { recursive: true });
+        }
+        for (const frameworkPath of allFrameworks) {
+            const frameworkName = deps.basename(frameworkPath);
+            deps.log?.(`开始复制 framework: ${frameworkName}`);
+            const targetPath = deps.join(frameworksDir, frameworkName);
+            const copyResult = await copyFrameworkUsingArchive(frameworkPath, targetPath, {
+                existsSync: deps.existsSync,
+                readdirSync: deps.readdirSync,
+                join: deps.join,
+                dirname: deps.dirname,
+                exec: deps.exec,
+                basename: deps.basename,
+                mkdirSync: deps.mkdirSync,
+                copyFileSync: deps.copyFileSync,
+            }, deps.log);
+            if (copyResult.success) {
+                deps.log?.(`已复制 framework: ${frameworkName}`);
+            }
+            else {
+                deps.log?.(`警告: 复制 framework 失败 (${frameworkName}): ${copyResult.error}`);
+            }
+        }
+        deps.log?.("步骤 4.4: 查找 xcframework");
+        const findXcframeworkStartTime = Date.now();
+        const xcframeworks = findFilesRecursive(iosDir, [".xcframework"], deps);
+        const findXcframeworkTime = Date.now() - findXcframeworkStartTime;
+        deps.log?.(`  找到 ${xcframeworks.length} 个 xcframework (查找耗时: ${findXcframeworkTime}ms)`);
+        for (const xcframeworkPath of xcframeworks) {
+            const xcframeworkName = deps.basename(xcframeworkPath);
+            const targetPath = deps.join(frameworksDir, xcframeworkName);
+            deps.log?.(`开始复制 xcframework: ${xcframeworkName}`);
+            const copyResult = await copyFrameworkUsingArchive(xcframeworkPath, targetPath, {
+                existsSync: deps.existsSync,
+                readdirSync: deps.readdirSync,
+                join: deps.join,
+                dirname: deps.dirname,
+                exec: deps.exec,
+                basename: deps.basename,
+                mkdirSync: deps.mkdirSync,
+                copyFileSync: deps.copyFileSync,
+            }, deps.log);
+            if (copyResult.success) {
+                deps.log?.(`已复制 xcframework: ${xcframeworkName}`);
+            }
+            else {
+                deps.log?.(`警告: 复制 xcframework 失败 (${xcframeworkName}): ${copyResult.error}`);
+            }
+        }
+        deps.log?.("步骤 4.5: 复制资源文件");
+        if (resources && resources.length > 0) {
+            const resourcesTargetDir = deps.join(projectPath, projectName, "Resources");
+            if (!deps.existsSync(resourcesTargetDir)) {
+                deps.mkdirSync(resourcesTargetDir, { recursive: true });
+            }
+            for (const resourcePath of resources) {
+                const sourcePath = deps.join(iosDir, resourcePath);
+                if (deps.existsSync(sourcePath)) {
+                    const resourceName = deps.basename(resourcePath);
+                    const targetPath = deps.join(resourcesTargetDir, resourceName);
+                    const stat = deps.statSync(sourcePath);
+                    if (stat.isDirectory()) {
+                        await deps.cp(sourcePath, targetPath, {
+                            recursive: true,
+                            force: true,
+                        });
+                    }
+                    else {
+                        deps.copyFileSync(sourcePath, targetPath);
+                    }
+                    deps.log?.(`已复制资源文件: ${resourceName}`);
+                }
+                else {
+                    deps.log?.(`警告: 资源文件不存在: ${sourcePath}`);
+                }
+            }
+        }
+        deps.log?.("步骤 4.6: 查找头文件 (.h)");
+        const findHeaderStartTime = Date.now();
+        const headers = findFilesRecursive(iosDir, [".h"], deps);
+        const findHeaderTime = Date.now() - findHeaderStartTime;
+        deps.log?.(`  找到 ${headers.length} 个头文件 (查找耗时: ${findHeaderTime}ms)`);
+        const headersDir = deps.join(projectPath, projectName, "NativePlugins");
+        if (headers.length > 0) {
+            if (!deps.existsSync(headersDir)) {
+                deps.mkdirSync(headersDir, { recursive: true });
+            }
+            for (const headerPath of headers) {
+                const headerName = deps.basename(headerPath);
+                const targetPath = deps.join(headersDir, headerName);
+                deps.copyFileSync(headerPath, targetPath);
+                deps.log?.(`已复制头文件: ${headerName}`);
+            }
+        }
+        deps.log?.("步骤 5: 修改 Info.plist");
+        const infoPlistPath = deps.join(projectPath, projectName, `${projectName}-Info.plist`);
+        if (deps.existsSync(infoPlistPath)) {
+            try {
+                const xmlContent = deps.readFileSync(infoPlistPath, "utf8");
+                const parser = new deps.xmlParser();
+                const xmlDoc = parser.parseFromString(xmlContent, "text/xml");
+                addPluginToInfoPlist(xmlDoc, pluginItems, hooksClass || "");
+                deps.log?.("已添加插件信息到 dcloud_uniplugins");
+                if (privacies && privacies.length > 0) {
+                    addPrivaciesToInfoPlist(xmlDoc, privacies);
+                    deps.log?.(`已添加 ${privacies.length} 个隐私权限描述`);
+                }
+                if (pluginParameters && parameters) {
+                    addPluginParametersToInfoPlist(xmlDoc, pluginParameters, parameters);
+                    deps.log?.("已添加插件参数配置");
+                }
+                const serializer = new deps.xmlSerializer();
+                const newXmlContent = serializer.serializeToString(xmlDoc);
+                deps.writeFileSync(infoPlistPath, newXmlContent, "utf8");
+                deps.log?.("Info.plist 修改完成");
+            }
+            catch (error) {
+                deps.log?.(`修改 Info.plist 失败: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        deps.log?.("步骤 6: 添加文件到 Xcode 项目");
+        const projectFiles = deps
+            .readdirSync(projectPath)
+            .filter((file) => file.endsWith(".xcodeproj"));
+        if (projectFiles.length === 0) {
+            deps.log?.("警告: 未找到 .xcodeproj 文件，跳过 Xcode 项目配置");
+        }
+        else {
+            const projectFile = projectFiles[0];
+            const projectPbxprojPath = deps.join(projectPath, projectFile, "project.pbxproj");
+            for (const libPath of staticLibs) {
+                const libName = deps.basename(libPath);
+                const relativePath = `libs/${libName}`;
+                const addResult = addFileToXcodeProject(projectPbxprojPath, relativePath, "staticLibrary", {
+                    existsSync: deps.existsSync,
+                    readFileSync: deps.readFileSync,
+                    writeFileSync: deps.writeFileSync,
+                });
+                if (addResult.success) {
+                    deps.log?.(`已添加到 Xcode 项目: ${libName}`);
+                }
+                else {
+                    deps.log?.(`警告: 添加到 Xcode 项目失败: ${addResult.error}`);
+                }
+            }
+            const embedFrameworkNames = new Set((embedFrameworks || []).map((name) => {
+                return name.endsWith(".framework") ? name : `${name}.framework`;
+            }));
+            const frameworksToEmbed = [];
+            const frameworksToLink = [];
+            for (const frameworkPath of allFrameworks) {
+                const frameworkName = deps.basename(frameworkPath);
+                if (embedFrameworkNames.has(frameworkName)) {
+                    frameworksToEmbed.push(frameworkPath);
+                }
+                else {
+                    frameworksToLink.push(frameworkPath);
+                }
+            }
+            if (frameworksToEmbed.length > 0) {
+                deps.log?.(`步骤 6.2.1: 添加 ${frameworksToEmbed.length} 个 framework 到 Link Binary With Libraries 和 Embed Frameworks`);
+                for (const frameworkPath of frameworksToEmbed) {
+                    const frameworkName = deps.basename(frameworkPath);
+                    const relativePath = `Frameworks/${frameworkName}`;
+                    const linkResult = addFileToXcodeProject(projectPbxprojPath, relativePath, "framework", {
+                        existsSync: deps.existsSync,
+                        readFileSync: deps.readFileSync,
+                        writeFileSync: deps.writeFileSync,
+                    });
+                    if (!linkResult.success) {
+                        deps.log?.(`警告: 添加到 Link Binary With Libraries 失败: ${linkResult.error}`);
+                    }
+                    const embedResult = addFileToEmbedFrameworks(projectPbxprojPath, relativePath, {
+                        existsSync: deps.existsSync,
+                        readFileSync: deps.readFileSync,
+                        writeFileSync: deps.writeFileSync,
+                    });
+                    if (embedResult.success) {
+                        deps.log?.(`已添加到 Embed Frameworks: ${frameworkName}`);
+                    }
+                    else {
+                        deps.log?.(`警告: 添加到 Embed Frameworks 失败: ${embedResult.error}`);
+                    }
+                }
+            }
+            if (frameworksToLink.length > 0) {
+                deps.log?.(`步骤 6.2.2: 添加 ${frameworksToLink.length} 个 framework 到 Link Binary With Libraries`);
+                for (const frameworkPath of frameworksToLink) {
+                    const frameworkName = deps.basename(frameworkPath);
+                    const relativePath = `Frameworks/${frameworkName}`;
+                    const addResult = addFileToXcodeProject(projectPbxprojPath, relativePath, "framework", {
+                        existsSync: deps.existsSync,
+                        readFileSync: deps.readFileSync,
+                        writeFileSync: deps.writeFileSync,
+                    });
+                    if (addResult.success) {
+                        deps.log?.(`已添加到 Link Binary With Libraries: ${frameworkName}`);
+                    }
+                    else {
+                        deps.log?.(`警告: 添加到 Link Binary With Libraries 失败: ${addResult.error}`);
+                    }
+                }
+            }
+            for (const xcframeworkPath of xcframeworks) {
+                const xcframeworkName = deps.basename(xcframeworkPath);
+                const relativePath = `Frameworks/${xcframeworkName}`;
+                const addResult = addFileToXcodeProject(projectPbxprojPath, relativePath, "framework", {
+                    existsSync: deps.existsSync,
+                    readFileSync: deps.readFileSync,
+                    writeFileSync: deps.writeFileSync,
+                });
+                if (addResult.success) {
+                    deps.log?.(`已添加到 Xcode 项目: ${xcframeworkName}`);
+                }
+                else {
+                    deps.log?.(`警告: 添加到 Xcode 项目失败: ${addResult.error}`);
+                }
+            }
+            if (resources && resources.length > 0) {
+                for (const resourcePath of resources) {
+                    const resourceName = deps.basename(resourcePath);
+                    const relativePath = `${projectName}/Resources/${resourceName}`;
+                    const addResult = addFileToXcodeProject(projectPbxprojPath, relativePath, "bundle", {
+                        existsSync: deps.existsSync,
+                        readFileSync: deps.readFileSync,
+                        writeFileSync: deps.writeFileSync,
+                    });
+                    if (addResult.success) {
+                        deps.log?.(`已添加资源到 Xcode 项目: ${resourceName}`);
+                    }
+                    else {
+                        deps.log?.(`警告: 添加资源到 Xcode 项目失败: ${addResult.error}`);
+                    }
+                }
+            }
+            if (frameworks && frameworks.length > 0) {
+                deps.log?.("注意: 系统库需要手动在 Xcode 中添加到 Link Binary With Libraries:");
+                for (const framework of frameworks) {
+                    deps.log?.(`  - ${framework}`);
+                }
+            }
+            deps.log?.("步骤 6.8: 检查插件依赖");
+            const pluginFrameworkDir = deps.join(pluginDir, "ios");
+            if (deps.existsSync(pluginFrameworkDir)) {
+                try {
+                    const frameworkFiles = findFilesRecursive(pluginFrameworkDir, [".m", ".mm", ".swift"], deps);
+                    let hasSVGKitImport = false;
+                    for (const file of frameworkFiles) {
+                        try {
+                            const content = deps.readFileSync(file, "utf8");
+                            if (content.includes("SVGKit") || content.includes("SVGKImage")) {
+                                hasSVGKitImport = true;
+                                break;
+                            }
+                        }
+                        catch {
+                        }
+                    }
+                    if (hasSVGKitImport) {
+                        deps.log?.("⚠️  警告: 插件使用了 SVGKit 库，但主项目中可能未包含该库");
+                        deps.log?.("   解决方案 1: 在主项目中使用 CocoaPods 安装 SVGKit");
+                        deps.log?.('     1. 在主项目根目录创建 Podfile，添加: pod "SVGKit", "~> 3.0"');
+                        deps.log?.("     2. 运行: pod install");
+                        deps.log?.("     3. 使用 .xcworkspace 打开项目");
+                        deps.log?.("   解决方案 2: 手动下载 SVGKit.framework 并添加到项目中");
+                        deps.log?.("   解决方案 3: 如果不需要 SVG 支持，可以移除插件中的 SVG 相关代码");
+                    }
+                }
+                catch (error) {
+                }
+            }
+            if (allFrameworks.length > 0 ||
+                xcframeworks.length > 0) {
+                deps.log?.("步骤 6.7: 更新 FRAMEWORK_SEARCH_PATHS");
+                try {
+                    let content = deps.readFileSync(projectPbxprojPath, "utf8");
+                    const frameworksSearchPath = '"$(PROJECT_DIR)/Frameworks"';
+                    let modified = false;
+                    const frameworkSearchPathsRegex = /(FRAMEWORK_SEARCH_PATHS\s*=\s*\()([\s\S]*?)(\t+\);)/g;
+                    const matches = [];
+                    let match;
+                    while ((match = frameworkSearchPathsRegex.exec(content)) !== null) {
+                        matches.push({
+                            full: match[0],
+                            start: match[1],
+                            middle: match[2],
+                            end: match[3],
+                            index: match.index
+                        });
+                    }
+                    for (let i = matches.length - 1; i >= 0; i--) {
+                        const m = matches[i];
+                        const currentPaths = m.middle.trim();
+                        if (!currentPaths.includes("Frameworks") &&
+                            !currentPaths.includes(frameworksSearchPath)) {
+                            const indent = m.end.match(/^\t+/)?.[0] || '\t\t\t\t';
+                            const newPathEntry = `${indent}${frameworksSearchPath},\n`;
+                            const newMiddle = currentPaths
+                                ? `${currentPaths}\n${newPathEntry}`
+                                : newPathEntry;
+                            const newContent = `${m.start}${newMiddle}${m.end}`;
+                            const before = content.substring(0, m.index);
+                            const after = content.substring(m.index + m.full.length);
+                            content = before + newContent + after;
+                            modified = true;
+                        }
+                    }
+                    if (modified) {
+                        deps.writeFileSync(projectPbxprojPath, content, "utf8");
+                        deps.log?.(`已添加 Frameworks 目录到所有 FRAMEWORK_SEARCH_PATHS 配置`);
+                    }
+                    else {
+                        deps.log?.(`所有 FRAMEWORK_SEARCH_PATHS 已包含 Frameworks 目录`);
+                    }
+                }
+                catch (error) {
+                    deps.log?.(`警告: 更新 FRAMEWORK_SEARCH_PATHS 失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        deps.log?.("步骤 7: 清理临时文件");
+        try {
+            deps.log?.(`  检查临时目录: ${tempDir}`);
+            if (deps.existsSync(tempDir)) {
+                deps.log?.(`  开始清理临时目录: ${tempDir}`);
+                await new Promise((resolve) => {
+                    const timeout = deps.setTimeout(() => {
+                        deps.log?.(`警告: 清理临时目录超时: ${tempDir}`);
+                        resolve();
+                    }, 5000);
+                    deps.exec(`rm -rf "${tempDir}"`, (error) => {
+                        deps.clearTimeout(timeout);
+                        if (error) {
+                            deps.log?.(`警告: 清理临时目录失败: ${tempDir} (${error.message})`);
+                        }
+                        else {
+                            deps.log?.(`✓ 已清理临时目录: ${tempDir}`);
+                        }
+                        resolve();
+                    });
+                });
+            }
+            else {
+                deps.log?.(`  临时目录不存在，跳过清理: ${tempDir}`);
+            }
+            const frameworksDir = deps.join(projectPath, "Frameworks");
+            const frameworkTempDir = deps.join(frameworksDir, ".temp_framework_copy");
+            deps.log?.(`  检查 framework 临时目录: ${frameworkTempDir}`);
+            if (deps.existsSync(frameworkTempDir)) {
+                deps.log?.(`  开始清理 framework 临时目录: ${frameworkTempDir}`);
+                await new Promise((resolve) => {
+                    const timeout = deps.setTimeout(() => {
+                        deps.log?.(`警告: 清理 framework 临时目录超时: ${frameworkTempDir}`);
+                        resolve();
+                    }, 5000);
+                    deps.exec(`rm -rf "${frameworkTempDir}"`, (error) => {
+                        deps.clearTimeout(timeout);
+                        if (error) {
+                            deps.log?.(`警告: 清理 framework 临时目录失败: ${frameworkTempDir} (${error.message})`);
+                        }
+                        else {
+                            deps.log?.(`✓ 已清理 framework 临时目录: ${frameworkTempDir}`);
+                        }
+                        resolve();
+                    });
+                });
+            }
+            else {
+                deps.log?.(`  framework 临时目录不存在，跳过清理: ${frameworkTempDir}`);
+            }
+            deps.log?.("✓ 清理临时文件完成");
+        }
+        catch (cleanupError) {
+            deps.log?.(`警告: 清理临时文件时出错: ${cleanupError instanceof Error
+                ? cleanupError.message
+                : String(cleanupError)}`);
+        }
+        deps.log?.("原生插件集成完成");
+        return {
+            success: true,
+            message: "原生插件集成成功",
+            logs: [],
+        };
+    }
+    catch (error) {
+        deps.log?.(`原生插件集成异常: ${error instanceof Error ? error.message : String(error)}`);
+        try {
+            const tempDir = deps.join(projectPath, ".temp");
+            if (deps.existsSync(tempDir)) {
+                deps.exec(`rm -rf "${tempDir}"`, () => { });
+            }
+            const frameworksDir = deps.join(projectPath, "Frameworks");
+            const frameworkTempDir = deps.join(frameworksDir, ".temp_framework_copy");
+            if (deps.existsSync(frameworkTempDir)) {
+                deps.exec(`rm -rf "${frameworkTempDir}"`, () => { });
+            }
+        }
+        catch { }
+        return {
+            success: false,
+            error: `原生插件集成异常: ${error instanceof Error ? error.message : String(error)}`,
+            logs: [],
+        };
+    }
+}
+//# sourceMappingURL=integrateNativePlugin.js.map