"use strict"; var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", { value: true }); exports.resolveUasmCopyAssets = exports.resolveUasmLoadPath = exports.resolveUasmWebLoad = exports.parseUasmModuleName = exports.resolveUasmModule = exports.resolveUasmTargetArch = exports.getUasmModules = exports.uniUasmPlugin = exports.initUasmModules = exports.createLoadUasmTransformer = exports.initUasmWebTransformOptions = exports.initUasmTransformerCreator = exports.initUasmTransformOptions = exports.parseUniAppXTargetArchs = void 0; const fs_extra_1 = __importDefault(require("fs-extra")); const node_path_1 = __importDefault(require("node:path")); const fast_glob_1 = require("fast-glob"); const utils_1 = require("./utils"); const uts_1 = require("./uts"); const UASM_PLATFORMS = ['app-android', 'app-ios', 'app-harmony']; const UASM_IOS_MANIFEST_VERSION = 1; let uasmModules = Object.create(null); function parseUniAppXTargetArchs(value = process.env.UNI_APP_X_TARGET_ARCHS) { if (!value) { return []; } try { const targetArchs = JSON.parse(value); return Array.isArray(targetArchs) ? targetArchs.filter((arch) => typeof arch === 'string' && !!arch) : []; } catch { return []; } } exports.parseUniAppXTargetArchs = parseUniAppXTargetArchs; function initUasmTransformOptions(platform) { return { targetArchs: parseUniAppXTargetArchs(), resolve: (modulePath) => resolveUasmLoadPath(modulePath, platform), createLoadUasmTransformer, }; } exports.initUasmTransformOptions = initUasmTransformOptions; function initUasmTransformerCreator(platform) { if (process.env.UNI_APP_X_DOM2 !== 'true') { return; } const options = initUasmTransformOptions(platform); return (typescript) => ({ before: options.createLoadUasmTransformer({ ...options, typescript, resolveLoader: platform === 'app-android' ? resolveUasmAndroidLoader : platform === 'app-ios' ? resolveUasmIOSLoader : undefined, resolveType: platform === 'app-harmony' ? resolveUasmHarmonyType : undefined, reportDiagnostic(context, diagnostic) { const utsContext = context; if (utsContext.error) { utsContext.error(diagnostic); } else { throw new Error(diagnostic.messageText.toString()); } }, }), }); } exports.initUasmTransformerCreator = initUasmTransformerCreator; function initUasmWebTransformOptions() { return { resolve: resolveUasmWebLoad, createLoadUasmTransformer(options) { return createLoadUasmTransformer({ ...options, methodNames: ['loadUasm'], resolveError(modulePath) { const moduleName = parseUasmModuleName(modulePath); const entry = moduleName ? `uni_modules/${moduleName}/uasm/web/${moduleName}.js` : 'uni_modules/<插件ID>/uasm/web/<插件ID>.js'; return `无法加载 uasm 插件[${modulePath}],请确认插件路径正确,且插件已提供入口文件 ${entry}`; }, }); }, }; } exports.initUasmWebTransformOptions = initUasmWebTransformOptions; function createUasmDiagnostic(options, sourceFile, node, messageText) { return { file: sourceFile, start: node.getStart(sourceFile), length: node.getWidth(sourceFile), code: 0, category: options.typescript.DiagnosticCategory.Error, messageText, }; } function createLoadUasmTransformer(options) { const { typescript, resolve, reportDiagnostic } = options; const methodNames = new Set(options.methodNames || ['loadUasm', 'loadUasmSync']); const targetArchs = options.targetArchs?.join(', ') || '未指定'; return (context) => { const { factory } = context; return (sourceFile) => { const imports = new Set(); const typeImports = new Map(); const staticImports = new Map(); const resolveStaticImport = (resolved) => { if (resolved.import !== 'static') { return; } let identifier = staticImports.get(resolved.entry); if (!identifier) { let index = 0; do { identifier = `__uniUasmModule${index++}`; } while (sourceFile.text.includes(identifier) || Array.from(staticImports.values()).includes(identifier)); staticImports.set(resolved.entry, identifier); options.onSourceEdit?.({ start: 0, end: 0, content: `import ${identifier} from ${JSON.stringify(resolved.entry)};\n`, }); } return identifier; }; const visitor = (node) => { if (typescript.isCallExpression(node) && node.arguments.length >= 1 && typescript.isPropertyAccessExpression(node.expression) && methodNames.has(node.expression.name.text) && typescript.isIdentifier(node.expression.expression) && node.expression.expression.escapedText === 'uni') { const methodName = node.expression.name.text; const firstArg = node.arguments[0]; if (!typescript.isStringLiteral(firstArg) && !typescript.isNoSubstitutionTemplateLiteral(firstArg)) { reportDiagnostic(context, createUasmDiagnostic(options, sourceFile, firstArg, `uni.${methodName}(modulePath) 的 modulePath 参数必须是字符串字面量`)); return node; } const resolved = resolve(firstArg.text); if (!resolved) { reportDiagnostic(context, createUasmDiagnostic(options, sourceFile, firstArg, options.resolveError?.(firstArg.text) || `无法加载 uasm 插件[${firstArg.text}],当前设备支持的 ABI:${targetArchs}。请确认插件路径正确,且插件已提供匹配的库文件`)); return node; } const staticImport = typeof resolved === 'string' ? undefined : resolveStaticImport(resolved); const loader = options.resolveLoader?.(firstArg.text); if (loader && typeof loader !== 'string') { loader.imports?.forEach((module) => imports.add(module)); } const type = options.resolveType?.(firstArg.text); if (type && !node.typeArguments?.length) { typeImports.set(type.source, type.name); } options.onSourceEdit?.({ start: firstArg.getStart(sourceFile), end: firstArg.getEnd(), content: resolveUasmSourceEdit(resolved, staticImport), }); return factory.updateCallExpression(node, node.expression, type && !node.typeArguments?.length ? [factory.createTypeReferenceNode(type.name)] : node.typeArguments, [ typeof resolved === 'string' ? factory.createStringLiteral(resolved) : factory.createObjectLiteralExpression([ factory.createPropertyAssignment('id', factory.createStringLiteral(resolved.id)), factory.createPropertyAssignment('loader', factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(typescript.SyntaxKind.EqualsGreaterThanToken), staticImport ? factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Promise'), 'resolve'), undefined, [ factory.createObjectLiteralExpression([ factory.createPropertyAssignment('default', factory.createIdentifier(staticImport)), ]), ]) : factory.createCallExpression(factory.createToken(typescript.SyntaxKind.ImportKeyword), undefined, [factory.createStringLiteral(resolved.entry)]))), ], false), ...(loader ? [createUasmLoader(factory, loader, typescript)] : []), ...node.arguments.slice(1), ]); } return typescript.visitEachChild(node, visitor, context); }; const transformed = typescript.visitNode(sourceFile, visitor); if (!imports.size && !typeImports.size && !staticImports.size) { return transformed; } return factory.updateSourceFile(transformed, [ ...Array.from(staticImports).map(([entry, identifier]) => factory.createImportDeclaration(undefined, factory.createImportClause(false, factory.createIdentifier(identifier), undefined), factory.createStringLiteral(entry))), ...Array.from(imports).map((module) => factory.createImportDeclaration(undefined, undefined, factory.createStringLiteral(module))), ...Array.from(typeImports).map(([source, name]) => factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([ factory.createImportSpecifier(false, undefined, factory.createIdentifier(name)), ])), factory.createStringLiteral(source))), ...transformed.statements, ]); }; }; } exports.createLoadUasmTransformer = createLoadUasmTransformer; function resolveUasmAndroidLoader(modulePath) { const moduleName = parseUasmModuleName(modulePath); if (!moduleName) { return; } const packageName = (0, uts_1.parseKotlinPackageWithPluginId)(moduleName, true); const className = (0, utils_1.capitalize)((0, utils_1.camelize)(moduleName)); return `${packageName}.${className}`; } function resolveUasmIOSLoader(modulePath) { const moduleName = parseUasmModuleName(modulePath); if (!moduleName) { return; } const swiftModule = (0, uts_1.parseSwiftModuleWithPluginId)(moduleName, true); const className = (0, utils_1.capitalize)((0, utils_1.camelize)(moduleName)); const type = `${swiftModule}.${className}`; return { type: `${type}.Type`, value: `${type}.self`, imports: [swiftModule], }; } function resolveUasmHarmonyType(modulePath) { const moduleName = parseUasmModuleName(modulePath); if (!moduleName) { return; } const typeName = (0, utils_1.capitalize)((0, utils_1.camelize)(moduleName)); return { name: typeName, source: `@/uni_modules/${moduleName}`, }; } function createUasmLoader(factory, loader, typescript) { const descriptor = typeof loader === 'string' ? { type: loader, value: loader } : loader; const [firstType, ...restType] = descriptor.type.split('.'); const typeName = restType.reduce((typeName, name) => factory.createQualifiedName(typeName, name), factory.createIdentifier(firstType)); const [firstValue, ...restValue] = descriptor.value.split('.'); const expression = restValue.reduce((expression, name) => factory.createPropertyAccessExpression(expression, name), factory.createIdentifier(firstValue)); return factory.createArrowFunction(undefined, undefined, [], factory.createTypeReferenceNode(typeName), factory.createToken(typescript.SyntaxKind.EqualsGreaterThanToken), expression); } function resolveUasmSourceEdit(resolved, staticImport) { if (typeof resolved === 'string') { return JSON.stringify(resolved); } const loader = staticImport ? `Promise.resolve({ default: ${staticImport} })` : `import(${JSON.stringify(resolved.entry)})`; return `{ id: ${JSON.stringify(resolved.id)}, loader: () => ${loader} }`; } function initUasmModules(inputDir) { uasmModules = scanUasmModules(inputDir, UASM_PLATFORMS); return uasmModules; } exports.initUasmModules = initUasmModules; function uniUasmPlugin(inputDir = process.env.UNI_INPUT_DIR) { let processed = false; initUasmModules(inputDir); return { name: 'uni:uasm', apply: 'build', enforce: 'post', writeBundle() { if (processed || !shouldCopyUasmIOSFrameworks()) { return; } copyUasmIOSFrameworks(inputDir); processed = true; }, }; } exports.uniUasmPlugin = uniUasmPlugin; function shouldCopyUasmIOSFrameworks() { return (process.env.UNI_UTS_PLATFORM === 'app-ios' && (process.env.UNI_NODE_ENV || process.env.NODE_ENV) === 'development' && process.env.UNI_APP_X_DOM2 === 'true' && !process.env.UNI_COMPILE_TARGET); } function copyUasmIOSFrameworks(inputDir) { const dependenciesDir = process.env.HX_DEPENDENCIES_DIR; if (!dependenciesDir) { return; } const libraryIdentifier = process.env.HX_RUN_DEVICE_TYPE === 'ios_simulator' ? 'ios-arm64_x86_64-simulator' : 'ios-arm64'; const targetDir = node_path_1.default.resolve(dependenciesDir, 'modules'); for (const module of Object.values(uasmModules)) { const resources = module.platforms['app-ios']; if (!resources) { continue; } const frameworksDir = node_path_1.default.resolve(inputDir, resources.dir); const pluginRelativeDir = node_path_1.default.join('uni_modules', module.name, 'uasm'); const manifestFile = node_path_1.default.resolve(dependenciesDir, 'app-ios', 'uasm', pluginRelativeDir, 'manifest.json'); const sourceDirs = fs_extra_1.default .readdirSync(frameworksDir, { withFileTypes: true }) .filter((entry) => isDirectoryEntry(frameworksDir, entry) && entry.name.endsWith('.xcframework')) .map((entry) => ({ name: entry.name, dir: node_path_1.default.resolve(frameworksDir, entry.name, libraryIdentifier), })) .filter(({ dir }) => fs_extra_1.default.existsSync(dir)) .sort((a, b) => a.name.localeCompare(b.name)); const manifest = resolveUasmIOSCopyManifest(sourceDirs, libraryIdentifier); const oldManifest = readUasmIOSCopyManifest(manifestFile); if (JSON.stringify(oldManifest) === JSON.stringify(manifest)) { continue; } sourceDirs.forEach(({ dir }) => fs_extra_1.default.copySync(dir, targetDir, { overwrite: true })); fs_extra_1.default.outputJsonSync(manifestFile, manifest, { spaces: 2 }); } } function resolveUasmIOSCopyManifest(sourceDirs, libraryIdentifier) { const manifest = { version: UASM_IOS_MANIFEST_VERSION, libraryIdentifier, files: Object.create(null), }; sourceDirs.forEach(({ name, dir }) => { (0, fast_glob_1.sync)('**/*', { cwd: dir, dot: true, onlyFiles: false, followSymbolicLinks: false, }) .sort() .forEach((file) => { const absoluteFile = node_path_1.default.resolve(dir, file); const stat = fs_extra_1.default.lstatSync(absoluteFile); if (!stat.isFile() && !stat.isSymbolicLink()) { return; } const manifestFile = { size: stat.size, mtimeMs: stat.mtimeMs, mode: stat.mode, }; if (stat.isSymbolicLink()) { manifestFile.link = fs_extra_1.default.readlinkSync(absoluteFile); } manifest.files[(0, utils_1.normalizePath)(node_path_1.default.join(name, file))] = manifestFile; }); }); return manifest; } function readUasmIOSCopyManifest(file) { try { return fs_extra_1.default.readJsonSync(file); } catch { } } function scanUasmModules(inputDir, platformsToScan) { const modules = Object.create(null); const uniModulesDir = node_path_1.default.resolve(inputDir, 'uni_modules'); if (!fs_extra_1.default.existsSync(uniModulesDir)) { return modules; } fs_extra_1.default.readdirSync(uniModulesDir, { withFileTypes: true }).forEach((entry) => { if (!isDirectoryEntry(uniModulesDir, entry)) { return; } const platforms = {}; for (const platform of platformsToScan) { const resources = scanUasmPlatform(inputDir, entry.name, platform); if (resources) { platforms[platform] = resources; } } const web = scanUasmWeb(inputDir, entry.name); if (Object.keys(platforms).length || web) { modules[entry.name] = { name: entry.name, platforms, ...(web ? { web } : {}), }; } }); return modules; } function getUasmModules() { return uasmModules; } exports.getUasmModules = getUasmModules; function resolveUasmTargetArch(moduleName, platform, targetArchs = parseUniAppXTargetArchs()) { const archs = uasmModules[moduleName]?.platforms[platform]?.archs; return archs && targetArchs.find((arch) => archs[arch]); } exports.resolveUasmTargetArch = resolveUasmTargetArch; function resolveUasmModule(moduleName, platform, targetArchs = parseUniAppXTargetArchs()) { return resolveUasmModuleFrom(uasmModules, moduleName, platform, targetArchs); } exports.resolveUasmModule = resolveUasmModule; function parseUasmModuleName(modulePath) { const normalized = modulePath.replace(/^@?\//, ''); return /^uni_modules\/([^/]+)$/.exec(normalized)?.[1]; } exports.parseUasmModuleName = parseUasmModuleName; function resolveUasmLibraryFileName(moduleName) { return `libUasm${(0, utils_1.capitalize)((0, utils_1.camelize)(moduleName))}.so`; } function resolveUasmWebLoad(modulePath) { const moduleName = parseUasmModuleName(modulePath); const entry = moduleName && uasmModules[moduleName]?.web?.entry; if (!moduleName || !entry) { return; } return { id: moduleName, entry: `@/${entry}`, }; } exports.resolveUasmWebLoad = resolveUasmWebLoad; function resolveUasmLoadPath(modulePath, platform, isProduction = (process.env.UNI_NODE_ENV || process.env.NODE_ENV) !== 'development', targetArchs = parseUniAppXTargetArchs()) { const moduleName = parseUasmModuleName(modulePath); if (!moduleName || !uasmModules[moduleName]?.platforms[platform]) { return; } if (platform === 'app-ios') { return `Uasm${(0, utils_1.capitalize)((0, utils_1.camelize)(moduleName))}`; } const libraryName = resolveUasmLibraryFileName(moduleName); if (isProduction) { return libraryName; } const file = resolveUasmModule(moduleName, platform, targetArchs)?.file; if (!file) { return; } return platform === 'app-harmony' ? libraryName : file; } exports.resolveUasmLoadPath = resolveUasmLoadPath; function resolveUasmModuleFrom(modules, moduleName, platform, targetArchs) { const resources = modules[moduleName]?.platforms[platform]; if (!resources) { return; } if (platform === 'app-ios') { return { name: moduleName, platform, dir: resources.dir, }; } const arch = targetArchs.find((arch) => resources.archs[arch]); if (!arch) { return; } const archResources = resources.archs[arch]; return { name: moduleName, platform, arch, dir: archResources.dir, file: archResources.file, }; } function resolveUasmCopyAssets(platform, isProduction, targetArchs = parseUniAppXTargetArchs()) { const resourceDir = platform === 'app-ios' ? 'frameworks' : 'libs'; if (isProduction) { return [`uni_modules/*/uasm/${platform}/${resourceDir}/**/*`]; } if (platform === 'app-ios' || !targetArchs.length) { return []; } return Object.keys(uasmModules).reduce((assets, moduleName) => { const resolved = resolveUasmModule(moduleName, platform, targetArchs); if (resolved) { assets.push(`${resolved.dir}/**/*`); } return assets; }, []); } exports.resolveUasmCopyAssets = resolveUasmCopyAssets; function scanUasmPlatform(inputDir, moduleName, platform) { const resourceDir = platform === 'app-ios' ? 'frameworks' : 'libs'; const relativeDir = (0, utils_1.normalizePath)(node_path_1.default.join('uni_modules', moduleName, 'uasm', platform, resourceDir)); const absoluteDir = node_path_1.default.resolve(inputDir, relativeDir); if (!fs_extra_1.default.existsSync(absoluteDir)) { return; } const resources = { dir: relativeDir, archs: Object.create(null), }; if (platform !== 'app-ios') { fs_extra_1.default.readdirSync(absoluteDir, { withFileTypes: true }).forEach((entry) => { if (!isDirectoryEntry(absoluteDir, entry)) { return; } const relativeArchDir = (0, utils_1.normalizePath)(node_path_1.default.join(relativeDir, entry.name)); const file = (0, utils_1.normalizePath)(node_path_1.default.join(relativeArchDir, resolveUasmLibraryFileName(moduleName))); if (!fs_extra_1.default.existsSync(node_path_1.default.resolve(inputDir, file))) { return; } resources.archs[entry.name] = { dir: relativeArchDir, file, }; }); if (!Object.keys(resources.archs).length) { return; } } return resources; } function scanUasmWeb(inputDir, moduleName) { const entry = (0, utils_1.normalizePath)(node_path_1.default.join('uni_modules', moduleName, 'uasm', 'web', `${moduleName}.js`)); if (fs_extra_1.default.existsSync(node_path_1.default.resolve(inputDir, entry))) { return { entry }; } } function isDirectoryEntry(parentDir, entry) { if (entry.isDirectory()) { return true; } if (!entry.isSymbolicLink()) { return false; } try { return fs_extra_1.default.statSync(node_path_1.default.resolve(parentDir, entry.name)).isDirectory(); } catch { return false; } }