minidev 0.0.1

package/assets/builder-debug-utils/lib/sdk.d.ts

@@ -0,0 +1,30 @@
+import { IBuilderDebugClient, IBuilderDebugClientOptions, IUpdateAssetsOptions, IGenerateInjectCodeOptions, IGetBoatmanBundleOptions } from './interface';
+import { AssetsUpdater } from './updater';
+import { BuilderDebugContext } from './context';
+export declare class BuilderDebugClient implements IBuilderDebugClient {
+    protected assetsUpdater: AssetsUpdater;
+    protected context: BuilderDebugContext;
+    constructor(options?: IBuilderDebugClientOptions);
+    updateOfflineAssets(options: IUpdateAssetsOptions): Promise<void>;
+    generateInjectCode(options: IGenerateInjectCodeOptions): Promise<import("./interface").IInjectionPoints>;
+    /**
+     * generateInjectCode 同步方法
+     */
+    generateInjectCodeSync(options: IGenerateInjectCodeOptions): import("./interface").IInjectionPoints;
+    /**
+     * 生成构建器消费的 InjectCode JSON 文件，并返回路径
+     */
+    generateInjectCodePath(options: IGenerateInjectCodeOptions): Promise<string>;
+    /**
+     * generateInjectCodePath 同步方法
+     */
+    generateInjectCodePathSync(options: IGenerateInjectCodeOptions): string;
+    /**
+     * 获取本地 boatman 文件资源路径
+     */
+    getBoatmanBundlePath(options: IGetBoatmanBundleOptions): Promise<string>;
+    /**
+     * getBoatmanBundlePath 同步方法
+     */
+    getBoatmanBundlePathSync(options: IGetBoatmanBundleOptions): string;
+}

package/assets/builder-debug-utils/lib/sdk.js

@@ -0,0 +1,148 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const interface_1 = require("./interface");
+const updater_1 = require("./updater");
+const config_1 = require("./config");
+const compose_1 = require("./compose");
+const context_1 = require("./context");
+class BuilderDebugClient {
+    constructor(options) {
+        this.context = new context_1.BuilderDebugContext(Object.assign(Object.assign({}, config_1.defaultConfig), options));
+    }
+    updateOfflineAssets(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.assetsUpdater) {
+                this.assetsUpdater = new updater_1.AssetsUpdater(this.context);
+            }
+            if (options.cacheToday) {
+                yield this.assetsUpdater.updateOfflineAssetsToday();
+            }
+            else {
+                yield this.assetsUpdater.updateOfflineAssets();
+            }
+        });
+    }
+    generateInjectCode(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            options = getInjectCodeOptions(options);
+            const assetsMap = yield readAssetsMap(this.context);
+            return compose_1.composeAssetsByCompileMode(assetsMap, options);
+        });
+    }
+    /**
+     * generateInjectCode 同步方法
+     */
+    generateInjectCodeSync(options) {
+        options = getInjectCodeOptions(options);
+        const assetsMap = readAssetsMapSync(this.context);
+        return compose_1.composeAssetsByCompileMode(assetsMap, options);
+    }
+    /**
+     * 生成构建器消费的 InjectCode JSON 文件，并返回路径
+     */
+    generateInjectCodePath(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const injectCode = yield this.generateInjectCode(options);
+            yield fs_extra_1.default.writeJSON(config_1.defaultConfig.injectCodeTempPath, injectCode);
+            return config_1.defaultConfig.injectCodeTempPath;
+        });
+    }
+    /**
+     * generateInjectCodePath 同步方法
+     */
+    generateInjectCodePathSync(options) {
+        const injectCode = this.generateInjectCodeSync(options);
+        fs_extra_1.default.writeJSONSync(config_1.defaultConfig.injectCodeTempPath, injectCode);
+        return config_1.defaultConfig.injectCodeTempPath;
+    }
+    /**
+     * 获取本地 boatman 文件资源路径
+     */
+    getBoatmanBundlePath(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opt = getGetBoatmanBundleOptions(options);
+            // 若文件不存在降级到 readonly 备份
+            try {
+                const offlineFile = this.context.getBoatmanFilePath(opt.target);
+                yield fs_extra_1.default.access(offlineFile, fs_extra_1.default.constants.R_OK);
+                return offlineFile;
+            }
+            catch (error) {
+                return this.context.getReadonlyBoatmanFilePath(opt.target);
+            }
+        });
+    }
+    /**
+     * getBoatmanBundlePath 同步方法
+     */
+    getBoatmanBundlePathSync(options) {
+        const opt = getGetBoatmanBundleOptions(options);
+        try {
+            const offlineFile = this.context.getBoatmanFilePath(opt.target);
+            fs_extra_1.default.accessSync(offlineFile, fs_extra_1.default.constants.R_OK);
+            return offlineFile;
+        }
+        catch (error) {
+            return this.context.getReadonlyBoatmanFilePath(opt.target);
+        }
+    }
+}
+exports.BuilderDebugClient = BuilderDebugClient;
+function getGetBoatmanBundleOptions(options) {
+    const result = {
+        target: interface_1.ECompileTargetType.Mini,
+    };
+    if (options.target && Object.keys(interface_1.ECompileTargetType).indexOf(options.target) > -1) {
+        result.target = options.target;
+    }
+    return result;
+}
+function getInjectCodeOptions(options) {
+    const opt = Object.assign({}, options);
+    if (!opt.mode || Object.keys(interface_1.ECompileModeType).indexOf(opt.mode) === -1) {
+        throw new Error(`[${config_1.libName}] invalid 'mode' option: ${opt.mode}`);
+    }
+    if (!opt.target || Object.keys(interface_1.ECompileTargetType).indexOf(opt.target) === -1) {
+        opt.target = interface_1.ECompileTargetType.Mini;
+    }
+    return options;
+}
+function readAssetsMapSync(context) {
+    let localJSON = fs_extra_1.default.readJSONSync(context.getAssetsMapFilePath(), { throws: false });
+    if (!localJSON) {
+        console.log(`[${config_1.libName}] offline assets_map file was damaged, fallback to readonly file`);
+        // 避免文件损坏，readonly/assets_map 做兜底
+        localJSON = fs_extra_1.default.readJSONSync(context.getReadonlyAssetsMapFilePath());
+    }
+    return localJSON;
+}
+function readAssetsMap(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let localJSON;
+        try {
+            localJSON = yield fs_extra_1.default.readJSON(context.getAssetsMapFilePath(), { throws: false });
+        }
+        catch (error) {
+            // throws if file is not found
+        }
+        if (!localJSON) {
+            console.log(`[${config_1.libName}] offline assets_map file was damaged, fallback to readonly file`);
+            // 避免文件损坏，readonly/assets_map 做兜底
+            localJSON = yield fs_extra_1.default.readJSON(context.getReadonlyAssetsMapFilePath());
+        }
+        return localJSON;
+    });
+}

