前端 uni-app 重写: 9页面 H5

This commit is contained in:
zhiqui
2026-11-15 15:09:37 +08:00
parent 513b53672e
commit ea7c2529e9
24104 changed files with 3667749 additions and 0 deletions
+528
View File
@@ -0,0 +1,528 @@
"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;
}
}