@arkts/image-manager 0.3.5 → 0.4.1

package/dist/index.cjs

@@ -36,11 +36,9 @@ let mitt = require("mitt");
 mitt = __toESM(mitt);
 let progress_stream = require("progress-stream");
 progress_stream = __toESM(progress_stream);
-let unzipper = require("unzipper");
-unzipper = __toESM(unzipper);
 
 //#region package.json
-var version = "0.3.5";
+var version = "0.4.1";
 
 //#endregion
 //#region src/devices/list.ts
@@ -55,6 +53,51 @@ let DevModel = /* @__PURE__ */ function(DevModel) {
 	return DevModel;
 }({});
 
+//#endregion
+//#region src/emulator-config.ts
+let BaseEmulatorConfigItem;
+(function(_BaseEmulatorConfigItem) {
+	function is(value) {
+		return typeof value === "object" && value !== null && "name" in value && typeof value.name === "string" && "deviceType" in value && typeof value.deviceType === "string" && "api" in value && typeof value.api === "number";
+	}
+	_BaseEmulatorConfigItem.is = is;
+})(BaseEmulatorConfigItem || (BaseEmulatorConfigItem = {}));
+let ParentEmulatorConfigItem;
+(function(_ParentEmulatorConfigItem) {
+	function is(value) {
+		return BaseEmulatorConfigItem.is(value) && "resolutionWidth" in value && typeof value.resolutionWidth === "number" && "resolutionHeight" in value && typeof value.resolutionHeight === "number" && "physicalWidth" in value && typeof value.physicalWidth === "number" && "physicalHeight" in value && typeof value.physicalHeight === "number" && "diagonalSize" in value && typeof value.diagonalSize === "number" && "density" in value && typeof value.density === "number" && "memoryRamSize" in value && typeof value.memoryRamSize === "number" && "datadiskSize" in value && typeof value.datadiskSize === "number" && "procNumber" in value && typeof value.procNumber === "number" && "api" in value && typeof value.api === "number";
+	}
+	_ParentEmulatorConfigItem.is = is;
+})(ParentEmulatorConfigItem || (ParentEmulatorConfigItem = {}));
+let PhoneAllEmulatorConfigItem;
+(function(_PhoneAllEmulatorConfigItem) {
+	function is(value) {
+		return ParentEmulatorConfigItem.is(value);
+	}
+	_PhoneAllEmulatorConfigItem.is = is;
+})(PhoneAllEmulatorConfigItem || (PhoneAllEmulatorConfigItem = {}));
+let GroupPhoneAllEmulatorConfigItem;
+(function(_GroupPhoneAllEmulatorConfigItem) {
+	function is(value) {
+		return BaseEmulatorConfigItem.is(value) && "children" in value && Array.isArray(value.children) && value.children.every(PhoneAllEmulatorConfigItem.is);
+	}
+	_GroupPhoneAllEmulatorConfigItem.is = is;
+})(GroupPhoneAllEmulatorConfigItem || (GroupPhoneAllEmulatorConfigItem = {}));
+let PCAllEmulatorConfigItem;
+(function(_PCAllEmulatorConfigItem) {
+	function is(value) {
+		return ParentEmulatorConfigItem.is(value);
+	}
+	_PCAllEmulatorConfigItem.is = is;
+})(PCAllEmulatorConfigItem || (PCAllEmulatorConfigItem = {}));
+let GroupPCAllEmulatorConfigItem;
+(function(_GroupPCAllEmulatorConfigItem) {
+	function is(value) {
+		return BaseEmulatorConfigItem.is(value) && "children" in value && Array.isArray(value.children) && value.children.every(PCAllEmulatorConfigItem.is);
+	}
+	_GroupPCAllEmulatorConfigItem.is = is;
+})(GroupPCAllEmulatorConfigItem || (GroupPCAllEmulatorConfigItem = {}));
+
 //#endregion
 //#region src/errors/deploy-error.ts
 var DeployError = class extends Error {
@@ -91,23 +134,59 @@ var RequestUrlError = class extends Error {
 };
 
 //#endregion
-//#region src/screens/screen.ts
-var ScreenImpl = class {
-	constructor(options) {
-		this.options = options;
+//#region src/product-config.ts
+let ProductConfigItem;
+(function(_ProductConfigItem) {
+	function is(value) {
+		return typeof value === "object" && value !== null && "name" in value && "screenWidth" in value && "screenHeight" in value && "screenDiagonal" in value && "screenDensity" in value && typeof value.name === "string" && typeof value.screenWidth === "string" && typeof value.screenHeight === "string" && typeof value.screenDiagonal === "string" && typeof value.screenDensity === "string";
+	}
+	_ProductConfigItem.is = is;
+})(ProductConfigItem || (ProductConfigItem = {}));
+function isProductConfig(value) {
+	return typeof value === "object" && value !== null && Object.values(value).every((item) => Array.isArray(item));
+}
+
+//#endregion
+//#region src/types.ts
+function isPhoneAllSnakecaseDeviceType(value) {
+	return value === "phone" || value === "triplefold" || value === "widefold" || value === "foldable";
+}
+function isPCAllSnakecaseDeviceType(value) {
+	return value === "2in1_foldable" || value === "2in1";
+}
+
+//#endregion
+//#region src/screens/emulator-preset.ts
+var EmulatorPresetImpl = class {
+	constructor(emulatorConfigItem, screenPreset) {
+		this.emulatorConfigItem = emulatorConfigItem;
+		this.screenPreset = screenPreset;
 	}
-	getDiagonal() {
-		return this.options.diagonal;
+	getScreenPreset() {
+		return this.screenPreset;
 	}
-	setDiagonal(diagonal) {
-		this.options.diagonal = diagonal;
-		return this;
+	getEmulatorConfig() {
+		return this.emulatorConfigItem;
 	}
-	getDensity() {
-		return this.options.density;
+	toJSON() {
+		return { emulatorConfig: this.emulatorConfigItem };
 	}
-	setDensity(density) {
-		this.options.density = density;
+};
+function createEmulatorPreset(emulatorConfigItem, screenPreset) {
+	return new EmulatorPresetImpl(emulatorConfigItem, screenPreset);
+}
+
+//#endregion
+//#region src/screens/base-screen.ts
+var BaseScreenImpl = class {
+	constructor(options) {
+		this.options = options;
+	}
+	getWidth() {
+		return this.options.width;
+	}
+	setWidth(width) {
+		this.options.width = width;
 		return this;
 	}
 	getHeight() {
@@ -117,27 +196,86 @@ var ScreenImpl = class {
 		this.options.height = height;
 		return this;
 	}
-	getWidth() {
-		return this.options.width;
+	getDiagonal() {
+		return this.options.diagonal;
 	}
-	setWidth(width) {
-		this.options.width = width;
+	setDiagonal(diagonal) {
+		this.options.diagonal = diagonal;
 		return this;
 	}
 	toJSON() {
 		return this.options;
 	}
 };
-function createScreen(options) {
-	return new ScreenImpl(options);
+
+//#endregion
+//#region src/screens/outer-screen.ts
+let OuterScreen;
+(function(_OuterScreen) {
+	function is(value) {
+		return value instanceof OuterScreenImpl;
+	}
+	_OuterScreen.is = is;
+})(OuterScreen || (OuterScreen = {}));
+var OuterScreenImpl = class extends BaseScreenImpl {
+	outerDoubleScreen;
+	constructor(options, screen) {
+		super(options);
+		this.options = options;
+		this.screen = screen;
+		if (options.double) this.outerDoubleScreen = OuterDoubleScreen.is(options.double) ? options.double : createOuterDoubleScreen(options.double, this);
+	}
+	getScreen() {
+		return this.screen;
+	}
+	getOuterDoubleScreen() {
+		return this.outerDoubleScreen;
+	}
+	setOuterDoubleScreen(outerDoubleScreen) {
+		this.outerDoubleScreen = OuterDoubleScreen.is(outerDoubleScreen) ? outerDoubleScreen : createOuterDoubleScreen(outerDoubleScreen, this);
+		return this;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			double: this.outerDoubleScreen?.toJSON()
+		};
+	}
+};
+function createOuterScreen(options, screen) {
+	return new OuterScreenImpl(options, screen);
+}
+
+//#endregion
+//#region src/screens/outer-double-screen.ts
+let OuterDoubleScreen;
+(function(_OuterDoubleScreen) {
+	function is(value) {
+		return value instanceof OuterDoubleScreenImpl;
+	}
+	_OuterDoubleScreen.is = is;
+})(OuterDoubleScreen || (OuterDoubleScreen = {}));
+var OuterDoubleScreenImpl = class extends OuterScreenImpl {
+	constructor(options, outerScreen) {
+		super(options, outerScreen.getScreen());
+		this.options = options;
+		this.outerScreen = outerScreen;
+	}
+	getOuterScreen() {
+		return this.outerScreen;
+	}
+};
+function createOuterDoubleScreen(options, outerScreen) {
+	return new OuterDoubleScreenImpl(options, outerScreen);
 }
 
 //#endregion
 //#region src/screens/product-preset.ts
 var ProductPresetImpl = class {
-	constructor(productConfig, deviceType) {
+	constructor(productConfig, deviceType, screenPreset) {
 		this.productConfig = productConfig;
 		this.deviceType = deviceType;
+		this.screenPreset = screenPreset;
 	}
 	getProductConfig() {
 		return this.productConfig;
@@ -145,13 +283,8 @@ var ProductPresetImpl = class {
 	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)
-		});
+	getScreenPreset() {
+		return this.screenPreset;
 	}
 	toJSON() {
 		return {
@@ -160,8 +293,280 @@ var ProductPresetImpl = class {
 		};
 	}
 };
-async function createProductPreset(productConfig, deviceType) {
-	return new ProductPresetImpl(productConfig, deviceType);
+function createProductPreset(productConfig, deviceType, screenPreset) {
+	return new ProductPresetImpl(productConfig, deviceType, screenPreset);
+}
+
+//#endregion
+//#region src/screens/cover-screen.ts
+let CoverScreen;
+(function(_CoverScreen) {
+	function is(value) {
+		return value instanceof CoverScreenImpl;
+	}
+	_CoverScreen.is = is;
+})(CoverScreen || (CoverScreen = {}));
+var CoverScreenImpl = class extends BaseScreenImpl {
+	constructor(options, screen) {
+		super(options);
+		this.options = options;
+		this.screen = screen;
+	}
+	getScreen() {
+		return this.screen;
+	}
+};
+function createCoverScreen(options, screen) {
+	return new CoverScreenImpl(options, screen);
+}
+
+//#endregion
+//#region src/screens/double-screen.ts
+let DoubleScreen;
+(function(_DoubleScreen) {
+	function is(value) {
+		return value instanceof DoubleScreenImpl;
+	}
+	_DoubleScreen.is = is;
+})(DoubleScreen || (DoubleScreen = {}));
+var DoubleScreenImpl = class extends BaseScreenImpl {
+	constructor(options, screen) {
+		super(options);
+		this.options = options;
+		this.screen = screen;
+	}
+	getScreen() {
+		return this.screen;
+	}
+};
+function createDoubleScreen(options, screen) {
+	return new DoubleScreenImpl(options, screen);
+}
+
+//#endregion
+//#region src/screens/single-screen.ts
+let SingleScreen;
+(function(_SingleScreen) {
+	function is(value) {
+		return value instanceof SingleScreenImpl;
+	}
+	_SingleScreen.is = is;
+})(SingleScreen || (SingleScreen = {}));
+var SingleScreenImpl = class extends BaseScreenImpl {
+	constructor(options, screen) {
+		super(options);
+		this.options = options;
+		this.screen = screen;
+	}
+	getScreen() {
+		return this.screen;
+	}
+};
+function createSingleScreen(options, screen) {
+	return new SingleScreenImpl(options, screen);
+}
+
+//#endregion
+//#region src/screens/screen.ts
+let Screen;
+(function(_Screen) {
+	function is(value) {
+		return value instanceof ScreenImpl;
+	}
+	_Screen.is = is;
+})(Screen || (Screen = {}));
+var ScreenImpl = class extends BaseScreenImpl {
+	outerScreen;
+	coverScreen;
+	singleScreen;
+	doubleScreen;
+	constructor(options) {
+		super(options);
+		this.options = options;
+		if (options.outer) this.outerScreen = OuterScreen.is(options.outer) ? options.outer : createOuterScreen(options.outer, this);
+		if (options.cover) this.coverScreen = CoverScreen.is(options.cover) ? options.cover : createCoverScreen(options.cover, this);
+		if (options.single) this.singleScreen = SingleScreen.is(options.single) ? options.single : createSingleScreen(options.single, this);
+		if (options.double) this.doubleScreen = DoubleScreen.is(options.double) ? options.double : createDoubleScreen(options.double, this);
+	}
+	getScreen() {
+		return this;
+	}
+	getApiVersion() {
+		return this.options.apiVersion;
+	}
+	getSnakecaseDeviceType() {
+		return this.options.deviceType;
+	}
+	getOuterScreen() {
+		return this.outerScreen;
+	}
+	setOuterScreen(outerScreen) {
+		this.outerScreen = OuterScreen.is(outerScreen) ? outerScreen : createOuterScreen(outerScreen, this);
+		return this;
+	}
+	getCoverScreen() {
+		return this.coverScreen;
+	}
+	setCoverScreen(coverScreen) {
+		this.coverScreen = CoverScreen.is(coverScreen) ? coverScreen : createCoverScreen(coverScreen, this);
+		return this;
+	}
+	getSingleScreen() {
+		return this.singleScreen;
+	}
+	setSingleScreen(singleScreen) {
+		this.singleScreen = SingleScreen.is(singleScreen) ? singleScreen : createSingleScreen(singleScreen, this);
+		return this;
+	}
+	getDoubleScreen() {
+		return this.doubleScreen;
+	}
+	setDoubleScreen(doubleScreen) {
+		this.doubleScreen = DoubleScreen.is(doubleScreen) ? doubleScreen : createDoubleScreen(doubleScreen, this);
+		return this;
+	}
+	getDensity() {
+		return this.options.density;
+	}
+	setDensity(density) {
+		this.options.density = density;
+		return this;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			density: this.options.density,
+			apiVersion: this.options.apiVersion,
+			deviceType: this.options.deviceType,
+			outer: this.outerScreen?.toJSON(),
+			cover: this.coverScreen?.toJSON(),
+			single: this.singleScreen?.toJSON()
+		};
+	}
+};
+function createScreen(options) {
+	return new ScreenImpl(options);
+}
+
+//#endregion
+//#region src/screens/screen-preset.ts
+let ScreenPreset;
+(function(_ScreenPreset) {
+	function is(value) {
+		return value instanceof ScreenPresetImpl;
+	}
+	_ScreenPreset.is = is;
+})(ScreenPreset || (ScreenPreset = {}));
+var ScreenPresetImpl = class {
+	emulatorPreset;
+	productPreset;
+	constructor(options) {
+		this.options = options;
+		this._screen = this.getScreen();
+		this.setEmulatorPreset();
+		this.setProductPreset();
+	}
+	isScreenOptions(options) {
+		return "screen" in options && Screen.is(options.screen);
+	}
+	_screen;
+	getScreen() {
+		if (this.isScreenOptions(this.options)) return this.options.screen;
+		if (this._screen) return this._screen;
+		this._screen = createScreen({
+			width: Number(this.options.productConfig.screenWidth),
+			height: Number(this.options.productConfig.screenHeight),
+			diagonal: Number(this.options.productConfig.screenDiagonal),
+			density: Number(this.options.productConfig.screenDensity),
+			apiVersion: Number.parseInt(this.options.image.getApiVersion()),
+			deviceType: this.options.image.getSnakecaseDeviceType()
+		});
+		if (this.options.productConfig.outerScreenWidth && this.options.productConfig.outerScreenHeight && this.options.productConfig.outerScreenDiagonal) this._screen.setOuterScreen(createOuterScreen({
+			width: Number(this.options.productConfig.outerScreenWidth),
+			height: Number(this.options.productConfig.outerScreenHeight),
+			diagonal: Number(this.options.productConfig.outerScreenDiagonal)
+		}, this._screen));
+		if (this.options.productConfig.outerDoubleScreenWidth && this.options.productConfig.outerDoubleScreenHeight && this.options.productConfig.outerDoubleScreenDiagonal) this._screen.getOuterScreen()?.setOuterDoubleScreen(createOuterDoubleScreen({
+			width: Number(this.options.productConfig.outerDoubleScreenWidth),
+			height: Number(this.options.productConfig.outerDoubleScreenHeight),
+			diagonal: Number(this.options.productConfig.outerDoubleScreenDiagonal)
+		}, this._screen.getOuterScreen()));
+		return this._screen;
+	}
+	getProductConfigItems() {
+		if (!this.options.productConfig || !isProductConfig(this.options.productConfig)) return;
+		for (const [pascalCaseDeviceType, productConfigItem] of Object.entries(this.options.productConfig)) if (pascalCaseDeviceType === "2in1" && this.getScreen().getSnakecaseDeviceType() === "2in1") return [productConfigItem, pascalCaseDeviceType];
+		else if (pascalCaseDeviceType === "2in1 Foldable" && this.getScreen().getSnakecaseDeviceType() === "2in1_foldable") return [productConfigItem, pascalCaseDeviceType];
+		else if (pascalCaseDeviceType === "Foldable" && this.getScreen().getSnakecaseDeviceType() === "foldable") return [productConfigItem, pascalCaseDeviceType];
+		else if (pascalCaseDeviceType === "Phone" && this.getScreen().getSnakecaseDeviceType() === "phone") return [productConfigItem, pascalCaseDeviceType];
+		else if (pascalCaseDeviceType === "TV" && this.getScreen().getSnakecaseDeviceType() === "tv") return [productConfigItem, pascalCaseDeviceType];
+		else if (pascalCaseDeviceType === "Tablet" && this.getScreen().getSnakecaseDeviceType() === "tablet") return [productConfigItem, pascalCaseDeviceType];
+		else if (pascalCaseDeviceType === "TripleFold" && this.getScreen().getSnakecaseDeviceType() === "triplefold") return [productConfigItem, pascalCaseDeviceType];
+		else if (pascalCaseDeviceType === "Wearable" && this.getScreen().getSnakecaseDeviceType() === "wearable") return [productConfigItem, pascalCaseDeviceType];
+		else if (pascalCaseDeviceType === "WideFold" && this.getScreen().getSnakecaseDeviceType() === "widefold") return [productConfigItem, pascalCaseDeviceType];
+		else if (pascalCaseDeviceType.toLowerCase() === this.getScreen().getSnakecaseDeviceType().toLowerCase()) return [productConfigItem, pascalCaseDeviceType];
+	}
+	setProductPreset() {
+		if (!this.isScreenOptions(this.options)) {
+			this.productPreset = createProductPreset(this.options.productConfig, this.options.pascalCaseDeviceType, this);
+			return;
+		}
+		const [productConfigItems = [], pascalCaseDeviceType] = this.getProductConfigItems() ?? [];
+		if (!pascalCaseDeviceType || !productConfigItems.length) return;
+		for (const productConfigItem of productConfigItems) {
+			if (this.getScreen().getWidth() !== Number(productConfigItem.screenWidth) || this.getScreen().getHeight() !== Number(productConfigItem.screenHeight) || this.getScreen().getDiagonal() !== Number(productConfigItem.screenDiagonal) || this.getScreen().getDensity() !== Number(productConfigItem.screenDensity)) continue;
+			if (productConfigItem.outerScreenWidth && productConfigItem.outerScreenHeight && productConfigItem.outerScreenDiagonal) {
+				const outerScreen = this.getScreen().getOuterScreen();
+				if (!outerScreen) continue;
+				if (outerScreen.getWidth() !== Number(productConfigItem.outerScreenWidth) || outerScreen.getHeight() !== Number(productConfigItem.outerScreenHeight) || outerScreen.getDiagonal() !== Number(productConfigItem.outerScreenDiagonal)) continue;
+			}
+			if (productConfigItem.outerDoubleScreenWidth && productConfigItem.outerDoubleScreenHeight && productConfigItem.outerDoubleScreenDiagonal) {
+				const outerDoubleScreen = this.getScreen().getOuterScreen()?.getOuterDoubleScreen();
+				if (!outerDoubleScreen) continue;
+				if (outerDoubleScreen.getWidth() !== Number(productConfigItem.outerDoubleScreenWidth) || outerDoubleScreen.getHeight() !== Number(productConfigItem.outerDoubleScreenHeight) || outerDoubleScreen.getDiagonal() !== Number(productConfigItem.outerDoubleScreenDiagonal)) continue;
+			}
+			this.productPreset = createProductPreset(productConfigItem, pascalCaseDeviceType, this);
+			return;
+		}
+	}
+	setEmulatorPreset() {
+		if (!this.isScreenOptions(this.options)) return;
+		if (!this.options.emulatorConfig) return;
+		for (const parentConfigItem of this.options.emulatorConfig) {
+			if (parentConfigItem.api !== this.options.screen.getApiVersion()) continue;
+			if (ParentEmulatorConfigItem.is(parentConfigItem) && parentConfigItem.deviceType === this.options.screen.getSnakecaseDeviceType()) {
+				this.emulatorPreset = createEmulatorPreset(parentConfigItem, this);
+				return;
+			}
+			if (GroupPhoneAllEmulatorConfigItem.is(parentConfigItem) && isPhoneAllSnakecaseDeviceType(this.options.screen.getSnakecaseDeviceType())) {
+				for (const childrenConfigItem of parentConfigItem.children) if (PhoneAllEmulatorConfigItem.is(childrenConfigItem) && childrenConfigItem.deviceType === this.options.screen.getSnakecaseDeviceType()) {
+					this.emulatorPreset = createEmulatorPreset(childrenConfigItem, this);
+					return;
+				}
+			}
+			if (GroupPCAllEmulatorConfigItem.is(parentConfigItem) && isPCAllSnakecaseDeviceType(this.options.screen.getSnakecaseDeviceType())) {
+				for (const childrenConfigItem of parentConfigItem.children) if (PCAllEmulatorConfigItem.is(childrenConfigItem) && childrenConfigItem.deviceType === this.options.screen.getSnakecaseDeviceType()) {
+					this.emulatorPreset = createEmulatorPreset(childrenConfigItem, this);
+					return;
+				}
+			}
+		}
+	}
+	getEmulatorPreset() {
+		return this.emulatorPreset;
+	}
+	getProductPreset() {
+		return this.productPreset;
+	}
+	toJSON() {
+		return {
+			emulatorPreset: this.emulatorPreset?.toJSON(),
+			productPreset: this.productPreset?.toJSON()
+		};
+	}
+};
+function createScreenPreset(options) {
+	return new ScreenPresetImpl(options);
 }
 
 //#endregion
@@ -180,9 +585,12 @@ var DeviceImpl = class {
 		return this.image;
 	}
 	getScreen() {
-		if (this.options.screen instanceof ProductPresetImpl) return this.options.screen.toScreen();
+		if (this.options.screen instanceof ScreenPresetImpl) return this.options.screen.getScreen();
 		return this.options.screen;
 	}
+	getScreenPreset() {
+		if (this.options.screen instanceof ScreenPresetImpl) return this.options.screen;
+	}
 	setUuid(uuid) {
 		this.uuid = uuid;
 		return this;
@@ -228,10 +636,10 @@ var DeviceImpl = class {
 			"harmonyOSVersion": `${this.image.getTargetOS()}-${this.image.getTargetVersion()}`,
 			"guestVersion": `${this.image.getTargetOS()} ${this.image.getVersion()}(${this.image.getReleaseType()})`
 		};
-		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;
+		if (this.options.screen instanceof ScreenPresetImpl) {
+			const productConfig = this.options.screen.getProductPreset()?.getProductConfig();
+			if (productConfig?.devModel) list.devModel = productConfig.devModel;
+			if (productConfig?.name) list.model = productConfig.name;
 		}
 		return list;
 	}
@@ -240,8 +648,8 @@ var DeviceImpl = class {
 		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 screenPreset = this.options.screen instanceof ScreenPresetImpl ? this.options.screen.getProductPreset() : null;
+		const productConfig = screenPreset?.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();
@@ -274,7 +682,7 @@ var DeviceImpl = class {
 			"hw.lcd.number": useDualScreen ? "2" : "1",
 			"hw.ramSize": listConfig.memoryRamSize,
 			"hw.dataPartitionSize": listConfig.dataDiskSize,
-			"isCustomize": productPreset ? "false" : "true",
+			"isCustomize": screenPreset ? "false" : "true",
 			"hw.hdc.port": "notset",
 			...options.overrides
 		};
@@ -283,7 +691,7 @@ var DeviceImpl = class {
 			ini["hw.lcd.double.height"] = doubleHeight;
 			ini["hw.lcd.double.width"] = doubleWidth;
 		}
-		if (productPreset && productConfig && !useDualScreen) {
+		if (screenPreset && productConfig && !useDualScreen) {
 			if (productConfig.outerScreenHeight) ini["hw.phy.height"] = productConfig.outerScreenHeight;
 			if (productConfig.outerScreenWidth) ini["hw.phy.width"] = productConfig.outerScreenWidth;
 		}
@@ -440,11 +848,12 @@ var ImageDownloaderImpl = class {
 		return hash.digest("hex") === checksum;
 	}
 	async extract(signal, symlinkOpenHarmonySdk = true) {
+		const unzipper = await import("unzipper");
 		const { fs, path, imageBasePath, sdkPath } = this.image.getImageManager().getOptions();
 		const cacheFsPath = this.getCacheFsPath();
 		const stream = fs.createReadStream(cacheFsPath, { signal });
 		const progressStream = (0, progress_stream.default)({ length: fs.statSync(cacheFsPath).size });
-		const extractStream = unzipper.default.Extract({ path: this.image.getFsPath() });
+		const extractStream = unzipper.Extract({ path: this.image.getFsPath() });
 		progressStream.on("progress", (progress) => this.emitter.emit("extract-progress", progress));
 		stream.pipe(progressStream).pipe(extractStream);
 		await extractStream.promise();
@@ -655,21 +1064,41 @@ var LocalImageImpl = class extends ImageBase {
 		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 productConfig = await this.getImageManager().getProductConfig();
 		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({
+		const screen = createScreen({
 			diagonal: Number(listsJsonItem.diagonalSize),
 			height: Number(listsJsonItem.resolutionHeight),
 			width: Number(listsJsonItem.resolutionWidth),
-			density: Number(listsJsonItem.density)
+			density: Number(listsJsonItem.density),
+			deviceType: listsJsonItem.type,
+			apiVersion: Number(listsJsonItem.apiVersion),
+			cover: listsJsonItem.coverResolutionWidth && listsJsonItem.coverResolutionHeight && listsJsonItem.coverDiagonalSize ? {
+				height: Number(listsJsonItem.coverResolutionHeight),
+				width: Number(listsJsonItem.coverResolutionWidth),
+				diagonal: Number(listsJsonItem.coverDiagonalSize)
+			} : void 0
+		});
+		if (pascalCaseDeviceType) {
+			const productConfigItem = productConfig[pascalCaseDeviceType]?.find((item) => item.name === listsJsonItem.model);
+			if (productConfigItem && productConfigItem.outerScreenWidth && productConfigItem.outerScreenHeight && productConfigItem.outerScreenDiagonal) screen.setOuterScreen(createOuterScreen({
+				width: Number(productConfigItem.outerScreenWidth),
+				height: Number(productConfigItem.outerScreenHeight),
+				diagonal: Number(productConfigItem.outerScreenDiagonal)
+			}, screen));
+			if (productConfigItem && productConfigItem.outerDoubleScreenWidth && productConfigItem.outerDoubleScreenHeight && productConfigItem.outerDoubleScreenDiagonal) screen.getOuterScreen()?.setOuterDoubleScreen(createOuterDoubleScreen({
+				width: Number(productConfigItem.outerDoubleScreenWidth),
+				height: Number(productConfigItem.outerDoubleScreenHeight),
+				diagonal: Number(productConfigItem.outerDoubleScreenDiagonal)
+			}, screen.getOuterScreen()));
+		}
+		const screenPreset = createScreenPreset({
+			screen,
+			productConfig,
+			emulatorConfig: await this.getImageManager().getEmulatorConfig()
 		});
-		return createProductPreset(productConfigItem, pascalCaseDeviceType);
+		if (screenPreset.getProductPreset() || screenPreset.getEmulatorPreset()) return screenPreset;
+		else return screen;
 	}
 	async getDevices() {
 		const { path, fs, deployedPath, imageBasePath } = this.getImageManager().getOptions();
@@ -818,6 +1247,11 @@ var ImageManagerImpl = class {
 		if (!this.resolvedOptions.fs.existsSync(productConfigPath) || !this.resolvedOptions.fs.statSync(productConfigPath).isFile()) return (await Promise.resolve().then(() => require("./default-product-config.cjs"))).default;
 		return JSON.parse(this.resolvedOptions.fs.readFileSync(productConfigPath, "utf-8"));
 	}
+	async getEmulatorConfig() {
+		const emulatorConfigPath = this.resolvedOptions.path.resolve(this.resolvedOptions.emulatorPath, "emulator.json");
+		if (!this.resolvedOptions.fs.existsSync(emulatorConfigPath) || !this.resolvedOptions.fs.statSync(emulatorConfigPath).isFile()) return (await Promise.resolve().then(() => require("./default-emulator-config.cjs"))).default;
+		return JSON.parse(this.resolvedOptions.fs.readFileSync(emulatorConfigPath, "utf-8"));
+	}
 	async writeDefaultProductConfig(existSkip = false) {
 		const productConfigPath = this.resolvedOptions.path.resolve(this.resolvedOptions.imageBasePath, "productConfig.json");
 		if (existSkip && this.resolvedOptions.fs.existsSync(productConfigPath)) return;
@@ -838,6 +1272,12 @@ async function createImageManager(options = {}) {
 }
 
 //#endregion
+Object.defineProperty(exports, 'BaseEmulatorConfigItem', {
+  enumerable: true,
+  get: function () {
+    return BaseEmulatorConfigItem;
+  }
+});
 Object.defineProperty(exports, 'DeployError', {
   enumerable: true,
   get: function () {
@@ -845,10 +1285,45 @@ Object.defineProperty(exports, 'DeployError', {
   }
 });
 exports.DevModel = DevModel;
+Object.defineProperty(exports, 'GroupPCAllEmulatorConfigItem', {
+  enumerable: true,
+  get: function () {
+    return GroupPCAllEmulatorConfigItem;
+  }
+});
+Object.defineProperty(exports, 'GroupPhoneAllEmulatorConfigItem', {
+  enumerable: true,
+  get: function () {
+    return GroupPhoneAllEmulatorConfigItem;
+  }
+});
+Object.defineProperty(exports, 'PCAllEmulatorConfigItem', {
+  enumerable: true,
+  get: function () {
+    return PCAllEmulatorConfigItem;
+  }
+});
+Object.defineProperty(exports, 'ParentEmulatorConfigItem', {
+  enumerable: true,
+  get: function () {
+    return ParentEmulatorConfigItem;
+  }
+});
+Object.defineProperty(exports, 'PhoneAllEmulatorConfigItem', {
+  enumerable: true,
+  get: function () {
+    return PhoneAllEmulatorConfigItem;
+  }
+});
 exports.RequestUrlError = RequestUrlError;
+exports.createCoverScreen = createCoverScreen;
+exports.createDoubleScreen = createDoubleScreen;
 exports.createImageManager = createImageManager;
-exports.createProductPreset = createProductPreset;
+exports.createOuterDoubleScreen = createOuterDoubleScreen;
+exports.createOuterScreen = createOuterScreen;
 exports.createScreen = createScreen;
+exports.createScreenPreset = createScreenPreset;
+exports.createSingleScreen = createSingleScreen;
 Object.defineProperty(exports, 'version', {
   enumerable: true,
   get: function () {