529 lines
23 KiB
JavaScript
529 lines
23 KiB
JavaScript
"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;
|
||
}
|
||
}
|