package/assets/builder-debug-utils/lib/updater.d.ts

@@ -0,0 +1,16 @@
+import { BuilderDebugContext } from './context';
+export declare class AssetsUpdater {
+    protected context: BuilderDebugContext;
+    protected updatingTask: Promise<void> | undefined;
+    constructor(context: BuilderDebugContext);
+    /**
+     * 检查本地资源文件是否过期并进行更新，每日只更新一次
+     */
+    updateOfflineAssetsToday(): Promise<void>;
+    /**
+     * 更新本地资源文件
+     */
+    updateOfflineAssets(): Promise<void>;
+    protected runUpdateTask(): Promise<void>;
+    protected updateLocalFile(filePath: string, url: string | undefined, integrity: string | undefined): Promise<void>;
+}

package/assets/builder-debug-utils/lib/updater.js

@@ -0,0 +1,137 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bent_1 = __importDefault(require("bent"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const crypto_1 = __importDefault(require("crypto"));
+const config_1 = require("./config");
+const interface_1 = require("./interface");
+const getJSON = bent_1.default('json');
+const getBuffer = bent_1.default('buffer');
+const LOG_TAG = `[${config_1.libName}]`;
+class AssetsUpdater {
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * 检查本地资源文件是否过期并进行更新，每日只更新一次
+     */
+    updateOfflineAssetsToday() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!isFileModifiedToday(this.context.getAssetsMapFilePath())) {
+                console.log(`${LOG_TAG} local assets are outdated, start to download new debug assets`);
+                yield this.updateOfflineAssets();
+            }
+            else {
+                console.log(`${LOG_TAG} local assets are in the period of validity`);
+            }
+        });
+    }
+    /**
+     * 更新本地资源文件
+     */
+    updateOfflineAssets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.updatingTask) {
+                return this.updatingTask;
+            }
+            this.updatingTask = this.runUpdateTask();
+            try {
+                yield this.updatingTask;
+                this.updatingTask = undefined;
+            }
+            catch (error) {
+                this.updatingTask = undefined;
+                throw error;
+            }
+        });
+    }
+    runUpdateTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. 请求在线配置
+            let assetsConfig;
+            try {
+                assetsConfig = (yield getJSON(config_1.defaultConfig.assetsQueryUrl));
+            }
+            catch (error) {
+                throw new Error('Failed to request online config');
+            }
+            yield Promise.all([
+                this.updateLocalFile(this.context.getAssetsMapFilePath(), assetsConfig.url_v2, assetsConfig.integrity_v2),
+                this.updateLocalFile(this.context.getBoatmanFilePath(interface_1.ECompileTargetType.Mini), assetsConfig.url_boatman_mini, assetsConfig.integrity_boatman_mini),
+                this.updateLocalFile(this.context.getBoatmanFilePath(interface_1.ECompileTargetType.Cube), assetsConfig.url_boatman_cube, assetsConfig.integrity_boatman_cube),
+            ]);
+        });
+    }
+    updateLocalFile(filePath, url, integrity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!url || !integrity) {
+                // 线上配置有误
+                console.error(`${LOG_TAG} Empty key in config`);
+                return;
+            }
+            // 2. 校验本地资源是否最新
+            try {
+                const localAssetsBuffer = yield fs_extra_1.default.readFile(filePath);
+                const localAssetsHash = crypto_1.default
+                    .createHash('sha256')
+                    .update(localAssetsBuffer)
+                    .digest('base64');
+                if (localAssetsHash === integrity) {
+                    console.log(`${LOG_TAG} Local is latested`);
+                    return;
+                }
+            }
+            catch (error) {
+                // 本地资源文件不存在
+            }
+            console.log(`${LOG_TAG} Start to update local`);
+            // 3. 下载新版本资源
+            let downloadBuffer;
+            try {
+                downloadBuffer = (yield getBuffer(url));
+            }
+            catch (error) {
+                console.error(`${LOG_TAG} Download error ${error.message}`);
+                return;
+            }
+            // 4. 校验下载资源文件 hash，并写入本地文件
+            const downloadHash = crypto_1.default.createHash('sha256').update(downloadBuffer).digest('base64');
+            if (downloadHash === integrity) {
+                yield fs_extra_1.default.writeFile(filePath, downloadBuffer);
+                console.log(`${LOG_TAG} Updated`);
+            }
+            else {
+                throw new Error('Failed to verify');
+            }
+        });
+    }
+}
+exports.AssetsUpdater = AssetsUpdater;
+/**
+ * 检查本地资源文件是否今日更新过
+ * @returns {boolean} true-更新过; false-未更新
+ */
+function isFileModifiedToday(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const stat = yield fs_extra_1.default.stat(filePath);
+            const mtime = new Date(parseInt(`${stat.mtimeMs}`, 10));
+            return new Date().toLocaleDateString() === mtime.toLocaleDateString();
+        }
+        catch (error) {
+            return false;
+        }
+    });
+}

