@dcloudio/uni-uts-v1 3.0.0-3061320221209001

package/dist/kotlin.js

@@ -0,0 +1,324 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAndroidVersionTips = exports.compile = exports.resolveAndroidDepFiles = 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 = __importStar(require("path"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const fast_glob_1 = require("fast-glob");
+const shared_1 = require("@vue/shared");
+const android_versions_1 = require("android-versions");
+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;
+    }
+    const inputDir = process.env.UNI_INPUT_DIR;
+    const outputDir = process.env.UNI_OUTPUT_DIR;
+    await compile(filename, { inputDir, outputDir, sourceMap: true });
+    (0, utils_1.genUTSPlatformResource)(filename, {
+        inputDir,
+        outputDir,
+        platform: 'app-android',
+        extname: '.kt',
+    });
+}
+exports.runKotlinProd = runKotlinProd;
+async function runKotlinDev(filename) {
+    // 文件有可能是 app-ios 里边的，因为编译到 android 时，为了保证不报错，可能会去读取 ios 下的 uts
+    if (filename.includes('app-ios')) {
+        return;
+    }
+    const inputDir = process.env.UNI_INPUT_DIR;
+    const outputDir = process.env.UNI_OUTPUT_DIR;
+    const result = (await compile(filename, {
+        inputDir,
+        outputDir,
+        sourceMap: true,
+    }));
+    result.type = 'kotlin';
+    result.changed = [];
+    const kotlinFile = (0, utils_1.resolveUTSPlatformFile)(filename, {
+        inputDir,
+        outputDir,
+        platform: 'app-android',
+        extname: '.kt',
+    });
+    // 开发模式下，需要生成 dex
+    if (fs_extra_1.default.existsSync(kotlinFile)) {
+        const compilerServer = (0, utils_1.getCompilerServer)('uniapp-runextension');
+        if (!compilerServer) {
+            throw `项目使用了uts插件，正在安装 uts Android 运行扩展...`;
+        }
+        const { getDefaultJar, getKotlincHome, compile, checkDependencies, checkRResources, } = compilerServer;
+        let deps = [];
+        if (checkDependencies) {
+            deps = await checkDeps(filename, checkDependencies);
+        }
+        let resDeps = [];
+        if (checkRResources) {
+            resDeps = await checkRes(filename, checkRResources);
+        }
+        // time = Date.now()
+        const jarFile = resolveJarPath(kotlinFile);
+        const options = {
+            kotlinc: resolveKotlincArgs(kotlinFile, getKotlincHome(), getDefaultJar()
+                .concat(resolveLibs(filename))
+                .concat(deps)
+                .concat(resDeps)),
+            d8: resolveD8Args(jarFile),
+            sourceRoot: inputDir,
+            sourceMapPath: resolveSourceMapFile(outputDir, kotlinFile),
+        };
+        const res = await compile(options, inputDir);
+        // 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)) {
+                result.changed = [(0, shared_2.normalizePath)(path_1.default.relative(outputDir, dexFile))];
+            }
+        }
+        // else {
+        //   throw `${normalizePath(
+        //     path.relative(process.env.UNI_INPUT_DIR, filename)
+        //   )} 编译失败`
+        // }
+    }
+    return result;
+}
+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) {
+                console.error(msg);
+                return [];
+            }
+            return data;
+        });
+    }
+    return Promise.resolve([]);
+}
+function hasDeps(configJsonFile) {
+    const deps = (0, shared_2.parseJson)(fs_extra_1.default.readFileSync(configJsonFile, 'utf8')).dependencies || [];
+    if ((0, shared_1.isArray)(deps) && deps.length) {
+        return true;
+    }
+    return false;
+}
+function checkRes(filename, checkRResources) {
+    const resDir = resolveResDir(filename);
+    if (resDir) {
+        return checkRResources(resDir).then(({ code, msg, data }) => {
+            if (code !== 0) {
+                console.error(msg);
+                return [];
+            }
+            return [data.jarPath];
+        });
+    }
+    return Promise.resolve([]);
+}
+function resolveResDir(filename) {
+    const resDir = path_1.default.resolve((0, utils_1.resolveAndroidDir)(filename), 'res');
+    if (fs_extra_1.default.existsSync(resDir)) {
+        return resDir;
+    }
+}
+function resolveAndroidResourceClass(filename) {
+    const resDir = resolveResDir(filename);
+    if (resDir && fs_extra_1.default.readdirSync(resDir).length) {
+        const pkg = resolveAndroidManifestPackage(filename);
+        if (pkg) {
+            return pkg + '.R';
+        }
+    }
+}
+const packageRe = /\s+package="(.*)"/;
+function resolveAndroidManifestPackage(filename) {
+    const manifestXmlPath = path_1.default.resolve((0, utils_1.resolveAndroidDir)(filename), 'AndroidManifest.xml');
+    if (fs_extra_1.default.existsSync(manifestXmlPath)) {
+        const matches = fs_extra_1.default.readFileSync(manifestXmlPath, 'utf8').match(packageRe);
+        if (matches && matches[1]) {
+            return matches[1];
+        }
+    }
+}
+const deps = ['AndroidManifest.xml', 'config.json'];
+function resolveAndroidDepFiles(filename) {
+    const dir = (0, utils_1.resolveAndroidDir)(filename);
+    return deps.map((dep) => path_1.default.resolve(dir, dep));
+}
+exports.resolveAndroidDepFiles = resolveAndroidDepFiles;
+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');
+}
+const DEFAULT_IMPORTS = [
+    'kotlinx.coroutines.async',
+    'kotlinx.coroutines.CoroutineScope',
+    'kotlinx.coroutines.Deferred',
+    'kotlinx.coroutines.Dispatchers',
+    'io.dcloud.uts.*',
+];
+async function compile(filename, { inputDir, outputDir, sourceMap }) {
+    const { bundle, UtsTarget } = (0, utils_1.getUtsCompiler)();
+    // let time = Date.now()
+    const imports = [...DEFAULT_IMPORTS];
+    const rClass = resolveAndroidResourceClass(filename);
+    if (rClass) {
+        imports.push(rClass);
+    }
+    const result = await bundle(UtsTarget.KOTLIN, {
+        input: {
+            root: inputDir,
+            filename,
+        },
+        output: {
+            isPlugin: true,
+            outDir: outputDir,
+            package: parseKotlinPackage(filename).package,
+            sourceMap: sourceMap ? (0, utils_1.resolveUTSSourceMapPath)() : false,
+            extname: 'kt',
+            imports,
+            logFilename: true,
+            noColor: (0, shared_2.isInHBuilderX)(),
+        },
+    });
+    sourceMap &&
+        (0, utils_1.moveRootIndexSourceMap)(filename, {
+            inputDir,
+            outputDir,
+            platform: 'app-android',
+            extname: '.kt',
+        });
+    return result;
+}
+exports.compile = compile;
+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);
+            }
+            libs.push(...(0, fast_glob_1.sync)('**/*.jar', {
+                cwd: outputPath,
+                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 checkAndroidVersionTips(pluginId, pluginDir, is_uni_modules) {
+    const configJsonFile = (0, path_1.join)(pluginDir, is_uni_modules ? 'utssdk' : '', 'app-android', 'config.json');
+    if (configJsonFile && fs_extra_1.default.existsSync(configJsonFile)) {
+        try {
+            const configJson = (0, shared_2.parseJson)(fs_extra_1.default.readFileSync(configJsonFile, 'utf8'));
+            if (configJson.minSdkVersion) {
+                const androidVersion = (0, android_versions_1.get)(configJson.minSdkVersion);
+                if (androidVersion) {
+                    return `uts插件[${pluginId}]需在 Android ${androidVersion.semver} 版本及以上方可正常使用`;
+                }
+            }
+        }
+        catch (e) { }
+    }
+}
+exports.checkAndroidVersionTips = checkAndroidVersionTips;

package/dist/legacy/index.d.ts

@@ -0,0 +1,23 @@
+import { BasicSourceMapConsumer, IndexedSourceMapConsumer } from 'source-map';
+interface MessageSourceLocation {
+    type: 'exception' | 'error' | 'warning' | 'info' | 'logging' | 'output';
+    message: string;
+    file?: string;
+    line: number;
+    column: number;
+    code?: string;
+}
+interface GenerateCodeFrameOptions {
+    sourceRoot?: string;
+    replaceTabsWithSpace?: boolean;
+}
+export declare function generateCodeFrameSourceMapConsumer(consumer: BasicSourceMapConsumer | IndexedSourceMapConsumer, m: MessageSourceLocation, options?: GenerateCodeFrameOptions): Required<MessageSourceLocation> | undefined;
+export declare function generateCodeFrameWithSourceMapPath(filename: string, messages: MessageSourceLocation[] | string, options?: GenerateCodeFrameOptions): Promise<Required<MessageSourceLocation>[]>;
+interface GenerateCodeFrameWithStacktraceOptions {
+    name: string;
+    inputDir: string;
+    outputDir: string;
+}
+export declare function generateCodeFrameWithKotlinStacktrace(stacktrace: string, { name, inputDir, outputDir }: GenerateCodeFrameWithStacktraceOptions): Promise<unknown>;
+export declare function generateCodeFrameWithSwiftStacktrace(stacktrace: string, { name, inputDir, outputDir }: GenerateCodeFrameWithStacktraceOptions): Promise<unknown>;
+export {};

package/dist/legacy/index.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCodeFrameWithSwiftStacktrace = exports.generateCodeFrameWithKotlinStacktrace = exports.generateCodeFrameWithSourceMapPath = exports.generateCodeFrameSourceMapConsumer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const source_map_1 = require("source-map");
+const stacktrace_1 = require("../stacktrace");
+function generateCodeFrameSourceMapConsumer(consumer, m, options = {}) {
+    if (m.file) {
+        const res = consumer.originalPositionFor({
+            line: m.line,
+            column: m.column,
+        });
+        if (res.source != null && res.line != null && res.column != null) {
+            let code = consumer.sourceContentFor(res.source, true);
+            if (code) {
+                code = (0, stacktrace_1.generateCodeFrame)(code, { line: res.line, column: res.column });
+                if (options.replaceTabsWithSpace) {
+                    code = code.replace(/\t/g, ' ');
+                }
+                return {
+                    type: m.type,
+                    file: res.source,
+                    line: res.line,
+                    column: res.column,
+                    message: m.message,
+                    code,
+                };
+            }
+        }
+    }
+}
+exports.generateCodeFrameSourceMapConsumer = generateCodeFrameSourceMapConsumer;
+function initConsumer(filename) {
+    if (fs_1.default.existsSync(filename)) {
+        return new source_map_1.SourceMapConsumer(fs_1.default.readFileSync(filename, 'utf8'));
+    }
+    return Promise.resolve(undefined);
+}
+function generateCodeFrameWithSourceMapPath(filename, messages, options = {}) {
+    if (typeof messages === 'string') {
+        try {
+            messages = JSON.parse(messages);
+        }
+        catch (e) { }
+    }
+    if (Array.isArray(messages) && messages.length) {
+        return new Promise((resolve) => {
+            initConsumer(filename).then((consumer) => {
+                resolve(messages
+                    .map((m) => {
+                    if (m.file && consumer) {
+                        const message = generateCodeFrameSourceMapConsumer(consumer, m, options);
+                        if (message) {
+                            return message;
+                        }
+                    }
+                    if (!m.file) {
+                        m.file = '';
+                    }
+                    return m;
+                })
+                    .filter(Boolean));
+            });
+        });
+    }
+    return Promise.resolve([]);
+}
+exports.generateCodeFrameWithSourceMapPath = generateCodeFrameWithSourceMapPath;
+function resolveSourceMapPath(sourceMapFilename, name, outputDir) {
+    const is_uni_modules = path_1.default.basename(path_1.default.dirname(name)) === 'uni_modules';
+    return path_1.default.resolve(outputDir, '../.sourcemap/app', name, is_uni_modules ? 'utssdk' : '', sourceMapFilename);
+}
+function generateCodeFrameWithKotlinStacktrace(stacktrace, { name, inputDir, outputDir }) {
+    const sourceMapFilename = resolveSourceMapPath('app-android/index.kt.map', name, outputDir);
+    return generateCodeFrameWithStacktrace(stacktrace, /e:\s+(.*):\s+\(([0-9]+),\s+([0-9]+)\):\s+(.*)/g, {
+        sourceRoot: inputDir,
+        sourceMapFilename,
+    });
+}
+exports.generateCodeFrameWithKotlinStacktrace = generateCodeFrameWithKotlinStacktrace;
+function generateCodeFrameWithSwiftStacktrace(stacktrace, { name, inputDir, outputDir }) {
+    const sourceMapFilename = resolveSourceMapPath('app-ios/index.swift.map', name, outputDir);
+    return generateCodeFrameWithStacktrace(stacktrace, /(.*):([0-9]+):([0-9]+):\s+error:\s+(.*)/g, {
+        sourceRoot: inputDir,
+        sourceMapFilename,
+    });
+}
+exports.generateCodeFrameWithSwiftStacktrace = generateCodeFrameWithSwiftStacktrace;
+function generateCodeFrameWithStacktrace(stacktrace, regexp, { sourceRoot, sourceMapFilename, replaceTabsWithSpace, }) {
+    return new Promise((resolve) => {
+        initConsumer(sourceMapFilename).then((consumer) => {
+            if (!consumer) {
+                return resolve(stacktrace);
+            }
+            resolve(stacktrace.replace(regexp, (substring, file, line, column, message) => {
+                const m = generateCodeFrameSourceMapConsumer(consumer, {
+                    type: 'error',
+                    file,
+                    message,
+                    line: parseInt(line),
+                    column: parseInt(column),
+                }, { sourceRoot, replaceTabsWithSpace });
+                if (!m) {
+                    return substring;
+                }
+                return `error: ${message}
+at ${m.file}:${m.line}:${m.column}
+${m.code}
+`;
+            }));
+        });
+    });
+}

package/dist/manifest/dex.d.ts

@@ -0,0 +1,2 @@
+export declare function storeDex(dexFile: string, pluginRelativeDir: string, outputDir: string): void;
+export declare function restoreDex(pluginRelativeDir: string, outputDir: string, is_uni_modules: boolean): void;

package/dist/manifest/dex.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreDex = exports.storeDex = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+function dexName() {
+    return 'classes.dex';
+}
+function storeDex(dexFile, pluginRelativeDir, outputDir) {
+    (0, fs_extra_1.copySync)(dexFile, resolveDexCacheFilename(pluginRelativeDir, outputDir));
+}
+exports.storeDex = storeDex;
+function restoreDex(pluginRelativeDir, outputDir, is_uni_modules) {
+    const cacheFile = resolveDexCacheFile(pluginRelativeDir, outputDir);
+    if (cacheFile) {
+        (0, fs_extra_1.copySync)(cacheFile, (0, path_1.join)(outputDir, pluginRelativeDir, is_uni_modules ? 'utssdk' : '', 'app-android', dexName()));
+    }
+}
+exports.restoreDex = restoreDex;
+function resolveDexCacheFilename(pluginRelativeDir, outputDir) {
+    return (0, path_1.join)(outputDir, '../.uts/dex', pluginRelativeDir, dexName());
+}
+function resolveDexCacheFile(pluginRelativeDir, outputDir) {
+    const file = resolveDexCacheFilename(pluginRelativeDir, outputDir);
+    return ((0, fs_extra_1.existsSync)(file) && file) || '';
+}

package/dist/manifest/index.d.ts

@@ -0,0 +1,8 @@
+import { APP_PLATFORM, CheckOptions, CheckResult } from './utils';
+export { genManifestFile } from './manifest';
+export { restoreDex, storeDex } from './dex';
+export { restoreSourceMap, storeSourceMap } from './sourceMap';
+export declare function checkKotlinCompile(playground: typeof process.env.HX_USE_BASE_TYPE, options: CheckOptions): Promise<CheckResult>;
+export declare function checkSwiftCompile(playground: typeof process.env.HX_USE_BASE_TYPE, options: CheckOptions): Promise<CheckResult>;
+export declare function checkCompile(platform: APP_PLATFORM, playground: typeof process.env.HX_USE_BASE_TYPE, options: CheckOptions): Promise<CheckResult>;
+export declare function initCheckOptionsEnv(): CheckOptions['env'];

package/dist/manifest/index.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCheckOptionsEnv = exports.checkCompile = exports.checkSwiftCompile = exports.checkKotlinCompile = exports.storeSourceMap = exports.restoreSourceMap = exports.storeDex = exports.restoreDex = exports.genManifestFile = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const shared_1 = require("../shared");
+const manifest_1 = require("./manifest");
+const utils_1 = require("./utils");
+var manifest_2 = require("./manifest");
+Object.defineProperty(exports, "genManifestFile", { enumerable: true, get: function () { return manifest_2.genManifestFile; } });
+var dex_1 = require("./dex");
+Object.defineProperty(exports, "restoreDex", { enumerable: true, get: function () { return dex_1.restoreDex; } });
+Object.defineProperty(exports, "storeDex", { enumerable: true, get: function () { return dex_1.storeDex; } });
+var sourceMap_1 = require("./sourceMap");
+Object.defineProperty(exports, "restoreSourceMap", { enumerable: true, get: function () { return sourceMap_1.restoreSourceMap; } });
+Object.defineProperty(exports, "storeSourceMap", { enumerable: true, get: function () { return sourceMap_1.storeSourceMap; } });
+const ANDROID_CUSTOM_RES = [
+    'app-android/assets/',
+    'app-android/libs/',
+    'app-android/res/',
+    'app-android/AndroidManifest.xml',
+];
+const IOS_CUSTOM_RES = [
+    'app-ios/Frameworks/',
+    'app-ios/Resources/',
+    'app-ios/Info.plist',
+];
+function checkKotlinCompile(playground, options) {
+    return checkCompile('app-android', playground, options);
+}
+exports.checkKotlinCompile = checkKotlinCompile;
+function checkSwiftCompile(playground, options) {
+    return checkCompile('app-ios', playground, options);
+}
+exports.checkSwiftCompile = checkSwiftCompile;
+function checkCompile(platform, playground, options) {
+    const platformOptions = {
+        customRes: platform === 'app-android' ? ANDROID_CUSTOM_RES : IOS_CUSTOM_RES,
+    };
+    if (playground === 'standard') {
+        return checkWithPlayground(platform, 'standard', options, platformOptions);
+    }
+    return checkWithPlayground(platform, 'custom', options, platformOptions);
+}
+exports.checkCompile = checkCompile;
+async function checkWithPlayground(platform, type, { id, env, cacheDir, pluginDir, pluginRelativeDir, is_uni_modules, }, { customRes }) {
+    // 第一步：获取所有文件列表
+    const files = await (0, manifest_1.resolvePluginFiles)(platform, pluginDir, is_uni_modules);
+    let tips = '';
+    // 标准基座检查是否包含原生资源/配置
+    if (type === 'standard') {
+        if ((0, manifest_1.hasCustomResources)(files, customRes)) {
+            tips = (0, utils_1.customResourceTips)(id);
+        }
+        else {
+            // 检查 config.json
+            if (platform === 'app-android') {
+                if (androidHasCustomConfigJson(pluginDir, is_uni_modules)) {
+                    tips = (0, utils_1.customResourceTips)(id);
+                }
+            }
+            else if (platform === 'app-ios') {
+                if (iOSHasCustomConfigJson(pluginDir, is_uni_modules)) {
+                    tips = (0, utils_1.customResourceTips)(id);
+                }
+            }
+        }
+    }
+    // 第二步：获取当前插件缓存文件信息
+    const manifest = (0, manifest_1.resolveManifestJson)(platform, pluginRelativeDir, cacheDir);
+    if (!manifest) {
+        return { expired: true, tips, files };
+    }
+    // 第四步：检查文件变更
+    const res = await (0, manifest_1.checkManifest)(manifest, { env, files, pluginDir });
+    // 自定义基座检查原生资源/配置是否发生变化
+    if (type === 'custom' && typeof res === 'string') {
+        if ((0, manifest_1.isCustomResources)(res, customRes)) {
+            tips = (0, utils_1.customResourceChangedTips)(id);
+        }
+    }
+    return {
+        expired: res !== true,
+        tips,
+        files,
+    };
+}
+function initCheckOptionsEnv() {
+    return {
+        compilerVersion: require('../../package.json').version,
+    };
+}
+exports.initCheckOptionsEnv = initCheckOptionsEnv;
+function androidHasCustomConfigJson(pluginDir, is_uni_modules) {
+    return hasCustomConfigJson('app-android', 'minSdkVersion', pluginDir, is_uni_modules);
+}
+function iOSHasCustomConfigJson(pluginDir, is_uni_modules) {
+    return hasCustomConfigJson('app-ios', 'deploymentTarget', pluginDir, is_uni_modules);
+}
+function hasCustomConfigJson(platform, key, pluginDir, is_uni_modules) {
+    const configJsonFile = (0, path_1.join)(pluginDir, is_uni_modules ? 'utssdk' : '', platform, 'config.json');
+    if (configJsonFile && (0, fs_extra_1.existsSync)(configJsonFile)) {
+        try {
+            const configJson = (0, shared_1.parseJson)((0, fs_extra_1.readFileSync)(configJsonFile, 'utf8'));
+            const len = Object.keys(configJson).length;
+            if (len > 1) {
+                return true;
+            }
+            if (len === 1) {
+                if (!configJson.hasOwnProperty(key)) {
+                    return true;
+                }
+            }
+        }
+        catch (e) { }
+    }
+    return false;
+}

package/dist/manifest/manifest.d.ts

@@ -0,0 +1,44 @@
+import { APP_PLATFORM } from './utils';
+interface ManifestFile {
+    md5: string;
+}
+declare const VERSION = "1";
+export interface Manifest {
+    version: typeof VERSION;
+    env: Record<string, unknown>;
+    files: {
+        [file: string]: ManifestFile;
+    };
+}
+/**
+ * 计算文件 md5（有缓存）
+ * @param file
+ * @returns
+ */
+export declare function hash(file: string): Promise<string>;
+interface GenManifestJsonOptions {
+    pluginDir: string;
+    env: Record<string, unknown>;
+    files?: string[];
+    is_uni_modules: boolean;
+}
+export interface GenManifestFileOptions {
+    cacheDir: string;
+    pluginRelativeDir: string;
+    is_uni_modules: boolean;
+    env: Record<string, unknown>;
+    pluginDir: string;
+    files?: string[];
+}
+export declare function genManifestFile(platform: APP_PLATFORM, { files, pluginDir, env, cacheDir, pluginRelativeDir, is_uni_modules, }: GenManifestFileOptions): Promise<boolean>;
+export declare function genManifestJson(platform: APP_PLATFORM, { pluginDir, files, env, is_uni_modules }: GenManifestJsonOptions): Promise<Manifest>;
+export declare function resolvePluginFiles(platform: APP_PLATFORM, pluginDir: string, is_uni_modules: boolean): Promise<string[]>;
+export declare function checkManifest(manifest: Manifest, { env, files, pluginDir, }: {
+    pluginDir: string;
+    files: string[];
+    env: Record<string, unknown>;
+}): Promise<string | boolean>;
+export declare function hasCustomResources(files: string[], resources: string[]): true | undefined;
+export declare function isCustomResources(file: string, resources: string[]): boolean;
+export declare function resolveManifestJson(platform: APP_PLATFORM, pluginRelativeDir: string, cacheDir: string): Manifest | undefined;
+export {};