You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1658 lines
270 KiB
1658 lines
270 KiB
"use strict";
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
// @ts-ignore
|
|
const package_json_1 = __importDefault(require("../../../../package.json"));
|
|
/**
|
|
* 预览：地址读取/刷新/连通性探测 + 无 iframe 的 DOM 渲染 + 左右分隔条拖拽。
|
|
*
|
|
* 面板内直接渲染游戏（不用 iframe）的加载链路：
|
|
* 1. 按序加载引擎脚本（<script> 标签跨域加载 JS 不受 CORS 限制）
|
|
* 2. import-map 内的相对/绝对路径基于「面板 origin」解析会 404，
|
|
* 因此先读取原始 map 内容，把所有路径重写为预览服务绝对 URL 后再注入
|
|
* 3. 最终 System.import(preview-app) 与引擎内部 fetch 资源属于跨域请求，
|
|
* 是否成功取决于预览服务器是否返回 CORS 头（实测验证点）
|
|
*/
|
|
/** socket.io 最小 stub：EventEmitter 语义，满足 preview-app 的 n.on()/t.emit() 调用。
|
|
* 不发起真实 socket.io 连接（面板 origin 与预览服务不一致，连接必然失败且无意义）。 */
|
|
function socketIoStub() {
|
|
const handlers = {};
|
|
return {
|
|
on(evt, fn) {
|
|
(handlers[evt] = handlers[evt] || []).push(fn);
|
|
return this;
|
|
},
|
|
off(evt) {
|
|
delete handlers[evt];
|
|
return this;
|
|
},
|
|
emit(evt, ...args) {
|
|
(handlers[evt] || []).slice().forEach((fn) => fn(...args));
|
|
return this;
|
|
},
|
|
close() {
|
|
for (const k of Object.keys(handlers)) {
|
|
delete handlers[k];
|
|
}
|
|
},
|
|
};
|
|
}
|
|
/** 设备尺寸表（键与真实预览服务渲染的 data-device 完全一致）。
|
|
* 面板内 exactFitScreen=false（SubFrame）模式下引擎画布跟随 #GameDiv 容器尺寸、
|
|
* 忽略 screen.windowSize，因此设备切换要在前端把 #GameDiv 设成目标比例居中显示。
|
|
* 精简集：每档只留一个代表机型，分辨率不重复；键必须能被 preview-app._devices 识别。 */
|
|
const DEVICE_SIZES = {
|
|
'Default': { w: 960, h: 640, label: '设计分辨率' },
|
|
'Apple iPhone 12; 13; 14; 12/13 Pro': { w: 390, h: 844, label: 'iPhone 12/13/14' },
|
|
'Apple iPhone 14 Pro': { w: 393, h: 852, label: 'iPhone 14 Pro' },
|
|
'Apple iPhone 12/13 Pro Max; 14 Plus': { w: 428, h: 926, label: 'iPhone Pro Max/14 Plus' },
|
|
'Apple iPhone XR; 11': { w: 414, h: 896, label: 'iPhone XR/11' },
|
|
'Apple iPhone X; XS; 11 Pro; 12/13 Mini': { w: 375, h: 812, label: 'iPhone X/XS' },
|
|
'Apple iPad 10.2': { w: 1620, h: 2160, label: 'iPad 10.2' },
|
|
'HUAWEI Mate 40 Pro': { w: 448, h: 924, label: 'HUAWEI Mate 40 Pro' },
|
|
'OPPO Reno 2': { w: 360, h: 800, label: 'OPPO Reno 2' },
|
|
'Xiaomi Redmi 8': { w: 360, h: 760, label: 'Xiaomi Redmi 8' },
|
|
'Lenovo Legion 2 Pro': { w: 360, h: 820, label: 'Lenovo Legion 2 Pro' },
|
|
};
|
|
exports.default = {
|
|
async initPreviewInfo() {
|
|
// 设计分辨率默认 960×640，随后用项目真实配置覆盖（Default 等比视口以此为基准）
|
|
this.prefDesignW = 960;
|
|
this.prefDesignH = 640;
|
|
try {
|
|
const [info, proj] = await Promise.all([
|
|
Editor.Message.request(package_json_1.default.name, 'get-preview-info'),
|
|
Editor.Message.request(package_json_1.default.name, 'get-projects-settings'),
|
|
]);
|
|
if (info && info.url) {
|
|
this.previewUrl = info.url;
|
|
}
|
|
const d = proj && proj.designResolution;
|
|
if (d && Number(d.width) > 0 && Number(d.height) > 0) {
|
|
this.prefDesignW = Number(d.width);
|
|
this.prefDesignH = Number(d.height);
|
|
}
|
|
}
|
|
catch (_a) {
|
|
// 保持默认地址/分辨率
|
|
}
|
|
},
|
|
/** 当前项目设计分辨率（读取失败回到 960×640）。 */
|
|
prefDesign() {
|
|
return {
|
|
w: Number(this.prefDesignW) > 0 ? Number(this.prefDesignW) : 960,
|
|
h: Number(this.prefDesignH) > 0 ? Number(this.prefDesignH) : 640,
|
|
};
|
|
},
|
|
/** 地址栏回车 / 点「刷新」/ 遮罩重试：重新渲染游戏画面。 */
|
|
onLoadPreview() {
|
|
this.previewLoaded = false;
|
|
this.previewRenderErr = '';
|
|
this.renderPreview();
|
|
},
|
|
// ===== 预览工具条：新版面工具条通过驱动「隐藏 H5 工具条」与引擎联动 =====
|
|
// 引擎 preview-app 用 document.querySelector('#view-select'/'#btn-rotate'/'#input-set-fps'/
|
|
// '#btn-show-fps'/'#btn-pause'/'#btn-step') 绑定事件，面板内的该工具条被 CSS 隐藏，
|
|
// 只作数据契约。这里用真实 DOM 事件模拟用户操作，与手点效果一致。
|
|
/** 设备/分辨率切换：点选隐藏 #view-select 的对应选项。 */
|
|
onPreviewDevice(device) {
|
|
this.previewDevice = device;
|
|
const el = document.querySelector('#view-select');
|
|
if (!el)
|
|
return;
|
|
el.setAttribute('value', device);
|
|
const name = el.querySelector('#name');
|
|
if (name)
|
|
name.textContent = device;
|
|
el.querySelectorAll('.options li').forEach((li) => {
|
|
if (li.getAttribute('data-device') === device) {
|
|
li.classList.add('selected');
|
|
li.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));
|
|
li.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true }));
|
|
li.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
|
|
}
|
|
else {
|
|
li.classList.remove('selected');
|
|
}
|
|
});
|
|
// 面板内 SubFrame 模式引擎画布跟随 #GameDiv 容器尺寸，设备切换需在此设容器比例，
|
|
// 否则 preview-app 只改 screen.windowSize 不产生视觉变化（真实 H5 才生效）。
|
|
this.applyDeviceViewport(device);
|
|
},
|
|
/** 设备/缩放视口：把 #GameDiv 设成 设备比例 × 缩放因子 的真实尺寸并居中。
|
|
* 引擎 SubFrame 模式按 #GameDiv 实际尺寸重建画布，因此画面比例与输入映射始终一致，
|
|
* 任意缩放比下点击都不会错位。横竖屏方向（previewRotated）交换宽高。
|
|
* 非尺寸映射（FullScreen/Webpage）回到铺满、不应用缩放。 */
|
|
applyDeviceViewport(device, zoom = this.previewZoom) {
|
|
const gd = document.getElementById('GameDiv');
|
|
if (!gd)
|
|
return;
|
|
let d = DEVICE_SIZES[device];
|
|
const host = document.getElementById('yyka-game-host');
|
|
if (!d || !host) {
|
|
gd.style.width = '';
|
|
gd.style.height = '';
|
|
gd.style.margin = '';
|
|
window.dispatchEvent(new Event('resize'));
|
|
return;
|
|
}
|
|
if (device === 'Default') {
|
|
// 设计分辨率取项目真实配置（勿用固定 960×640）
|
|
const pd = this.prefDesign();
|
|
d = { w: pd.w, h: pd.h, label: '设计分辨率' };
|
|
}
|
|
let dw = d.w, dh = d.h;
|
|
if (this.previewRotated) {
|
|
dw = d.h;
|
|
dh = d.w; // 竖屏 ↔ 横屏，交换宽高
|
|
}
|
|
// 预览区（.game-view）基准，等比放入该设备（zoom=1 恰好放入）。
|
|
// 设备模式只留 12px 外边距，外壳尽量大，让游戏窗口撑满壳内部、四角被圆角裁切成全面屏；
|
|
// Default 留 32px。
|
|
const isDev = device !== 'Default' && !!d;
|
|
const pad = isDev ? 12 : 32;
|
|
const aw = Math.max(1, host.clientWidth - pad);
|
|
const ah = Math.max(1, host.clientHeight - pad);
|
|
let w = aw, h = aw * (dh / dw);
|
|
if (h > ah) {
|
|
h = ah;
|
|
w = ah * (dw / dh);
|
|
}
|
|
const z = Math.max(0.2, Math.min(8, zoom));
|
|
const winW = Math.max(10, w * z), winH = Math.max(10, h * z);
|
|
const frame = host.querySelector('.device-frame');
|
|
const isDevice = !!d && device !== 'Default';
|
|
if (frame)
|
|
frame.classList.toggle('device', isDevice);
|
|
if (isDevice && frame) {
|
|
// 真机比例：屏幕（#GameDiv）按设备宽高比尽量放大居中；外壳跟随屏幕，
|
|
// 边框贴着屏幕四周一起缩放（外壳尺寸 = 屏幕 + 细边框）。
|
|
// 旋转（previewRotated）已在 dw/dh 交换过，因此外壳形状会随横竖屏变化。
|
|
const bezX = 42, bezY = 54; // 预留余量：外壳整体在预览区内缩一圈，四周露出背景，避免贴平成"平面"
|
|
const mw = host.clientWidth, mh = host.clientHeight;
|
|
let sw = mw - bezX, sh = sw * (dh / dw);
|
|
if (sh > mh - bezY) {
|
|
sh = mh - bezY;
|
|
sw = sh * (dw / dh);
|
|
}
|
|
let fw = sw * z, fh = sh * z;
|
|
// 缩放上限：放大时整体不超出预览视口，四周留 effPad 余地，等比收缩防溢出
|
|
const effPad = 12;
|
|
const maxW = mw - effPad, maxH = mh - effPad;
|
|
if (fw > maxW || fh > maxH) {
|
|
const r = Math.min(maxW / fw, maxH / fh);
|
|
fw *= r;
|
|
fh *= r;
|
|
}
|
|
frame.style.width = Math.max(20, Math.round(fw)) + 'px';
|
|
frame.style.height = Math.max(20, Math.round(fh)) + 'px';
|
|
frame.style.margin = 'auto';
|
|
gd.style.width = '100%';
|
|
gd.style.height = '100%';
|
|
gd.style.margin = '0';
|
|
// 灵动岛随缩放联动：取机身短边的一定比例作为宽度，
|
|
// 横竖屏（短边不变）尺寸稳定，缩放大小时同步缩放（使用像素避免横屏相对放大）。
|
|
const iso = frame.querySelector('.dynamic-island');
|
|
if (iso) {
|
|
iso.style.width = Math.max(24, Math.round(Math.min(fw, fh) * 0.26)) + 'px';
|
|
}
|
|
}
|
|
else {
|
|
// 普通/Default 视口：按设计分辨率等比居中，同样限幅不超视口并留边距。
|
|
// 尺寸载体用 .device-frame 外壳而非 #GameDiv：面板 CSS 对 #GameDiv 有
|
|
// width/height:100%!important，写在其上的内联像素不生效；若外壳保持
|
|
// max-content，整条链会回落成 canvas 元素固有尺寸（引擎把 canvas.width
|
|
// 设成 screen.windowSize = #GameDiv.clientWidth×dpr，dpr>1 时不断放大），
|
|
// 导致游戏窗口比视口大、被裁剪。给外壳写确定的 fit 像素后 #GameDiv=100%
|
|
// 跟随，尺寸完全确定，不再有 max-content 反馈放大（与设备模式同构）。
|
|
const effPad = 32;
|
|
const maxW = host.clientWidth - effPad, maxH = host.clientHeight - effPad;
|
|
let winW2 = w * z, winH2 = h * z;
|
|
if (winW2 > maxW || winH2 > maxH) {
|
|
const r = Math.min(maxW / winW2, maxH / winH2);
|
|
winW2 *= r;
|
|
winH2 *= r;
|
|
}
|
|
const pxW = Math.max(20, Math.round(winW2)) + 'px';
|
|
const pxH = Math.max(20, Math.round(winH2)) + 'px';
|
|
if (frame) {
|
|
frame.style.width = pxW;
|
|
frame.style.height = pxH;
|
|
frame.style.margin = 'auto';
|
|
gd.style.width = '100%';
|
|
gd.style.height = '100%';
|
|
gd.style.margin = '0';
|
|
}
|
|
else {
|
|
gd.style.width = pxW;
|
|
gd.style.height = pxH;
|
|
gd.style.margin = 'auto';
|
|
}
|
|
}
|
|
// 引擎画面铺满策略：设备模式精确铺满（屏幕顶满边框内缘，无内部黑边），
|
|
// 普通/Default 保持等比适配。screen._exactFitScreen 由 Cocos SubFrame adapter 读取。
|
|
try {
|
|
const ccw = window.cc || window.cclegacy;
|
|
const sc = ccw && (ccw.screen || (ccw.game && ccw.game.screen));
|
|
const targets = sc ? [sc, sc.screenAdapter] : [];
|
|
for (const t of targets) {
|
|
if (t && '_exactFitScreen' in t)
|
|
t._exactFitScreen = !!isDevice;
|
|
}
|
|
}
|
|
catch (_) {
|
|
/* 引擎未就绪时忽略 */
|
|
}
|
|
window.dispatchEvent(new Event('resize'));
|
|
},
|
|
/** 强制走 SubFrame 视口（画布跟随 #GameDiv 尺寸，避免用整窗尺寸生成过大的画布导致
|
|
* 画面比视口大/被裁剪）。批量覆盖所有已知 screenAdapter 来源，并重试等待 System 异步
|
|
* 模块就绪；每成功覆盖一次即重放视口 + 触发 resize 重算。 */
|
|
async forceSubFrameViewport(alive) {
|
|
const apply = (adapter) => {
|
|
if (adapter && '_exactFitScreen' in adapter && adapter._exactFitScreen !== false) {
|
|
adapter._exactFitScreen = false;
|
|
}
|
|
};
|
|
// 1) 同步来源：window.cc.screen 及其 screenAdapter
|
|
const ccw = window.cc || window.cclegacy;
|
|
if (ccw && ccw.screen) {
|
|
apply(ccw.screen);
|
|
apply(ccw.screen.screenAdapter);
|
|
apply(ccw.game && ccw.game.screen);
|
|
apply(ccw.game && ccw.game.screen.screenAdapter);
|
|
}
|
|
// 2) 异步来源：System.import 得到的真实 screenAdapter，重试直至可用或超时（刷新前返回）
|
|
const SysMod = window.System;
|
|
const deadline = Date.now() + 3000;
|
|
while (alive() && Date.now() < deadline) {
|
|
let got = false;
|
|
if (SysMod && typeof SysMod.import === 'function') {
|
|
try {
|
|
const saMod = await SysMod.import('q-bundled:///fs/pal/screen-adapter/web/screen-adapter.js');
|
|
const sa = (saMod && (saMod.screenAdapter || (saMod.default && saMod.default.screenAdapter))) || null;
|
|
if (sa) {
|
|
apply(sa);
|
|
got = true;
|
|
}
|
|
}
|
|
catch (_a) {
|
|
/* 模块未就绪，继续重试 */
|
|
}
|
|
}
|
|
if (got)
|
|
break;
|
|
await new Promise((r) => setTimeout(r, 120));
|
|
}
|
|
if (alive()) {
|
|
this.applyDeviceViewport(this.previewDevice || 'Default');
|
|
window.dispatchEvent(new Event('resize'));
|
|
}
|
|
},
|
|
onPreviewRotate() {
|
|
const btn = document.querySelector('#btn-rotate');
|
|
if (btn)
|
|
btn.click();
|
|
this.previewRotated = !this.previewRotated; // 面板侧视觉指示
|
|
// 设备/默认视口模式下旋转后按新方向重算 #GameDiv 比例
|
|
if (this.previewDevice && DEVICE_SIZES[this.previewDevice]) {
|
|
this.applyDeviceViewport(this.previewDevice);
|
|
}
|
|
this.syncPreviewState();
|
|
},
|
|
/** 帧率上限设置：写隐藏 #input-set-fps 并派发 input/change。 */
|
|
onPreviewFps(val) {
|
|
const n = Math.max(1, Math.min(240, Number(val) || 60));
|
|
this.previewFps = n;
|
|
const inp = document.querySelector('#input-set-fps');
|
|
if (inp) {
|
|
inp.value = String(n);
|
|
inp.dispatchEvent(new Event('input', { bubbles: true }));
|
|
inp.dispatchEvent(new Event('change', { bubbles: true }));
|
|
}
|
|
},
|
|
/** 显示FPS开关：触发隐藏 #btn-show-fps 并回读激活态。 */
|
|
onPreviewShowFps() {
|
|
const btn = document.querySelector('#btn-show-fps');
|
|
if (btn)
|
|
btn.click();
|
|
this.syncPreviewState();
|
|
},
|
|
/** 暂停/继续：触发隐藏 #btn-pause。 */
|
|
onPreviewPause() {
|
|
const btn = document.querySelector('#btn-pause');
|
|
if (btn)
|
|
btn.click();
|
|
this.syncPreviewState();
|
|
},
|
|
/** 步进一帧：仅暂停态可用，触发隐藏 #btn-step。 */
|
|
onPreviewStep() {
|
|
const btn = document.querySelector('#btn-step');
|
|
if (btn)
|
|
btn.click();
|
|
},
|
|
// ─────────── 窗囗级全局静音（default / 预览面板共享）───────────
|
|
onPreviewMute() {
|
|
this.previewMuted = !this.previewMuted;
|
|
this._applyMute();
|
|
},
|
|
/** 确保 context 有 master gain（如无则注入），并返回它。 */
|
|
_ensureMaster(c) {
|
|
if (!c || c.__yykaMaster)
|
|
return c && c.__yykaMaster;
|
|
try {
|
|
const mg = c.createGain();
|
|
c.__yykaMaster = mg;
|
|
const list = this.__muteCtxs();
|
|
if (list.indexOf(c) < 0)
|
|
list.push(c);
|
|
return mg;
|
|
}
|
|
catch (_) {
|
|
return null;
|
|
}
|
|
},
|
|
/** context 采集列表（模块级，换场景/重渲染保持）。 */
|
|
__muteCtxs() {
|
|
const key = '__yykaAudioCtxs';
|
|
const w = window;
|
|
if (!w[key])
|
|
w[key] = [];
|
|
return w[key];
|
|
},
|
|
/** 全局静音标志：进入静音前先把当前实例状态写进全局，供 connect 劫持读取。 */
|
|
__muteGlobal() {
|
|
const key = '__yykaGlobalMute';
|
|
const w = window;
|
|
return { get: () => !!w[key], set: (v) => { w[key] = v; } };
|
|
},
|
|
/** 应用静音到单个 context：master gain 实时开关（g=0 无声 / g=1 有声）。 */
|
|
_applyMuteToCtx(c, muted) {
|
|
try {
|
|
if (!c)
|
|
return;
|
|
if (c.__yykaMaster) {
|
|
c.__yykaMaster.gain.value = muted ? 0 : 1;
|
|
}
|
|
else if (c.createGain) {
|
|
const mg = this._ensureMaster(c);
|
|
if (mg) {
|
|
mg.gain.value = muted ? 0 : 1;
|
|
try {
|
|
mg.connect(c.destination);
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
}
|
|
}
|
|
if (!muted && typeof c.resume === 'function' && c.state === 'suspended') {
|
|
try {
|
|
c.resume();
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
}
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
},
|
|
/** 应用全局静音：写标志 + 引擎音量 + 全部 context master gain + 媒体元素。无轮询。 */
|
|
_applyMute() {
|
|
const muted = !!this.previewMuted;
|
|
this.__muteGlobal().set(muted);
|
|
const lg = window.cc || window.cclegacy;
|
|
const ae = lg && (lg.AudioEngine || (lg.audio && lg.audio.AudioEngine));
|
|
if (ae) {
|
|
try {
|
|
if (typeof ae.setMusicVolume === 'function')
|
|
ae.setMusicVolume(muted ? 0 : 1);
|
|
if (typeof ae.setEffectsVolume === 'function')
|
|
ae.setEffectsVolume(muted ? 0 : 1);
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
}
|
|
const ctxs = this.__muteCtxs();
|
|
for (const c of ctxs)
|
|
this._applyMuteToCtx(c, muted);
|
|
try {
|
|
document.querySelectorAll('audio, video').forEach((el) => {
|
|
try {
|
|
el.muted = muted;
|
|
if (muted)
|
|
el.pause();
|
|
else
|
|
el.play().catch(() => { });
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
});
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
},
|
|
/**
|
|
* 安装窗囗级音频静音 hook（事件驱动，无轮询）：
|
|
* 1) 包装 AudioContext 构造器：新建即挂 master 并采集；
|
|
* 2) 劫持 AudioNode.prototype.connect：任何节点连到 context.destination 时接进 master gain。
|
|
* 即使引擎复用模块级缓存的原始 context 单例，connect 时也会动态注入 master，
|
|
* 声音必经 master，g=0 立即无声（攻击音效瞬时哑，无需轮询）。
|
|
*/
|
|
_hookAudioCtx() {
|
|
const w = window;
|
|
const selfRef = this;
|
|
const hijackConnect = (NodeCtor) => {
|
|
if (!NodeCtor || NodeCtor.__yykaConnHook)
|
|
return;
|
|
NodeCtor.__yykaConnHook = true;
|
|
const orig = NodeCtor.prototype.connect;
|
|
NodeCtor.prototype.connect = function (dest, ...rest) {
|
|
try {
|
|
const ctx = this && this.context;
|
|
// master 节点自身连到输出时要放行（直连 destination），否则会把自己
|
|
// 重定向到自身形成自连，音频图被破坏→永久静音（无论开关状态）。
|
|
if (ctx && this === ctx.__yykaMaster) {
|
|
return orig.apply(this, [dest, ...rest]);
|
|
}
|
|
if (ctx && ctx.destination && dest === ctx.destination) {
|
|
let mg = ctx.__yykaMaster;
|
|
if (!mg && ctx.createGain) {
|
|
mg = ctx.createGain();
|
|
ctx.__yykaMaster = mg;
|
|
const list = selfRef.__muteCtxs();
|
|
if (list.indexOf(ctx) < 0)
|
|
list.push(ctx);
|
|
try {
|
|
orig.call(mg, ctx.destination);
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
}
|
|
if (mg) {
|
|
mg.gain.value = selfRef.__muteGlobal().get() ? 0 : 1;
|
|
dest = mg;
|
|
}
|
|
}
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
return orig.apply(this, [dest, ...rest]);
|
|
};
|
|
};
|
|
const AudioNodeCtor = w.AudioNode;
|
|
if (AudioNodeCtor) {
|
|
try {
|
|
hijackConnect(AudioNodeCtor);
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
}
|
|
const wrapCtor = (Ctor, name) => {
|
|
if (!Ctor || Ctor.__patchYyka)
|
|
return;
|
|
const Old = Ctor;
|
|
const Self = function (...a) {
|
|
const c = new Old(...a);
|
|
try {
|
|
const mg = selfRef._ensureMaster(c);
|
|
if (mg) {
|
|
mg.connect(c.destination);
|
|
mg.gain.value = selfRef.__muteGlobal().get() ? 0 : 1;
|
|
}
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
return c;
|
|
};
|
|
Self.prototype = Old.prototype;
|
|
Self.__patchYyka = true;
|
|
w[name] = Self;
|
|
};
|
|
wrapCtor(w.AudioContext, 'AudioContext');
|
|
wrapCtor(w.webkitAudioContext, 'webkitAudioContext');
|
|
try {
|
|
const OE = document.createElement.bind(document);
|
|
document.createElement = function (tag, ...rest) {
|
|
const el = OE(tag, ...rest);
|
|
const t = String(tag).toLowerCase();
|
|
if (t === 'audio' || t === 'video') {
|
|
try {
|
|
if (selfRef.__muteGlobal().get())
|
|
el.muted = true;
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
}
|
|
return el;
|
|
};
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
},
|
|
/** 刷新预览：重置缩放并重新渲染。 */
|
|
doRefreshPreview() {
|
|
this.previewZoom = 1;
|
|
this.previewLoaded = false;
|
|
this.previewRenderErr = '';
|
|
this.renderPreview();
|
|
},
|
|
/** 重渲染前拆解上一次游戏实例：停主循环、清调度器（计时器/update）、停音频、释放资源。
|
|
* 面板内无法像浏览器预览那样整页 reload，cc 全局是单例，旧实例若不清理，
|
|
* 刷新后音乐/计时器/主循环会残留叠加、不关闭面板就无法复原。
|
|
* 每步单独 try/catch 以防某 API 缺失/报错阻断重载流程。 */
|
|
teardownPreview() {
|
|
const lg = window.cc || window.cclegacy;
|
|
if (!lg || !lg.game)
|
|
return; // 首次渲染尚无实例，跳过
|
|
const stop = (fn) => {
|
|
try {
|
|
fn();
|
|
}
|
|
catch (_) {
|
|
/* 忽略单个清理失败 */
|
|
}
|
|
};
|
|
// 停主循环更新（暂停 update/游戏逻辑）
|
|
const g = lg.game;
|
|
stop(() => g.pause && g.pause());
|
|
stop(() => g.pauseByEngine && g.pauseByEngine());
|
|
// 停 director 更新
|
|
const dir = lg.director;
|
|
stop(() => dir.pause && dir.pause());
|
|
// 清调度器：项目用 scheduleOnce/setTimeout 等定时器
|
|
stop(() => {
|
|
const sch = dir && dir.getScheduler && dir.getScheduler();
|
|
sch && sch.unscheduleAll && sch.unscheduleAll();
|
|
});
|
|
// 停止音频（项目音乐/音效，AudioEngine 全局 close 停全部）
|
|
stop(() => {
|
|
const ae = lg.AudioEngine || (lg.audio && lg.audio.AudioEngine);
|
|
ae && ae.close && ae.close();
|
|
});
|
|
// 释放已加载资源，避免新场景复用旧资源句柄造成叠加
|
|
stop(() => lg.assetManager && lg.assetManager.releaseAll && lg.assetManager.releaseAll());
|
|
},
|
|
/** 从隐藏 H5 工具条回读状态，同步面板按钮激活态（loading 完整后调用一次 + 每次操作后）。 */
|
|
syncPreviewState() {
|
|
const showReady = () => {
|
|
const show = document.querySelector('#btn-show-fps');
|
|
const pause = document.querySelector('#btn-pause');
|
|
const step = document.querySelector('#btn-step');
|
|
let paused = false;
|
|
if (pause)
|
|
paused = pause.classList.contains('checked');
|
|
if (!paused && step)
|
|
paused = getComputedStyle(step).display !== 'none';
|
|
this.previewShowFps = !!(show && show.classList.contains('checked'));
|
|
this.previewPaused = paused;
|
|
};
|
|
// 等待 #GameCanvas 就绪后再读；宿主重建瞬间可能取到空 DOM
|
|
const waitFor = () => {
|
|
if (document.querySelector('#btn-pause')) {
|
|
showReady();
|
|
}
|
|
else {
|
|
window.setTimeout(waitFor, 60);
|
|
}
|
|
};
|
|
waitFor();
|
|
},
|
|
/** 预览区滚轮缩放：调整缩放因子并重算 #GameDiv 真实尺寸（等比放大缩小，居中）。
|
|
* 用对称乘法步进（放大 ×1.12 / 缩小 ÷1.12）保证可逆；引擎按容器尺寸重建画布，
|
|
* 因此放大缩小过程输入映射始终正确，不会出现放大了点不到的情况。 */
|
|
onPreviewWheel(e) {
|
|
e.preventDefault();
|
|
// 关键：拦截滚轮传播。否则事件还会继续传到本插件加载的编辑器 preview-app
|
|
// Ui（其滚轮处理器会把设计分辨率重置成默认横屏 960×640，导致竖屏变横屏）。
|
|
// 这里在捕获阶段阻止冒泡到内容层，保证只由我们自己的 applyDeviceViewport 控制缩放。
|
|
e.stopPropagation();
|
|
e.stopImmediatePropagation();
|
|
if (!document.getElementById('GameDiv'))
|
|
return;
|
|
const zoomIn = e.deltaY < 0;
|
|
const step = Math.pow(1.12, zoomIn ? 1 : -1);
|
|
this.previewZoom = Math.min(8, Math.max(0.2, Math.round(this.previewZoom * step * 100) / 100));
|
|
// 仅对尺寸映射的设备/默认视口应用缩放（FullScreen/Webpage 铺满不缩放）
|
|
const dev = this.previewDevice || 'Default';
|
|
if (DEVICE_SIZES[dev]) {
|
|
this.applyDeviceViewport(dev);
|
|
}
|
|
// 兜底：编辑器 preview-app Ui 可能在同一次滚轮/resize 里异步把设计分辨率重置成
|
|
// 默认横屏（960×640）。下一帧再重放一次视口（等比 + _exactFitScreen=false），
|
|
// 把设备/默认设计分辨率强制拉回项目真实竖屏比例。
|
|
cancelAnimationFrame(this._wheelReapply);
|
|
this._wheelReapply = requestAnimationFrame(() => {
|
|
this._wheelReapply = 0;
|
|
const dev0 = this.previewDevice || 'Default';
|
|
if (DEVICE_SIZES[dev0])
|
|
this.applyDeviceViewport(dev0);
|
|
});
|
|
},
|
|
/** 把相对/绝对路径拼到预览服务 origin 上（面板 origin 解析会 404）。 */
|
|
abs(path) {
|
|
const base = (this.previewUrl || '').trim().replace(/\/+$/, '') || 'http://localhost:7456';
|
|
if (/^(https?:)?\/\//i.test(path) || path.startsWith('data:') || path.startsWith('blob:')) {
|
|
return path;
|
|
}
|
|
return base + (path.startsWith('/') ? path : '/' + path);
|
|
},
|
|
/** 游戏宿主容器：创建在顶层 document.body 上。面板内容可能渲染在 shadow DOM 中
|
|
* （Cocos ui-panel 机制），Ui 构造的 document.querySelector 无法穿透 shadow root，
|
|
* 因此游戏 DOM 必须挂在顶层 document 上才能被找到。 */
|
|
ensureGameHost() {
|
|
let host = document.getElementById('yyka-game-host');
|
|
if (!host) {
|
|
host = document.createElement('div');
|
|
host.id = 'yyka-game-host';
|
|
// flex column：toolbar 隐藏后 content(flex:auto) 才能撑满宿主高度
|
|
// z-index 40：盖住面板主体内容（z-index ≤ 10），
|
|
// 但低于 .mcp-mask(50)/.node-picker-mask(9999)，避免遮盖面板弹层
|
|
host.style.cssText =
|
|
'position:fixed;z-index:40;overflow:hidden;background:#171717;display:none;' +
|
|
'flex-direction:column;align-items:stretch;';
|
|
document.body.appendChild(host);
|
|
}
|
|
// 滚轮缩放：游戏放大后 #GameDiv 会超出预览区，若把 wheel 绑在宿主上，
|
|
// 当鼠标悬停在溢出的画面区域时事件可能被子元素拦截/丢失，导致放大了缩不回来。
|
|
// 挂在 document（window 捕获）的捕获阶段，保证鼠标落在游戏宿主内任意元素（含溢出部分）
|
|
// 都能触发；且在编辑器 preview-app Ui 的任何滚轮处理器之前先执行（见 onPreviewWheel）。
|
|
// 用 this._docZoomBound 防重复绑定（window 常驻，host 可反复重建）。
|
|
if (!this._docZoomBound) {
|
|
this._docZoomBound = true;
|
|
window.addEventListener('wheel', (e) => {
|
|
const h = document.getElementById('yyka-game-host');
|
|
if (h && (h.contains(e.target) || e.target === h)) {
|
|
this.onPreviewWheel(e);
|
|
}
|
|
}, { capture: true, passive: false });
|
|
}
|
|
return host;
|
|
},
|
|
/** 让游戏宿主跟随面板预览区域（.game-view）的视口位置与尺寸。
|
|
* getBoundingClientRect 对 shadow DOM 内元素同样返回视口坐标，配合 fixed 定位可精确覆盖。
|
|
* 面板被拖动/切走/弹窗遮挡时宿主必须跟随或隐藏，否则会「漂浮」在屏幕上盖住其它窗口。 */
|
|
syncGameHost() {
|
|
const host = document.getElementById('yyka-game-host');
|
|
if (!host)
|
|
return;
|
|
const ref = this.$refs.gameView || document.querySelector('.game-view');
|
|
if (!ref)
|
|
return;
|
|
const r = ref.getBoundingClientRect();
|
|
const vw = window.innerWidth;
|
|
const vh = window.innerHeight;
|
|
// 尺寸为 0（v-show 隐藏）或完全移出视口（面板拖动/独立成窗）时隐藏宿主，避免漂浮遮挡
|
|
const offscreen = r.width <= 1 || r.height <= 1 || r.left >= vw || r.top >= vh || r.left + r.width <= 0 || r.top + r.height <= 0;
|
|
const display = offscreen ? 'none' : 'flex';
|
|
// 仅在状态变化时写样式，避免定期轮询造成无谓重排
|
|
if (this._hostDisplay === display && this._hostLeft === r.left && this._hostTop === r.top &&
|
|
this._hostW === r.width && this._hostH === r.height) {
|
|
return;
|
|
}
|
|
this._hostDisplay = display;
|
|
this._hostLeft = r.left;
|
|
this._hostTop = r.top;
|
|
this._hostW = r.width;
|
|
this._hostH = r.height;
|
|
host.style.display = display; // 与 cssText 的 flex column 布局一致
|
|
if (display === 'none')
|
|
return;
|
|
host.style.left = r.left + 'px';
|
|
host.style.top = r.top + 'px';
|
|
host.style.width = r.width + 'px';
|
|
host.style.height = r.height + 'px';
|
|
},
|
|
/** 停止定期宿主同步（渲染被取代或面板关闭时调用）。 */
|
|
stopHostSync() {
|
|
if (this._hostSyncTimer) {
|
|
window.clearInterval(this._hostSyncTimer);
|
|
this._hostSyncTimer = 0;
|
|
}
|
|
},
|
|
/** 监听预览区域尺寸/显隐变化，自动同步游戏宿主位置（分隔条拖拽、窗口缩放、v-show 切换）。 */
|
|
observeGameHost() {
|
|
if (this._hostObserved)
|
|
return;
|
|
this._hostObserved = true;
|
|
const ref = this.$refs.gameView || document.querySelector('.game-view');
|
|
if (!ref || typeof ResizeObserver === 'undefined')
|
|
return;
|
|
const ro = new ResizeObserver(() => this.syncGameHost());
|
|
ro.observe(ref);
|
|
},
|
|
/** 构建完整游戏 DOM（toolbar 控件条 + content/GameDiv/canvas/splash/bulletin/error），
|
|
* 挂载到顶层 document 的游戏宿主上，并同步定位到面板预览区域。
|
|
* Ui 构造的 document.querySelector('#GameCanvas') 依赖这些元素在顶层 document 可见。 */
|
|
buildGameDom() {
|
|
const host = this.ensureGameHost();
|
|
host.innerHTML = '';
|
|
const el = (tag, cls = '', id = '') => {
|
|
const e = document.createElement(tag);
|
|
if (cls)
|
|
e.className = cls;
|
|
if (id)
|
|
e.id = id;
|
|
return e;
|
|
};
|
|
// 内联样式：等价预览模板 index.css 的关键布局（只作用于 #yyka-game-host 内部）。
|
|
// 缺少这些样式会导致：toolbar 裸奔显示（布局乱）、
|
|
// #GameDiv/#Cocos3dGameContainer/#GameCanvas 塌陷为 0 尺寸（黑屏）。
|
|
const style = el('style');
|
|
style.textContent = `
|
|
#yyka-game-host, #yyka-game-host * { box-sizing: border-box; -webkit-user-select: none; user-select: none; }
|
|
#yyka-game-host .toolbar { display: none !important; } /* 面板内不需要预览器控件条 */
|
|
#yyka-game-host .content {
|
|
flex: auto; min-height: 0;
|
|
display: flex; flex-direction: column;
|
|
align-items: center; justify-content: center; overflow: hidden;
|
|
}
|
|
#yyka-game-host .contentWrap {
|
|
width: 100%; height: 100%; overflow: hidden;
|
|
display: flex; align-items: center; justify-content: center; flex-direction: column;
|
|
}
|
|
#yyka-game-host #GameDiv,
|
|
#yyka-game-host #Cocos3dGameContainer,
|
|
#yyka-game-host #GameCanvas { width: 100%; height: 100%; }
|
|
#yyka-game-host #GameDiv { overflow: hidden; position: relative; }
|
|
#yyka-game-host .wrapper { position: relative; }
|
|
/* 设备外壳容器：默认只作居中包裹；选中设备时加 .device 呈现手机屏幕外观 */
|
|
#yyka-game-host .device-frame {
|
|
display: flex; align-items: center; justify-content: center; width: max-content; height: max-content;
|
|
}
|
|
/* 手机外壳（全面屏）：窄边中框 + 圆角裁剪（游戏窗口直角被圆角遮掉，呈全面屏），
|
|
顶部挖孔屏胶囊刘海 + 底部下巴 */
|
|
#yyka-game-host .device-frame.device {
|
|
position: relative;
|
|
border-radius: 18px;
|
|
padding: 0;
|
|
overflow: hidden; /* 让内部游戏窗口直角被圆角裁切 */
|
|
background: linear-gradient(160deg, #3a3f47 0%, #23262b 45%, #141619 100%);
|
|
color: #fff;
|
|
box-shadow:
|
|
inset 0 0 0 1px rgba(255, 255, 255, 0.06),
|
|
0 2px 5px rgba(0, 0, 0, 0.5),
|
|
0 12px 26px rgba(0, 0, 0, 0.45),
|
|
0 26px 52px rgba(0, 0, 0, 0.55);
|
|
}
|
|
/* 边框覆盖层：叠在屏幕之上（不能在 background/box-shadow 画，那些会被子元素屏幕盖住），
|
|
中央透明透出屏幕，四边机身色形成可见的手机边框，圆角跟随外壳 */
|
|
#yyka-game-host .device-frame.device::before {
|
|
content: ""; position: absolute; inset: 0; z-index: 5; pointer-events: none;
|
|
border: 6px solid #26292f;
|
|
border-radius: 16px;
|
|
box-shadow:
|
|
inset 0 1px 0 rgba(255, 255, 255, 0.18),
|
|
inset 0 -1px 0 rgba(0, 0, 0, 0.55),
|
|
inset 0 0 0 1px rgba(255, 255, 255, 0.06);
|
|
}
|
|
/* 底部点亮条（叠在边框下方，像 home 键光条） */
|
|
#yyka-game-host .device-frame.device::after {
|
|
content: ""; position: absolute; bottom: 2px; left: 50%; transform: translateX(-50%);
|
|
width: 46px; height: 2px; border-radius: 2px; background: rgba(255, 255, 255, 0.16);
|
|
z-index: 6;
|
|
}
|
|
/* 灵动岛挖孔镜头：设备模式下覆盖在屏幕顶部中央，圆角胶囊外观。
|
|
尺寸用相对值（宽度取屏幕宽的一定的百分比），随外壳整体缩放同步变化，
|
|
避免缩放时机身放大而灵动岛保持固定像素导致“相对变小/反向”的现象。 */
|
|
#yyka-game-host .device-frame .dynamic-island {
|
|
display: none;
|
|
position: absolute; top: 4%; left: 50%; transform: translateX(-50%);
|
|
width: 26%; aspect-ratio: 4 / 1; border-radius: 999px; background: #000;
|
|
z-index: 6; pointer-events: none;
|
|
box-shadow:
|
|
inset 0 0 0 1px rgba(255, 255, 255, 0.06),
|
|
inset 0 0 6px rgba(255, 255, 255, 0.05),
|
|
0 2px 8px rgba(0, 0, 0, 0.5);
|
|
}
|
|
#yyka-game-host .device-frame.device .dynamic-island { display: block; }
|
|
#yyka-game-host #splash { position: absolute; top: 0; left: 0; width: 100%; height: 100%; overflow: hidden; visibility: hidden; }
|
|
#yyka-game-host #bulletin { position: absolute; left: 50%; top: 50%; display: none; }
|
|
#yyka-game-host .error {
|
|
color: #fff; position: absolute; width: 70%; max-width: 960px; top: 5vh; right: 0; left: 0;
|
|
margin: auto; display: none; z-index: 2; background: #171717; padding: 16px;
|
|
border-radius: 4px; word-break: break-all;
|
|
}
|
|
#yyka-game-host canvas { background-color: transparent; outline: none; }
|
|
`;
|
|
host.appendChild(style);
|
|
// 预览器 UI 控件条：Ui 构造函数用 document.querySelector 强依赖这些元素，缺失即抛
|
|
// "UI element xxx doesn't exist"。显示层面由 CSS 隐藏。
|
|
const toolbar = el('div', 'toolbar disabled');
|
|
// 设备列表 data-device 与真实预览服务渲染的完全一致，preview-app 据此键应用分辨率。
|
|
toolbar.innerHTML = `
|
|
<div class="item"><div id="view-select" class="view-select-container" value="Default" tabindex="-1">
|
|
<div class="view-select"><div class="label"><span id="name"></span></div><i class="arrow-triangle"></i></div>
|
|
<div class="options"><ul>
|
|
<li class="selected" data-device="Default">设计分辨率 (960X640)</li>
|
|
<li class="" data-device="FullScreen">全屏</li>
|
|
<li class="" data-device="WebpageFullScreen">网页全屏</li>
|
|
<li class="separator"></li>
|
|
<li class="" data-device="Apple iPhone 12; 13; 14; 12/13 Pro">iPhone 12/13/14 (390X844)</li>
|
|
<li class="" data-device="Apple iPhone 14 Pro">iPhone 14 Pro (393X852)</li>
|
|
<li class="" data-device="Apple iPhone 12/13 Pro Max; 14 Plus">iPhone Pro Max/14 Plus (428X926)</li>
|
|
<li class="" data-device="Apple iPhone XR; 11">iPhone XR/11 (414X896)</li>
|
|
<li class="" data-device="Apple iPhone X; XS; 11 Pro; 12/13 Mini">iPhone X/XS (375X812)</li>
|
|
<li class="" data-device="Apple iPad 10.2">iPad 10.2 (1620X2160)</li>
|
|
<li class="" data-device="HUAWEI Mate 40 Pro">HUAWEI Mate 40 Pro (448X924)</li>
|
|
<li class="" data-device="OPPO Reno 2">OPPO Reno 2 (360X800)</li>
|
|
<li class="" data-device="Xiaomi Redmi 8">Xiaomi Redmi 8 (360X760)</li>
|
|
<li class="" data-device="Lenovo Legion 2 Pro">Lenovo Legion 2 Pro (360X820)</li>
|
|
</ul></div>
|
|
</div></div>
|
|
<div class="item"><button id="btn-rotate" class="checked">Rotate</button></div>
|
|
<span class="item">Debug Mode:</span>
|
|
<div class="item"><select id="opts-debug-mode" value="INFO">
|
|
<option value="NONE">None</option><option value="VERBOSE">Verbose</option>
|
|
<option value="INFO">Info</option><option value="WARN">Warn</option>
|
|
<option value="ERROR">Error</option><option value="INFO_FOR_WEB_PAGE">Info For Web Page</option>
|
|
<option value="WARN_FOR_WEB_PAGE">Warn For Web Page</option>
|
|
<option value="ERROR_FOR_WEB_PAGE">Error For Web Page</option>
|
|
</select></div>
|
|
<div class="item"><button id="btn-show-fps" class="">Show FPS</button></div>
|
|
<div class="item"><span>FPS:</span><input id="input-set-fps" type="number" value="60" /></div>
|
|
<div id="step-length"><span>Step Length: </span><input type="text" value="1"><span>ms</span></div>
|
|
<div class="item"><button id="btn-pause">Pause</button><button id="btn-step" style="display:none;">Step</button></div>`;
|
|
host.appendChild(toolbar);
|
|
const gameDiv = el('div', 'wrapper', 'GameDiv');
|
|
const container = el('div', '', 'Cocos3dGameContainer');
|
|
const canvas = el('canvas', '', 'GameCanvas');
|
|
canvas.tabIndex = -1;
|
|
container.appendChild(canvas);
|
|
gameDiv.appendChild(container);
|
|
const splash = el('div', '', 'splash');
|
|
const bar = el('div', 'progress-bar stripes');
|
|
bar.innerHTML = '<span></span>';
|
|
splash.appendChild(bar);
|
|
gameDiv.appendChild(splash);
|
|
const bulletin = el('div', '', 'bulletin');
|
|
const empty = el('div', 'inner', 'sceneIsEmpty');
|
|
empty.textContent = '预览场景中啥都没有，加点什么，或在编辑器中打开其它场景吧';
|
|
bulletin.appendChild(empty);
|
|
gameDiv.appendChild(bulletin);
|
|
const err = el('div', 'error', 'error');
|
|
err.appendChild(el('div', 'title')).textContent = 'Error (Please open the console to see detailed errors)';
|
|
err.appendChild(el('div', 'error-main'));
|
|
err.appendChild(el('div', 'error-stack'));
|
|
gameDiv.appendChild(err);
|
|
const frame = el('div', 'device-frame'); // 手机外壳容器：选中设备时呈现手机屏幕样式
|
|
frame.appendChild(gameDiv);
|
|
frame.appendChild(el('div', 'dynamic-island')); // 灵动岛挖孔摄像头（覆盖屏幕之上）
|
|
const wrap = el('div', 'contentWrap');
|
|
wrap.appendChild(frame);
|
|
const content = el('div', 'content');
|
|
content.appendChild(wrap);
|
|
host.appendChild(content);
|
|
// 确认 #GameCanvas 已挂载到顶层 document（Ui 构造依赖）
|
|
if (document.querySelector('#GameCanvas')) {
|
|
this.logs.push({ evt: 'sys', msg: '[预览] 游戏 DOM 就绪 (#GameCanvas 已挂载到顶层 document)' });
|
|
}
|
|
else {
|
|
this.logs.push({ evt: 'sys', msg: '[预览] 警告: #GameCanvas 未挂载到顶层 document' });
|
|
}
|
|
this.syncGameHost();
|
|
this.observeGameHost();
|
|
},
|
|
/** 注入补充 import-map：preview-app 内部硬编码 import("/socket.io/socket.io.js")，
|
|
* 该路径基于面板 origin 解析会 404，需映射到预览服务绝对地址。
|
|
* 必须在 system.js 加载前注入，SystemJS 初始化时才会收集。 */
|
|
injectExtraImportMap() {
|
|
const inj = document.createElement('script');
|
|
inj.type = 'systemjs-importmap';
|
|
inj.textContent = JSON.stringify({
|
|
imports: {
|
|
'/socket.io/socket.io.js': this.abs('/socket.io/socket.io.js'),
|
|
},
|
|
});
|
|
document.head.appendChild(inj);
|
|
},
|
|
/** 在 /socket.io/socket.io.js（映射后的绝对地址）注册 SystemJS stub 模块。
|
|
* 必须在 system.js 加载之后、System.import(preview-app) 之前调用。 */
|
|
registerSocketIoStub() {
|
|
const Sys = window.System;
|
|
const socketUrl = this.abs('/socket.io/socket.io.js');
|
|
if (!Sys || typeof Sys.register !== 'function' || Sys.has(socketUrl)) {
|
|
return;
|
|
}
|
|
Sys.register(socketUrl, [], (_export) => ({
|
|
// 注意：execute 不得返回真值（_export 的返回值是导出的值，如 socketIoStub 函数）。
|
|
// SystemJS 的 doExec 对真值直接调 execPromise.then(...)，非 Promise 即抛
|
|
// "execPromise.then is not a function"；返回 undefined 走同步完成分支。
|
|
execute: () => {
|
|
_export('default', socketIoStub);
|
|
},
|
|
}));
|
|
this.logs.push({ evt: 'sys', msg: `[预览] socket.io stub 已注册 (${socketUrl})` });
|
|
},
|
|
/** 预览环境补齐：面板运行在编辑器 Electron 窗口内，引擎 cc/env 模块用
|
|
* tryDefineGlobal('CC_EDITOR', 探测 electron process) 会把 EDITOR 误判为 true，
|
|
* 从而走进编辑器桥接分支并引用未定义的 EditorExtends 全局导致崩溃
|
|
* （真实浏览器预览无 process，EDITOR=false 故正常）。必须在引擎 bundle 加载前
|
|
* 预置正确的预览标志 + EditorExtends 桩。 */
|
|
patchPreviewEnv() {
|
|
// 预置环境标志：cc/env 的 tryDefineGlobal 优先读 window 上的同名全局
|
|
window.CC_EDITOR = false;
|
|
window.CC_PREVIEW = true;
|
|
window.CC_DEV = true;
|
|
window.CC_JSB = false;
|
|
// EditorExtends 桩：兜住引擎中无 EDITOR 守卫的引用
|
|
// （如 Node._registerIfAttached 的 `if (EditorExtends.Node && ...)`），
|
|
// 各成员为 no-op，避免 ReferenceError/TypeError，也不产生编辑器副作用。
|
|
window.EditorExtends = {
|
|
Node: { add() { }, remove() { }, getNode() { return null; }, emit() { } },
|
|
Component: { add() { }, remove() { }, addMenu() { }, removeMenu() { } },
|
|
PrefabUtils: { addPrefabInstance() { } },
|
|
serialize: { asAsset() { return null; } },
|
|
UuidUtils: { isUuid() { return false; }, decompressUuid() { return null; } },
|
|
};
|
|
this.logs.push({ evt: 'sys', msg: '[预览] 预览环境已补齐 (CC_EDITOR=false, EditorExtends stub)' });
|
|
},
|
|
/** 包装 window.fetch + XMLHttpRequest：记录预览服务(origin 匹配)请求的非 2xx 响应，
|
|
* 面板内看不到网络面板时的调试兜底；编辑器自身请求不受影响。
|
|
* 引擎 AssetManager 部分下载走 XHR，只包装 fetch 会漏掉资源加载失败。
|
|
* 注意：每次渲染都调用本方法重装，但基于 window 上保存的「原始引用」重新包装
|
|
* （__yykaRawIo 只存一次），既保证最新版本逻辑生效，又避免层层嵌套。 */
|
|
hookFetchLogger() {
|
|
const self = this;
|
|
const w = window;
|
|
// 原始 IO 引用只保存一次：旧版本没有此标记时首次取「当前实现」（可能是旧包装），
|
|
// 功能等价；WebContents 重建后 window 全新，这里取到原生实现。
|
|
if (!w.__yykaRawIo) {
|
|
w.__yykaRawIo = {
|
|
fetch: w.fetch.bind(w),
|
|
xhrOpen: XMLHttpRequest.prototype.open,
|
|
xhrSend: XMLHttpRequest.prototype.send,
|
|
};
|
|
}
|
|
const raw = w.__yykaRawIo;
|
|
const base = (this.previewUrl || '').trim().replace(/\/+$/, '');
|
|
const inPreview = (u) => !!base && u.indexOf(base) === 0;
|
|
// 只记录关键请求：非 200（失败/CORS 拦截 status=0）或 URL 含 /scene/（场景加载结果）
|
|
const shouldLog = (u, status) => status !== 200 || /\/scene\//i.test(u);
|
|
// 纯相对路径（无 scheme、不以 / 或 // 开头）在编辑器 document 下会解析到编辑器 origin，
|
|
// 而 preview-app/引擎以相对路径请求场景与资源（scene/xxx.json、assets/general/import/...）。
|
|
// 浏览器预览页面就在预览 origin 下所以正常；面板内必须改写成预览服务绝对地址，
|
|
// 否则场景 JSON 404 → no-scene 黑屏。
|
|
// 特别注意：引擎 wasm 走根相对 /engine_external/?url=external:...（wasm-web.ts），
|
|
// 按面板 origin 解析会失败，且该 fetch 的 catch 是空实现（promise 永不 resolve），
|
|
// 导致 game.init 永久挂起 → no-scene 黑屏且无任何报错。必须一并改写为预览服务 origin。
|
|
const toAbs = (u) => {
|
|
if (/^[a-z][a-z0-9+.-]*:/i.test(u) || u.startsWith('//')) {
|
|
return u;
|
|
}
|
|
if (u.startsWith('/engine_external/')) {
|
|
return self.abs(u);
|
|
}
|
|
return u.startsWith('/') ? u : self.abs(u);
|
|
};
|
|
w.fetch = (input, init) => {
|
|
const raw0 = input;
|
|
const realInput = typeof raw0 === 'string' ? toAbs(raw0) : raw0;
|
|
const realStr = typeof realInput === 'string'
|
|
? realInput
|
|
: realInput instanceof URL
|
|
? realInput.href
|
|
: String((realInput && realInput.url) || '');
|
|
return raw.fetch(realInput, init)
|
|
.then((res) => {
|
|
if (inPreview(realStr) && shouldLog(realStr, res.status)) {
|
|
self.logs.push({ evt: 'sys', msg: `[预览网络] fetch ${res.status} ${realStr}` });
|
|
}
|
|
return res;
|
|
})
|
|
.catch((e) => {
|
|
// 引擎的 wasm fetch 静默吞错，这里补日志定位加载失败的真实 URL
|
|
if (inPreview(realStr) || /\/engine_external\//i.test(realStr)) {
|
|
self.logs.push({ evt: 'sys', msg: `[预览网络] fetch 失败 ${realStr}: ${String((e && e.message) || e)}` });
|
|
}
|
|
throw e;
|
|
});
|
|
};
|
|
// XHR：改写相对路径 + 记录关键请求（场景/纹理/音频等）
|
|
XMLHttpRequest.prototype.open = function (method, url, ...rest) {
|
|
const u = toAbs(String(url));
|
|
this.__yykaUrl = u;
|
|
return raw.xhrOpen.apply(this, [method, u, ...rest]);
|
|
};
|
|
XMLHttpRequest.prototype.send = function (...args) {
|
|
this.addEventListener('load', () => {
|
|
const u = this.__yykaUrl || '';
|
|
if (inPreview(u) && shouldLog(u, this.status)) {
|
|
self.logs.push({ evt: 'sys', msg: `[预览网络] XHR ${this.status} ${u}` });
|
|
}
|
|
});
|
|
this.addEventListener('error', () => {
|
|
const u = this.__yykaUrl || '';
|
|
if (inPreview(u)) {
|
|
self.logs.push({ evt: 'sys', msg: `[预览网络] XHR 失败 ${u}` });
|
|
}
|
|
});
|
|
return raw.xhrSend.apply(this, args);
|
|
};
|
|
// 引擎纹理/图片用 Image 元素加载，相对 src 同样基于 document base 解析，一并改写。
|
|
// 同时强制跨源图片带 crossOrigin='anonymous'：引擎的 download-dom-image 只在
|
|
// location.protocol !== 'file:' 时设置，面板/file:// 等跨源场景下漏设会导致
|
|
// WebGL 纹理上传失败（texSubImage2D SecurityError → 粉色贴图）。
|
|
try {
|
|
const srcDesc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src');
|
|
if (srcDesc && srcDesc.set) {
|
|
Object.defineProperty(HTMLImageElement.prototype, 'src', {
|
|
get: function () {
|
|
return srcDesc.get.call(this);
|
|
},
|
|
set: function (v) {
|
|
const nv = typeof v === 'string' ? toAbs(v) : v;
|
|
if (typeof nv === 'string' && /^https?:/i.test(nv)) {
|
|
this.crossOrigin = 'anonymous';
|
|
}
|
|
return srcDesc.set.call(this, nv);
|
|
},
|
|
configurable: true,
|
|
});
|
|
}
|
|
}
|
|
catch (_) {
|
|
/* ignore */
|
|
}
|
|
// 引擎 bundle 脚本（assets/internal/index.js、assets/main/index.js 等）由 downloadScript
|
|
// 直接设 script.src（相对路径），不经过 fetch/XHR，必须同样改写为预览服务绝对地址，
|
|
// 否则按面板 origin 解析 404 → loadBuiltinAssets 失败 → game.init 挂起 → no-scene。
|
|
try {
|
|
const scriptDesc = Object.getOwnPropertyDescriptor(HTMLScriptElement.prototype, 'src');
|
|
if (scriptDesc && scriptDesc.set) {
|
|
Object.defineProperty(HTMLScriptElement.prototype, 'src', {
|
|
get: function () {
|
|
return scriptDesc.get.call(this);
|
|
},
|
|
set: function (v) {
|
|
return scriptDesc.set.call(this, typeof v === 'string' ? toAbs(v) : v);
|
|
},
|
|
configurable: true,
|
|
});
|
|
}
|
|
}
|
|
catch (_) {
|
|
/* ignore */
|
|
}
|
|
},
|
|
/** 全量转发 console 输出（log/info/warn/error/debug）到面板日志栏。
|
|
* 必须在加载引擎脚本前安装：preview-app 的 bootstrap 是 fire-and-forget 的
|
|
* async 函数，内部每一步（Ui 构造/System.import("cc")/game.init/game.run/onStart）
|
|
* 抛错都被内层 catch 用 console.error 吞掉，而 onStart 的场景加载又在
|
|
* bootFn 返回后才跑——若转发装得太晚，场景加载失败的真实原因完全不可见。
|
|
* 引擎内部报错同样走 console.error（不触发 window.onerror）。
|
|
* 每次渲染基于 window 保存的「原始方法引用」重新包装，逻辑最新且不层层嵌套；
|
|
* 相同消息 10 秒内合并计数（如 "foo (x3)"）防每帧刷屏。 */
|
|
hookConsoleForward() {
|
|
const self = this;
|
|
const w = window;
|
|
if (!w.__yykaRawConsole) {
|
|
const o = {};
|
|
for (const m of ['log', 'info', 'warn', 'error', 'debug']) {
|
|
o[m] = console[m].bind(console);
|
|
}
|
|
w.__yykaRawConsole = o;
|
|
}
|
|
const raw = w.__yykaRawConsole;
|
|
for (const m of ['log', 'info', 'warn', 'error', 'debug']) {
|
|
console[m] = (...args) => {
|
|
const text = args
|
|
.map((a) => {
|
|
if (a instanceof Error) {
|
|
return a.stack || a.message;
|
|
}
|
|
try {
|
|
if (typeof a === 'string') {
|
|
return a;
|
|
}
|
|
const s = JSON.stringify(a);
|
|
return s === undefined ? String(a) : s;
|
|
}
|
|
catch (_) {
|
|
return String(a);
|
|
}
|
|
})
|
|
.join(' ');
|
|
const now = Date.now();
|
|
const key = `${m}|${text}`;
|
|
const last = self._consoleDedup && self._consoleDedup.get(key);
|
|
if (last && now - last.t < 10000) {
|
|
last.n++;
|
|
last.t = now;
|
|
// 已合并的消息只更新计数（数组尾元素），不再新增条目
|
|
const arr = self.logs;
|
|
for (let i = arr.length - 1; i >= 0; i--) {
|
|
const it = arr[i];
|
|
if (it && it.evt === 'console' && it.key === key) {
|
|
it.text = it.base + ` (x${last.n})`;
|
|
it.t = now;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!self._consoleDedup || self._consoleDedup.size > 3000) {
|
|
// 重渲染/长时间运行后清理去重状态，防止 Map 无限增长
|
|
self._consoleDedup = new Map();
|
|
}
|
|
self._consoleDedup.set(key, { n: 1, t: now });
|
|
self.logs.push({ evt: 'console', level: m, key, base: text, text, t: now });
|
|
}
|
|
// 上限保护：日志栏渲染性能
|
|
while (self.logs.length > 3000) {
|
|
self.logs.shift();
|
|
}
|
|
const orig = raw[m];
|
|
return orig(...args);
|
|
};
|
|
}
|
|
},
|
|
/** 加载单个外部脚本，返回 Promise（onload / onerror / 超时兜底）。 */
|
|
loadScript(src, attrs = {}) {
|
|
return new Promise((resolve, reject) => {
|
|
const s = document.createElement('script');
|
|
s.src = src;
|
|
for (const k in attrs) {
|
|
s.setAttribute(k, attrs[k]);
|
|
}
|
|
const timer = window.setTimeout(() => reject(new Error('脚本加载超时: ' + src)), 20000);
|
|
s.onload = () => {
|
|
window.clearTimeout(timer);
|
|
resolve(s);
|
|
};
|
|
s.onerror = () => {
|
|
window.clearTimeout(timer);
|
|
reject(new Error('脚本加载失败: ' + src));
|
|
};
|
|
document.head.appendChild(s);
|
|
});
|
|
},
|
|
/** 以原生 <script type="systemjs-importmap" src=...> 加载 import-map（与 docs/view.html 一致）。
|
|
* 由 SystemJS 自己 fetch 并按「map 自身 URL」解析相对目标与链式裸说明符，
|
|
* 从而保持引擎 bundle 内 q-bundled:/// 命名模块的相对 import 上下文正确。
|
|
*
|
|
* 早期实现改为「面板 fetch + 重写 + 内联注入 JSON」：手动把 ./、/起始路径绝对化，
|
|
* 破坏了 SystemJS 对 bundle 内物理/网格 loader 相对 import
|
|
* (../../../../virtual/external%253A...wasm.wasm.js) 的解析——被锁成网络
|
|
* /virtual/... (404, Error#3)，且 q-bundled:///virtual/... 虚拟模块注册上下文丢失
|
|
* (has→false)。原生 src 加载完全复刻 view.html 的工作链路。
|
|
*/
|
|
async applyImportMap(src) {
|
|
const url = this.abs(src);
|
|
const inj = document.createElement('script');
|
|
inj.type = 'systemjs-importmap';
|
|
inj.src = url;
|
|
document.head.appendChild(inj);
|
|
this.logs.push({ evt: 'sys', msg: `[预览] ${src} import-map 以原生 src 注入 (由 SystemJS 加载)` });
|
|
},
|
|
/** 面板内直接渲染游戏（无 iframe）。每一步结果写入日志栏，便于定位失败环节。 */
|
|
async renderPreview() {
|
|
const seq = (this._renderSeq = (this._renderSeq || 0) + 1); // 新渲染取代旧渲染，旧的立即停止
|
|
this.stopHostSync(); // 清理上一次渲染的定期宿主同步
|
|
// 刷新时先拆解旧游戏实例，避免音乐/计时器/主循环残留叠加
|
|
this.teardownPreview();
|
|
const url = (this.previewUrl || '').trim();
|
|
if (!url) {
|
|
this.previewRenderErr = '未配置预览地址';
|
|
return;
|
|
}
|
|
const log = (msg) => this.logs.push({ evt: 'sys', msg: `[预览] ${msg}` });
|
|
const alive = () => this._renderSeq === seq;
|
|
// 安装窗口级音频静音 hook（事件驱动、幂等），在引擎脚本加载前保证静音覆盖所有播放路径
|
|
try {
|
|
this._hookAudioCtx();
|
|
}
|
|
catch (_) { /* ignore */ }
|
|
// 版本标识：日志开头直接确认面板加载的是哪个版本，避免旧产物误判
|
|
log(`渲染 v${package_json_1.default.version}`);
|
|
// 环境诊断：确认面板 origin（file:/自定义协议决定引擎对 crossOrigin/location 的处理路径）
|
|
log(`环境 href=${window.location.href} base=${document.baseURI} proto=${window.location.protocol} ` +
|
|
`trace=${!!window.__yykaTraceInstalled} rawIo=${!!window.__yykaRawIo}`);
|
|
// 全局错误捕获：拿到完整堆栈，定位引擎初始化失败的真实模块。
|
|
// 标记放 window 上而非实例字段：插件重载/面板复用可能遗留实例 true，
|
|
// 导致新版本代码跳过安装（曾发生：v1.0.156+ 的 /engine_external/、script.src、
|
|
// crossOrigin 钩子从未生效，面板端 wasm 仍静默挂起）。
|
|
if (!window.__yykaErrHooked) {
|
|
window.__yykaErrHooked = true;
|
|
window.addEventListener('error', (ev) => {
|
|
const m = ev.error ? ev.error.stack || ev.error.message || String(ev.error) : ev.message;
|
|
this.logs.push({ evt: 'sys', msg: `[预览错误] ${m}` });
|
|
});
|
|
window.addEventListener('unhandledrejection', (ev) => {
|
|
const r = ev.reason;
|
|
this.logs.push({ evt: 'sys', msg: `[预览错误] unhandledrejection: ${r && r.stack ? r.stack : String(r)}` });
|
|
});
|
|
}
|
|
// 每次渲染强制重装最新版钩子：内部基于全局原始引用重新包装，幂等且不层层嵌套
|
|
this.hookFetchLogger();
|
|
log('网络 hook 已安装 (fetch/XHR/Image/script 路径重写 + 请求结果记录)');
|
|
// console 全量转发同样提前安装：preview-app bootstrap 内部错误走 console.error 被吞，
|
|
// 且场景加载(onStart)在 bootFn 返回后才跑，转发装晚了会漏掉失败的真实原因
|
|
this.hookConsoleForward();
|
|
log('console 转发已安装 (引擎/preview-app 输出全量可见)');
|
|
// 注入 <base href>：SystemJS 的 baseUrl 读取 document.querySelector('base[href]')，
|
|
// external:emscripten/... 虚拟 wasm 模块按 base 解析，面板 base 是 file:// 导致
|
|
// 解析到不存在的本地路径而加载失败（bt.DbvtBroadphase_new is not a function 根因），
|
|
// 改到预览服务 origin 后命中其 virtual handler
|
|
try {
|
|
let baseEl = document.querySelector('base[href]');
|
|
if (!baseEl) {
|
|
baseEl = document.createElement('base');
|
|
document.head.appendChild(baseEl);
|
|
}
|
|
baseEl.href = (this.previewUrl || 'http://localhost:7456/').trim().replace(/\/+$/, '') + '/';
|
|
log(`<base href> 已注入 (${baseEl.href})`);
|
|
}
|
|
catch (_) {
|
|
/* ignore */
|
|
}
|
|
try {
|
|
this.checkPreview(); // 快速探测在线状态（内部节流）
|
|
this.previewRenderErr = '';
|
|
this.previewLoaded = false;
|
|
log('开始加载引擎脚本…');
|
|
await this.loadScript(this.abs('/scripting/polyfills/bundle.js'));
|
|
if (!alive())
|
|
return;
|
|
log('polyfills ✓');
|
|
await this.applyImportMap('/scripting/engine/bin/.cache/dev/preview/import-map.json');
|
|
if (!alive())
|
|
return;
|
|
log('引擎 import-map ✓');
|
|
await this.applyImportMap('/scripting/x/import-map.json');
|
|
if (!alive())
|
|
return;
|
|
log('项目 import-map ✓');
|
|
await this.applyImportMap('/scripting/import-map-global');
|
|
if (!alive())
|
|
return;
|
|
log('cc import-map ✓');
|
|
// 补充映射（socket.io 等 preview-app 硬编码路径），须在 system.js 之前注入
|
|
this.injectExtraImportMap();
|
|
await this.loadScript(this.abs('/scripting/systemjs/system.js'));
|
|
if (!alive())
|
|
return;
|
|
log('systemjs ✓');
|
|
// socket.io stub：preview-app bootstrap 会 import('/socket.io/socket.io.js') 并调用 n.default()。
|
|
// 面板内跨域 + 重复渲染时 SystemJS 的全局探测不可靠（io 全局已存在则探测不到新全局，default 缺失），
|
|
// 直接在该路径注册 stub 模块，保证 n.default() 必定可用且不发起真实 socket.io 连接。
|
|
this.registerSocketIoStub();
|
|
if (!alive())
|
|
return;
|
|
// 注意：不设 System.config({baseURL})、不包装 System.import。
|
|
// 这两样是 view.html 所没有的额外编排，会干扰 engine bundle 内
|
|
// q-bundled:/// 命名模块的相对 import 解析（../../../../virtual/... 被拉起
|
|
// 成网络 /virtual/ 404、has→false）。完全复刻 view.html：只靠 <base href>。
|
|
// 分辨率细节映射（跨域 fetch，失败会反映到启动错误）
|
|
const Sys = window.System;
|
|
if (Sys && typeof Sys.setResolutionDetailMapCallback === 'function') {
|
|
Sys.setResolutionDetailMapCallback(() => {
|
|
const u = this.abs('/scripting/x/resolution-detail-map.json');
|
|
return fetch(u).then((r) => r.json()).then((json) => ({ json, url: u }));
|
|
});
|
|
}
|
|
// 分辨率细节映射已在上方 setResolutionDetailMapCallback 设置。
|
|
// 注意：view.html 不包装 System.import；这里也不做，保持与 view.html 一致的加载链路。
|
|
// 引擎 bundle 加载前置好环境（CC_EDITOR=false + EditorExtends 桩），
|
|
// 否则编辑器 Electron 窗口内 EDITOR 误判为 true 会触发 EditorExtends 崩溃
|
|
this.patchPreviewEnv();
|
|
await this.loadScript(this.abs('/scripting/engine/bin/.cache/dev/preview/bundled/index.js'));
|
|
if (!alive())
|
|
return;
|
|
log('引擎 bundle ✓');
|
|
await this.loadScript(this.abs('/settings.js?scene=current_scene'));
|
|
if (!alive())
|
|
return;
|
|
log('settings ✓');
|
|
const settings = window._CCSettings;
|
|
// 强制 SubFrame 尺寸模式：ScreenAdapter 的 _windowType 在 exactFitScreen=true
|
|
// 时走 BrowserWindow 分支，用 window.innerWidth/Height（编辑器窗口尺寸，非预览区域）
|
|
// 设置 #GameDiv 与画布 buffer，导致布局错位 + 黑屏。
|
|
// exactFitScreen=false → SubFrame → 尺寸按 #GameDiv 实际尺寸(clientWidth/Height)计算。
|
|
// 顶层字段走 _compatibleWithOldParams 转 overrideSettings，screen 字段走 settings.json。
|
|
if (settings && typeof settings === 'object') {
|
|
settings.exactFitScreen = false;
|
|
settings.screen = settings.screen || {};
|
|
settings.screen.exactFitScreen = false;
|
|
log('exactFitScreen=false (SubFrame 尺寸模式)');
|
|
}
|
|
// 引擎脚本全部就绪后，Vue 渲染必然已完成：此刻确保游戏 DOM 就位，
|
|
// 保证 Ui 构造的 document.querySelector('#GameCanvas') 必定命中
|
|
this.buildGameDom();
|
|
if (!alive())
|
|
return;
|
|
// 运行期跟踪：包装 game.run/loadWithJson/runSceneImmediate 并转发 console 错误，
|
|
// 精确定位场景加载卡点（必须在 preview-app 调用之前安装）
|
|
this.installPreviewTrace();
|
|
if (!alive())
|
|
return;
|
|
log('启动预览应用…');
|
|
try {
|
|
const mod = await window.System.import(this.abs('/preview-app/index.js') + '?__t=' + seq);
|
|
// 兼容 { bootstrap } 与 { default: { bootstrap } } 两种导出结构
|
|
const bootFn = (mod && typeof mod.bootstrap === 'function' && mod.bootstrap) ||
|
|
(mod && mod.default && typeof mod.default.bootstrap === 'function' && mod.default.bootstrap);
|
|
if (!bootFn) {
|
|
throw new Error('preview-app 未导出 bootstrap 函数，模块结构: ' + JSON.stringify(Object.keys(mod || {})));
|
|
}
|
|
if (!alive())
|
|
return;
|
|
// 双保险：无论 preview-app 以何种方式传 config 给 game.init，
|
|
// 都确保 ScreenAdapter 走 SubFrame 尺寸模式。
|
|
// querySettings 优先读 settings._override，再读 settings.json；
|
|
// settings.init 只会逐项 set overrideSettings，不会整体覆盖已有键。
|
|
const legacy = window.cc || window.cclegacy;
|
|
if (legacy && legacy.settings) {
|
|
legacy.settings._override = legacy.settings._override || {};
|
|
legacy.settings._override.screen = legacy.settings._override.screen || {};
|
|
legacy.settings._override.screen.exactFitScreen = false;
|
|
}
|
|
// devices 为 Ui 控件条强依赖（设备列表），缺了 Ui 构造会直接崩溃（设备表必须
|
|
// 包含工具栏 li 里出现的全部 data-device；漏设备抛 undefined.name）。
|
|
const _pd = this.prefDesign();
|
|
await bootFn({
|
|
engineBaseUrl: this.abs('/scripting/engine'),
|
|
settings,
|
|
devices: Object.assign({ 'Default': { name: `设计分辨率 (${_pd.w}×${_pd.h})`, width: _pd.w, height: _pd.h }, 'FullScreen': { name: '全屏', width: _pd.w, height: _pd.h }, 'WebpageFullScreen': { name: '网页全屏', width: _pd.w, height: _pd.h } }, Object.entries(DEVICE_SIZES)
|
|
.filter(([k]) => !['Default', 'FullScreen', 'WebpageFullScreen'].includes(k))
|
|
.reduce((acc, [k, v]) => {
|
|
acc[k] = { name: v.label, width: v.w, height: v.h };
|
|
return acc;
|
|
}, {})),
|
|
});
|
|
this.previewLoaded = true;
|
|
this.previewZoom = 1; // 新一次渲染从 100% 缩放开始
|
|
this.syncPreviewState(); // 同步工具条激活态
|
|
log('游戏已启动 ✓');
|
|
// 先定位并显示游戏宿主（display:none → flex），让 #GameDiv 拥有真实尺寸；
|
|
// 必须在 screenAdapter 注入的 resize 之前完成，否则 resize 时容器尺寸为 0，
|
|
// 画布 buffer 会按 0 尺寸计算（表现为 buf 远小于实际区域）。
|
|
this.syncGameHost();
|
|
// 默认按当前设备/设计分辨率等比居中显示（避免画面被拉伸成方形）。
|
|
// 需在宿主已定位、Engine resize 兜底之前应用，#GameDiv 才拿到真实容器尺寸。
|
|
this.applyDeviceViewport(this.previewDevice || 'Default');
|
|
// ===== exactFitScreen 最终兜底：直接改 ScreenAdapter 实例字段 =====
|
|
// 三层 settings 覆盖（_CCSettings / screen 字段 / _override）都依赖 preview-app
|
|
// 如何把 settings 传给 game.init 与 Settings.init 的 override 合并方式，
|
|
// 实测未生效（win 仍是编辑器窗口尺寸/dpr）。直接改实例字段最可靠：
|
|
// _windowType = _exactFitScreen ? BrowserWindow : SubFrame，
|
|
// 改 false 后触发 resize 走 SubFrame 分支按 #GameDiv 实际尺寸重算画布。
|
|
// System.import 是异步的，刷新那一刻可能还没 resolve 就开始渲染 → 画布仍是
|
|
// 浏览器窗口尺寸（比预览视口大）。这里用重试循环等到 adapter 就绪，并在每次
|
|
// 成功后重放视口，确保 SubFrame（跟随 #GameDiv 尺寸）在渲染前必然生效。
|
|
await this.forceSubFrameViewport(alive);
|
|
// 兜底注入可能把 _exactFitScreen 强制成 false（供 Default 铺满），
|
|
// 会覆盖掉上面 applyDeviceViewport 为设备模式设的 true，导致画面不按当前分辨率/缩放显示；
|
|
// 这里在注入之后按当前设备与缩放重放一次，恢复正确视口。
|
|
this.applyDeviceViewport(this.previewDevice || 'Default');
|
|
this.syncGameHost();
|
|
// 场景加载跟踪：若场景加载完成/失败，日志栏可见
|
|
try {
|
|
const legacy2 = window.cc || window.cclegacy;
|
|
const director = legacy2 && legacy2.director;
|
|
if (director && typeof director.on === 'function') {
|
|
const evt = (legacy2.Director && legacy2.Director.EVENT_AFTER_SCENE_LAUNCH) ||
|
|
'director_after_scene_launch';
|
|
director.on(evt, () => {
|
|
if (alive()) {
|
|
const sc = director.getScene && director.getScene();
|
|
log(`场景已加载: ${(sc && sc.name) || '?'}`);
|
|
// 场景激活后才重建最终画布/相机视口；此时重放视口并触发 resize，
|
|
// 让相机按 #GameDiv 最终尺寸计算 viewport（等效于用户滚轮），
|
|
// 修复刷新后相机视角跑偏。
|
|
this.applyDeviceViewport(this.previewDevice || 'Default');
|
|
this.syncGameHost();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
catch (e) {
|
|
log('场景监听注册失败: ' + String((e === null || e === void 0 ? void 0 : e.message) || e));
|
|
}
|
|
// 场景加载看门狗：无场景时周期性输出引擎状态快照，定位主循环/资源管线卡点
|
|
this.startSceneWatchdog();
|
|
// 定期同步：面板拖动/窗口移动/布局变化时 ResizeObserver 可能漏报
|
|
// （只监听尺寸不监听位置），轮询兜底保证宿主不「漂浮」
|
|
this._hostSyncTimer = window.setInterval(() => this.syncGameHost(), 300);
|
|
}
|
|
catch (err) {
|
|
const msg = String((err === null || err === void 0 ? void 0 : err.message) || err);
|
|
this.previewLoaded = false;
|
|
this.previewRenderErr = msg;
|
|
log('启动失败 ✗ ' + msg);
|
|
}
|
|
}
|
|
catch (err) {
|
|
const msg = String((err === null || err === void 0 ? void 0 : err.message) || err);
|
|
this.previewRenderErr = msg;
|
|
log('加载失败 ✗ ' + msg);
|
|
}
|
|
},
|
|
/** 运行期跟踪（必须在 preview-app 调用 game.run 之前安装）：
|
|
* 包装 game.run/onStart、pause/resume、loadWithJson、runSceneImmediate，
|
|
* 并把 console.log/info/warn/error/debug 全量转发到面板日志。场景加载黑屏时
|
|
* 可直接从日志栏定位卡点：主循环未启动（onStart 未执行）/ 场景 JSON 请求 /
|
|
* 依赖加载 / 反序列化。
|
|
* 注意：引擎 bundle 是 System.register 模块，<script> 加载只注册不执行，
|
|
* window.cc 要等 System.import(preview-app) 才就绪；因此这里轮询等待安装窗口，
|
|
* 避免漏掉 game.run/loadWithJson 的包装（preview-app 的 game.init 是异步的，
|
|
* 25ms 轮询足够赶在 game.run 之前装上）。 */
|
|
installPreviewTrace() {
|
|
if (this._traceInstalled)
|
|
return;
|
|
const self = this;
|
|
const log = (msg) => self.logs.push({ evt: 'sys', msg: `[预览跟踪] ${msg}` });
|
|
const installNow = () => {
|
|
const legacy = window.cc || window.cclegacy;
|
|
if (!legacy) {
|
|
return false;
|
|
}
|
|
self._traceInstalled = true;
|
|
const g = legacy.game;
|
|
if (g) {
|
|
const origRun = g.run && g.run.bind(g);
|
|
if (origRun) {
|
|
g.run = (onStart) => {
|
|
log('game.run 被调用');
|
|
const wrapped = () => {
|
|
log('onStart 开始（场景加载流程启动）');
|
|
try {
|
|
const r = onStart && onStart();
|
|
if (r && typeof r.then === 'function') {
|
|
r.then(() => log('onStart 完成'), (e) => log('onStart 异常: ' + String((e && (e.message || e)) || e)));
|
|
}
|
|
return r;
|
|
}
|
|
catch (e) {
|
|
log('onStart 同步异常: ' + String((e === null || e === void 0 ? void 0 : e.message) || e));
|
|
throw e;
|
|
}
|
|
};
|
|
return origRun(wrapped);
|
|
};
|
|
}
|
|
for (const m of ['pause', 'resume', 'pauseByEngine', 'resumeByEngine']) {
|
|
const orig = g[m] && g[m].bind(g);
|
|
if (!orig)
|
|
continue;
|
|
g[m] = (...args) => {
|
|
log(`game.${m}()`);
|
|
return orig(...args);
|
|
};
|
|
}
|
|
}
|
|
const am = legacy.assetManager;
|
|
if (am && am.loadWithJson) {
|
|
const orig = am.loadWithJson.bind(am);
|
|
am.loadWithJson = (json, options, onProgress, onComplete) => {
|
|
log(`loadWithJson 开始 id=${options && options.assetId}`);
|
|
const wProgress = (finished, total) => {
|
|
log(`loadWithJson 进度 ${finished}/${total}`);
|
|
if (onProgress)
|
|
onProgress(finished, total);
|
|
};
|
|
const wComplete = (err, data) => {
|
|
log(`loadWithJson 完成 err=${err ? String((err === null || err === void 0 ? void 0 : err.message) || err) : '无'} ` +
|
|
`scene=${data && data.scene ? (data.scene.name || data.scene._name) : '?'}`);
|
|
if (onComplete)
|
|
onComplete(err, data);
|
|
};
|
|
return orig(json, options, wProgress, wComplete);
|
|
};
|
|
}
|
|
const dr = legacy.director;
|
|
if (dr && dr.runSceneImmediate) {
|
|
const orig = dr.runSceneImmediate.bind(dr);
|
|
dr.runSceneImmediate = (scene, onBeforeLoadScene, onLaunched) => {
|
|
log(`runSceneImmediate 调用 scene=${scene && (scene.name || scene._name)}`);
|
|
return orig(scene, onBeforeLoadScene, onLaunched);
|
|
};
|
|
}
|
|
// console 全量转发已由 hookConsoleForward 在渲染早期安装，此处不再重复包装
|
|
log('运行期跟踪已安装 (game.run/loadWithJson/runSceneImmediate)');
|
|
return true;
|
|
};
|
|
if (installNow()) {
|
|
return;
|
|
}
|
|
// System.register 惰性执行：window.cc 尚未就绪，轮询等待（最多约 10s）
|
|
let tries = 0;
|
|
const timer = window.setInterval(() => {
|
|
tries++;
|
|
if (installNow() || tries > 400) {
|
|
window.clearInterval(timer);
|
|
}
|
|
}, 25);
|
|
},
|
|
/** 场景加载看门狗：bootFn 成功后每 2 秒检查一次 director.getScene()，
|
|
* 若长时间无场景则输出引擎状态快照（paused/pacer/assets），区分
|
|
* 「主循环未运行」与「资源管线挂起」两类卡点。重渲染时自动失效。 */
|
|
startSceneWatchdog() {
|
|
const seq = this._renderSeq;
|
|
const log = (msg) => this.logs.push({ evt: 'sys', msg: `[预览跟踪] ${msg}` });
|
|
const legacy = window.cc || window.cclegacy;
|
|
let waited = 0;
|
|
const MAX_TIMEOUT_LOG = 2; // 场景久不出现时最多提示几轮，避免定时器持续刷屏
|
|
let timeoutLogs = 0;
|
|
const timer = window.setInterval(() => {
|
|
var _a, _b, _c, _d;
|
|
if (this._renderSeq !== seq || !this.previewLoaded) {
|
|
window.clearInterval(timer);
|
|
return;
|
|
}
|
|
waited += 2;
|
|
let sc = null;
|
|
try {
|
|
sc = (_b = (_a = legacy === null || legacy === void 0 ? void 0 : legacy.director) === null || _a === void 0 ? void 0 : _a.getScene) === null || _b === void 0 ? void 0 : _b.call(_a);
|
|
}
|
|
catch (_) {
|
|
/* ignore */
|
|
}
|
|
if (sc) {
|
|
log(`场景已出现: ${sc.name || sc._name || '?'}`);
|
|
window.clearInterval(timer);
|
|
return;
|
|
}
|
|
if (waited >= 24 && timeoutLogs < MAX_TIMEOUT_LOG) {
|
|
let paused = '?';
|
|
let pacer = '?';
|
|
try {
|
|
const gg = legacy === null || legacy === void 0 ? void 0 : legacy.game;
|
|
paused = String(!!(gg && gg._paused));
|
|
pacer = gg && gg._pacer ? String(!!gg._pacer._isPlaying) : '无pacer';
|
|
}
|
|
catch (_) {
|
|
/* ignore */
|
|
}
|
|
let assets = 0;
|
|
try {
|
|
assets = ((_d = (_c = legacy === null || legacy === void 0 ? void 0 : legacy.assetManager) === null || _c === void 0 ? void 0 : _c.assets) === null || _d === void 0 ? void 0 : _d.count) || 0;
|
|
}
|
|
catch (_) {
|
|
/* ignore */
|
|
}
|
|
timeoutLogs++;
|
|
log(`场景等待超时 ${waited}s: paused=${paused} pacer=${pacer} assets=${assets}`);
|
|
if (timeoutLogs >= MAX_TIMEOUT_LOG) {
|
|
window.clearInterval(timer);
|
|
}
|
|
}
|
|
}, 2000);
|
|
},
|
|
/** 探测预览服务是否在线（no-cors 请求，跨域只判连通性，不读内容）。 */
|
|
async checkPreview() {
|
|
if (this.previewChecking) {
|
|
return;
|
|
}
|
|
// 节流：至少 3 秒探测一次
|
|
if (Date.now() - this.previewCheckAt < 3000) {
|
|
return;
|
|
}
|
|
this.previewChecking = true;
|
|
const url = (this.previewUrl || '').trim();
|
|
try {
|
|
if (!url) {
|
|
this.previewOnline = false;
|
|
return;
|
|
}
|
|
const ctl = new AbortController();
|
|
const timer = window.setTimeout(() => ctl.abort(), 6000);
|
|
await fetch(url, { method: 'GET', mode: 'no-cors', cache: 'no-store', signal: ctl.signal });
|
|
window.clearTimeout(timer);
|
|
this.previewOnline = true;
|
|
}
|
|
catch (_a) {
|
|
this.previewOnline = false;
|
|
}
|
|
finally {
|
|
this.previewCheckAt = Date.now();
|
|
this.previewChecking = false;
|
|
}
|
|
},
|
|
onResize() {
|
|
if (this.showPerf) {
|
|
this.drawPerf();
|
|
}
|
|
},
|
|
startDrag(kind, e) {
|
|
e.preventDefault();
|
|
const el = e.currentTarget;
|
|
if (el && el.setPointerCapture) {
|
|
try {
|
|
el.setPointerCapture(e.pointerId);
|
|
}
|
|
catch (_) {
|
|
/* 捕获失败也不影响 window 级监听 */
|
|
}
|
|
}
|
|
document.body.style.userSelect = 'none';
|
|
document.body.style.cursor = 'col-resize';
|
|
this.drag = {
|
|
kind,
|
|
startX: e.clientX,
|
|
startW: kind === 'left' ? this.treeWidth : this.detailWidth,
|
|
pointerId: e.pointerId,
|
|
el,
|
|
};
|
|
},
|
|
onDragMove(e) {
|
|
if (!this.drag) {
|
|
return;
|
|
}
|
|
const dx = e.clientX - this.drag.startX;
|
|
const w = this.drag.kind === 'left' ? this.drag.startW + dx : this.drag.startW - dx;
|
|
const clamped = Math.max(140, Math.min(480, w));
|
|
if (this.drag.kind === 'left') {
|
|
this.treeWidth = clamped;
|
|
}
|
|
else {
|
|
this.detailWidth = clamped;
|
|
}
|
|
},
|
|
endDrag() {
|
|
if (!this.drag) {
|
|
return;
|
|
}
|
|
if (this.drag.el && this.drag.el.hasPointerCapture && this.drag.el.hasPointerCapture(this.drag.pointerId)) {
|
|
try {
|
|
this.drag.el.releasePointerCapture(this.drag.pointerId);
|
|
}
|
|
catch (_) {
|
|
/* ignore */
|
|
}
|
|
}
|
|
document.body.style.userSelect = '';
|
|
document.body.style.cursor = '';
|
|
this.drag = null;
|
|
},
|
|
};
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preview.js","sourceRoot":"","sources":["../../../../source/panels/default/methods/preview.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-ignore\nimport packageJSON from '../../../../package.json';\n\n/**\n * 预览：地址读取/刷新/连通性探测 + 无 iframe 的 DOM 渲染 + 左右分隔条拖拽。\n *\n * 面板内直接渲染游戏（不用 iframe）的加载链路：\n *   1. 按序加载引擎脚本（<script> 标签跨域加载 JS 不受 CORS 限制）\n *   2. import-map 内的相对/绝对路径基于「面板 origin」解析会 404，\n *      因此先读取原始 map 内容，把所有路径重写为预览服务绝对 URL 后再注入\n *   3. 最终 System.import(preview-app) 与引擎内部 fetch 资源属于跨域请求，\n *      是否成功取决于预览服务器是否返回 CORS 头（实测验证点）\n */\n\n/** socket.io 最小 stub：EventEmitter 语义，满足 preview-app 的 n.on()/t.emit() 调用。\n *  不发起真实 socket.io 连接（面板 origin 与预览服务不一致，连接必然失败且无意义）。 */\nfunction socketIoStub(): any {\n    const handlers: Record<string, Function[]> = {};\n    return {\n        on(evt: string, fn: Function) {\n            (handlers[evt] = handlers[evt] || []).push(fn);\n            return this;\n        },\n        off(evt: string) {\n            delete handlers[evt];\n            return this;\n        },\n        emit(evt: string, ...args: any[]) {\n            (handlers[evt] || []).slice().forEach((fn) => fn(...args));\n            return this;\n        },\n        close() {\n            for (const k of Object.keys(handlers)) {\n                delete handlers[k];\n            }\n        },\n    };\n}\n\n/** 设备尺寸表（键与真实预览服务渲染的 data-device 完全一致）。\n *  面板内 exactFitScreen=false（SubFrame）模式下引擎画布跟随 #GameDiv 容器尺寸、\n *  忽略 screen.windowSize，因此设备切换要在前端把 #GameDiv 设成目标比例居中显示。\n *  精简集：每档只留一个代表机型，分辨率不重复；键必须能被 preview-app._devices 识别。 */\nconst DEVICE_SIZES: Record<string, { w: number; h: number; label: string }> = {\n    'Default': { w: 960, h: 640, label: '设计分辨率' },\n    'Apple iPhone 12; 13; 14; 12/13 Pro': { w: 390, h: 844, label: 'iPhone 12/13/14' },\n    'Apple iPhone 14 Pro': { w: 393, h: 852, label: 'iPhone 14 Pro' },\n    'Apple iPhone 12/13 Pro Max; 14 Plus': { w: 428, h: 926, label: 'iPhone Pro Max/14 Plus' },\n    'Apple iPhone XR; 11': { w: 414, h: 896, label: 'iPhone XR/11' },\n    'Apple iPhone X; XS; 11 Pro; 12/13 Mini': { w: 375, h: 812, label: 'iPhone X/XS' },\n    'Apple iPad 10.2': { w: 1620, h: 2160, label: 'iPad 10.2' },\n    'HUAWEI Mate 40 Pro': { w: 448, h: 924, label: 'HUAWEI Mate 40 Pro' },\n    'OPPO Reno 2': { w: 360, h: 800, label: 'OPPO Reno 2' },\n    'Xiaomi Redmi 8': { w: 360, h: 760, label: 'Xiaomi Redmi 8' },\n    'Lenovo Legion 2 Pro': { w: 360, h: 820, label: 'Lenovo Legion 2 Pro' },\n};\n\nexport default {\n    async initPreviewInfo(this: any) {\n        // 设计分辨率默认 960×640，随后用项目真实配置覆盖（Default 等比视口以此为基准）\n        this.prefDesignW = 960;\n        this.prefDesignH = 640;\n        try {\n            const [info, proj] = await Promise.all([\n                Editor.Message.request(packageJSON.name as any, 'get-preview-info' as any),\n                Editor.Message.request(packageJSON.name as any, 'get-projects-settings' as any),\n            ]);\n            if (info && info.url) {\n                this.previewUrl = info.url;\n            }\n            const d = proj && proj.designResolution;\n            if (d && Number(d.width) > 0 && Number(d.height) > 0) {\n                this.prefDesignW = Number(d.width);\n                this.prefDesignH = Number(d.height);\n            }\n        } catch {\n            // 保持默认地址/分辨率\n        }\n    },\n    /** 当前项目设计分辨率（读取失败回到 960×640）。 */\n    prefDesign(this: any) {\n        return {\n            w: Number(this.prefDesignW) > 0 ? Number(this.prefDesignW) : 960,\n            h: Number(this.prefDesignH) > 0 ? Number(this.prefDesignH) : 640,\n        };\n    },\n    /** 地址栏回车 / 点「刷新」/ 遮罩重试：重新渲染游戏画面。 */\n    onLoadPreview(this: any) {\n        this.previewLoaded = false;\n        this.previewRenderErr = '';\n        this.renderPreview();\n    },\n    // ===== 预览工具条：新版面工具条通过驱动「隐藏 H5 工具条」与引擎联动 =====\n    // 引擎 preview-app 用 document.querySelector('#view-select'/'#btn-rotate'/'#input-set-fps'/\n    // '#btn-show-fps'/'#btn-pause'/'#btn-step') 绑定事件，面板内的该工具条被 CSS 隐藏，\n    // 只作数据契约。这里用真实 DOM 事件模拟用户操作，与手点效果一致。\n    /** 设备/分辨率切换：点选隐藏 #view-select 的对应选项。 */\n    onPreviewDevice(this: any, device: string) {\n        this.previewDevice = device;\n        const el = document.querySelector('#view-select') as HTMLElement | null;\n        if (!el) return;\n        el.setAttribute('value', device);\n        const name = el.querySelector('#name') as HTMLElement | null;\n        if (name) (name as HTMLElement).textContent = device;\n        el.querySelectorAll<HTMLElement>('.options li').forEach((li) => {\n            if (li.getAttribute('data-device') === device) {\n                li.classList.add('selected');\n                li.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));\n                li.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true }));\n                li.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));\n            } else {\n                li.classList.remove('selected');\n            }\n        });\n        // 面板内 SubFrame 模式引擎画布跟随 #GameDiv 容器尺寸，设备切换需在此设容器比例，\n        // 否则 preview-app 只改 screen.windowSize 不产生视觉变化（真实 H5 才生效）。\n        this.applyDeviceViewport(device);\n    },\n    /** 设备/缩放视口：把 #GameDiv 设成 设备比例 × 缩放因子 的真实尺寸并居中。\n     *  引擎 SubFrame 模式按 #GameDiv 实际尺寸重建画布，因此画面比例与输入映射始终一致，\n     *  任意缩放比下点击都不会错位。横竖屏方向（previewRotated）交换宽高。\n     *  非尺寸映射（FullScreen/Webpage）回到铺满、不应用缩放。 */\n    applyDeviceViewport(this: any, device: string, zoom = this.previewZoom) {\n        const gd = document.getElementById('GameDiv') as HTMLElement | null;\n        if (!gd) return;\n        let d = DEVICE_SIZES[device];\n        const host = document.getElementById('yyka-game-host') as HTMLElement | null;\n        if (!d || !host) {\n            gd.style.width = '';\n            gd.style.height = '';\n            gd.style.margin = '';\n            window.dispatchEvent(new Event('resize'));\n            return;\n        }\n        if (device === 'Default') {\n            // 设计分辨率取项目真实配置（勿用固定 960×640）\n            const pd = this.prefDesign();\n            d = { w: pd.w, h: pd.h, label: '设计分辨率' };\n        }\n        let dw = d.w, dh = d.h;\n        if (this.previewRotated) {\n            dw = d.h; dh = d.w; // 竖屏 ↔ 横屏，交换宽高\n        }\n        // 预览区（.game-view）基准，等比放入该设备（zoom=1 恰好放入）。\n        // 设备模式只留 12px 外边距，外壳尽量大，让游戏窗口撑满壳内部、四角被圆角裁切成全面屏；\n        // Default 留 32px。\n        const isDev = device !== 'Default' && !!d;\n        const pad = isDev ? 12 : 32;\n        const aw = Math.max(1, host.clientWidth - pad);\n        const ah = Math.max(1, host.clientHeight - pad);\n        let w = aw, h = aw * (dh / dw);\n        if (h > ah) {\n            h = ah; w = ah * (dw / dh);\n        }\n        const z = Math.max(0.2, Math.min(8, zoom));\n        const winW = Math.max(10, w * z), winH = Math.max(10, h * z);\n        const frame = host.querySelector('.device-frame') as HTMLElement | null;\n        const isDevice = !!d && device !== 'Default';\n        if (frame) frame.classList.toggle('device', isDevice);\n        if (isDevice && frame) {\n            // 真机比例：屏幕（#GameDiv）按设备宽高比尽量放大居中；外壳跟随屏幕，\n            // 边框贴着屏幕四周一起缩放（外壳尺寸 = 屏幕 + 细边框）。\n            // 旋转（previewRotated）已在 dw/dh 交换过，因此外壳形状会随横竖屏变化。\n            const bezX = 42, bezY = 54; // 预留余量：外壳整体在预览区内缩一圈，四周露出背景，避免贴平成\"平面\"\n            const mw = host.clientWidth, mh = host.clientHeight;\n            let sw = mw - bezX, sh = sw * (dh / dw);\n            if (sh > mh - bezY) {\n                sh = mh - bezY;\n                sw = sh * (dw / dh);\n            }\n            let fw = sw * z, fh = sh * z;\n            // 缩放上限：放大时整体不超出预览视口，四周留 effPad 余地，等比收缩防溢出\n            const effPad = 12;\n            const maxW = mw - effPad, maxH = mh - effPad;\n            if (fw > maxW || fh > maxH) {\n                const r = Math.min(maxW / fw, maxH / fh);\n                fw *= r; fh *= r;\n            }\n            frame.style.width = Math.max(20, Math.round(fw)) + 'px';\n            frame.style.height = Math.max(20, Math.round(fh)) + 'px';\n            frame.style.margin = 'auto';\n            gd.style.width = '100%';\n            gd.style.height = '100%';\n            gd.style.margin = '0';\n            // 灵动岛随缩放联动：取机身短边的一定比例作为宽度，\n            // 横竖屏（短边不变）尺寸稳定，缩放大小时同步缩放（使用像素避免横屏相对放大）。\n            const iso = frame.querySelector('.dynamic-island') as HTMLElement | null;\n            if (iso) {\n                iso.style.width = Math.max(24, Math.round(Math.min(fw, fh) * 0.26)) + 'px';\n            }\n        } else {\n            // 普通/Default 视口：按设计分辨率等比居中，同样限幅不超视口并留边距。\n            // 尺寸载体用 .device-frame 外壳而非 #GameDiv：面板 CSS 对 #GameDiv 有\n            // width/height:100%!important，写在其上的内联像素不生效；若外壳保持\n            // max-content，整条链会回落成 canvas 元素固有尺寸（引擎把 canvas.width\n            // 设成 screen.windowSize = #GameDiv.clientWidth×dpr，dpr>1 时不断放大），\n            // 导致游戏窗口比视口大、被裁剪。给外壳写确定的 fit 像素后 #GameDiv=100%\n            // 跟随，尺寸完全确定，不再有 max-content 反馈放大（与设备模式同构）。\n            const effPad = 32;\n            const maxW = host.clientWidth - effPad, maxH = host.clientHeight - effPad;\n            let winW2 = w * z, winH2 = h * z;\n            if (winW2 > maxW || winH2 > maxH) {\n                const r = Math.min(maxW / winW2, maxH / winH2);\n                winW2 *= r; winH2 *= r;\n            }\n            const pxW = Math.max(20, Math.round(winW2)) + 'px';\n            const pxH = Math.max(20, Math.round(winH2)) + 'px';\n            if (frame) {\n                frame.style.width = pxW;\n                frame.style.height = pxH;\n                frame.style.margin = 'auto';\n                gd.style.width = '100%';\n                gd.style.height = '100%';\n                gd.style.margin = '0';\n            } else {\n                gd.style.width = pxW;\n                gd.style.height = pxH;\n                gd.style.margin = 'auto';\n            }\n        }\n        // 引擎画面铺满策略：设备模式精确铺满（屏幕顶满边框内缘，无内部黑边），\n        // 普通/Default 保持等比适配。screen._exactFitScreen 由 Cocos SubFrame adapter 读取。\n        try {\n            const ccw = (window as any).cc || (window as any).cclegacy;\n            const sc: any = ccw && (ccw.screen || (ccw.game && ccw.game.screen));\n            const targets: any[] = sc ? [sc, sc.screenAdapter] : [];\n            for (const t of targets) {\n                if (t && '_exactFitScreen' in t) t._exactFitScreen = !!isDevice;\n            }\n        } catch (_) {\n            /* 引擎未就绪时忽略 */\n        }\n        window.dispatchEvent(new Event('resize'));\n    },\n    /** 强制走 SubFrame 视口（画布跟随 #GameDiv 尺寸，避免用整窗尺寸生成过大的画布导致\n     *  画面比视口大/被裁剪）。批量覆盖所有已知 screenAdapter 来源，并重试等待 System 异步\n     *  模块就绪；每成功覆盖一次即重放视口 + 触发 resize 重算。 */\n    async forceSubFrameViewport(this: any, alive: () => boolean) {\n        const apply = (adapter: any) => {\n            if (adapter && '_exactFitScreen' in adapter && adapter._exactFitScreen !== false) {\n                adapter._exactFitScreen = false;\n            }\n        };\n        // 1) 同步来源：window.cc.screen 及其 screenAdapter\n        const ccw = (window as any).cc || (window as any).cclegacy;\n        if (ccw && ccw.screen) {\n            apply(ccw.screen);\n            apply(ccw.screen.screenAdapter);\n            apply(ccw.game && ccw.game.screen);\n            apply(ccw.game && ccw.game.screen.screenAdapter);\n        }\n        // 2) 异步来源：System.import 得到的真实 screenAdapter，重试直至可用或超时（刷新前返回）\n        const SysMod = (window as any).System;\n        const deadline = Date.now() + 3000;\n        while (alive() && Date.now() < deadline) {\n            let got = false;\n            if (SysMod && typeof SysMod.import === 'function') {\n                try {\n                    const saMod = await SysMod.import(\n                        'q-bundled:///fs/pal/screen-adapter/web/screen-adapter.js'\n                    );\n                    const sa = (saMod && (saMod.screenAdapter || (saMod.default && saMod.default.screenAdapter))) || null;\n                    if (sa) {\n                        apply(sa);\n                        got = true;\n                    }\n                } catch {\n                    /* 模块未就绪，继续重试 */\n                }\n            }\n            if (got) break;\n            await new Promise((r) => setTimeout(r, 120));\n        }\n        if (alive()) {\n            this.applyDeviceViewport(this.previewDevice || 'Default');\n            window.dispatchEvent(new Event('resize'));\n        }\n    },\n    onPreviewRotate(this: any) {\n        const btn = document.querySelector('#btn-rotate') as HTMLElement | null;\n        if (btn) btn.click();\n        this.previewRotated = !this.previewRotated; // 面板侧视觉指示\n        // 设备/默认视口模式下旋转后按新方向重算 #GameDiv 比例\n        if (this.previewDevice && DEVICE_SIZES[this.previewDevice]) {\n            this.applyDeviceViewport(this.previewDevice);\n        }\n        this.syncPreviewState();\n    },\n    /** 帧率上限设置：写隐藏 #input-set-fps 并派发 input/change。 */\n    onPreviewFps(this: any, val: unknown) {\n        const n = Math.max(1, Math.min(240, Number(val) || 60));\n        this.previewFps = n;\n        const inp = document.querySelector('#input-set-fps') as HTMLInputElement | null;\n        if (inp) {\n            inp.value = String(n);\n            inp.dispatchEvent(new Event('input', { bubbles: true }));\n            inp.dispatchEvent(new Event('change', { bubbles: true }));\n        }\n    },\n    /** 显示FPS开关：触发隐藏 #btn-show-fps 并回读激活态。 */\n    onPreviewShowFps(this: any) {\n        const btn = document.querySelector('#btn-show-fps') as HTMLElement | null;\n        if (btn) btn.click();\n        this.syncPreviewState();\n    },\n    /** 暂停/继续：触发隐藏 #btn-pause。 */\n    onPreviewPause(this: any) {\n        const btn = document.querySelector('#btn-pause') as HTMLElement | null;\n        if (btn) btn.click();\n        this.syncPreviewState();\n    },\n    /** 步进一帧：仅暂停态可用，触发隐藏 #btn-step。 */\n    onPreviewStep(this: any) {\n        const btn = document.querySelector('#btn-step') as HTMLElement | null;\n        if (btn) btn.click();\n    },\n    // ─────────── 窗囗级全局静音（default / 预览面板共享）───────────\n    onPreviewMute(this: any) {\n        this.previewMuted = !this.previewMuted;\n        this._applyMute();\n    },\n    /** 确保 context 有 master gain（如无则注入），并返回它。 */\n    _ensureMaster(this: any, c: any) {\n        if (!c || c.__yykaMaster) return c && c.__yykaMaster;\n        try {\n            const mg = c.createGain();\n            c.__yykaMaster = mg;\n            const list = this.__muteCtxs();\n            if (list.indexOf(c) < 0) list.push(c);\n            return mg;\n        } catch (_) { return null; }\n    },\n    /** context 采集列表（模块级，换场景/重渲染保持）。 */\n    __muteCtxs(this: any): any[] {\n        const key = '__yykaAudioCtxs';\n        const w = window as any;\n        if (!w[key]) w[key] = [];\n        return w[key];\n    },\n    /** 全局静音标志：进入静音前先把当前实例状态写进全局，供 connect 劫持读取。 */\n    __muteGlobal(this: any) {\n        const key = '__yykaGlobalMute';\n        const w = window as any;\n        return { get: () => !!w[key], set: (v: boolean) => { w[key] = v; } };\n    },\n    /** 应用静音到单个 context：master gain 实时开关（g=0 无声 / g=1 有声）。 */\n    _applyMuteToCtx(this: any, c: any, muted: boolean) {\n        try {\n            if (!c) return;\n            if (c.__yykaMaster) {\n                c.__yykaMaster.gain.value = muted ? 0 : 1;\n            } else if (c.createGain) {\n                const mg = this._ensureMaster(c);\n                if (mg) {\n                    mg.gain.value = muted ? 0 : 1;\n                    try { mg.connect(c.destination); } catch (_) { /* ignore */ }\n                }\n            }\n            if (!muted && typeof c.resume === 'function' && c.state === 'suspended') {\n                try { c.resume(); } catch (_) { /* ignore */ }\n            }\n        } catch (_) { /* ignore */ }\n    },\n    /** 应用全局静音：写标志 + 引擎音量 + 全部 context master gain + 媒体元素。无轮询。 */\n    _applyMute(this: any) {\n        const muted = !!this.previewMuted;\n        this.__muteGlobal().set(muted);\n        const lg = (window as any).cc || (window as any).cclegacy;\n        const ae = lg && (lg.AudioEngine || (lg.audio && lg.audio.AudioEngine));\n        if (ae) {\n            try {\n                if (typeof ae.setMusicVolume === 'function') ae.setMusicVolume(muted ? 0 : 1);\n                if (typeof ae.setEffectsVolume === 'function') ae.setEffectsVolume(muted ? 0 : 1);\n            } catch (_) { /* ignore */ }\n        }\n        const ctxs = this.__muteCtxs();\n        for (const c of ctxs) this._applyMuteToCtx(c, muted);\n        try {\n            document.querySelectorAll('audio, video').forEach((el: any) => {\n                try { el.muted = muted; if (muted) el.pause(); else el.play().catch(() => {}); } catch (_) { /* ignore */ }\n            });\n        } catch (_) { /* ignore */ }\n    },\n    /**\n     * 安装窗囗级音频静音 hook（事件驱动，无轮询）：\n     * 1) 包装 AudioContext 构造器：新建即挂 master 并采集；\n     * 2) 劫持 AudioNode.prototype.connect：任何节点连到 context.destination 时接进 master gain。\n     *    即使引擎复用模块级缓存的原始 context 单例，connect 时也会动态注入 master，\n     *    声音必经 master，g=0 立即无声（攻击音效瞬时哑，无需轮询）。\n     */\n    _hookAudioCtx(this: any) {\n        const w = window as any;\n        const selfRef = this;\n        const hijackConnect = (NodeCtor: any) => {\n            if (!NodeCtor || NodeCtor.__yykaConnHook) return;\n            NodeCtor.__yykaConnHook = true;\n            const orig = NodeCtor.prototype.connect;\n            NodeCtor.prototype.connect = function (dest: any, ...rest: any[]) {\n                try {\n                    const ctx = this && this.context;\n                    // master 节点自身连到输出时要放行（直连 destination），否则会把自己\n                    // 重定向到自身形成自连，音频图被破坏→永久静音（无论开关状态）。\n                    if (ctx && this === ctx.__yykaMaster) {\n                        return orig.apply(this, [dest, ...rest]);\n                    }\n                    if (ctx && ctx.destination && dest === ctx.destination) {\n                        let mg = ctx.__yykaMaster;\n                        if (!mg && ctx.createGain) {\n                            mg = ctx.createGain();\n                            ctx.__yykaMaster = mg;\n                            const list = selfRef.__muteCtxs();\n                            if (list.indexOf(ctx) < 0) list.push(ctx);\n                            try { orig.call(mg, ctx.destination); } catch (_) { /* ignore */ }\n                        }\n                        if (mg) {\n                            mg.gain.value = selfRef.__muteGlobal().get() ? 0 : 1;\n                            dest = mg;\n                        }\n                    }\n                } catch (_) { /* ignore */ }\n                return orig.apply(this, [dest, ...rest]);\n            };\n        };\n        const AudioNodeCtor = w.AudioNode;\n        if (AudioNodeCtor) { try { hijackConnect(AudioNodeCtor); } catch (_) { /* ignore */ } }\n        const wrapCtor = (Ctor: any, name: string) => {\n            if (!Ctor || Ctor.__patchYyka) return;\n            const Old = Ctor;\n            const Self = function (...a: any[]) {\n                const c = new Old(...a);\n                try {\n                    const mg = selfRef._ensureMaster(c);\n                    if (mg) { mg.connect(c.destination); mg.gain.value = selfRef.__muteGlobal().get() ? 0 : 1; }\n                } catch (_) { /* ignore */ }\n                return c;\n            };\n            (Self as any).prototype = Old.prototype;\n            (Self as any).__patchYyka = true;\n            w[name] = Self;\n        };\n        wrapCtor(w.AudioContext, 'AudioContext');\n        wrapCtor(w.webkitAudioContext, 'webkitAudioContext');\n        try {\n            const OE = document.createElement.bind(document);\n            (document as any).createElement = function (tag: string, ...rest: any[]) {\n                const el = OE(tag, ...rest);\n                const t = String(tag).toLowerCase();\n                if (t === 'audio' || t === 'video') {\n                    try { if (selfRef.__muteGlobal().get()) (el as any).muted = true; } catch (_) { /* ignore */ }\n                }\n                return el;\n            };\n        } catch (_) { /* ignore */ }\n    },\n    /** 刷新预览：重置缩放并重新渲染。 */\n    doRefreshPreview(this: any) {\n        this.previewZoom = 1;\n        this.previewLoaded = false;\n        this.previewRenderErr = '';\n        this.renderPreview();\n    },\n    /** 重渲染前拆解上一次游戏实例：停主循环、清调度器（计时器/update）、停音频、释放资源。\n     *  面板内无法像浏览器预览那样整页 reload，cc 全局是单例，旧实例若不清理，\n     *  刷新后音乐/计时器/主循环会残留叠加、不关闭面板就无法复原。\n     *  每步单独 try/catch 以防某 API 缺失/报错阻断重载流程。 */\n    teardownPreview(this: any) {\n        const lg = (window as any).cc || (window as any).cclegacy;\n        if (!lg || !lg.game) return; // 首次渲染尚无实例，跳过\n        const stop = (fn: () => void) => {\n            try {\n                fn();\n            } catch (_) {\n                /* 忽略单个清理失败 */\n            }\n        };\n        // 停主循环更新（暂停 update/游戏逻辑）\n        const g = lg.game;\n        stop(() => g.pause && g.pause());\n        stop(() => g.pauseByEngine && g.pauseByEngine());\n        // 停 director 更新\n        const dir = lg.director;\n        stop(() => dir.pause && dir.pause());\n        // 清调度器：项目用 scheduleOnce/setTimeout 等定时器\n        stop(() => {\n            const sch = dir && dir.getScheduler && dir.getScheduler();\n            sch && sch.unscheduleAll && sch.unscheduleAll();\n        });\n        // 停止音频（项目音乐/音效，AudioEngine 全局 close 停全部）\n        stop(() => {\n            const ae = lg.AudioEngine || (lg.audio && lg.audio.AudioEngine);\n            ae && ae.close && ae.close();\n        });\n        // 释放已加载资源，避免新场景复用旧资源句柄造成叠加\n        stop(() => lg.assetManager && lg.assetManager.releaseAll && lg.assetManager.releaseAll());\n    },\n    /** 从隐藏 H5 工具条回读状态，同步面板按钮激活态（loading 完整后调用一次 + 每次操作后）。 */\n    syncPreviewState(this: any) {\n        const showReady = () => {\n            const show = document.querySelector('#btn-show-fps');\n            const pause = document.querySelector('#btn-pause');\n            const step = document.querySelector('#btn-step');\n            let paused = false;\n            if (pause) paused = pause.classList.contains('checked');\n            if (!paused && step) paused = getComputedStyle(step).display !== 'none';\n            this.previewShowFps = !!(show && show.classList.contains('checked'));\n            this.previewPaused = paused;\n        };\n        // 等待 #GameCanvas 就绪后再读；宿主重建瞬间可能取到空 DOM\n        const waitFor = () => {\n            if (document.querySelector('#btn-pause')) {\n                showReady();\n            } else {\n                window.setTimeout(waitFor, 60);\n            }\n        };\n        waitFor();\n    },\n    /** 预览区滚轮缩放：调整缩放因子并重算 #GameDiv 真实尺寸（等比放大缩小，居中）。\n     *  用对称乘法步进（放大 ×1.12 / 缩小 ÷1.12）保证可逆；引擎按容器尺寸重建画布，\n     *  因此放大缩小过程输入映射始终正确，不会出现放大了点不到的情况。 */\n    onPreviewWheel(this: any, e: WheelEvent) {\n        e.preventDefault();\n        // 关键：拦截滚轮传播。否则事件还会继续传到本插件加载的编辑器 preview-app\n        // Ui（其滚轮处理器会把设计分辨率重置成默认横屏 960×640，导致竖屏变横屏）。\n        // 这里在捕获阶段阻止冒泡到内容层，保证只由我们自己的 applyDeviceViewport 控制缩放。\n        e.stopPropagation();\n        e.stopImmediatePropagation();\n        if (!document.getElementById('GameDiv')) return;\n        const zoomIn = e.deltaY < 0;\n        const step = Math.pow(1.12, zoomIn ? 1 : -1);\n        this.previewZoom = Math.min(8, Math.max(0.2, Math.round(this.previewZoom * step * 100) / 100));\n        // 仅对尺寸映射的设备/默认视口应用缩放（FullScreen/Webpage 铺满不缩放）\n        const dev = this.previewDevice || 'Default';\n        if (DEVICE_SIZES[dev]) {\n            this.applyDeviceViewport(dev);\n        }\n        // 兜底：编辑器 preview-app Ui 可能在同一次滚轮/resize 里异步把设计分辨率重置成\n        // 默认横屏（960×640）。下一帧再重放一次视口（等比 + _exactFitScreen=false），\n        // 把设备/默认设计分辨率强制拉回项目真实竖屏比例。\n        cancelAnimationFrame(this._wheelReapply);\n        this._wheelReapply = requestAnimationFrame(() => {\n            this._wheelReapply = 0;\n            const dev0 = this.previewDevice || 'Default';\n            if (DEVICE_SIZES[dev0]) this.applyDeviceViewport(dev0);\n        });\n    },\n    /** 把相对/绝对路径拼到预览服务 origin 上（面板 origin 解析会 404）。 */\n    abs(this: any, path: string): string {\n        const base = (this.previewUrl || '').trim().replace(/\\/+$/, '') || 'http://localhost:7456';\n        if (/^(https?:)?\\/\\//i.test(path) || path.startsWith('data:') || path.startsWith('blob:')) {\n            return path;\n        }\n        return base + (path.startsWith('/') ? path : '/' + path);\n    },\n    /** 游戏宿主容器：创建在顶层 document.body 上。面板内容可能渲染在 shadow DOM 中\n     *  （Cocos ui-panel 机制），Ui 构造的 document.querySelector 无法穿透 shadow root，\n     *  因此游戏 DOM 必须挂在顶层 document 上才能被找到。 */\n    ensureGameHost(this: any): HTMLElement {\n        let host = document.getElementById('yyka-game-host') as HTMLElement | null;\n        if (!host) {\n            host = document.createElement('div');\n            host.id = 'yyka-game-host';\n            // flex column：toolbar 隐藏后 content(flex:auto) 才能撑满宿主高度\n            // z-index 40：盖住面板主体内容（z-index ≤ 10），\n            // 但低于 .mcp-mask(50)/.node-picker-mask(9999)，避免遮盖面板弹层\n            host.style.cssText =\n                'position:fixed;z-index:40;overflow:hidden;background:#171717;display:none;' +\n                'flex-direction:column;align-items:stretch;';\n            document.body.appendChild(host);\n        }\n        // 滚轮缩放：游戏放大后 #GameDiv 会超出预览区，若把 wheel 绑在宿主上，\n        // 当鼠标悬停在溢出的画面区域时事件可能被子元素拦截/丢失，导致放大了缩不回来。\n        // 挂在 document（window 捕获）的捕获阶段，保证鼠标落在游戏宿主内任意元素（含溢出部分）\n        // 都能触发；且在编辑器 preview-app Ui 的任何滚轮处理器之前先执行（见 onPreviewWheel）。\n        // 用 this._docZoomBound 防重复绑定（window 常驻，host 可反复重建）。\n        if (!this._docZoomBound) {\n            this._docZoomBound = true;\n            window.addEventListener(\n                'wheel',\n                (e) => {\n                    const h = document.getElementById('yyka-game-host');\n                    if (h && (h.contains(e.target as Node) || e.target === h)) {\n                        this.onPreviewWheel(e);\n                    }\n                },\n                { capture: true, passive: false }\n            );\n        }\n        return host;\n    },\n    /** 让游戏宿主跟随面板预览区域（.game-view）的视口位置与尺寸。\n     *  getBoundingClientRect 对 shadow DOM 内元素同样返回视口坐标，配合 fixed 定位可精确覆盖。\n     *  面板被拖动/切走/弹窗遮挡时宿主必须跟随或隐藏，否则会「漂浮」在屏幕上盖住其它窗口。 */\n    syncGameHost(this: any) {\n        const host = document.getElementById('yyka-game-host');\n        if (!host) return;\n        const ref = (this.$refs.gameView as HTMLElement | null) || document.querySelector('.game-view');\n        if (!ref) return;\n        const r = ref.getBoundingClientRect();\n        const vw = window.innerWidth;\n        const vh = window.innerHeight;\n        // 尺寸为 0（v-show 隐藏）或完全移出视口（面板拖动/独立成窗）时隐藏宿主，避免漂浮遮挡\n        const offscreen = r.width <= 1 || r.height <= 1 || r.left >= vw || r.top >= vh || r.left + r.width <= 0 || r.top + r.height <= 0;\n        const display = offscreen ? 'none' : 'flex';\n        // 仅在状态变化时写样式，避免定期轮询造成无谓重排\n        if (this._hostDisplay === display && this._hostLeft === r.left && this._hostTop === r.top &&\n            this._hostW === r.width && this._hostH === r.height) {\n            return;\n        }\n        this._hostDisplay = display;\n        this._hostLeft = r.left;\n        this._hostTop = r.top;\n        this._hostW = r.width;\n        this._hostH = r.height;\n        host.style.display = display; // 与 cssText 的 flex column 布局一致\n        if (display === 'none') return;\n        host.style.left = r.left + 'px';\n        host.style.top = r.top + 'px';\n        host.style.width = r.width + 'px';\n        host.style.height = r.height + 'px';\n    },\n    /** 停止定期宿主同步（渲染被取代或面板关闭时调用）。 */\n    stopHostSync(this: any) {\n        if (this._hostSyncTimer) {\n            window.clearInterval(this._hostSyncTimer);\n            this._hostSyncTimer = 0;\n        }\n    },\n    /** 监听预览区域尺寸/显隐变化，自动同步游戏宿主位置（分隔条拖拽、窗口缩放、v-show 切换）。 */\n    observeGameHost(this: any) {\n        if (this._hostObserved) return;\n        this._hostObserved = true;\n        const ref = (this.$refs.gameView as HTMLElement | null) || document.querySelector('.game-view');\n        if (!ref || typeof ResizeObserver === 'undefined') return;\n        const ro = new ResizeObserver(() => this.syncGameHost());\n        ro.observe(ref);\n    },\n    /** 构建完整游戏 DOM（toolbar 控件条 + content/GameDiv/canvas/splash/bulletin/error），\n     *  挂载到顶层 document 的游戏宿主上，并同步定位到面板预览区域。\n     *  Ui 构造的 document.querySelector('#GameCanvas') 依赖这些元素在顶层 document 可见。 */\n    buildGameDom(this: any) {\n        const host = this.ensureGameHost();\n        host.innerHTML = '';\n        const el = (tag: string, cls = '', id = '') => {\n            const e = document.createElement(tag);\n            if (cls) e.className = cls;\n            if (id) e.id = id;\n            return e;\n        };\n        // 内联样式：等价预览模板 index.css 的关键布局（只作用于 #yyka-game-host 内部）。\n        // 缺少这些样式会导致：toolbar 裸奔显示（布局乱）、\n        // #GameDiv/#Cocos3dGameContainer/#GameCanvas 塌陷为 0 尺寸（黑屏）。\n        const style = el('style');\n        style.textContent = `\n            #yyka-game-host, #yyka-game-host * { box-sizing: border-box; -webkit-user-select: none; user-select: none; }\n            #yyka-game-host .toolbar { display: none !important; } /* 面板内不需要预览器控件条 */\n            #yyka-game-host .content {\n                flex: auto; min-height: 0;\n                display: flex; flex-direction: column;\n                align-items: center; justify-content: center; overflow: hidden;\n            }\n            #yyka-game-host .contentWrap {\n                width: 100%; height: 100%; overflow: hidden;\n                display: flex; align-items: center; justify-content: center; flex-direction: column;\n            }\n            #yyka-game-host #GameDiv,\n            #yyka-game-host #Cocos3dGameContainer,\n            #yyka-game-host #GameCanvas { width: 100%; height: 100%; }\n            #yyka-game-host #GameDiv { overflow: hidden; position: relative; }\n            #yyka-game-host .wrapper { position: relative; }\n            /* 设备外壳容器：默认只作居中包裹；选中设备时加 .device 呈现手机屏幕外观 */\n            #yyka-game-host .device-frame {\n                display: flex; align-items: center; justify-content: center; width: max-content; height: max-content;\n            }\n            /* 手机外壳（全面屏）：窄边中框 + 圆角裁剪（游戏窗口直角被圆角遮掉，呈全面屏），\n                顶部挖孔屏胶囊刘海 + 底部下巴 */\n            #yyka-game-host .device-frame.device {\n                position: relative;\n                border-radius: 18px;\n                padding: 0;\n                overflow: hidden; /* 让内部游戏窗口直角被圆角裁切 */\n                background: linear-gradient(160deg, #3a3f47 0%, #23262b 45%, #141619 100%);\n                color: #fff;\n                box-shadow:\n                    inset 0 0 0 1px rgba(255, 255, 255, 0.06),\n                    0 2px 5px rgba(0, 0, 0, 0.5),\n                    0 12px 26px rgba(0, 0, 0, 0.45),\n                    0 26px 52px rgba(0, 0, 0, 0.55);\n            }\n            /* 边框覆盖层：叠在屏幕之上（不能在 background/box-shadow 画，那些会被子元素屏幕盖住），\n                中央透明透出屏幕，四边机身色形成可见的手机边框，圆角跟随外壳 */\n            #yyka-game-host .device-frame.device::before {\n                content: \"\"; position: absolute; inset: 0; z-index: 5; pointer-events: none;\n                border: 6px solid #26292f;\n                border-radius: 16px;\n                box-shadow:\n                    inset 0 1px 0 rgba(255, 255, 255, 0.18),\n                    inset 0 -1px 0 rgba(0, 0, 0, 0.55),\n                    inset 0 0 0 1px rgba(255, 255, 255, 0.06);\n            }\n            /* 底部点亮条（叠在边框下方，像 home 键光条） */\n            #yyka-game-host .device-frame.device::after {\n                content: \"\"; position: absolute; bottom: 2px; left: 50%; transform: translateX(-50%);\n                width: 46px; height: 2px; border-radius: 2px; background: rgba(255, 255, 255, 0.16);\n                z-index: 6;\n            }\n            /* 灵动岛挖孔镜头：设备模式下覆盖在屏幕顶部中央，圆角胶囊外观。\n    尺寸用相对值（宽度取屏幕宽的一定的百分比），随外壳整体缩放同步变化，\n    避免缩放时机身放大而灵动岛保持固定像素导致“相对变小/反向”的现象。 */\n            #yyka-game-host .device-frame .dynamic-island {\n                display: none;\n                position: absolute; top: 4%; left: 50%; transform: translateX(-50%);\n                width: 26%; aspect-ratio: 4 / 1; border-radius: 999px; background: #000;\n                z-index: 6; pointer-events: none;\n                box-shadow:\n                    inset 0 0 0 1px rgba(255, 255, 255, 0.06),\n                    inset 0 0 6px rgba(255, 255, 255, 0.05),\n                    0 2px 8px rgba(0, 0, 0, 0.5);\n            }\n            #yyka-game-host .device-frame.device .dynamic-island { display: block; }\n            #yyka-game-host #splash { position: absolute; top: 0; left: 0; width: 100%; height: 100%; overflow: hidden; visibility: hidden; }\n            #yyka-game-host #bulletin { position: absolute; left: 50%; top: 50%; display: none; }\n            #yyka-game-host .error {\n                color: #fff; position: absolute; width: 70%; max-width: 960px; top: 5vh; right: 0; left: 0;\n                margin: auto; display: none; z-index: 2; background: #171717; padding: 16px;\n                border-radius: 4px; word-break: break-all;\n            }\n            #yyka-game-host canvas { background-color: transparent; outline: none; }\n        `;\n        host.appendChild(style);\n        // 预览器 UI 控件条：Ui 构造函数用 document.querySelector 强依赖这些元素，缺失即抛\n        // \"UI element xxx doesn't exist\"。显示层面由 CSS 隐藏。\n        const toolbar = el('div', 'toolbar disabled');\n        // 设备列表 data-device 与真实预览服务渲染的完全一致，preview-app 据此键应用分辨率。\n        toolbar.innerHTML = `\n            <div class=\"item\"><div id=\"view-select\" class=\"view-select-container\" value=\"Default\" tabindex=\"-1\">\n                <div class=\"view-select\"><div class=\"label\"><span id=\"name\"></span></div><i class=\"arrow-triangle\"></i></div>\n                <div class=\"options\"><ul>\n                    <li class=\"selected\" data-device=\"Default\">设计分辨率 (960X640)</li>\n                    <li class=\"\" data-device=\"FullScreen\">全屏</li>\n                    <li class=\"\" data-device=\"WebpageFullScreen\">网页全屏</li>\n                    <li class=\"separator\"></li>\n                    <li class=\"\" data-device=\"Apple iPhone 12; 13; 14; 12/13 Pro\">iPhone 12/13/14 (390X844)</li>\n                    <li class=\"\" data-device=\"Apple iPhone 14 Pro\">iPhone 14 Pro (393X852)</li>\n                    <li class=\"\" data-device=\"Apple iPhone 12/13 Pro Max; 14 Plus\">iPhone Pro Max/14 Plus (428X926)</li>\n                    <li class=\"\" data-device=\"Apple iPhone XR; 11\">iPhone XR/11 (414X896)</li>\n                    <li class=\"\" data-device=\"Apple iPhone X; XS; 11 Pro; 12/13 Mini\">iPhone X/XS (375X812)</li>\n                    <li class=\"\" data-device=\"Apple iPad 10.2\">iPad 10.2 (1620X2160)</li>\n                    <li class=\"\" data-device=\"HUAWEI Mate 40 Pro\">HUAWEI Mate 40 Pro (448X924)</li>\n                    <li class=\"\" data-device=\"OPPO Reno 2\">OPPO Reno 2 (360X800)</li>\n                    <li class=\"\" data-device=\"Xiaomi Redmi 8\">Xiaomi Redmi 8 (360X760)</li>\n                    <li class=\"\" data-device=\"Lenovo Legion 2 Pro\">Lenovo Legion 2 Pro (360X820)</li>\n                </ul></div>\n            </div></div>\n            <div class=\"item\"><button id=\"btn-rotate\" class=\"checked\">Rotate</button></div>\n            <span class=\"item\">Debug Mode:</span>\n            <div class=\"item\"><select id=\"opts-debug-mode\" value=\"INFO\">\n                <option value=\"NONE\">None</option><option value=\"VERBOSE\">Verbose</option>\n                <option value=\"INFO\">Info</option><option value=\"WARN\">Warn</option>\n                <option value=\"ERROR\">Error</option><option value=\"INFO_FOR_WEB_PAGE\">Info For Web Page</option>\n                <option value=\"WARN_FOR_WEB_PAGE\">Warn For Web Page</option>\n                <option value=\"ERROR_FOR_WEB_PAGE\">Error For Web Page</option>\n            </select></div>\n            <div class=\"item\"><button id=\"btn-show-fps\" class=\"\">Show FPS</button></div>\n            <div class=\"item\"><span>FPS:</span><input id=\"input-set-fps\" type=\"number\" value=\"60\" /></div>\n            <div id=\"step-length\"><span>Step Length: </span><input type=\"text\" value=\"1\"><span>ms</span></div>\n            <div class=\"item\"><button id=\"btn-pause\">Pause</button><button id=\"btn-step\" style=\"display:none;\">Step</button></div>`;\n        host.appendChild(toolbar);\n        const gameDiv = el('div', 'wrapper', 'GameDiv');\n        const container = el('div', '', 'Cocos3dGameContainer');\n        const canvas = el('canvas', '', 'GameCanvas');\n        canvas.tabIndex = -1;\n        container.appendChild(canvas);\n        gameDiv.appendChild(container);\n        const splash = el('div', '', 'splash');\n        const bar = el('div', 'progress-bar stripes');\n        bar.innerHTML = '<span></span>';\n        splash.appendChild(bar);\n        gameDiv.appendChild(splash);\n        const bulletin = el('div', '', 'bulletin');\n        const empty = el('div', 'inner', 'sceneIsEmpty');\n        empty.textContent = '预览场景中啥都没有，加点什么，或在编辑器中打开其它场景吧';\n        bulletin.appendChild(empty);\n        gameDiv.appendChild(bulletin);\n        const err = el('div', 'error', 'error');\n        err.appendChild(el('div', 'title')).textContent = 'Error (Please open the console to see detailed errors)';\n        err.appendChild(el('div', 'error-main'));\n        err.appendChild(el('div', 'error-stack'));\n        gameDiv.appendChild(err);\n        const frame = el('div', 'device-frame'); // 手机外壳容器：选中设备时呈现手机屏幕样式\n        frame.appendChild(gameDiv);\n        frame.appendChild(el('div', 'dynamic-island')); // 灵动岛挖孔摄像头（覆盖屏幕之上）\n        const wrap = el('div', 'contentWrap');\n        wrap.appendChild(frame);\n        const content = el('div', 'content');\n        content.appendChild(wrap);\n        host.appendChild(content);\n        // 确认 #GameCanvas 已挂载到顶层 document（Ui 构造依赖）\n        if (document.querySelector('#GameCanvas')) {\n            this.logs.push({ evt: 'sys', msg: '[预览] 游戏 DOM 就绪 (#GameCanvas 已挂载到顶层 document)' });\n        } else {\n            this.logs.push({ evt: 'sys', msg: '[预览] 警告: #GameCanvas 未挂载到顶层 document' });\n        }\n        this.syncGameHost();\n        this.observeGameHost();\n    },\n    /** 注入补充 import-map：preview-app 内部硬编码 import(\"/socket.io/socket.io.js\")，\n     *  该路径基于面板 origin 解析会 404，需映射到预览服务绝对地址。\n     *  必须在 system.js 加载前注入，SystemJS 初始化时才会收集。 */\n    injectExtraImportMap(this: any) {\n        const inj = document.createElement('script');\n        inj.type = 'systemjs-importmap';\n        inj.textContent = JSON.stringify({\n            imports: {\n                '/socket.io/socket.io.js': this.abs('/socket.io/socket.io.js'),\n            },\n        });\n        document.head.appendChild(inj);\n    },\n    /** 在 /socket.io/socket.io.js（映射后的绝对地址）注册 SystemJS stub 模块。\n     *  必须在 system.js 加载之后、System.import(preview-app) 之前调用。 */\n    registerSocketIoStub(this: any) {\n        const Sys = (window as any).System;\n        const socketUrl = this.abs('/socket.io/socket.io.js');\n        if (!Sys || typeof Sys.register !== 'function' || Sys.has(socketUrl)) {\n            return;\n        }\n        Sys.register(socketUrl, [], (_export: any) => ({\n            // 注意：execute 不得返回真值（_export 的返回值是导出的值，如 socketIoStub 函数）。\n            // SystemJS 的 doExec 对真值直接调 execPromise.then(...)，非 Promise 即抛\n            // \"execPromise.then is not a function\"；返回 undefined 走同步完成分支。\n            execute: () => {\n                _export('default', socketIoStub);\n            },\n        }));\n        this.logs.push({ evt: 'sys', msg: `[预览] socket.io stub 已注册 (${socketUrl})` });\n    },\n    /** 预览环境补齐：面板运行在编辑器 Electron 窗口内，引擎 cc/env 模块用\n     *  tryDefineGlobal('CC_EDITOR', 探测 electron process) 会把 EDITOR 误判为 true，\n     *  从而走进编辑器桥接分支并引用未定义的 EditorExtends 全局导致崩溃\n     *  （真实浏览器预览无 process，EDITOR=false 故正常）。必须在引擎 bundle 加载前\n     *  预置正确的预览标志 + EditorExtends 桩。 */\n    patchPreviewEnv(this: any) {\n        // 预置环境标志：cc/env 的 tryDefineGlobal 优先读 window 上的同名全局\n        (window as any).CC_EDITOR = false;\n        (window as any).CC_PREVIEW = true;\n        (window as any).CC_DEV = true;\n        (window as any).CC_JSB = false;\n        // EditorExtends 桩：兜住引擎中无 EDITOR 守卫的引用\n        // （如 Node._registerIfAttached 的 `if (EditorExtends.Node && ...)`），\n        // 各成员为 no-op，避免 ReferenceError/TypeError，也不产生编辑器副作用。\n        (window as any).EditorExtends = {\n            Node: { add() {}, remove() {}, getNode() { return null; }, emit() {} },\n            Component: { add() {}, remove() {}, addMenu() {}, removeMenu() {} },\n            PrefabUtils: { addPrefabInstance() {} },\n            serialize: { asAsset() { return null; } },\n            UuidUtils: { isUuid() { return false; }, decompressUuid() { return null; } },\n        };\n        this.logs.push({ evt: 'sys', msg: '[预览] 预览环境已补齐 (CC_EDITOR=false, EditorExtends stub)' });\n    },\n    /** 包装 window.fetch + XMLHttpRequest：记录预览服务(origin 匹配)请求的非 2xx 响应，\n     *  面板内看不到网络面板时的调试兜底；编辑器自身请求不受影响。\n     *  引擎 AssetManager 部分下载走 XHR，只包装 fetch 会漏掉资源加载失败。\n     *  注意：每次渲染都调用本方法重装，但基于 window 上保存的「原始引用」重新包装\n     *  （__yykaRawIo 只存一次），既保证最新版本逻辑生效，又避免层层嵌套。 */\n    hookFetchLogger(this: any) {\n        const self = this;\n        const w = window as any;\n        // 原始 IO 引用只保存一次：旧版本没有此标记时首次取「当前实现」（可能是旧包装），\n        // 功能等价；WebContents 重建后 window 全新，这里取到原生实现。\n        if (!w.__yykaRawIo) {\n            w.__yykaRawIo = {\n                fetch: w.fetch.bind(w),\n                xhrOpen: XMLHttpRequest.prototype.open,\n                xhrSend: XMLHttpRequest.prototype.send,\n            };\n        }\n        const raw = w.__yykaRawIo as {\n            fetch: typeof window.fetch;\n            xhrOpen: typeof XMLHttpRequest.prototype.open;\n            xhrSend: typeof XMLHttpRequest.prototype.send;\n        };\n        const base = (this.previewUrl || '').trim().replace(/\\/+$/, '');\n        const inPreview = (u: string) => !!base && u.indexOf(base) === 0;\n        // 只记录关键请求：非 200（失败/CORS 拦截 status=0）或 URL 含 /scene/（场景加载结果）\n        const shouldLog = (u: string, status: number) => status !== 200 || /\\/scene\\//i.test(u);\n        // 纯相对路径（无 scheme、不以 / 或 // 开头）在编辑器 document 下会解析到编辑器 origin，\n        // 而 preview-app/引擎以相对路径请求场景与资源（scene/xxx.json、assets/general/import/...）。\n        // 浏览器预览页面就在预览 origin 下所以正常；面板内必须改写成预览服务绝对地址，\n        // 否则场景 JSON 404 → no-scene 黑屏。\n        // 特别注意：引擎 wasm 走根相对 /engine_external/?url=external:...（wasm-web.ts），\n        // 按面板 origin 解析会失败，且该 fetch 的 catch 是空实现（promise 永不 resolve），\n        // 导致 game.init 永久挂起 → no-scene 黑屏且无任何报错。必须一并改写为预览服务 origin。\n        const toAbs = (u: string): string => {\n            if (/^[a-z][a-z0-9+.-]*:/i.test(u) || u.startsWith('//')) {\n                return u;\n            }\n            if (u.startsWith('/engine_external/')) {\n                return self.abs(u);\n            }\n            return u.startsWith('/') ? u : self.abs(u);\n        };\n        w.fetch = (input: RequestInfo | URL, init?: RequestInit) => {\n            const raw0 = input;\n            const realInput = typeof raw0 === 'string' ? toAbs(raw0) : raw0;\n            const realStr =\n                typeof realInput === 'string'\n                    ? realInput\n                    : realInput instanceof URL\n                        ? realInput.href\n                        : String((realInput && (realInput as any).url) || '');\n            return raw.fetch(realInput, init)\n                .then((res: Response) => {\n                    if (inPreview(realStr) && shouldLog(realStr, res.status)) {\n                        self.logs.push({ evt: 'sys', msg: `[预览网络] fetch ${res.status} ${realStr}` });\n                    }\n                    return res;\n                })\n                .catch((e: any) => {\n                    // 引擎的 wasm fetch 静默吞错，这里补日志定位加载失败的真实 URL\n                    if (inPreview(realStr) || /\\/engine_external\\//i.test(realStr)) {\n                        self.logs.push({ evt: 'sys', msg: `[预览网络] fetch 失败 ${realStr}: ${String((e && e.message) || e)}` });\n                    }\n                    throw e;\n                });\n        };\n        // XHR：改写相对路径 + 记录关键请求（场景/纹理/音频等）\n        XMLHttpRequest.prototype.open = function (this: any, method: string, url: string, ...rest: any[]) {\n            const u = toAbs(String(url));\n            this.__yykaUrl = u;\n            return raw.xhrOpen.apply(this, [method, u, ...rest] as any);\n        };\n        XMLHttpRequest.prototype.send = function (this: any, ...args: any[]) {\n            this.addEventListener('load', () => {\n                const u = this.__yykaUrl || '';\n                if (inPreview(u) && shouldLog(u, this.status)) {\n                    self.logs.push({ evt: 'sys', msg: `[预览网络] XHR ${this.status} ${u}` });\n                }\n            });\n            this.addEventListener('error', () => {\n                const u = this.__yykaUrl || '';\n                if (inPreview(u)) {\n                    self.logs.push({ evt: 'sys', msg: `[预览网络] XHR 失败 ${u}` });\n                }\n            });\n            return raw.xhrSend.apply(this, args as any);\n        };\n        // 引擎纹理/图片用 Image 元素加载，相对 src 同样基于 document base 解析，一并改写。\n        // 同时强制跨源图片带 crossOrigin='anonymous'：引擎的 download-dom-image 只在\n        // location.protocol !== 'file:' 时设置，面板/file:// 等跨源场景下漏设会导致\n        // WebGL 纹理上传失败（texSubImage2D SecurityError → 粉色贴图）。\n        try {\n            const srcDesc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src');\n            if (srcDesc && srcDesc.set) {\n                Object.defineProperty(HTMLImageElement.prototype, 'src', {\n                    get: function (this: HTMLImageElement) {\n                        return srcDesc.get!.call(this);\n                    },\n                    set: function (this: HTMLImageElement, v: string) {\n                        const nv = typeof v === 'string' ? toAbs(v) : v;\n                        if (typeof nv === 'string' && /^https?:/i.test(nv)) {\n                            this.crossOrigin = 'anonymous';\n                        }\n                        return srcDesc.set!.call(this, nv);\n                    },\n                    configurable: true,\n                });\n            }\n        } catch (_) {\n            /* ignore */\n        }\n        // 引擎 bundle 脚本（assets/internal/index.js、assets/main/index.js 等）由 downloadScript\n        // 直接设 script.src（相对路径），不经过 fetch/XHR，必须同样改写为预览服务绝对地址，\n        // 否则按面板 origin 解析 404 → loadBuiltinAssets 失败 → game.init 挂起 → no-scene。\n        try {\n            const scriptDesc = Object.getOwnPropertyDescriptor(HTMLScriptElement.prototype, 'src');\n            if (scriptDesc && scriptDesc.set) {\n                Object.defineProperty(HTMLScriptElement.prototype, 'src', {\n                    get: function (this: HTMLScriptElement) {\n                        return scriptDesc.get!.call(this);\n                    },\n                    set: function (this: HTMLScriptElement, v: string) {\n                        return scriptDesc.set!.call(this, typeof v === 'string' ? toAbs(v) : v);\n                    },\n                    configurable: true,\n                });\n            }\n        } catch (_) {\n            /* ignore */\n        }\n    },\n    /** 全量转发 console 输出（log/info/warn/error/debug）到面板日志栏。\n     *  必须在加载引擎脚本前安装：preview-app 的 bootstrap 是 fire-and-forget 的\n     *  async 函数，内部每一步（Ui 构造/System.import(\"cc\")/game.init/game.run/onStart）\n     *  抛错都被内层 catch 用 console.error 吞掉，而 onStart 的场景加载又在\n     *  bootFn 返回后才跑——若转发装得太晚，场景加载失败的真实原因完全不可见。\n     *  引擎内部报错同样走 console.error（不触发 window.onerror）。\n     *  每次渲染基于 window 保存的「原始方法引用」重新包装，逻辑最新且不层层嵌套；\n     *  相同消息 10 秒内合并计数（如 \"foo (x3)\"）防每帧刷屏。 */\n    hookConsoleForward(this: any) {\n        const self = this;\n        const w = window as any;\n        if (!w.__yykaRawConsole) {\n            const o: Record<string, (...a: any[]) => void> = {};\n            for (const m of ['log', 'info', 'warn', 'error', 'debug']) {\n                o[m] = (console as any)[m].bind(console);\n            }\n            w.__yykaRawConsole = o;\n        }\n        const raw = w.__yykaRawConsole as Record<string, (...a: any[]) => void>;\n        for (const m of ['log', 'info', 'warn', 'error', 'debug']) {\n            (console as any)[m] = (...args: any[]) => {\n                const text = args\n                    .map((a) => {\n                        if (a instanceof Error) {\n                            return a.stack || a.message;\n                        }\n                        try {\n                            if (typeof a === 'string') {\n                                return a;\n                            }\n                            const s = JSON.stringify(a);\n                            return s === undefined ? String(a) : s;\n                        } catch (_) {\n                            return String(a);\n                        }\n                    })\n                    .join(' ');\n                const now = Date.now();\n                const key = `${m}|${text}`;\n                const last = self._consoleDedup && self._consoleDedup.get(key);\n                if (last && now - last.t < 10000) {\n                    last.n++;\n                    last.t = now;\n                    // 已合并的消息只更新计数（数组尾元素），不再新增条目\n                    const arr = self.logs;\n                    for (let i = arr.length - 1; i >= 0; i--) {\n                        const it = arr[i] as any;\n                        if (it && it.evt === 'console' && it.key === key) {\n                            it.text = it.base + ` (x${last.n})`;\n                            it.t = now;\n                            break;\n                        }\n                    }\n                } else {\n                    if (!self._consoleDedup || self._consoleDedup.size > 3000) {\n                        // 重渲染/长时间运行后清理去重状态，防止 Map 无限增长\n                        self._consoleDedup = new Map();\n                    }\n                    self._consoleDedup.set(key, { n: 1, t: now });\n                    self.logs.push({ evt: 'console', level: m, key, base: text, text, t: now });\n                }\n                // 上限保护：日志栏渲染性能\n                while (self.logs.length > 3000) {\n                    self.logs.shift();\n                }\n                const orig = raw[m];\n                return orig!(...args);\n            };\n        }\n    },\n    /** 加载单个外部脚本，返回 Promise（onload / onerror / 超时兜底）。 */\n    loadScript(this: any, src: string, attrs: Record<string, string> = {}): Promise<HTMLScriptElement> {\n        return new Promise((resolve, reject) => {\n            const s = document.createElement('script');\n            s.src = src;\n            for (const k in attrs) {\n                s.setAttribute(k, attrs[k]);\n            }\n            const timer = window.setTimeout(() => reject(new Error('脚本加载超时: ' + src)), 20000);\n            s.onload = () => {\n                window.clearTimeout(timer);\n                resolve(s);\n            };\n            s.onerror = () => {\n                window.clearTimeout(timer);\n                reject(new Error('脚本加载失败: ' + src));\n            };\n            document.head.appendChild(s);\n        });\n    },\n    /** 以原生 <script type=\"systemjs-importmap\" src=...> 加载 import-map（与 docs/view.html 一致）。\n     * 由 SystemJS 自己 fetch 并按「map 自身 URL」解析相对目标与链式裸说明符，\n     * 从而保持引擎 bundle 内 q-bundled:/// 命名模块的相对 import 上下文正确。\n     *\n     * 早期实现改为「面板 fetch + 重写 + 内联注入 JSON」：手动把 ./、/起始路径绝对化，\n     * 破坏了 SystemJS 对 bundle 内物理/网格 loader 相对 import\n     * (../../../../virtual/external%253A...wasm.wasm.js) 的解析——被锁成网络\n     * /virtual/... (404, Error#3)，且 q-bundled:///virtual/... 虚拟模块注册上下文丢失\n     * (has→false)。原生 src 加载完全复刻 view.html 的工作链路。\n     */\n    async applyImportMap(this: any, src: string): Promise<void> {\n        const url = this.abs(src);\n        const inj = document.createElement('script');\n        inj.type = 'systemjs-importmap';\n        inj.src = url;\n        document.head.appendChild(inj);\n        this.logs.push({ evt: 'sys', msg: `[预览] ${src} import-map 以原生 src 注入 (由 SystemJS 加载)` });\n    },\n    /** 面板内直接渲染游戏（无 iframe）。每一步结果写入日志栏，便于定位失败环节。 */\n    async renderPreview(this: any) {\n        const seq = (this._renderSeq = (this._renderSeq || 0) + 1); // 新渲染取代旧渲染，旧的立即停止\n        this.stopHostSync(); // 清理上一次渲染的定期宿主同步\n        // 刷新时先拆解旧游戏实例，避免音乐/计时器/主循环残留叠加\n        this.teardownPreview();\n        const url = (this.previewUrl || '').trim();\n        if (!url) {\n            this.previewRenderErr = '未配置预览地址';\n            return;\n        }\n        const log = (msg: string) => this.logs.push({ evt: 'sys', msg: `[预览] ${msg}` });\n        const alive = () => this._renderSeq === seq;\n        // 安装窗口级音频静音 hook（事件驱动、幂等），在引擎脚本加载前保证静音覆盖所有播放路径\n        try {\n            this._hookAudioCtx();\n        } catch (_) { /* ignore */ }\n        // 版本标识：日志开头直接确认面板加载的是哪个版本，避免旧产物误判\n        log(`渲染 v${packageJSON.version}`);\n        // 环境诊断：确认面板 origin（file:/自定义协议决定引擎对 crossOrigin/location 的处理路径）\n        log(\n            `环境 href=${window.location.href} base=${document.baseURI} proto=${window.location.protocol} ` +\n            `trace=${!!(window as any).__yykaTraceInstalled} rawIo=${!!(window as any).__yykaRawIo}`\n        );\n        // 全局错误捕获：拿到完整堆栈，定位引擎初始化失败的真实模块。\n        // 标记放 window 上而非实例字段：插件重载/面板复用可能遗留实例 true，\n        // 导致新版本代码跳过安装（曾发生：v1.0.156+ 的 /engine_external/、script.src、\n        // crossOrigin 钩子从未生效，面板端 wasm 仍静默挂起）。\n        if (!(window as any).__yykaErrHooked) {\n            (window as any).__yykaErrHooked = true;\n            window.addEventListener('error', (ev: ErrorEvent) => {\n                const m = ev.error ? ev.error.stack || ev.error.message || String(ev.error) : ev.message;\n                this.logs.push({ evt: 'sys', msg: `[预览错误] ${m}` });\n            });\n            window.addEventListener('unhandledrejection', (ev: PromiseRejectionEvent) => {\n                const r = ev.reason;\n                this.logs.push({ evt: 'sys', msg: `[预览错误] unhandledrejection: ${r && r.stack ? r.stack : String(r)}` });\n            });\n        }\n        // 每次渲染强制重装最新版钩子：内部基于全局原始引用重新包装，幂等且不层层嵌套\n        this.hookFetchLogger();\n        log('网络 hook 已安装 (fetch/XHR/Image/script 路径重写 + 请求结果记录)');\n        // console 全量转发同样提前安装：preview-app bootstrap 内部错误走 console.error 被吞，\n        // 且场景加载(onStart)在 bootFn 返回后才跑，转发装晚了会漏掉失败的真实原因\n        this.hookConsoleForward();\n        log('console 转发已安装 (引擎/preview-app 输出全量可见)');\n        // 注入 <base href>：SystemJS 的 baseUrl 读取 document.querySelector('base[href]')，\n        // external:emscripten/... 虚拟 wasm 模块按 base 解析，面板 base 是 file:// 导致\n        // 解析到不存在的本地路径而加载失败（bt.DbvtBroadphase_new is not a function 根因），\n        // 改到预览服务 origin 后命中其 virtual handler\n        try {\n            let baseEl = document.querySelector('base[href]') as HTMLBaseElement | null;\n            if (!baseEl) {\n                baseEl = document.createElement('base');\n                document.head.appendChild(baseEl);\n            }\n            baseEl.href = (this.previewUrl || 'http://localhost:7456/').trim().replace(/\\/+$/, '') + '/';\n            log(`<base href> 已注入 (${baseEl.href})`);\n        } catch (_) {\n            /* ignore */\n        }\n        try {\n            this.checkPreview(); // 快速探测在线状态（内部节流）\n            this.previewRenderErr = '';\n            this.previewLoaded = false;\n            log('开始加载引擎脚本…');\n\n            await this.loadScript(this.abs('/scripting/polyfills/bundle.js'));\n            if (!alive()) return;\n            log('polyfills ✓');\n            await this.applyImportMap('/scripting/engine/bin/.cache/dev/preview/import-map.json');\n            if (!alive()) return;\n            log('引擎 import-map ✓');\n            await this.applyImportMap('/scripting/x/import-map.json');\n            if (!alive()) return;\n            log('项目 import-map ✓');\n            await this.applyImportMap('/scripting/import-map-global');\n            if (!alive()) return;\n            log('cc import-map ✓');\n            // 补充映射（socket.io 等 preview-app 硬编码路径），须在 system.js 之前注入\n            this.injectExtraImportMap();\n            await this.loadScript(this.abs('/scripting/systemjs/system.js'));\n            if (!alive()) return;\n            log('systemjs ✓');\n            // socket.io stub：preview-app bootstrap 会 import('/socket.io/socket.io.js') 并调用 n.default()。\n            // 面板内跨域 + 重复渲染时 SystemJS 的全局探测不可靠（io 全局已存在则探测不到新全局，default 缺失），\n            // 直接在该路径注册 stub 模块，保证 n.default() 必定可用且不发起真实 socket.io 连接。\n            this.registerSocketIoStub();\n            if (!alive()) return;\n\n            // 注意：不设 System.config({baseURL})、不包装 System.import。\n            // 这两样是 view.html 所没有的额外编排，会干扰 engine bundle 内\n            // q-bundled:/// 命名模块的相对 import 解析（../../../../virtual/... 被拉起\n            // 成网络 /virtual/ 404、has→false）。完全复刻 view.html：只靠 <base href>。\n            // 分辨率细节映射（跨域 fetch，失败会反映到启动错误）\n            const Sys = (window as any).System;\n            if (Sys && typeof Sys.setResolutionDetailMapCallback === 'function') {\n                Sys.setResolutionDetailMapCallback(() => {\n                    const u = this.abs('/scripting/x/resolution-detail-map.json');\n                    return fetch(u).then((r) => r.json()).then((json) => ({ json, url: u }));\n                });\n            }\n            // 分辨率细节映射已在上方 setResolutionDetailMapCallback 设置。\n            // 注意：view.html 不包装 System.import；这里也不做，保持与 view.html 一致的加载链路。\n            // 引擎 bundle 加载前置好环境（CC_EDITOR=false + EditorExtends 桩），\n            // 否则编辑器 Electron 窗口内 EDITOR 误判为 true 会触发 EditorExtends 崩溃\n            this.patchPreviewEnv();\n            await this.loadScript(this.abs('/scripting/engine/bin/.cache/dev/preview/bundled/index.js'));\n            if (!alive()) return;\n            log('引擎 bundle ✓');\n            await this.loadScript(this.abs('/settings.js?scene=current_scene'));\n            if (!alive()) return;\n            log('settings ✓');\n\n            const settings = (window as any)._CCSettings;\n            // 强制 SubFrame 尺寸模式：ScreenAdapter 的 _windowType 在 exactFitScreen=true\n            // 时走 BrowserWindow 分支，用 window.innerWidth/Height（编辑器窗口尺寸，非预览区域）\n            // 设置 #GameDiv 与画布 buffer，导致布局错位 + 黑屏。\n            // exactFitScreen=false → SubFrame → 尺寸按 #GameDiv 实际尺寸(clientWidth/Height)计算。\n            // 顶层字段走 _compatibleWithOldParams 转 overrideSettings，screen 字段走 settings.json。\n            if (settings && typeof settings === 'object') {\n                settings.exactFitScreen = false;\n                settings.screen = settings.screen || {};\n                settings.screen.exactFitScreen = false;\n                log('exactFitScreen=false (SubFrame 尺寸模式)');\n            }\n            // 引擎脚本全部就绪后，Vue 渲染必然已完成：此刻确保游戏 DOM 就位，\n            // 保证 Ui 构造的 document.querySelector('#GameCanvas') 必定命中\n            this.buildGameDom();\n            if (!alive()) return;\n            // 运行期跟踪：包装 game.run/loadWithJson/runSceneImmediate 并转发 console 错误，\n            // 精确定位场景加载卡点（必须在 preview-app 调用之前安装）\n            this.installPreviewTrace();\n            if (!alive()) return;\n            log('启动预览应用…');\n            try {\n                const mod = await (window as any).System.import(this.abs('/preview-app/index.js') + '?__t=' + seq);\n                // 兼容 { bootstrap } 与 { default: { bootstrap } } 两种导出结构\n                const bootFn =\n                    (mod && typeof mod.bootstrap === 'function' && mod.bootstrap) ||\n                    (mod && mod.default && typeof mod.default.bootstrap === 'function' && mod.default.bootstrap);\n                if (!bootFn) {\n                    throw new Error('preview-app 未导出 bootstrap 函数，模块结构: ' + JSON.stringify(Object.keys(mod || {})));\n                }\n                if (!alive()) return;\n                // 双保险：无论 preview-app 以何种方式传 config 给 game.init，\n                // 都确保 ScreenAdapter 走 SubFrame 尺寸模式。\n                // querySettings 优先读 settings._override，再读 settings.json；\n                // settings.init 只会逐项 set overrideSettings，不会整体覆盖已有键。\n                const legacy = (window as any).cc || (window as any).cclegacy;\n                if (legacy && legacy.settings) {\n                    legacy.settings._override = legacy.settings._override || {};\n                    legacy.settings._override.screen = legacy.settings._override.screen || {};\n                    legacy.settings._override.screen.exactFitScreen = false;\n                }\n                // devices 为 Ui 控件条强依赖（设备列表），缺了 Ui 构造会直接崩溃（设备表必须\n                // 包含工具栏 li 里出现的全部 data-device；漏设备抛 undefined.name）。\n                const _pd = this.prefDesign();\n                await bootFn({\n                    engineBaseUrl: this.abs('/scripting/engine'),\n                    settings,\n                    devices: {\n                        'Default': { name: `设计分辨率 (${_pd.w}×${_pd.h})`, width: _pd.w, height: _pd.h },\n                        'FullScreen': { name: '全屏', width: _pd.w, height: _pd.h },\n                        'WebpageFullScreen': { name: '网页全屏', width: _pd.w, height: _pd.h },\n                        ...Object.entries(DEVICE_SIZES as Record<string, { w: number; h: number; label: string }>)\n                            .filter(([k]) => !['Default', 'FullScreen', 'WebpageFullScreen'].includes(k))\n                            .reduce((acc, [k, v]) => {\n                                acc[k] = { name: v.label, width: v.w, height: v.h };\n                                return acc;\n                            }, {} as Record<string, { name: string; width: number; height: number }>),\n                    },\n                });\n                this.previewLoaded = true;\n                this.previewZoom = 1; // 新一次渲染从 100% 缩放开始\n                this.syncPreviewState(); // 同步工具条激活态\n                log('游戏已启动 ✓');\n                // 先定位并显示游戏宿主（display:none → flex），让 #GameDiv 拥有真实尺寸；\n                // 必须在 screenAdapter 注入的 resize 之前完成，否则 resize 时容器尺寸为 0，\n                // 画布 buffer 会按 0 尺寸计算（表现为 buf 远小于实际区域）。\n                this.syncGameHost();\n                // 默认按当前设备/设计分辨率等比居中显示（避免画面被拉伸成方形）。\n                // 需在宿主已定位、Engine resize 兜底之前应用，#GameDiv 才拿到真实容器尺寸。\n                this.applyDeviceViewport(this.previewDevice || 'Default');\n                // ===== exactFitScreen 最终兜底：直接改 ScreenAdapter 实例字段 =====\n                // 三层 settings 覆盖（_CCSettings / screen 字段 / _override）都依赖 preview-app\n                // 如何把 settings 传给 game.init 与 Settings.init 的 override 合并方式，\n                // 实测未生效（win 仍是编辑器窗口尺寸/dpr）。直接改实例字段最可靠：\n                // _windowType = _exactFitScreen ? BrowserWindow : SubFrame，\n                // 改 false 后触发 resize 走 SubFrame 分支按 #GameDiv 实际尺寸重算画布。\n                // System.import 是异步的，刷新那一刻可能还没 resolve 就开始渲染 → 画布仍是\n                // 浏览器窗口尺寸（比预览视口大）。这里用重试循环等到 adapter 就绪，并在每次\n                // 成功后重放视口，确保 SubFrame（跟随 #GameDiv 尺寸）在渲染前必然生效。\n                await this.forceSubFrameViewport(alive);\n                // 兜底注入可能把 _exactFitScreen 强制成 false（供 Default 铺满），\n                // 会覆盖掉上面 applyDeviceViewport 为设备模式设的 true，导致画面不按当前分辨率/缩放显示；\n                // 这里在注入之后按当前设备与缩放重放一次，恢复正确视口。\n                this.applyDeviceViewport(this.previewDevice || 'Default');\n                this.syncGameHost();\n                // 场景加载跟踪：若场景加载完成/失败，日志栏可见\n                try {\n                    const legacy2 = (window as any).cc || (window as any).cclegacy;\n                    const director = legacy2 && legacy2.director;\n                    if (director && typeof director.on === 'function') {\n                        const evt =\n                            (legacy2.Director && legacy2.Director.EVENT_AFTER_SCENE_LAUNCH) ||\n                            'director_after_scene_launch';\n                        director.on(evt, () => {\n                            if (alive()) {\n                                const sc = director.getScene && director.getScene();\n                                log(`场景已加载: ${(sc && sc.name) || '?'}`);\n                                // 场景激活后才重建最终画布/相机视口；此时重放视口并触发 resize，\n                                // 让相机按 #GameDiv 最终尺寸计算 viewport（等效于用户滚轮），\n                                // 修复刷新后相机视角跑偏。\n                                this.applyDeviceViewport(this.previewDevice || 'Default');\n                                this.syncGameHost();\n                            }\n                        });\n                    }\n                } catch (e) {\n                    log('场景监听注册失败: ' + String((e as Error)?.message || e));\n                }\n                // 场景加载看门狗：无场景时周期性输出引擎状态快照，定位主循环/资源管线卡点\n                this.startSceneWatchdog();\n                // 定期同步：面板拖动/窗口移动/布局变化时 ResizeObserver 可能漏报\n                // （只监听尺寸不监听位置），轮询兜底保证宿主不「漂浮」\n                this._hostSyncTimer = window.setInterval(() => this.syncGameHost(), 300);\n            } catch (err) {\n                const msg = String((err as Error)?.message || err);\n                this.previewLoaded = false;\n                this.previewRenderErr = msg;\n                log('启动失败 ✗ ' + msg);\n            }\n        } catch (err) {\n            const msg = String((err as Error)?.message || err);\n            this.previewRenderErr = msg;\n            log('加载失败 ✗ ' + msg);\n        }\n    },\n    /** 运行期跟踪（必须在 preview-app 调用 game.run 之前安装）：\n     *  包装 game.run/onStart、pause/resume、loadWithJson、runSceneImmediate，\n     *  并把 console.log/info/warn/error/debug 全量转发到面板日志。场景加载黑屏时\n     *  可直接从日志栏定位卡点：主循环未启动（onStart 未执行）/ 场景 JSON 请求 /\n     *  依赖加载 / 反序列化。\n     *  注意：引擎 bundle 是 System.register 模块，<script> 加载只注册不执行，\n     *  window.cc 要等 System.import(preview-app) 才就绪；因此这里轮询等待安装窗口，\n     *  避免漏掉 game.run/loadWithJson 的包装（preview-app 的 game.init 是异步的，\n     *  25ms 轮询足够赶在 game.run 之前装上）。 */\n    installPreviewTrace(this: any) {\n        if (this._traceInstalled) return;\n        const self = this;\n        const log = (msg: string) => self.logs.push({ evt: 'sys', msg: `[预览跟踪] ${msg}` });\n        const installNow = (): boolean => {\n            const legacy = (window as any).cc || (window as any).cclegacy;\n            if (!legacy) {\n                return false;\n            }\n            self._traceInstalled = true;\n        const g = legacy.game;\n        if (g) {\n            const origRun = g.run && g.run.bind(g);\n            if (origRun) {\n                g.run = (onStart?: Function) => {\n                    log('game.run 被调用');\n                    const wrapped = () => {\n                        log('onStart 开始（场景加载流程启动）');\n                        try {\n                            const r = onStart && onStart();\n                            if (r && typeof (r as any).then === 'function') {\n                                (r as any).then(\n                                    () => log('onStart 完成'),\n                                    (e: any) => log('onStart 异常: ' + String((e && (e.message || e)) || e))\n                                );\n                            }\n                            return r;\n                        } catch (e) {\n                            log('onStart 同步异常: ' + String((e as Error)?.message || e));\n                            throw e;\n                        }\n                    };\n                    return origRun(wrapped);\n                };\n            }\n            for (const m of ['pause', 'resume', 'pauseByEngine', 'resumeByEngine']) {\n                const orig = g[m] && g[m].bind(g);\n                if (!orig) continue;\n                g[m] = (...args: any[]) => {\n                    log(`game.${m}()`);\n                    return orig(...args);\n                };\n            }\n        }\n        const am = legacy.assetManager;\n        if (am && am.loadWithJson) {\n            const orig = am.loadWithJson.bind(am);\n            am.loadWithJson = (json: any, options: any, onProgress?: Function, onComplete?: Function) => {\n                log(`loadWithJson 开始 id=${options && options.assetId}`);\n                const wProgress = (finished: number, total: number) => {\n                    log(`loadWithJson 进度 ${finished}/${total}`);\n                    if (onProgress) onProgress(finished, total);\n                };\n                const wComplete = (err: any, data: any) => {\n                    log(\n                        `loadWithJson 完成 err=${err ? String((err as Error)?.message || err) : '无'} ` +\n                        `scene=${data && data.scene ? (data.scene.name || data.scene._name) : '?'}`\n                    );\n                    if (onComplete) onComplete(err, data);\n                };\n                return orig(json, options, wProgress, wComplete);\n            };\n        }\n        const dr = legacy.director;\n        if (dr && dr.runSceneImmediate) {\n            const orig = dr.runSceneImmediate.bind(dr);\n            dr.runSceneImmediate = (scene: any, onBeforeLoadScene?: Function, onLaunched?: Function) => {\n                log(`runSceneImmediate 调用 scene=${scene && (scene.name || scene._name)}`);\n                return orig(scene, onBeforeLoadScene, onLaunched);\n            };\n        }\n        // console 全量转发已由 hookConsoleForward 在渲染早期安装，此处不再重复包装\n            log('运行期跟踪已安装 (game.run/loadWithJson/runSceneImmediate)');\n            return true;\n        };\n        if (installNow()) {\n            return;\n        }\n        // System.register 惰性执行：window.cc 尚未就绪，轮询等待（最多约 10s）\n        let tries = 0;\n        const timer = window.setInterval(() => {\n            tries++;\n            if (installNow() || tries > 400) {\n                window.clearInterval(timer);\n            }\n        }, 25);\n    },\n    /** 场景加载看门狗：bootFn 成功后每 2 秒检查一次 director.getScene()，\n     *  若长时间无场景则输出引擎状态快照（paused/pacer/assets），区分\n     *  「主循环未运行」与「资源管线挂起」两类卡点。重渲染时自动失效。 */\n    startSceneWatchdog(this: any) {\n        const seq = this._renderSeq;\n        const log = (msg: string) => this.logs.push({ evt: 'sys', msg: `[预览跟踪] ${msg}` });\n        const legacy = (window as any).cc || (window as any).cclegacy;\n        let waited = 0;\n        const MAX_TIMEOUT_LOG = 2; // 场景久不出现时最多提示几轮，避免定时器持续刷屏\n        let timeoutLogs = 0;\n        const timer = window.setInterval(() => {\n            if (this._renderSeq !== seq || !this.previewLoaded) {\n                window.clearInterval(timer);\n                return;\n            }\n            waited += 2;\n            let sc: any = null;\n            try {\n                sc = legacy?.director?.getScene?.();\n            } catch (_) {\n                /* ignore */\n            }\n            if (sc) {\n                log(`场景已出现: ${sc.name || sc._name || '?'}`);\n                window.clearInterval(timer);\n                return;\n            }\n            if (waited >= 24 && timeoutLogs < MAX_TIMEOUT_LOG) {\n                let paused = '?';\n                let pacer = '?';\n                try {\n                    const gg = legacy?.game;\n                    paused = String(!!(gg && gg._paused));\n                    pacer = gg && gg._pacer ? String(!!gg._pacer._isPlaying) : '无pacer';\n                } catch (_) {\n                    /* ignore */\n                }\n                let assets = 0;\n                try {\n                    assets = legacy?.assetManager?.assets?.count || 0;\n                } catch (_) {\n                    /* ignore */\n                }\n                timeoutLogs++;\n                log(`场景等待超时 ${waited}s: paused=${paused} pacer=${pacer} assets=${assets}`);\n                if (timeoutLogs >= MAX_TIMEOUT_LOG) {\n                    window.clearInterval(timer);\n                }\n            }\n        }, 2000);\n    },\n    /** 探测预览服务是否在线（no-cors 请求，跨域只判连通性，不读内容）。 */\n    async checkPreview(this: any) {\n        if (this.previewChecking) {\n            return;\n        }\n        // 节流：至少 3 秒探测一次\n        if (Date.now() - this.previewCheckAt < 3000) {\n            return;\n        }\n        this.previewChecking = true;\n        const url = (this.previewUrl || '').trim();\n        try {\n            if (!url) {\n                this.previewOnline = false;\n                return;\n            }\n            const ctl = new AbortController();\n            const timer = window.setTimeout(() => ctl.abort(), 6000);\n            await fetch(url, { method: 'GET', mode: 'no-cors', cache: 'no-store', signal: ctl.signal });\n            window.clearTimeout(timer);\n            this.previewOnline = true;\n        } catch {\n            this.previewOnline = false;\n        } finally {\n            this.previewCheckAt = Date.now();\n            this.previewChecking = false;\n        }\n    },\n    onResize(this: any) {\n        if (this.showPerf) {\n            this.drawPerf();\n        }\n    },\n    startDrag(this: any, kind: 'left' | 'right', e: PointerEvent) {\n        e.preventDefault();\n        const el = e.currentTarget as HTMLElement | null;\n        if (el && el.setPointerCapture) {\n            try {\n                el.setPointerCapture(e.pointerId);\n            } catch (_) {\n                /* 捕获失败也不影响 window 级监听 */\n            }\n        }\n        document.body.style.userSelect = 'none';\n        document.body.style.cursor = 'col-resize';\n        this.drag = {\n            kind,\n            startX: e.clientX,\n            startW: kind === 'left' ? this.treeWidth : this.detailWidth,\n            pointerId: e.pointerId,\n            el,\n        };\n    },\n    onDragMove(this: any, e: PointerEvent) {\n        if (!this.drag) {\n            return;\n        }\n        const dx = e.clientX - this.drag.startX;\n        const w = this.drag.kind === 'left' ? this.drag.startW + dx : this.drag.startW - dx;\n        const clamped = Math.max(140, Math.min(480, w));\n        if (this.drag.kind === 'left') {\n            this.treeWidth = clamped;\n        } else {\n            this.detailWidth = clamped;\n        }\n    },\n    endDrag(this: any) {\n        if (!this.drag) {\n            return;\n        }\n        if (this.drag.el && this.drag.el.hasPointerCapture && this.drag.el.hasPointerCapture(this.drag.pointerId)) {\n            try {\n                this.drag.el.releasePointerCapture(this.drag.pointerId);\n            } catch (_) {\n                /* ignore */\n            }\n        }\n        document.body.style.userSelect = '';\n        document.body.style.cursor = '';\n        this.drag = null;\n    },\n};\n"]}
|