package/assets/builder-debug-utils/lib/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Legacy module API
+ * 直接导出函数
+ */
+import { IBuilderDebugClientOptions, IGenerateInjectCodeOptions, IGetBoatmanBundleOptions, IInjectionPoints, IUpdateAssetsOptions } from './interface';
+export declare function updateInjectCodeAssets(options?: IUpdateAssetsOptions): Promise<void>;
+export declare function generateInjectCode(options: IGenerateInjectCodeOptions): Promise<IInjectionPoints>;
+export declare function generateInjectCodeSync(options: IGenerateInjectCodeOptions): IInjectionPoints;
+export declare function generateInjectCodePath(options: IGenerateInjectCodeOptions): Promise<string>;
+export declare function generateInjectCodePathSync(options: IGenerateInjectCodeOptions): string;
+export declare function getBoatmanBundlePath(options?: IGetBoatmanBundleOptions): Promise<string>;
+export declare function getBoatmanBundlePathSync(options?: IGetBoatmanBundleOptions): string;
+export declare function loadConfig(options: IBuilderDebugClientOptions): void;

package/assets/builder-debug-utils/lib/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = require("./sdk");
+let sharedBuilderDebugClient;
+function getClient() {
+    if (!sharedBuilderDebugClient) {
+        sharedBuilderDebugClient = new sdk_1.BuilderDebugClient();
+    }
+    return sharedBuilderDebugClient;
+}
+function updateInjectCodeAssets(options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return getClient().updateOfflineAssets(options);
+    });
+}
+exports.updateInjectCodeAssets = updateInjectCodeAssets;
+function generateInjectCode(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return getClient().generateInjectCode(options);
+    });
+}
+exports.generateInjectCode = generateInjectCode;
+function generateInjectCodeSync(options) {
+    return getClient().generateInjectCodeSync(options);
+}
+exports.generateInjectCodeSync = generateInjectCodeSync;
+function generateInjectCodePath(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return getClient().generateInjectCodePath(options);
+    });
+}
+exports.generateInjectCodePath = generateInjectCodePath;
+function generateInjectCodePathSync(options) {
+    return getClient().generateInjectCodePathSync(options);
+}
+exports.generateInjectCodePathSync = generateInjectCodePathSync;
+function getBoatmanBundlePath(options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return getClient().getBoatmanBundlePath(options);
+    });
+}
+exports.getBoatmanBundlePath = getBoatmanBundlePath;
+function getBoatmanBundlePathSync(options = {}) {
+    return getClient().getBoatmanBundlePathSync(options);
+}
+exports.getBoatmanBundlePathSync = getBoatmanBundlePathSync;
+function loadConfig(options) {
+    sharedBuilderDebugClient = new sdk_1.BuilderDebugClient(options);
+}
+exports.loadConfig = loadConfig;