Files
OpenMaopaoya/frontend-uni/node_modules/@dcloudio/uni-cli-shared/dist/uasm.js
T

529 lines
23 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"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;
}
}