@dcloudio/uni-uts-v1 3.0.0-alpha-3060720221018004

package/dist/code.d.ts

@@ -0,0 +1,9 @@
+interface GenProxyCodeOptions {
+    is_uni_modules: boolean;
+    name: string;
+    namespace: string;
+}
+export declare function genProxyCode(module: string, options: GenProxyCodeOptions): Promise<string>;
+export declare function resolveRootIndex(module: string, options: GenProxyCodeOptions): string | false;
+export declare function resolvePlatformIndex(platform: 'app-android' | 'app-ios', module: string, options: GenProxyCodeOptions): string | false;
+export {};

package/dist/code.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePlatformIndex = exports.resolveRootIndex = exports.genProxyCode = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const shared_1 = require("./shared");
+async function genProxyCode(module, options) {
+    const { name, is_uni_modules } = options;
+    return `
+import { initUtsProxyClass, initUtsProxyFunction, initUtsPackageName, initUtsIndexClassName, initUtsClassName } from '@dcloudio/uni-app'
+const name = '${name}'
+const is_uni_modules = ${is_uni_modules}
+const pkg = initUtsPackageName(name, is_uni_modules)
+const cls = initUtsIndexClassName(name, is_uni_modules)
+${genModuleCode(await parseModuleDecls(module, options))}
+`;
+}
+exports.genProxyCode = genProxyCode;
+function resolveRootIndex(module, options) {
+    const filename = path_1.default.resolve(module, options.is_uni_modules ? 'utssdk' : '', 'index.uts');
+    return fs_1.default.existsSync(filename) && filename;
+}
+exports.resolveRootIndex = resolveRootIndex;
+function resolvePlatformIndex(platform, module, options) {
+    const filename = path_1.default.resolve(module, options.is_uni_modules ? 'utssdk' : '', platform, 'index.uts');
+    return fs_1.default.existsSync(filename) && filename;
+}
+exports.resolvePlatformIndex = resolvePlatformIndex;
+function genModuleCode(decls) {
+    const codes = [];
+    decls.forEach((decl) => {
+        if (decl.type === 'Class') {
+            if (decl.isDefault) {
+                codes.push(`export default initUtsProxyClass(Object.assign({ package: pkg, class: initUtsClassName(name, '${decl.cls}', is_uni_modules) }, ${JSON.stringify(decl.options)} ))`);
+            }
+            else {
+                codes.push(`export const ${decl.cls} = initUtsProxyClass(Object.assign({ package: pkg, class: initUtsClassName(name, '${decl.cls}', is_uni_modules) }, ${JSON.stringify(decl.options)} ))`);
+            }
+        }
+        else if (decl.type === 'FunctionDeclaration') {
+            if (decl.isDefault) {
+                codes.push(`export default initUtsProxyFunction(${decl.async}, { main: true, package: pkg, class: cls, name: '${decl.method}', params: ${JSON.stringify(decl.params)}})`);
+            }
+            else {
+                codes.push(`export const ${decl.method} = initUtsProxyFunction(${decl.async}, { main: true, package: pkg, class: cls, name: '${decl.method}', params: ${JSON.stringify(decl.params)}})`);
+            }
+        }
+        else if (decl.type === 'VariableDeclaration') {
+            codes.push(`export ${decl.kind} ${decl.declarations
+                .map((d) => `${d.id.value} = ${genInitCode(d.init)}`)
+                .join(', ')}`);
+        }
+    });
+    return codes.join(`\n`);
+}
+async function parseModuleDecls(module, options) {
+    // 优先合并 ios + android，如果没有，查找根目录 index.uts
+    const iosDecls = await parseFile(resolvePlatformIndex('app-ios', module, options), options);
+    const androidDecls = await parseFile(resolvePlatformIndex('app-android', module, options), options);
+    // 优先使用 app-ios，因为 app-ios 平台函数类型需要正确的参数列表
+    const decls = mergeDecls(androidDecls, iosDecls);
+    // 如果没有平台特有，查找 root index.uts
+    if (!decls.length) {
+        return await parseFile(resolveRootIndex(module, options), options);
+    }
+    return decls;
+}
+function mergeDecls(from, to) {
+    from.forEach((item) => {
+        if (item.type === 'Class') {
+            if (!to.find((toItem) => toItem.type === 'Class' && toItem.cls === item.cls)) {
+                to.push(item);
+            }
+        }
+        else if (item.type === 'FunctionDeclaration') {
+            if (!to.find((toItem) => toItem.type === 'FunctionDeclaration' &&
+                toItem.method === item.method)) {
+                to.push(item);
+            }
+        }
+        else if (item.type === 'VariableDeclaration' &&
+            item.declarations.length === 1) {
+            if (!to.find((toItem) => {
+                if (toItem.type === 'VariableDeclaration' &&
+                    toItem.declarations.length === 1) {
+                    const toDecl = toItem.declarations[0].id;
+                    const decl = item.declarations[0].id;
+                    return (toDecl.type === 'Identifier' &&
+                        decl.type === 'Identifier' &&
+                        toDecl.value === decl.value);
+                }
+                return false;
+            })) {
+                to.push(item);
+            }
+        }
+    });
+    return to;
+}
+async function parseFile(filename, options) {
+    if (filename) {
+        return parseCode(fs_1.default.readFileSync(filename, 'utf8'), options.namespace);
+    }
+    return [];
+}
+async function parseCode(code, namespace) {
+    // 懒加载 uts 编译器
+    // eslint-disable-next-line no-restricted-globals
+    const { parse } = require('@dcloudio/uts');
+    const ast = await parse(code, { noColor: (0, shared_1.isInHBuilderX)() });
+    return parseAst(ast, (0, utils_1.createResolveTypeReferenceName)(namespace, ast));
+}
+function parseAst({ body }, resolveTypeReferenceName) {
+    const decls = [];
+    body.forEach((item) => {
+        if (item.type === 'ExportDeclaration') {
+            const decl = item.declaration;
+            switch (decl.type) {
+                case 'FunctionDeclaration':
+                    decls.push(genFunctionDeclaration(decl, resolveTypeReferenceName, false));
+                    break;
+                case 'ClassDeclaration':
+                    decls.push(genClassDeclaration(decl, resolveTypeReferenceName, false));
+                    break;
+                case 'VariableDeclaration':
+                    const varDecl = genVariableDeclaration(decl);
+                    if (varDecl) {
+                        decls.push(varDecl);
+                    }
+                    break;
+            }
+        }
+        else if (item.type === 'ExportDefaultDeclaration') {
+            const decl = item.decl;
+            if (decl.type === 'ClassExpression') {
+                if (decl.identifier) {
+                    // export default class test{}
+                    decls.push(genClassDeclaration(decl, resolveTypeReferenceName, true));
+                }
+            }
+            else if (decl.type === 'FunctionExpression') {
+                if (decl.identifier) {
+                    decls.push(genFunctionDeclaration(decl, resolveTypeReferenceName, true));
+                }
+            }
+        }
+    });
+    return decls;
+}
+function isReturnPromise(anno) {
+    if (!anno) {
+        return false;
+    }
+    const { typeAnnotation } = anno;
+    return (typeAnnotation.type === 'TsTypeReference' &&
+        typeAnnotation.typeName.type === 'Identifier' &&
+        typeAnnotation.typeName.value === 'Promise');
+}
+function genProxyFunction(method, async, params, isDefault = false) {
+    return { type: 'FunctionDeclaration', method, async, params, isDefault };
+}
+function genProxyClass(cls, options, isDefault = false) {
+    return { type: 'Class', cls, options, isDefault };
+}
+function resolveIdentifierType(ident, resolveTypeReferenceName) {
+    if (ident.typeAnnotation) {
+        const { typeAnnotation } = ident.typeAnnotation;
+        if (typeAnnotation.type === 'TsKeywordType') {
+            return typeAnnotation.kind;
+        }
+        else if (typeAnnotation.type === 'TsFunctionType') {
+            return 'UTSCallback';
+        }
+        else if (typeAnnotation.type === 'TsTypeReference' &&
+            typeAnnotation.typeName.type === 'Identifier') {
+            return resolveTypeReferenceName(typeAnnotation.typeName.value);
+        }
+    }
+    return '';
+}
+function resolveFunctionParams(params, resolveTypeReferenceName) {
+    const result = [];
+    params.forEach(({ pat }) => {
+        if (pat.type === 'Identifier') {
+            result.push({
+                name: pat.value,
+                type: resolveIdentifierType(pat, resolveTypeReferenceName),
+            });
+        }
+        else {
+            result.push({ name: '', type: '' });
+        }
+    });
+    return result;
+}
+function genFunctionDeclaration(decl, resolveTypeReferenceName, isDefault = false) {
+    return genProxyFunction(decl.identifier.value, decl.async || isReturnPromise(decl.returnType), resolveFunctionParams(decl.params, resolveTypeReferenceName), isDefault);
+}
+function genClassDeclaration(decl, resolveTypeReferenceName, isDefault = false) {
+    const cls = decl.identifier.value;
+    const constructor = { params: [] };
+    const methods = {};
+    const staticMethods = {};
+    const props = [];
+    const staticProps = [];
+    decl.body.forEach((item) => {
+        if (item.type === 'Constructor') {
+            constructor.params = resolveFunctionParams(item.params, resolveTypeReferenceName);
+        }
+        else if (item.type === 'ClassMethod') {
+            if (item.key.type === 'Identifier') {
+                const name = item.key.value;
+                const value = {
+                    async: item.function.async || isReturnPromise(item.function.returnType),
+                    params: resolveFunctionParams(item.function.params, resolveTypeReferenceName),
+                };
+                if (item.isStatic) {
+                    staticMethods[name] = value;
+                }
+                else {
+                    methods[name] = value;
+                }
+            }
+        }
+        else if (item.type === 'ClassProperty') {
+            if (item.key.type === 'Identifier') {
+                if (item.isStatic) {
+                    staticProps.push(item.key.value);
+                }
+                else {
+                    props.push(item.key.value);
+                }
+            }
+        }
+    });
+    return genProxyClass(cls, { constructor, methods, staticMethods, props, staticProps }, isDefault);
+}
+function genInitCode(expr) {
+    switch (expr.type) {
+        case 'BooleanLiteral':
+            return expr.value + '';
+        case 'NumericLiteral':
+            return expr.value + '';
+        case 'StringLiteral':
+            return expr.value;
+    }
+    return '';
+}
+function genVariableDeclaration(decl) {
+    // 目前仅支持 const 的 boolean,number,string
+    const lits = ['BooleanLiteral', 'NumericLiteral', 'StringLiteral'];
+    if (decl.kind === 'const' &&
+        !decl.declarations.find((d) => {
+            if (d.id.type !== 'Identifier') {
+                return true;
+            }
+            if (!d.init) {
+                return true;
+            }
+            const type = d.init.type;
+            if (!lits.includes(type)) {
+                return true;
+            }
+            return false;
+        })) {
+        return decl;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { runKotlinProd, runKotlinDev } from './kotlin';
+import { runSwiftProd, runSwiftDev } from './swift';
+export { genProxyCode, resolvePlatformIndex, resolveRootIndex } from './code';
+export { resolvePackage } from './utils';
+export declare function getCompiler(type: 'kotlin' | 'swift'): {
+    runProd: typeof runSwiftProd;
+    runDev: typeof runSwiftDev;
+} | {
+    runProd: typeof runKotlinProd;
+    runDev: typeof runKotlinDev;
+};

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompiler = exports.resolvePackage = exports.resolveRootIndex = exports.resolvePlatformIndex = exports.genProxyCode = void 0;
+const kotlin_1 = require("./kotlin");
+const swift_1 = require("./swift");
+var code_1 = require("./code");
+Object.defineProperty(exports, "genProxyCode", { enumerable: true, get: function () { return code_1.genProxyCode; } });
+Object.defineProperty(exports, "resolvePlatformIndex", { enumerable: true, get: function () { return code_1.resolvePlatformIndex; } });
+Object.defineProperty(exports, "resolveRootIndex", { enumerable: true, get: function () { return code_1.resolveRootIndex; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "resolvePackage", { enumerable: true, get: function () { return utils_1.resolvePackage; } });
+function getCompiler(type) {
+    if (type === 'swift') {
+        return {
+            runProd: swift_1.runSwiftProd,
+            runDev: swift_1.runSwiftDev,
+        };
+    }
+    return {
+        runProd: kotlin_1.runKotlinProd,
+        runDev: kotlin_1.runKotlinDev,
+    };
+}
+exports.getCompiler = getCompiler;

package/dist/kotlin.d.ts

@@ -0,0 +1,4 @@
+import { Module } from '../types/types';
+export declare function createKotlinResolveTypeReferenceName(_namespace: string, _ast: Module): (name: string) => string;
+export declare function runKotlinProd(filename: string): Promise<void>;
+export declare function runKotlinDev(filename: string): Promise<string | undefined>;

package/dist/kotlin.js

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runKotlinDev = exports.runKotlinProd = exports.createKotlinResolveTypeReferenceName = void 0;
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const fast_glob_1 = require("fast-glob");
+const shared_1 = require("@vue/shared");
+const shared_2 = require("./shared");
+const utils_1 = require("./utils");
+function createKotlinResolveTypeReferenceName(_namespace, _ast) {
+    return (name) => name;
+}
+exports.createKotlinResolveTypeReferenceName = createKotlinResolveTypeReferenceName;
+function parseKotlinPackage(filename) {
+    const res = (0, utils_1.resolvePackage)(filename);
+    if (!res) {
+        return { package: '' };
+    }
+    return {
+        package: 'uts.sdk.' + (res.is_uni_modules ? 'modules.' : '') + res.name,
+    };
+}
+async function runKotlinProd(filename) {
+    // 文件有可能是 app-ios 里边的，因为编译到 android 时，为了保证不报错，可能会去读取 ios 下的 uts
+    if (filename.includes('app-ios')) {
+        return;
+    }
+    await compile(filename);
+    (0, utils_1.genUTSPlatformResource)(filename, {
+        inputDir: process.env.UNI_INPUT_DIR,
+        outputDir: process.env.UNI_OUTPUT_DIR,
+        platform: 'app-android',
+        extname: '.kt',
+    });
+}
+exports.runKotlinProd = runKotlinProd;
+async function runKotlinDev(filename) {
+    // 文件有可能是 app-ios 里边的，因为编译到 android 时，为了保证不报错，可能会去读取 ios 下的 uts
+    if (filename.includes('app-ios')) {
+        return;
+    }
+    await compile(filename);
+    const kotlinFile = (0, utils_1.resolveUTSPlatformFile)(filename, {
+        inputDir: process.env.UNI_INPUT_DIR,
+        outputDir: process.env.UNI_OUTPUT_DIR,
+        platform: 'app-android',
+        extname: '.kt',
+    });
+    // 开发模式下，需要生成 dex
+    if (fs_extra_1.default.existsSync(kotlinFile)) {
+        const compilerServer = getCompilerServer();
+        if (!compilerServer) {
+            return;
+        }
+        const { getDefaultJar, getKotlincHome, compile, checkDependencies } = compilerServer;
+        if (checkDependencies) {
+            await checkDeps(filename, checkDependencies);
+        }
+        // time = Date.now()
+        const jarFile = resolveJarPath(kotlinFile);
+        const options = {
+            kotlinc: resolveKotlincArgs(kotlinFile, getKotlincHome(), getDefaultJar().concat(resolveLibs(filename))),
+            d8: resolveD8Args(jarFile),
+            sourceRoot: process.env.UNI_INPUT_DIR,
+            sourceMapPath: resolveSourceMapFile(process.env.UNI_OUTPUT_DIR, kotlinFile),
+        };
+        const res = await compile(options, process.env.UNI_INPUT_DIR);
+        // console.log('dex compile time: ' + (Date.now() - time) + 'ms')
+        if (res) {
+            try {
+                fs_extra_1.default.unlinkSync(jarFile);
+                // 短期内先不删除，方便排查问题
+                // fs.unlinkSync(kotlinFile)
+            }
+            catch (e) { }
+            const dexFile = resolveDexFile(jarFile);
+            if (fs_extra_1.default.existsSync(dexFile)) {
+                return (0, shared_2.normalizePath)(path_1.default.relative(process.env.UNI_OUTPUT_DIR, dexFile));
+            }
+        }
+    }
+}
+exports.runKotlinDev = runKotlinDev;
+function checkDeps(filename, checkDependencies) {
+    const configJsonFile = resolveConfigJsonFile(filename);
+    if (configJsonFile && hasDeps(configJsonFile)) {
+        return checkDependencies(configJsonFile).then(({ code, msg, data }) => {
+            if (code > 0) {
+                throw msg;
+            }
+            return data;
+        });
+    }
+    return Promise.resolve([]);
+}
+function hasDeps(configJsonFile) {
+    const deps = (0, shared_2.parseJson)(configJsonFile).dependencies || [];
+    if ((0, shared_1.isArray)(deps) && deps.length) {
+        return true;
+    }
+    return false;
+}
+function resolveConfigJsonFile(filename) {
+    const configJsonFile = path_1.default.resolve((0, utils_1.resolveAndroidDir)(filename), 'config.json');
+    if (fs_extra_1.default.existsSync(configJsonFile)) {
+        return configJsonFile;
+    }
+}
+function resolveSourceMapFile(outputDir, kotlinFile) {
+    return (path_1.default.resolve((0, shared_2.resolveSourceMapPath)(), path_1.default.relative(outputDir, kotlinFile)) +
+        '.map');
+}
+async function compile(filename) {
+    if (!process.env.UNI_HBUILDERX_PLUGINS) {
+        return console.error('process.env.UNI_HBUILDERX_PLUGINS is not found');
+    }
+    const { bundle, UtsTarget } = (0, utils_1.getUtsCompiler)();
+    const inputDir = process.env.UNI_INPUT_DIR;
+    const outputDir = process.env.UNI_OUTPUT_DIR;
+    // let time = Date.now()
+    await bundle(UtsTarget.KOTLIN, {
+        input: {
+            root: inputDir,
+            filename,
+        },
+        output: {
+            isPlugin: true,
+            outDir: outputDir,
+            package: parseKotlinPackage(filename).package,
+            sourceMap: (0, utils_1.resolveUTSSourceMapPath)(filename),
+            extname: 'kt',
+            imports: [
+                'kotlinx.coroutines.async',
+                'kotlinx.coroutines.CoroutineScope',
+                'kotlinx.coroutines.Deferred',
+                'kotlinx.coroutines.Dispatchers',
+                'io.dcloud.uts.*',
+            ],
+            logFilename: true,
+            noColor: (0, shared_2.isInHBuilderX)(),
+        },
+    });
+    (0, utils_1.moveRootIndexSourceMap)(filename, {
+        inputDir: process.env.UNI_INPUT_DIR,
+        outputDir: process.env.UNI_OUTPUT_DIR,
+        platform: 'app-android',
+        extname: '.kt',
+    });
+}
+function resolveKotlincArgs(filename, kotlinc, jars) {
+    return [
+        filename,
+        '-cp',
+        resolveClassPath(jars),
+        '-d',
+        resolveJarPath(filename),
+        '-kotlin-home',
+        kotlinc,
+    ];
+}
+function resolveD8Args(filename) {
+    return [
+        filename,
+        '--no-desugaring',
+        '--min-api',
+        '19',
+        '--output',
+        resolveDexPath(filename),
+    ];
+}
+function resolveLibs(filename) {
+    const libsPath = path_1.default.resolve((0, utils_1.resolveAndroidDir)(filename), 'libs');
+    const libs = [];
+    if (fs_extra_1.default.existsSync(libsPath)) {
+        libs.push(...(0, fast_glob_1.sync)('*.jar', { cwd: libsPath, absolute: true }));
+        const zips = (0, fast_glob_1.sync)('*.aar', { cwd: libsPath });
+        zips.forEach((name) => {
+            const outputPath = resolveAndroidArchiveOutputPath(name);
+            if (!fs_extra_1.default.existsSync(outputPath)) {
+                // 解压
+                const zip = new adm_zip_1.default(path_1.default.resolve(libsPath, name));
+                zip.extractAllTo(outputPath, true);
+            }
+        });
+        if (zips.length) {
+            libs.push(...(0, fast_glob_1.sync)('*/*.jar', {
+                cwd: resolveAndroidArchiveOutputPath(),
+                absolute: true,
+            }));
+        }
+    }
+    return libs;
+}
+function resolveAndroidArchiveOutputPath(aar) {
+    return path_1.default.resolve(process.env.UNI_OUTPUT_DIR, '../.uts/aar', aar ? aar.replace('.aar', '') : '');
+}
+function resolveDexFile(jarFile) {
+    return (0, shared_2.normalizePath)(path_1.default.resolve(path_1.default.dirname(jarFile), 'classes.dex'));
+}
+function resolveDexPath(filename) {
+    return path_1.default.dirname(filename);
+}
+function resolveJarPath(filename) {
+    return filename.replace(path_1.default.extname(filename), '.jar');
+}
+function resolveClassPath(jars) {
+    return jars.join(os_1.default.platform() === 'win32' ? ';' : ':');
+}
+function getCompilerServer() {
+    const compilerServerPath = path_1.default.resolve(process.env.UNI_HBUILDERX_PLUGINS, 'uniapp-runextension/out/main.js');
+    if (fs_extra_1.default.existsSync(compilerServerPath)) {
+        // eslint-disable-next-line no-restricted-globals
+        return require(compilerServerPath);
+    }
+    else {
+        if ((0, shared_2.runByHBuilderX)()) {
+            (0, shared_2.installHBuilderXPlugin)('uniapp-runextension');
+        }
+        else {
+            console.error(compilerServerPath + ' is not found');
+        }
+    }
+}

package/dist/shared.d.ts

@@ -0,0 +1,8 @@
+export declare function parseJson(jsonStr: string): any;
+export declare function once<T extends (...args: any[]) => any>(fn: T, ctx?: unknown): T;
+export declare const runByHBuilderX: () => boolean;
+export declare const isInHBuilderX: () => boolean;
+export declare function resolveSourceMapPath(outputDir?: string, platform?: UniApp.PLATFORM): string;
+export declare const isWindows: boolean;
+export declare function normalizePath(id: string): string;
+export declare function installHBuilderXPlugin(plugin: string): void;

package/dist/shared.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installHBuilderXPlugin = exports.normalizePath = exports.isWindows = exports.resolveSourceMapPath = exports.isInHBuilderX = exports.runByHBuilderX = exports.once = exports.parseJson = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const jsonc_parser_1 = require("jsonc-parser");
+function parseJson(jsonStr) {
+    return (0, jsonc_parser_1.parse)(jsonStr);
+}
+exports.parseJson = parseJson;
+function once(fn, ctx = null) {
+    let res;
+    return ((...args) => {
+        if (fn) {
+            res = fn.apply(ctx, args);
+            fn = null;
+        }
+        return res;
+    });
+}
+exports.once = once;
+exports.runByHBuilderX = once(() => {
+    return !!process.env.UNI_HBUILDERX_PLUGINS && !!process.env.RUN_BY_HBUILDERX;
+});
+exports.isInHBuilderX = once(() => {
+    try {
+        // eslint-disable-next-line no-restricted-globals
+        const { name } = require(path_1.default.resolve(process.cwd(), '../about/package.json'));
+        if (name === 'about') {
+            process.env.UNI_HBUILDERX_PLUGINS = path_1.default.resolve(process.cwd(), '..');
+            return true;
+        }
+    }
+    catch (e) {
+        // console.error(e)
+    }
+    return false;
+});
+function resolveSourceMapPath(outputDir, platform) {
+    return path_1.default.resolve(outputDir || process.env.UNI_OUTPUT_DIR, '../.sourcemap/' +
+        (platform || process.env.UNI_SUB_PLATFORM || process.env.UNI_PLATFORM));
+}
+exports.resolveSourceMapPath = resolveSourceMapPath;
+exports.isWindows = os_1.default.platform() === 'win32';
+function normalizePath(id) {
+    return exports.isWindows ? id.replace(/\\/g, '/') : id;
+}
+exports.normalizePath = normalizePath;
+function supportAutoInstallPlugin() {
+    return !!process.env.HX_Version;
+}
+function installHBuilderXPlugin(plugin) {
+    if (!supportAutoInstallPlugin()) {
+        return;
+    }
+    return console.error(`%HXRunUniAPPPluginName%${plugin}%HXRunUniAPPPluginName%`);
+}
+exports.installHBuilderXPlugin = installHBuilderXPlugin;

package/dist/swift.d.ts

@@ -0,0 +1,2 @@
+export declare function runSwiftProd(filename: string): Promise<void>;
+export declare function runSwiftDev(_filename: string): Promise<void>;

package/dist/swift.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSwiftDev = exports.runSwiftProd = void 0;
+const shared_1 = require("@vue/shared");
+const utils_1 = require("./utils");
+const shared_2 = require("./shared");
+function parseSwiftPackage(filename) {
+    const res = (0, utils_1.resolvePackage)(filename);
+    if (!res) {
+        return {
+            namespace: '',
+        };
+    }
+    const namespace = 'UTSSDK' + (res.is_uni_modules ? 'Modules' : '') + (0, shared_1.capitalize)(res.name);
+    return {
+        namespace,
+    };
+}
+async function runSwiftProd(filename) {
+    // 文件有可能是 app-android 里边的，因为编译到 ios 时，为了保证不报错，可能会去读取 android 下的 uts
+    if (filename.includes('app-android')) {
+        return;
+    }
+    await compile(filename);
+    (0, utils_1.genUTSPlatformResource)(filename, {
+        inputDir: process.env.UNI_INPUT_DIR,
+        outputDir: process.env.UNI_OUTPUT_DIR,
+        platform: 'app-ios',
+        extname: '.swift',
+    });
+}
+exports.runSwiftProd = runSwiftProd;
+async function runSwiftDev(_filename) { }
+exports.runSwiftDev = runSwiftDev;
+async function compile(filename) {
+    if (!process.env.UNI_HBUILDERX_PLUGINS) {
+        return console.error('process.env.UNI_HBUILDERX_PLUGINS is not found');
+    }
+    const { bundle, UtsTarget } = (0, utils_1.getUtsCompiler)();
+    const inputDir = process.env.UNI_INPUT_DIR;
+    const outputDir = process.env.UNI_OUTPUT_DIR;
+    // let time = Date.now()
+    await bundle(UtsTarget.SWIFT, {
+        input: {
+            root: inputDir,
+            filename,
+        },
+        output: {
+            isPlugin: true,
+            outDir: outputDir,
+            package: parseSwiftPackage(filename).namespace,
+            sourceMap: (0, utils_1.resolveUTSSourceMapPath)(filename),
+            extname: 'swift',
+            imports: ['DCUTSPlugin'],
+            logFilename: true,
+            noColor: (0, shared_2.isInHBuilderX)(),
+        },
+    });
+    (0, utils_1.moveRootIndexSourceMap)(filename, {
+        inputDir: process.env.UNI_INPUT_DIR,
+        outputDir: process.env.UNI_OUTPUT_DIR,
+        platform: 'app-ios',
+        extname: '.swift',
+    });
+}

package/dist/utils.d.ts

@@ -0,0 +1,25 @@
+import type { parse, bundle, UtsTarget } from '@dcloudio/uts';
+import { Module } from '../types/types';
+export declare function resolveUTSSourceMapPath(_filename: string): string;
+export declare function getUtsCompiler(): {
+    parse: typeof parse;
+    bundle: typeof bundle;
+    UtsTarget: typeof UtsTarget;
+};
+export declare function resolvePackage(filename: string): {
+    is_uni_modules: boolean;
+    name: string;
+    namespace: string;
+} | undefined;
+export interface UTSPlatformResourceOptions {
+    inputDir: string;
+    outputDir: string;
+    platform: typeof process.env.UNI_UTS_PLATFORM;
+    extname: '.kt' | '.swift';
+}
+export declare function genUTSPlatformResource(filename: string, options: UTSPlatformResourceOptions): void;
+export declare function moveRootIndexSourceMap(filename: string, { inputDir, outputDir, platform, extname }: UTSPlatformResourceOptions): void;
+export declare function isRootIndex(filename: string, platform: typeof process.env.UNI_UTS_PLATFORM): boolean;
+export declare function resolveAndroidDir(filename: string): string;
+export declare function resolveUTSPlatformFile(filename: string, { inputDir, outputDir, platform, extname }: UTSPlatformResourceOptions): string;
+export declare function createResolveTypeReferenceName(namespace: string, ast: Module): (name: string) => string;

package/dist/utils.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResolveTypeReferenceName = exports.resolveUTSPlatformFile = exports.resolveAndroidDir = exports.isRootIndex = exports.moveRootIndexSourceMap = exports.genUTSPlatformResource = exports.resolvePackage = exports.getUtsCompiler = exports.resolveUTSSourceMapPath = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const shared_1 = require("@vue/shared");
+const shared_2 = require("./shared");
+function resolveUTSSourceMapPath(_filename) {
+    return (0, shared_2.resolveSourceMapPath)();
+}
+exports.resolveUTSSourceMapPath = resolveUTSSourceMapPath;
+function getUtsCompiler() {
+    // eslint-disable-next-line no-restricted-globals
+    return require('@dcloudio/uts');
+}
+exports.getUtsCompiler = getUtsCompiler;
+function resolvePackage(filename) {
+    const parts = (0, shared_2.normalizePath)(filename).split('/');
+    const isUniModules = parts.includes('uni_modules');
+    const index = isUniModules
+        ? parts.findIndex((part) => part === 'uni_modules')
+        : parts.findIndex((part) => part === 'utssdk');
+    if (index > -1) {
+        const name = (0, shared_1.camelize)(parts[index + 1]);
+        return {
+            is_uni_modules: isUniModules,
+            name,
+            namespace: 'UTSSDK' + (isUniModules ? 'Modules' : '') + (0, shared_1.capitalize)(name),
+        };
+    }
+}
+exports.resolvePackage = resolvePackage;
+function genUTSPlatformResource(filename, options) {
+    const platformFile = resolveUTSPlatformFile(filename, options);
+    const { platform } = options;
+    const utsInputDir = resolveUTSPlatformDir(filename, platform);
+    const utsOutputDir = resolveUTSPlatformDir(platformFile, platform);
+    // 拷贝所有非uts文件及目录
+    if (fs_extra_1.default.existsSync(utsInputDir)) {
+        fs_extra_1.default.copySync(utsInputDir, utsOutputDir, {
+            filter(src) {
+                return path_1.default.extname(src) !== '.uts';
+            },
+        });
+    }
+    // 生产模式下，需要将生成的平台文件转移到 src 下
+    const srcDir = path_1.default.resolve(utsOutputDir, 'src');
+    if (!fs_extra_1.default.existsSync(srcDir)) {
+        fs_extra_1.default.mkdirSync(srcDir);
+    }
+    if (fs_extra_1.default.existsSync(platformFile)) {
+        fs_extra_1.default.moveSync(platformFile, path_1.default.resolve(utsOutputDir, 'src/index' + options.extname), {
+            overwrite: true,
+        });
+    }
+}
+exports.genUTSPlatformResource = genUTSPlatformResource;
+function moveRootIndexSourceMap(filename, { inputDir, outputDir, platform, extname }) {
+    if (isRootIndex(filename, platform)) {
+        const sourceMapFilename = path_1.default
+            .resolve(resolveUTSSourceMapPath(filename), path_1.default.relative(inputDir, filename))
+            .replace(path_1.default.extname(filename), extname + '.map');
+        if (fs_extra_1.default.existsSync(sourceMapFilename)) {
+            const newSourceMapFilename = path_1.default.resolve(path_1.default.dirname(sourceMapFilename), platform, path_1.default.basename(sourceMapFilename));
+            fs_extra_1.default.moveSync(sourceMapFilename, newSourceMapFilename, {
+                overwrite: true,
+            });
+        }
+    }
+}
+exports.moveRootIndexSourceMap = moveRootIndexSourceMap;
+function isRootIndex(filename, platform) {
+    return path_1.default.basename(path_1.default.dirname(filename)) !== platform;
+}
+exports.isRootIndex = isRootIndex;
+function resolveAndroidDir(filename) {
+    return resolveUTSPlatformDir(filename, 'app-android');
+}
+exports.resolveAndroidDir = resolveAndroidDir;
+function resolveUTSPlatformDir(filename, platform) {
+    const maybePlatformDir = path_1.default.dirname(filename);
+    if (isRootIndex(filename, platform)) {
+        return path_1.default.join(maybePlatformDir, platform);
+    }
+    return maybePlatformDir;
+}
+function resolveUTSPlatformFile(filename, { inputDir, outputDir, platform, extname }) {
+    let platformFile = path_1.default
+        .resolve(outputDir, path_1.default.relative(inputDir, filename))
+        .replace(path_1.default.extname(filename), extname);
+    // 如果是根目录的 index.uts 编译出来的 index.kt，则移动到平台目录下
+    if (isRootIndex(filename, platform)) {
+        if (fs_extra_1.default.existsSync(platformFile)) {
+            const newPlatformFile = path_1.default.resolve(path_1.default.dirname(platformFile), platform + '/index' + extname);
+            fs_extra_1.default.moveSync(platformFile, newPlatformFile, {
+                overwrite: true,
+            });
+            platformFile = newPlatformFile;
+        }
+    }
+    return platformFile;
+}
+exports.resolveUTSPlatformFile = resolveUTSPlatformFile;
+function resolveTypeAliasDeclNames(items) {
+    const names = [];
+    items.forEach((item) => {
+        if (item.type === 'TsTypeAliasDeclaration') {
+            names.push(item.id.value);
+        }
+    });
+    return names;
+}
+function createResolveTypeReferenceName(namespace, ast) {
+    const names = resolveTypeAliasDeclNames(ast.body);
+    return (name) => {
+        if (names.includes(name)) {
+            return namespace + (0, shared_1.capitalize)(name);
+        }
+        return name;
+    };
+}
+exports.createResolveTypeReferenceName = createResolveTypeReferenceName;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@dcloudio/uni-uts-v1",
+  "version": "3.0.0-alpha-3060720221018004",
+  "description": "uni-uts-v1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcloudio/uni-app.git",
+    "directory": "packages/uni-uts-v1"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@dcloudio/uts": "3.0.0-alpha-3060720221018004",
+    "@vue/shared": "3.2.41",
+    "adm-zip": "^0.5.9",
+    "execa": "^5.1.1",
+    "fast-glob": "^3.2.11",
+    "fs-extra": "^10.0.0",
+    "jsonc-parser": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.0",
+    "@types/fs-extra": "^9.0.13"
+  }
+}