@dcloudio/uni-uts-v1 3.0.0-3061320221209001

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,314 @@
+"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 errMsg = \`${utils_1.ERR_MSG_PLACEHOLDER}\`
+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({ errMsg, package: pkg, class: initUtsClassName(name, '${decl.cls}', is_uni_modules) }, ${JSON.stringify(decl.options)} ))`);
+            }
+            else {
+                codes.push(`export const ${decl.cls} = initUtsProxyClass(Object.assign({ errMsg, 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}, { errMsg, main: true, package: pkg, class: cls, name: '${decl.method}', params: ${JSON.stringify(decl.params)}})`);
+            }
+            else {
+                codes.push(`export const ${decl.method} = initUtsProxyFunction(${decl.async}, { errMsg, 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 resolveIdentifierDefaultValue(ident) {
+    if (ident.type === 'NullLiteral') {
+        return 'UTSNull';
+    }
+    else if (ident.type === 'StringLiteral' ||
+        ident.type === 'NumericLiteral' ||
+        ident.type === 'BooleanLiteral') {
+        return ident.value;
+    }
+    return null;
+}
+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);
+        }
+        else if (typeAnnotation.type === 'TsUnionType') {
+            if (typeAnnotation.types.length === 2) {
+                const [type1, type2] = typeAnnotation.types;
+                if (type1.type === 'TsKeywordType' && type1.kind === 'null') {
+                    if (type2.type === 'TsParenthesizedType' &&
+                        type2.typeAnnotation.type === 'TsFunctionType') {
+                        return 'UTSCallback';
+                    }
+                }
+                if (type2.type === 'TsKeywordType' && type2.kind === 'null') {
+                    if (type1.type === 'TsParenthesizedType' &&
+                        type1.typeAnnotation.type === 'TsFunctionType') {
+                        return 'UTSCallback';
+                    }
+                }
+            }
+        }
+    }
+    return '';
+}
+function resolveFunctionParams(params, resolveTypeReferenceName) {
+    const result = [];
+    params.forEach(({ pat }) => {
+        if (pat.type === 'Identifier') {
+            result.push({
+                name: pat.value,
+                type: resolveIdentifierType(pat, resolveTypeReferenceName),
+            });
+        }
+        else if (pat.type === 'AssignmentPattern') {
+            if (pat.left.type === 'Identifier') {
+                const param = {
+                    name: pat.left.value,
+                    type: resolveIdentifierType(pat.left, resolveTypeReferenceName),
+                };
+                const defaultValue = resolveIdentifierDefaultValue(pat.right);
+                if (defaultValue !== null) {
+                    param.default = defaultValue;
+                }
+                result.push(param);
+            }
+        }
+        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,12 @@
+import { generateCodeFrameWithKotlinStacktrace, generateCodeFrameWithSwiftStacktrace } from './legacy';
+export declare const sourcemap: {
+    generateCodeFrameWithKotlinStacktrace: typeof generateCodeFrameWithKotlinStacktrace;
+    generateCodeFrameWithSwiftStacktrace: typeof generateCodeFrameWithSwiftStacktrace;
+};
+export * from './sourceMap';
+export { compile as toKotlin } from './kotlin';
+export { compile as toSwift } from './swift';
+export declare function compile(pluginDir: string): Promise<{
+    code: string;
+    deps: string[];
+} | undefined>;

package/dist/index.js

@@ -0,0 +1,268 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = exports.toSwift = exports.toKotlin = exports.sourcemap = void 0;
+const shared_1 = require("@vue/shared");
+const path_1 = require("path");
+const kotlin_1 = require("./kotlin");
+const swift_1 = require("./swift");
+const code_1 = require("./code");
+const utils_1 = require("./utils");
+const stacktrace_1 = require("./stacktrace");
+const sourceMap_1 = require("./sourceMap");
+const shared_2 = require("./shared");
+const legacy_1 = require("./legacy");
+const manifest_1 = require("./manifest");
+const utils_2 = require("./manifest/utils");
+exports.sourcemap = {
+    generateCodeFrameWithKotlinStacktrace: legacy_1.generateCodeFrameWithKotlinStacktrace,
+    generateCodeFrameWithSwiftStacktrace: legacy_1.generateCodeFrameWithSwiftStacktrace,
+};
+__exportStar(require("./sourceMap"), exports);
+var kotlin_2 = require("./kotlin");
+Object.defineProperty(exports, "toKotlin", { enumerable: true, get: function () { return kotlin_2.compile; } });
+var swift_2 = require("./swift");
+Object.defineProperty(exports, "toSwift", { enumerable: true, get: function () { return swift_2.compile; } });
+function parseErrMsg(code, errMsg) {
+    return code.replace(utils_1.ERR_MSG_PLACEHOLDER, errMsg);
+}
+function compileErrMsg(id) {
+    return `uts插件[${id}]编译失败，无法使用`;
+}
+function warn(msg) {
+    console.warn(`提示：${msg}`);
+}
+async function compile(pluginDir) {
+    const pkg = (0, utils_1.resolvePackage)(pluginDir);
+    if (!pkg) {
+        return;
+    }
+    const cacheDir = process.env.HX_DEPENDENCIES_DIR;
+    const inputDir = process.env.UNI_INPUT_DIR;
+    const outputDir = process.env.UNI_OUTPUT_DIR;
+    const utsPlatform = process.env.UNI_UTS_PLATFORM;
+    const pluginRelativeDir = (0, path_1.relative)(inputDir, pluginDir);
+    const env = (0, manifest_1.initCheckOptionsEnv)();
+    const deps = [];
+    const code = await (0, code_1.genProxyCode)(pluginDir, pkg);
+    let errMsg = '';
+    if (process.env.NODE_ENV !== 'development') {
+        // 生产模式 支持同时生成 android 和 ios 的 uts 插件
+        if (utsPlatform === 'app-android' || utsPlatform === 'app') {
+            const filename = (0, code_1.resolvePlatformIndex)('app-android', pluginDir, pkg) ||
+                (0, code_1.resolveRootIndex)(pluginDir, pkg);
+            if (filename) {
+                await getCompiler('kotlin').runProd(filename);
+                if (cacheDir) {
+                    (0, manifest_1.genManifestFile)('app-android', {
+                        pluginDir,
+                        env,
+                        cacheDir,
+                        pluginRelativeDir,
+                        is_uni_modules: pkg.is_uni_modules,
+                    });
+                }
+            }
+        }
+        if (utsPlatform === 'app-ios' || utsPlatform === 'app') {
+            const filename = (0, code_1.resolvePlatformIndex)('app-ios', pluginDir, pkg) ||
+                (0, code_1.resolveRootIndex)(pluginDir, pkg);
+            if (filename) {
+                await getCompiler('swift').runProd(filename);
+                if (cacheDir) {
+                    (0, manifest_1.genManifestFile)('app-ios', {
+                        pluginDir,
+                        env,
+                        cacheDir,
+                        pluginRelativeDir,
+                        is_uni_modules: pkg.is_uni_modules,
+                    });
+                }
+            }
+        }
+    }
+    else {
+        const compilerType = utsPlatform === 'app-android' ? 'kotlin' : 'swift';
+        const versionTips = getCompiler(compilerType).checkVersionTips(pkg.id, pluginDir, pkg.is_uni_modules);
+        // iOS windows 平台，标准基座不编译
+        if (utsPlatform === 'app-ios') {
+            if (shared_2.isWindows) {
+                process.env.UNI_UTS_TIPS = `iOS手机在windows上真机运行时uts插件代码修改需提交云端打包自定义基座才能生效`;
+                return {
+                    code: parseErrMsg(code, errMsg),
+                    deps,
+                };
+            }
+            // ios 模拟器不支持
+            if (process.env.HX_RUN_DEVICE_TYPE === 'ios_simulator') {
+                process.env.UNI_UTS_TIPS = `iOS手机在模拟器运行暂不支持uts插件，如需调用uts插件请使用自定义基座`;
+                return {
+                    code: parseErrMsg(code, compileErrMsg(pkg.id)),
+                    deps,
+                };
+            }
+        }
+        if (utsPlatform === 'app-android' || utsPlatform === 'app-ios') {
+            let tips = '';
+            // dev 模式
+            if (cacheDir) {
+                // 检查缓存
+                // let start = Date.now()
+                // console.log('uts插件[' + pkg.id + ']start', start)
+                const res = await (0, manifest_1.checkCompile)(utsPlatform, process.env.HX_USE_BASE_TYPE, {
+                    id: pkg.id,
+                    env,
+                    cacheDir,
+                    outputDir,
+                    pluginDir,
+                    pluginRelativeDir,
+                    is_uni_modules: pkg.is_uni_modules,
+                });
+                if (res.tips) {
+                    tips = res.tips;
+                }
+                // console.log('uts插件[' + pkg.id + ']end', Date.now())
+                // console.log('uts插件[' + pkg.id + ']缓存检查耗时：', Date.now() - start)
+                if (!res.expired) {
+                    if (utsPlatform === 'app-android') {
+                        (0, manifest_1.restoreDex)(pluginRelativeDir, outputDir, pkg.is_uni_modules);
+                    }
+                    // 还原 sourcemap
+                    (0, manifest_1.restoreSourceMap)(utsPlatform, pluginRelativeDir, outputDir, cacheDir, pkg.is_uni_modules);
+                    console.log((0, utils_2.cacheTips)(pkg.id));
+                    if (res.tips) {
+                        warn(res.tips);
+                    }
+                    if (versionTips) {
+                        warn(versionTips);
+                    }
+                    return {
+                        code: parseErrMsg(code, errMsg),
+                        // 所有文件加入依赖
+                        deps: res.files.map((name) => (0, path_1.join)(pluginDir, name)),
+                    };
+                }
+            }
+            const filename = (0, code_1.resolvePlatformIndex)(utsPlatform, pluginDir, pkg) ||
+                (0, code_1.resolveRootIndex)(pluginDir, pkg);
+            if (filename) {
+                deps.push(filename);
+                if (utsPlatform === 'app-android') {
+                    deps.push(...(0, kotlin_1.resolveAndroidDepFiles)(filename));
+                }
+                else {
+                    deps.push(...(0, swift_1.resolveIOSDepFiles)(filename));
+                }
+                const res = await getCompiler(compilerType).runDev(filename);
+                if (res) {
+                    if ((0, shared_1.isArray)(res.deps) && res.deps.length) {
+                        // 添加其他文件的依赖
+                        deps.push(...res.deps);
+                    }
+                    let isSuccess = false;
+                    if (res.type === 'swift') {
+                        if (res.code) {
+                            errMsg = compileErrMsg(pkg.id);
+                            console.error(`error: ` +
+                                (await (0, stacktrace_1.parseUtsSwiftPluginStacktrace)({
+                                    stacktrace: res.msg,
+                                    sourceMapFile: (0, sourceMap_1.resolveUtsPluginSourceMapFile)('swift', filename, inputDir, outputDir),
+                                    sourceRoot: inputDir,
+                                })));
+                        }
+                        else {
+                            isSuccess = true;
+                        }
+                    }
+                    else if (res.type === 'kotlin') {
+                        if (res.changed.length) {
+                            isSuccess = true;
+                        }
+                    }
+                    if (isSuccess) {
+                        // 生成缓存文件
+                        if (cacheDir) {
+                            // 存储 sourcemap
+                            (0, manifest_1.storeSourceMap)(utsPlatform, pluginRelativeDir, outputDir, cacheDir, pkg.is_uni_modules);
+                            // 生成 manifest
+                            (0, manifest_1.genManifestFile)(utsPlatform, {
+                                pluginDir,
+                                env,
+                                cacheDir,
+                                pluginRelativeDir,
+                                is_uni_modules: pkg.is_uni_modules,
+                            });
+                        }
+                        if (tips) {
+                            warn(tips);
+                        }
+                        if (versionTips) {
+                            warn(versionTips);
+                        }
+                    }
+                    const files = [];
+                    if (process.env.UNI_APP_UTS_CHANGED_FILES) {
+                        try {
+                            files.push(...JSON.parse(process.env.UNI_APP_UTS_CHANGED_FILES));
+                        }
+                        catch (e) { }
+                    }
+                    if (res.changed && res.changed.length) {
+                        files.push(...res.changed);
+                        // 需要缓存 dex 文件
+                        if (cacheDir && res.type === 'kotlin') {
+                            res.changed.forEach((file) => {
+                                if (file.endsWith('classes.dex')) {
+                                    (0, manifest_1.storeDex)((0, path_1.join)(outputDir, file), pluginRelativeDir, outputDir);
+                                }
+                            });
+                        }
+                    }
+                    else {
+                        if (res.type === 'kotlin') {
+                            errMsg = compileErrMsg(pkg.id);
+                        }
+                    }
+                    process.env.UNI_APP_UTS_CHANGED_FILES = JSON.stringify([
+                        ...new Set(files),
+                    ]);
+                }
+                else {
+                    errMsg = compileErrMsg(pkg.id);
+                }
+            }
+        }
+    }
+    return {
+        code: parseErrMsg(code, errMsg),
+        deps,
+    };
+}
+exports.compile = compile;
+function getCompiler(type) {
+    if (type === 'swift') {
+        return {
+            runProd: swift_1.runSwiftProd,
+            runDev: swift_1.runSwiftDev,
+            checkVersionTips: swift_1.checkIOSVersionTips,
+        };
+    }
+    return {
+        runProd: kotlin_1.runKotlinProd,
+        runDev: kotlin_1.runKotlinDev,
+        checkVersionTips: kotlin_1.checkAndroidVersionTips,
+    };
+}

package/dist/kotlin.d.ts

@@ -0,0 +1,13 @@
+import type { UtsResult } from '@dcloudio/uts';
+import { ToKotlinOptions } from './utils';
+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 type RunKotlinDevResult = UtsResult & {
+    type: 'kotlin';
+    changed: string[];
+};
+export declare function runKotlinDev(filename: string): Promise<RunKotlinDevResult | undefined>;
+export declare function resolveAndroidDepFiles(filename: string): string[];
+export declare function compile(filename: string, { inputDir, outputDir, sourceMap }: ToKotlinOptions): Promise<UtsResult>;
+export declare function checkAndroidVersionTips(pluginId: string, pluginDir: string, is_uni_modules: boolean): string | undefined;