@arkts/image-manager 0.2.3 → 0.3.1

package/dist/index.mjs

@@ -1,13 +1,14 @@
 import axios, { AxiosError } from "axios";
+import satisfies from "semver/functions/satisfies";
 import mitt from "mitt";
 import progress from "progress-stream";
 import unzipper from "unzipper";
 
 //#region package.json
-var version = "0.2.3";
+var version = "0.3.1";
 
 //#endregion
-//#region src/deployer/list.ts
+//#region src/devices/list.ts
 let DevModel = /* @__PURE__ */ function(DevModel) {
 	DevModel["MCHEMU_AL00CN"] = "MCHEMU-AL00CN";
 	DevModel["PHEMU_FD00"] = "PHEMU-FD00";
@@ -28,6 +29,9 @@ var DeployError = class extends Error {
 		this.message = message;
 		this.cause = cause;
 	}
+	getCode() {
+		return this.code;
+	}
 };
 (function(_DeployError) {
 	_DeployError.Code = /* @__PURE__ */ function(Code) {
@@ -52,221 +56,237 @@ var RequestUrlError = class extends Error {
 };
 
 //#endregion
-//#region src/deployer/image-deployer.ts
-var ImageDeployerImpl = class {
-	options = {};
-	isDefault = true;
-	isCustomize = false;
-	isPublic = true;
-	vendorCountry = "CN";
-	hwHdcPort = "notset";
-	constructor(image, uuid, name, config) {
-		this.image = image;
-		this.config = config;
-		this.options.uuid = uuid;
-		this.options.name = name;
-		Object.assign(this.options, config);
-		if ("productName" in this.options) delete this.options.productName;
+//#region src/screens/screen.ts
+var ScreenImpl = class {
+	constructor(options) {
+		this.options = options;
 	}
-	setUuid(uuid) {
-		this.options.uuid = uuid;
-		return this;
+	getDiagonal() {
+		return this.options.diagonal;
 	}
-	setModel(model) {
-		this.options.model = model;
+	setDiagonal(diagonal) {
+		this.options.diagonal = diagonal;
 		return this;
 	}
-	setDevModel(devModel) {
-		this.options.devModel = devModel;
-		return this;
+	getDensity() {
+		return this.options.density;
 	}
-	setCpuNumber(cpuNumber) {
-		this.options.cpuNumber = cpuNumber.toString();
+	setDensity(density) {
+		this.options.density = density;
 		return this;
 	}
-	setMemoryRamSize(memoryRamSize) {
-		this.options.memoryRamSize = memoryRamSize.toString();
-		return this;
+	getHeight() {
+		return this.options.height;
 	}
-	setDataDiskSize(dataDiskSize) {
-		this.options.dataDiskSize = dataDiskSize.toString();
+	setHeight(height) {
+		this.options.height = height;
 		return this;
 	}
-	setCoverResolutionWidth(coverResolutionWidth) {
-		this.options.coverResolutionWidth = coverResolutionWidth.toString();
-		return this;
+	getWidth() {
+		return this.options.width;
 	}
-	setCoverResolutionHeight(coverResolutionHeight) {
-		this.options.coverResolutionHeight = coverResolutionHeight.toString();
+	setWidth(width) {
+		this.options.width = width;
 		return this;
 	}
-	setCoverDiagonalSize(coverDiagonalSize) {
-		this.options.coverDiagonalSize = coverDiagonalSize.toString();
-		return this;
+	toJSON() {
+		return this.options;
 	}
-	setIsDefault(isDefault) {
-		this.isDefault = isDefault;
-		return this;
+};
+function createScreen(options) {
+	return new ScreenImpl(options);
+}
+
+//#endregion
+//#region src/screens/product-preset.ts
+var ProductPresetImpl = class {
+	constructor(productConfig, deviceType) {
+		this.productConfig = productConfig;
+		this.deviceType = deviceType;
 	}
-	setIsCustomize(isCustomize) {
-		this.isCustomize = isCustomize;
-		return this;
+	getProductConfig() {
+		return this.productConfig;
 	}
-	setIsPublic(isPublic) {
-		this.isPublic = isPublic;
-		return this;
+	getDeviceType() {
+		return this.deviceType;
+	}
+	toScreen() {
+		return createScreen({
+			diagonal: Number(this.productConfig.screenDiagonal),
+			density: Number(this.productConfig.screenDensity),
+			height: Number(this.productConfig.screenHeight),
+			width: Number(this.productConfig.screenWidth)
+		});
 	}
-	setHwHdcPort(hwHdcPort) {
-		this.hwHdcPort = hwHdcPort.toString();
-		return this;
+	toJSON() {
+		return {
+			product: this.productConfig,
+			deviceType: this.deviceType
+		};
 	}
-	setVendorCountry(vendorCountry) {
-		this.vendorCountry = vendorCountry;
+};
+async function createProductPreset(productConfig, deviceType) {
+	return new ProductPresetImpl(productConfig, deviceType);
+}
+
+//#endregion
+//#region src/devices/device.ts
+var DeviceImpl = class {
+	uuid;
+	constructor(image, options) {
+		this.image = image;
+		this.options = options;
+		this.uuid = image.getImageManager().getOptions().crypto.randomUUID();
+	}
+	getOptions() {
+		return this.options;
+	}
+	getImage() {
+		return this.image;
+	}
+	getScreen() {
+		if (this.options.screen instanceof ProductPresetImpl) return this.options.screen.toScreen();
+		return this.options.screen;
+	}
+	setUuid(uuid) {
+		this.uuid = uuid;
 		return this;
 	}
-	async getDevModel() {
-		if (this.options.devModel) return this.options.devModel;
-		const productConfigItem = (await this.image.getProductConfig()).find((item) => item.name === this.config.productName);
-		if (!productConfigItem) throw new Error(`Product config item ${this.config.productName} not found`);
-		if (productConfigItem.devModel) return productConfigItem.devModel;
-		const defaultProductConfigItem = (await this.image.getProductConfig(true)).find((item) => item.name === this.config.productName);
-		if (!defaultProductConfigItem) throw new Error(`Default product config item ${this.config.productName} not found`);
-		if (defaultProductConfigItem.devModel) return defaultProductConfigItem.devModel;
+	getUuid() {
+		return this.uuid;
 	}
-	async buildList() {
-		return {
-			...this.options,
-			"imageDir": this.image.getPath().split(",").join(this.image.getImageManager().getOptions().path.sep) + this.image.getImageManager().getOptions().path.sep,
-			"version": this.image.getVersion(),
-			"abi": this.image.getArch(),
+	buildList() {
+		const { path, deployedPath, imageBasePath, configPath, logPath } = this.image.getImageManager().getOptions();
+		const screen = this.getScreen();
+		const list = {
+			"name": this.options.name,
 			"apiVersion": this.image.getApiVersion(),
-			"path": this.image.getImageManager().getOptions().path.resolve(this.image.getImageManager().getOptions().deployedPath, this.options.name ?? ""),
+			"cpuNumber": this.options.cpuNumber.toFixed(),
+			"diagonalSize": screen.getDiagonal().toFixed(2),
+			"resolutionHeight": screen.getHeight().toFixed(),
+			"resolutionWidth": screen.getWidth().toFixed(),
+			"density": screen.getDensity().toFixed(),
+			"memoryRamSize": this.options.memorySize.toFixed(),
+			"dataDiskSize": this.options.diskSize.toFixed(),
+			"path": path.resolve(deployedPath, this.options.name),
+			"type": this.image.getSnakecaseDeviceType(),
+			"uuid": this.uuid,
+			"version": this.image.getVersion(),
+			"imageDir": this.image.getPath().split(",").join(path.sep) + path.sep,
 			"showVersion": `${this.image.getTargetOS()} ${this.image.getTargetVersion()}(${this.image.getApiVersion()})`,
-			"harmonyOSVersion": `${this.image.getTargetOS()}-${this.image.getTargetVersion()}`,
+			"harmonyos.sdk.path": imageBasePath,
+			"harmonyos.config.path": configPath,
+			"harmonyos.log.path": logPath,
 			"hw.apiName": this.image.getTargetVersion(),
-			"harmonyos.sdk.path": this.image.getImageManager().getOptions().imageBasePath,
-			"harmonyos.config.path": this.image.getImageManager().getOptions().configPath,
-			"harmonyos.log.path": this.image.getImageManager().getOptions().logPath,
-			"type": this.image.getSnakecaseDeviceType(),
-			"devModel": await this.getDevModel()
+			"abi": this.image.getArch(),
+			"harmonyOSVersion": `${this.image.getTargetOS()}-${this.image.getTargetVersion()}`,
+			"guestVersion": `${this.image.getTargetOS()} ${this.image.getVersion()}(${this.image.getReleaseType()})`
 		};
-	}
-	async buildIni() {
-		const config = await this.buildList();
-		const productConfigItem = (await this.image.getProductConfig()).find((item) => item.name === this.config.productName);
-		if (!productConfigItem) throw new Error(`Product config item ${this.config.productName} not found`);
-		return {
-			"name": config.name,
-			"hw.lcd.density": config.density,
-			"hw.lcd.height": productConfigItem.screenHeight,
-			"hw.lcd.width": productConfigItem.screenWidth,
-			"hw.cpu.ncore": config.cpuNumber,
-			"hw.phy.height": productConfigItem.outerScreenHeight,
-			"hw.phy.width": productConfigItem.outerScreenWidth,
-			"hw.cover.height": productConfigItem.outerScreenHeight,
-			"hw.cover.width": productConfigItem.outerScreenWidth,
-			"coverDiagonalSize": config.coverDiagonalSize ?? productConfigItem.outerScreenDiagonal,
-			"diagonalSize": config.diagonalSize,
-			"hw.ramSize": config.memoryRamSize,
-			"deviceType": config.type,
-			"uuid": config.uuid,
-			"hmApiVersion": config.apiVersion,
-			"hmAbi": config.abi,
-			"hmVersion": config.version,
-			"hw.cpu.arch": config.abi,
-			"hw.apiName": config["hw.apiName"],
-			"image.sysdir.1": config.imageDir,
-			"hvd.path": config.path,
-			"disk.dataPartition.size": `${config.dataDiskSize}M`,
-			"hmShowVersion": config.showVersion,
-			"harmonyOSVersion": config.harmonyOSVersion,
-			"harmonyos.sdk.path": config["harmonyos.sdk.path"],
-			"harmonyos.config.path": config["harmonyos.config.path"],
-			"harmonyos.log.path": config["harmonyos.log.path"],
-			"guest.version": config.version,
-			"devModel": config.devModel,
-			"model": config.model,
-			"isDefault": this.isDefault ? "true" : "false",
-			"isCustomize": this.isCustomize ? "true" : "false",
-			"isPublic": this.isPublic ? "true" : "false",
-			"vendorCountry": this.vendorCountry,
-			"hw.hdc.port": this.hwHdcPort.toString()
+		if (this.options.screen instanceof ProductPresetImpl) {
+			const productConfig = this.options.screen.getProductConfig();
+			if (productConfig.devModel) list.devModel = productConfig.devModel;
+			if (productConfig.name) list.model = productConfig.name;
+		}
+		return list;
+	}
+	buildIni(options = {}) {
+		const listConfig = this.buildList();
+		const screen = this.getScreen();
+		const is2in1Foldable = listConfig.type === "2in1_foldable";
+		const productPreset = this.options.screen instanceof ProductPresetImpl ? this.options.screen : null;
+		const productConfig = productPreset?.getProductConfig();
+		const useDualScreen = is2in1Foldable && productConfig?.outerScreenWidth != null && productConfig?.outerScreenHeight != null && productConfig?.outerScreenDiagonal != null;
+		const singleDiagonal = useDualScreen ? productConfig.outerScreenDiagonal : screen.getDiagonal().toString();
+		const singleHeight = useDualScreen ? productConfig.outerScreenHeight : screen.getHeight().toString();
+		const singleWidth = useDualScreen ? productConfig.outerScreenWidth : screen.getWidth().toString();
+		const doubleDiagonal = useDualScreen ? productConfig.screenDiagonal : void 0;
+		const doubleHeight = useDualScreen ? productConfig.screenHeight : void 0;
+		const doubleWidth = useDualScreen ? productConfig.screenWidth : void 0;
+		const ini = {
+			"name": listConfig.name,
+			"deviceType": listConfig.type,
+			"deviceModel": listConfig.devModel,
+			"productModel": listConfig.model,
+			"vendorCountry": options.vendorCountry ?? "CN",
+			"uuid": this.uuid,
+			"configPath": listConfig["harmonyos.config.path"],
+			"logPath": listConfig["harmonyos.log.path"],
+			"sdkPath": listConfig["harmonyos.sdk.path"],
+			"imageSubPath": listConfig.imageDir,
+			"instancePath": listConfig.path,
+			"os.osVersion": `${this.image.getTargetOS()} ${this.image.getTargetVersion()}(${this.image.getApiVersion()})`,
+			"os.apiVersion": this.image.getApiVersion(),
+			"os.softwareVersion": this.image.getVersion(),
+			"os.isPublic": options.isPublic ?? true ? "true" : "false",
+			"hw.cpu.arch": listConfig.abi,
+			"hw.cpu.ncore": listConfig.cpuNumber,
+			"hw.lcd.density": screen.getDensity().toFixed(),
+			"hw.lcd.single.diagonalSize": singleDiagonal,
+			"hw.lcd.single.height": singleHeight,
+			"hw.lcd.single.width": singleWidth,
+			"hw.lcd.number": useDualScreen ? "2" : "1",
+			"hw.ramSize": listConfig.memoryRamSize,
+			"hw.dataPartitionSize": listConfig.dataDiskSize,
+			"isCustomize": productPreset ? "false" : "true",
+			"hw.hdc.port": "notset",
+			...options.overrides
 		};
-	}
-	async toIniString() {
-		return `${Object.entries(await this.buildIni()).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${value}`).join("\n")}\n`;
-	}
-	async writeToListWithCheck(config) {
-		const fs = this.image.getImageManager().getOptions().fs;
-		const listsPath = this.image.getImageManager().getOptions().path.resolve(this.image.getImageManager().getOptions().deployedPath, "lists.json");
-		try {
-			if (!fs.existsSync(listsPath)) fs.writeFileSync(listsPath, JSON.stringify([config], null, 2));
-			else {
-				const lists = JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? [];
-				if (!Array.isArray(lists)) return new DeployError(DeployError.Code.LIST_JSON_NOT_AN_ARRAY, "Lists is not an array");
-				if (lists.find((item) => item.name === config.name)) return;
-				lists.push(config);
-				fs.writeFileSync(listsPath, JSON.stringify(lists, null, 2));
-			}
-		} catch (err) {
-			return err instanceof Error ? new DeployError(DeployError.Code.CATCHED_ERROR, String(err)) : new DeployError(DeployError.Code.CATCHED_ERROR, String(err));
+		if (useDualScreen && doubleDiagonal != null && doubleHeight != null && doubleWidth != null) {
+			ini["hw.lcd.double.diagonalSize"] = doubleDiagonal;
+			ini["hw.lcd.double.height"] = doubleHeight;
+			ini["hw.lcd.double.width"] = doubleWidth;
 		}
-		return new Promise((resolve) => {
-			const timer = setTimeout(() => {
-				const content = JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? [];
-				if (!Array.isArray(content)) resolve(new DeployError(DeployError.Code.LIST_JSON_NOT_AN_ARRAY, "List rechecker is not an array!"));
-				else if (!content.find((item) => item.name === config.name)) resolve(new DeployError(DeployError.Code.MAYBE_OPENED_DEVICE_MANAGER_IN_DEVECO_STUDIO, `Device ${config.name} not found in lists.json! Maybe not deployed yet?`));
-				else resolve();
-				clearTimeout(timer);
-			}, 1e3);
-		});
-	}
-	async deploy(symlinkImage = true) {
-		const { fs, path, imageBasePath, sdkPath } = this.image.getImageManager().getOptions();
-		const config = await this.buildList();
-		if (fs.existsSync(config.path)) return new DeployError(DeployError.Code.DEVICE_ALREADY_DEPLOYED, `Image ${config.name} already deployed`);
-		const error = await this.writeToListWithCheck(config);
-		if (error) return error;
-		fs.mkdirSync(config.path, { recursive: true });
-		fs.writeFileSync(path.join(config.path, "config.ini"), await this.toIniString());
-		const symlinkSdkPath = path.resolve(imageBasePath, "default", "openharmony");
-		if (!fs.existsSync(path.dirname(symlinkSdkPath))) fs.mkdirSync(path.dirname(symlinkSdkPath), { recursive: true });
-		try {
-			if (fs.lstatSync(symlinkSdkPath).isSymbolicLink()) fs.unlinkSync(symlinkSdkPath);
-			else return new DeployError(DeployError.Code.SYMLINK_SDK_PATH_EXISTS, "Symlink SDK path already exists");
-		} catch {}
-		fs.symlinkSync(sdkPath, symlinkSdkPath, "dir");
-		const systemImageDir = path.join(imageBasePath, "system-image");
-		if (symlinkImage && fs.existsSync(systemImageDir)) {
-			const linkPath = path.join(config.path, "system-image");
-			try {
-				const target = path.relative(config.path, systemImageDir);
-				fs.symlinkSync(target, linkPath);
-			} catch (err) {
-				return err instanceof Error ? new DeployError(DeployError.Code.CATCHED_ERROR, String(err)) : new DeployError(DeployError.Code.CATCHED_ERROR, String(err));
-			}
+		if (productPreset && productConfig && !useDualScreen) {
+			if (productConfig.outerScreenHeight) ini["hw.phy.height"] = productConfig.outerScreenHeight;
+			if (productConfig.outerScreenWidth) ini["hw.phy.width"] = productConfig.outerScreenWidth;
 		}
+		return ini;
 	}
-	async isDeployed() {
-		const { fs, path } = this.image.getImageManager().getOptions();
-		const listsPath = path.resolve(this.image.getImageManager().getOptions().deployedPath, "lists.json");
-		if (!fs.existsSync(listsPath) || !fs.statSync(listsPath).isFile()) return false;
-		return (JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? []).find((item) => item.name === this.options.name) !== void 0;
+	async toIniString() {
+		return `${Object.entries(this.buildIni()).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${value}`).join("\n")}\n`;
+	}
+	async deploy() {
+		const { fs, path, deployedPath } = this.image.getImageManager().getOptions();
+		if (!fs.existsSync(deployedPath)) fs.mkdirSync(deployedPath, { recursive: true });
+		const listsPath = path.join(deployedPath, "lists.json");
+		const listConfig = this.buildList();
+		if (fs.existsSync(listConfig.path)) throw new DeployError(DeployError.Code.DEVICE_ALREADY_DEPLOYED, `Image ${listConfig.name} already deployed`);
+		if (!fs.existsSync(listsPath)) return fs.writeFileSync(listsPath, JSON.stringify([listConfig], null, 2));
+		const lists = JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? [];
+		if (!Array.isArray(lists)) throw new DeployError(DeployError.Code.LIST_JSON_NOT_AN_ARRAY, "Lists is not an array");
+		if (lists.find((item) => item.name === listConfig.name)) throw new DeployError(DeployError.Code.DEVICE_ALREADY_DEPLOYED, `Image ${listConfig.name} already deployed in lists.json`);
+		lists.push(listConfig);
+		fs.writeFileSync(listsPath, JSON.stringify(lists, null, 2));
+		fs.mkdirSync(listConfig.path, { recursive: true });
+		fs.writeFileSync(path.join(listConfig.path, "config.ini"), await this.toIniString());
 	}
 	async delete() {
-		const { fs, path } = this.image.getImageManager().getOptions();
-		const listsPath = path.resolve(this.image.getImageManager().getOptions().deployedPath, "lists.json");
-		if (!fs.existsSync(listsPath) || !fs.statSync(listsPath).isFile()) return /* @__PURE__ */ new Error("Lists file not found");
+		const { fs, path, deployedPath } = this.image.getImageManager().getOptions();
+		const listsPath = path.join(deployedPath, "lists.json");
+		if (!fs.existsSync(listsPath) || !fs.statSync(listsPath).isFile()) throw new Error("Lists file not found");
 		const lists = JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? [];
 		const index = lists.findIndex((item) => item.name === this.options.name);
-		if (index === -1) return /* @__PURE__ */ new Error(`Device ${this.options.name} not found`);
+		if (index === -1) throw new Error(`Device ${this.options.name} not found`);
 		lists.splice(index, 1);
 		fs.writeFileSync(listsPath, JSON.stringify(lists, null, 2));
-		fs.rmSync(path.resolve(this.options.path ?? ""), { recursive: true });
+		fs.rmSync(path.resolve(this.buildList().path), { recursive: true });
+	}
+	async isDeployed() {
+		const { fs, path, deployedPath } = this.image.getImageManager().getOptions();
+		const listsPath = path.join(deployedPath, "lists.json");
+		if (!fs.existsSync(listsPath) || !fs.statSync(listsPath).isFile()) return false;
+		return (JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? []).some((item) => item.name === this.options.name && fs.existsSync(path.resolve(item.path, "config.ini")));
+	}
+	toJSON() {
+		return {
+			...this.options,
+			list: this.buildList(),
+			ini: this.buildIni()
+		};
 	}
 };
-function createImageDeployer(image, uuid, name, config) {
-	return new ImageDeployerImpl(image, uuid, name, config);
+function createDevice(image, options) {
+	return new DeviceImpl(image, options);
 }
 
 //#endregion
@@ -433,6 +453,9 @@ var ImageBase = class {
 	getChecksum() {
 		return this.response?.archive?.complete?.checksum;
 	}
+	getReleaseType() {
+		return this.response?.releaseType;
+	}
 	getFsPath() {
 		return this.resolvedFsPath;
 	}
@@ -508,8 +531,25 @@ var ImageBase = class {
 //#region src/images/local-image.ts
 var LocalImageImpl = class extends ImageBase {
 	imageType = "local";
-	createDevice(name, config) {
-		return createImageDeployer(this, this.getImageManager().getOptions().crypto.randomUUID(), name, config);
+	createDevice(options) {
+		return createDevice(this, options);
+	}
+	async getPascalCaseDeviceType() {
+		const deviceType = this.getDeviceType().toLowerCase();
+		if (!deviceType) return;
+		if (deviceType === "pc") return "2in1 Foldable";
+		const key = [
+			"phone",
+			"tablet",
+			"2in1",
+			"foldable",
+			"widefold",
+			"triplefold",
+			"2in1 foldable",
+			"tv",
+			"wearable"
+		].find((key) => key === deviceType);
+		if (key) return key;
 	}
 	async getProductConfig(usingDefaultProductConfig = false) {
 		const productConfig = usingDefaultProductConfig ? (await import("./default-product-config.mjs")).default : await this.getImageManager().getProductConfig();
@@ -533,8 +573,8 @@ var LocalImageImpl = class extends ImageBase {
 		const { emulatorPath, process, path } = this.getImageManager().getOptions();
 		return process.platform === "win32" ? path.join(emulatorPath, "Emulator.exe") : path.join(emulatorPath, "Emulator");
 	}
-	async buildStartCommand(deployer) {
-		const config = await deployer.buildList();
+	async buildStartCommand(device) {
+		const config = device.buildList();
 		return `${this.getExecutablePath()} ${[
 			"-hvd",
 			`"${config.name.replace(/"/g, "\\\"")}"`,
@@ -548,29 +588,49 @@ var LocalImageImpl = class extends ImageBase {
 		const { child_process, emulatorPath } = this.getImageManager().getOptions();
 		return child_process.exec(await this.buildStartCommand(deployer), { cwd: emulatorPath });
 	}
-	async buildStopCommand(deployer) {
-		const config = await deployer.buildList();
+	async buildStopCommand(device) {
+		const config = device.buildList();
 		return `${this.getExecutablePath()} ${["-stop", `"${config.name.replace(/"/g, "\\\"")}"`].join(" ")}`;
 	}
-	async stop(deployer) {
+	async stop(device) {
 		const { child_process, emulatorPath } = this.getImageManager().getOptions();
-		return child_process.exec(await this.buildStopCommand(deployer), { cwd: emulatorPath });
+		return child_process.exec(await this.buildStopCommand(device), { cwd: emulatorPath });
+	}
+	async createScreenLike(listsJsonItem) {
+		if (!listsJsonItem.model) return createScreen({
+			diagonal: Number(listsJsonItem.diagonalSize),
+			height: Number(listsJsonItem.resolutionHeight),
+			width: Number(listsJsonItem.resolutionWidth),
+			density: Number(listsJsonItem.density)
+		});
+		const productConfigItem = (await this.getProductConfig()).find((item) => item.name === listsJsonItem.model);
+		const pascalCaseDeviceType = await this.getPascalCaseDeviceType();
+		if (!productConfigItem || !pascalCaseDeviceType || productConfigItem.screenDiagonal !== listsJsonItem.diagonalSize || productConfigItem.screenHeight !== listsJsonItem.resolutionHeight || productConfigItem.screenWidth !== listsJsonItem.resolutionWidth || productConfigItem.screenDensity !== listsJsonItem.density) return createScreen({
+			diagonal: Number(listsJsonItem.diagonalSize),
+			height: Number(listsJsonItem.resolutionHeight),
+			width: Number(listsJsonItem.resolutionWidth),
+			density: Number(listsJsonItem.density)
+		});
+		return createProductPreset(productConfigItem, pascalCaseDeviceType);
 	}
-	typeAssert(value) {}
 	async getDevices() {
-		const { path, fs, imageBasePath } = this.getImageManager().getOptions();
-		const listsJsonPath = path.resolve(this.getImageManager().getOptions().deployedPath, "lists.json");
+		const { path, fs, deployedPath, imageBasePath } = this.getImageManager().getOptions();
+		const listsJsonPath = path.resolve(deployedPath, "lists.json");
 		if (!fs.existsSync(listsJsonPath) || !fs.statSync(listsJsonPath).isFile()) return [];
 		const listsJson = JSON.parse(fs.readFileSync(listsJsonPath, "utf-8"));
 		if (!Array.isArray(listsJson) || this.imageType !== "local") return [];
-		this.typeAssert(this);
 		const devices = [];
 		for (const listsJsonItem of listsJson) {
-			if (typeof listsJsonItem !== "object" || listsJsonItem === null) continue;
-			if (!("imageDir" in listsJsonItem) || typeof listsJsonItem.imageDir !== "string") continue;
-			if (!("name" in listsJsonItem) || typeof listsJsonItem.name !== "string") continue;
-			if (path.resolve(this.getFsPath()) !== path.resolve(imageBasePath, listsJsonItem.imageDir)) continue;
-			devices.push(this.createDevice(listsJsonItem.name, listsJsonItem));
+			if (path.resolve(imageBasePath, listsJsonItem.imageDir) !== this.getFsPath()) continue;
+			const device = this.createDevice({
+				name: listsJsonItem.name,
+				cpuNumber: Number(listsJsonItem.cpuNumber),
+				diskSize: Number(listsJsonItem.dataDiskSize),
+				memorySize: Number(listsJsonItem.memoryRamSize),
+				screen: await this.createScreenLike(listsJsonItem)
+			});
+			if (!fs.existsSync(device.buildList().path) || !fs.statSync(device.buildList().path).isDirectory()) continue;
+			devices.push(device);
 		}
 		return devices;
 	}
@@ -702,22 +762,19 @@ var ImageManagerImpl = class {
 		if (existSkip && this.resolvedOptions.fs.existsSync(productConfigPath)) return;
 		this.resolvedOptions.fs.writeFileSync(productConfigPath, JSON.stringify((await import("./default-product-config.mjs")).default, null, 2));
 	}
+	async isCompatible() {
+		const { fs, path, emulatorPath } = this.resolvedOptions;
+		const sdkPkgPath = path.resolve(emulatorPath, "sdk-pkg.json");
+		if (!fs.existsSync(sdkPkgPath) || !fs.statSync(sdkPkgPath).isFile()) return false;
+		const sdkPkg = JSON.parse(fs.readFileSync(sdkPkgPath, "utf-8"));
+		if (!sdkPkg?.data?.version || typeof sdkPkg.data.version !== "string") return false;
+		const [major, minor, patch] = sdkPkg.data.version.split(".").map(Number);
+		return satisfies(`${major}.${minor}.${patch}`, ">=6.0.2");
+	}
 };
 async function createImageManager(options = {}) {
 	return new ImageManagerImpl(await resolveImageManagerOptions(options));
 }
 
 //#endregion
-//#region src/product-config.ts
-function createDeployedImageConfig(productConfigItem) {
-	return {
-		density: productConfigItem.screenDensity,
-		resolutionHeight: productConfigItem.screenHeight,
-		resolutionWidth: productConfigItem.screenWidth,
-		diagonalSize: productConfigItem.screenDiagonal,
-		productName: productConfigItem.name
-	};
-}
-
-//#endregion
-export { DeployError, DevModel, RequestUrlError, createDeployedImageConfig, createImageManager, version };
+export { DeployError, DevModel, RequestUrlError, createImageManager, createProductPreset, createScreen, version };

package/dist/product-config-2xNDbvax.d.cts

@@ -0,0 +1,72 @@
+//#region src/types.d.ts
+interface Stringifiable<T> {
+  toJSON(): T;
+}
+type OS = 'windows' | 'mac' | 'linux';
+type Arch = 'x86' | 'arm64';
+type DeviceType = 'pc' | 'phone' | 'tablet' | 'wearable' | 'tv' | 'foldable' | 'widefold' | '2in1';
+type SnakecaseDeviceType = 'phone' | 'tablet' | '2in1' | 'foldable' | 'widefold' | 'triplefold' | '2in1_foldable' | 'tv' | 'wearable';
+type PascalCaseDeviceType = 'Phone' | 'Tablet' | '2in1' | 'Foldable' | 'WideFold' | 'TripleFold' | '2in1 Foldable' | 'TV' | 'Wearable';
+//#endregion
+//#region src/product-config.d.ts
+interface ProductConfigItem {
+  /**
+   * The name of the product.
+   */
+  name: string;
+  /**
+   * The screen width of the product.
+   */
+  screenWidth: string;
+  /**
+   * The screen height of the product.
+   */
+  screenHeight: string;
+  /**
+   * The screen diagonal of the product.
+   */
+  screenDiagonal: string;
+  /**
+   * The screen density of the product.
+   */
+  screenDensity: string;
+  /**
+   * The outer screen width of the product.
+   */
+  outerScreenWidth?: string;
+  /**
+   * The outer screen height of the product.
+   */
+  outerDoubleScreenWidth?: string;
+  /**
+   * The outer double screen height of the product.
+   */
+  outerDoubleScreenHeight?: string;
+  /**
+   * The outer double screen diagonal of the product.
+   */
+  outerDoubleScreenDiagonal?: string;
+  /**
+   * The outer screen height of the product.
+   */
+  outerScreenHeight?: string;
+  /**
+   * The outer screen diagonal of the product.
+   */
+  outerScreenDiagonal?: string;
+  /**
+   * Whether the product is visible.
+   */
+  visible: boolean;
+  /**
+   * The one cutout path of the product.
+   */
+  oneCutoutPath?: string;
+  /**
+   * The dev model of the product.
+   */
+  devModel?: string;
+}
+type ProductConfig = Record<PascalCaseDeviceType, ProductConfigItem[]>;
+//#endregion
+export { OS as a, Stringifiable as c, DeviceType as i, ProductConfigItem as n, PascalCaseDeviceType as o, Arch as r, SnakecaseDeviceType as s, ProductConfig as t };