cardbuddy 0.6.0

package/dist/vendored/runtime/event-model.js

@@ -0,0 +1,300 @@
+/**
+ * 事件编辑模型：对齐线上编辑器「事件」页签，节点持有 eventactions（触发事件 + 动作），
+ * 动作参数由 action-meta.json 声明，直接复用 Property/PropTree/PropControl 渲染回写机制。
+ * 三条纪律（与 NodeEditModel 一致）：①回填保真（孤儿项原样留存）②不污染 DSL（仅
+ * itemRequired / schema 原有 / 改过值的项写回）③顺序即身份（eventactions 整表按下标导出）。
+ */
+
+import Property from './property.js';
+import ACTION_META from '../meta/action-meta.json';
+import { getComponentMeta } from './node-model.js';
+
+let __seq = 0;
+const uid = (p) => `${p}_${(++__seq).toString(36)}`;
+const clone = (v) => (v === undefined ? v : JSON.parse(JSON.stringify(v)));
+
+/** 「就绪类」生命周期事件：与 RenderTree.LIFECYCLE_KEYS 保持一致 */
+export const LIFECYCLE_KEYS = new Set(['', 'onReady', 'onLoad', 'onCreate']);
+export const isLifecycleKey = (k) => LIFECYCLE_KEYS.has(k || '');
+
+export const LIFECYCLE_EVENTS = ACTION_META.lifecycleEvents || [];
+export const ACTION_LIST = ACTION_META.actions || [];
+export const ACTION_MAP = ACTION_LIST.reduce((m, a) => {
+  m[a.actionType] = a;
+  return m;
+}, {});
+
+export const actionNameOf = (t) => (ACTION_MAP[t] && ACTION_MAP[t].actionName) || t || '未选择';
+
+/** 收集 schema 中存在、但 meta 模型里没有对应项的参数（按 itemId / itemKey 判定） */
+function orphans(schemaItems, modelProps) {
+  const known = new Set();
+  (modelProps || []).forEach((p) => {
+    if (p.itemId) known.add(p.itemId);
+    if (p.itemKey) known.add(p.itemKey);
+  });
+  return (schemaItems || [])
+    .filter((s) => s && s.itemId && !known.has(s.itemId) && !(s.itemKey && known.has(s.itemKey)))
+    .map((s) => clone(s));
+}
+
+/** event / action 上除已知键之外的杂项，原样留存，导出时合并回去 */
+function rest(obj, keys) {
+  const out = {};
+  Object.keys(obj || {}).forEach((k) => {
+    if (keys.indexOf(k) < 0) out[k] = clone(obj[k]);
+  });
+  return out;
+}
+
+/* ------------------------------ 单条事件动作 ----------------------------- */
+
+export class EventActionRow {
+  constructor(schemaEA = {}) {
+    const ev = schemaEA.event || {};
+    const ac = schemaEA.action || {};
+
+    this.uid = uid('ea');
+    this.eventKey = ev.eventKey || '';
+    this.eventName = ev.eventName || '';
+    this.actionType = ac.actionType || '';
+
+    this._extraEvent = rest(ev, ['eventKey', 'eventName']);
+    this._extraAction = rest(ac, ['actionType', 'properties']);
+
+    this.properties = [];
+    this.extraProperties = [];
+    this.buildProps(ac.properties || []);
+  }
+
+  /** 按当前 actionType 从 meta 造参数树，再用 schema 项覆盖 */
+  buildProps(schemaProps = []) {
+    const metaProps = (ACTION_MAP[this.actionType] || {}).properties || [];
+    this.properties = metaProps.map((m) => {
+      const p = new Property(m);
+      // Property 只搬运它认识的字段，itemRequired 需要手工带上
+      p.itemRequired = !!m.itemRequired;
+      return p;
+    });
+    Property.restoreProperty(schemaProps, this.properties);
+    Property.updatePropertyVisible(this.properties);
+    this.extraProperties = orphans(schemaProps, this.properties);
+    // 动作类型换了以后，编辑器要重建 CodeJar 等托管 DOM 的控件
+    this.formKey = uid('form');
+  }
+
+  /** 该参数当前是否仍是「未填」状态（空值或与默认值相同） */
+  isPristine(p) {
+    const v = p.itemValue;
+    if (v === '' || v === null || v === undefined) return true;
+    try {
+      return JSON.stringify(v) === JSON.stringify(p.itemDefaultValue);
+    } catch (e) {
+      return v === p.itemDefaultValue;
+    }
+  }
+
+  /** 是否配置了有效内容（用于列表摘要） */
+  get summary() {
+    if (this.actionType === 'customAction') {
+      const fn = this.properties.find((p) => p.itemKey === 'function');
+      const code = fn && fn.itemValue && typeof fn.itemValue === 'object' ? fn.itemValue.code || '' : '';
+      if (!code) return '空脚本';
+      const first = String(code).split('\n').find((l) => l.trim()) || '';
+      return first.trim().slice(0, 46) + (first.trim().length > 46 ? '…' : '');
+    }
+    const filled = this.properties.filter((p) => !this.isPristine(p));
+    if (!filled.length) return '未配置参数';
+    return filled.map((p) => `${p.itemName}=${String(p.itemValue).slice(0, 20)}`).join('，');
+  }
+
+  /**
+   * 导出参数数组。
+   * 必填项 / schema 原有项 / 用户改过的项才写回，其余不落 schema（见文件头纪律 2）。
+   */
+  exportProps() {
+    const out = [];
+    this.properties.forEach((p) => {
+      if (!(p.itemRequired || p.itemUpdated || !this.isPristine(p))) return;
+      const e = p.onExport();
+      if (e) out.push(e);
+    });
+    return out.concat(this.extraProperties.map((p) => clone(p)));
+  }
+}
+
+/* -------------------------------- 节点模型 ------------------------------- */
+
+export class EventEditModel {
+  constructor(schemaNode = {}) {
+    this.schemaNode = schemaNode;
+    this.className = schemaNode.className || 'Root';
+
+    const meta = getComponentMeta(this.className) || {};
+    this.metaEvents = (meta.events || []).map((e) => clone(e));
+    this.hadKey = Object.prototype.hasOwnProperty.call(schemaNode, 'eventactions');
+
+    this.rows = (schemaNode.eventactions || []).map((ea) => new EventActionRow(ea));
+  }
+
+  get count() {
+    return this.rows.length;
+  }
+
+  /** 组件自身事件 + 全局生命周期事件（按 eventKey 去重，组件优先） */
+ get eventOptions() {
+   const seen = new Set();
+   const out = [];
+    const base = this.className === 'Root'
+      ? this.metaEvents.concat(LIFECYCLE_EVENTS)
+      : this.metaEvents;
+    base.forEach((e) => {
+     if (!e || !e.eventKey || seen.has(e.eventKey)) return;
+     seen.add(e.eventKey);
+     out.push(e);
+   });
+   return out;
+ }
+
+  /** 某行的事件下拉项：常规项 + 该行当前这个 meta 里没有的 key（避免选中值丢失） */
+  eventOptionsFor(row) {
+    const list = this.eventOptions;
+    if (row.eventKey && !list.some((e) => e.eventKey === row.eventKey)) {
+      return list.concat([{ eventKey: row.eventKey, eventName: row.eventName || row.eventKey, _unknown: true }]);
+    }
+    return list;
+  }
+
+  /** 某行的动作下拉项：事件声明了 includes 时只放行其中列出的动作类型 */
+  actionOptionsFor(row) {
+    const ev = this.eventOptions.find((e) => e.eventKey === row.eventKey);
+    const inc = ev && ev.includes;
+    const list = inc && inc.length ? ACTION_LIST.filter((a) => inc.indexOf(a.actionType) >= 0) : ACTION_LIST;
+    if (row.actionType && !list.some((a) => a.actionType === row.actionType)) {
+      return list.concat([{ actionType: row.actionType, actionName: row.actionType, _unknown: true }]);
+    }
+    return list;
+  }
+
+  eventNameOf(key) {
+    const e = this.eventOptions.find((x) => x.eventKey === key);
+   return e ? e.eventName : '';
+ }
+
+  get eventactionMap() {
+    const m = {};
+    this.rows.forEach((r) => { if (r.eventKey) m[r.eventKey] = r; });
+    return m;
+  }
+
+  rowForEvent(eventKey) { return this.eventactionMap[eventKey] || null; }
+
+  toggleEvent(event) {
+    const key = event && event.eventKey;
+    if (!key) return;
+    const existing = this.rowForEvent(key);
+    if (existing) { this.removeRow(existing); }
+    else {
+      const allow = this.actionOptionsForEvent(key, '');
+      const actionType = allow.length ? allow[0].actionType : 'customAction';
+      const row = new EventActionRow({
+        event: { eventKey: key, eventName: event.eventName || this.eventNameOf(key) },
+        action: { actionType, properties: [] },
+      });
+      this.rows.push(row);
+    }
+  }
+
+  actionOptionsForEvent(eventKey, currentActionType) {
+    const ev = this.eventOptions.find((e) => e.eventKey === eventKey);
+    const inc = ev && ev.includes;
+    const list = inc && inc.length ? ACTION_LIST.filter((a) => inc.indexOf(a.actionType) >= 0) : ACTION_LIST;
+    if (currentActionType && !list.some((a) => a.actionType === currentActionType))
+      return list.concat([{ actionType: currentActionType, actionName: currentActionType, _unknown: true }]);
+    return list;
+  }
+
+  setEventKey(row, key) {
+    row.eventKey = key || '';
+    row.eventName = this.eventNameOf(row.eventKey) || row.eventName;
+    // 新事件若限制了动作类型，当前动作不在白名单里就切到第一个可选项
+    const allow = this.actionOptionsFor(row);
+    if (row.actionType && !allow.some((a) => a.actionType === row.actionType) && allow.length) {
+      this.setActionType(row, allow[0].actionType);
+    }
+  }
+
+  /** 切换动作类型：同名参数的值尽量迁移，旧类型的孤儿项丢弃 */
+  setActionType(row, type) {
+    if (type === row.actionType) return;
+    const keep = {};
+    row.properties.forEach((p) => {
+      if (p.itemKey) keep[p.itemKey] = { itemValue: clone(p.itemValue), itemValueFrom: p.itemValueFrom };
+    });
+    row.actionType = type || '';
+    row.buildProps([]);
+    row.properties.forEach((p) => {
+      const k = keep[p.itemKey];
+      if (!k || k.itemValue === '' || k.itemValue == null) return;
+      p.itemValue = k.itemValue;
+      p.itemValueFrom = k.itemValueFrom;
+      p.itemUpdated = true;
+    });
+    Property.updatePropertyVisible(row.properties);
+  }
+
+  addRow() {
+    const first = this.eventOptions[0];
+    const row = new EventActionRow({
+      event: first ? { eventKey: first.eventKey, eventName: first.eventName } : {},
+      action: { actionType: 'customAction', properties: [] },
+    });
+    this.rows.push(row);
+    return row;
+  }
+
+  removeRow(row) {
+    const i = this.rows.indexOf(row);
+    if (i >= 0) this.rows.splice(i, 1);
+  }
+
+  moveRow(from, to) {
+    if (from < 0 || from >= this.rows.length) return;
+    const t = Math.max(0, Math.min(this.rows.length - 1, to));
+    if (t === from) return;
+    const [r] = this.rows.splice(from, 1);
+    this.rows.splice(t, 0, r);
+  }
+
+  refreshVisible() {
+    this.rows.forEach((r) => Property.updatePropertyVisible(r.properties));
+  }
+
+  /** 序列化成 schema.eventactions */
+  export() {
+    return this.rows.map((r) => {
+      const event = r.eventKey
+        ? Object.assign({}, r._extraEvent, {
+            eventName: this.eventNameOf(r.eventKey) || r.eventName || undefined,
+            eventKey: r.eventKey,
+          })
+        : Object.assign({}, r._extraEvent);
+      if (event.eventName === undefined) delete event.eventName;
+      const action = Object.assign({}, r._extraAction, {
+        actionType: r.actionType,
+        properties: r.exportProps(),
+      });
+      return { event, action };
+    });
+  }
+
+  /** 就地写回 schema 节点（保持与 currentSchema 的引用关系） */
+  applyToSchema() {
+    // 原本没有这个字段、现在也没配任何事件 —— 不要凭空加上
+    if (!this.hadKey && !this.rows.length) return;
+    this.schemaNode.eventactions = this.export();
+    this.hadKey = true;
+  }
+}
+
+export default EventEditModel;

package/dist/vendored/runtime/hoverGuide.js

@@ -0,0 +1,31 @@
+// hover 参考线覆盖层：在「组件结构」tab 把鼠标 hover 到某节点时，于画布上框出对应元素，
+// 用于「正式选中/定位前」的快速预览。与选中态遮罩 (selectionOverlay) 相互独立——
+// 选中框与 hover 参考线可同时显示、互不干扰。
+import { reactive } from 'vue'
+
+export const hoverGuide = reactive({
+  // 当前 hover 节点对应的画布根 DOM 元素
+  el: null,
+  visible: false,
+  // 当前高亮节点的标识（componentId 回退 id），用于离开时「只清自己」的守卫
+  nodeId: null,
+})
+
+/** 标记某节点为 hover：写入根元素、记录节点标识并置可见。重复写入同一元素由 watch 去重。 */
+export function setHoverEl(el, id) {
+  hoverGuide.el = el
+  hoverGuide.nodeId = id
+  hoverGuide.visible = true
+}
+
+/**
+ * 取消 hover：仅当传入标识正是当前高亮节点时才清除（防止「进入 B 后再离开 A」的竞态误清）。
+ * @param {*} id 离开节点的标识；传 null/undefined 表示无条件清除（如离开 tab）。
+ */
+export function clearHoverEl(id) {
+  if (hoverGuide.el && (id == null || hoverGuide.nodeId === id)) {
+    hoverGuide.el = null
+    hoverGuide.nodeId = null
+    hoverGuide.visible = false
+  }
+}

package/dist/vendored/runtime/jsapi-mock.js

@@ -0,0 +1,256 @@
+/**
+ * JSAPI 模拟统一分发中心。
+ *
+ * 卡片内所有 ynet.callJSAPI 调用（含弹窗卡片实例）都经由 window.ynet 汇聚到这里，
+ * 避免桩逻辑散落在预览外壳各处。对齐 docs/动态卡片方案详细说明.md 的 JSAPI 设计：
+ * - alertCard / closeAlertCard  -> alert-card.js 弹窗卡片运行时
+ * - alertDialog                 -> 原生风格确认对话框（手机框内模拟，回调 { ok, dismissByClickBg }）
+ * - showToast                   -> 弱提示 Toast（手机框内模拟，showIcon：0错误/1正确/2不显示；不传则不显示图标）
+ * - showPicker                  -> 底部弹出级联选择器（手机框内模拟，回调 { result:[{key,value}] }）
+ * - showDatePicker              -> 底部弹出日期选择器（手机框内模拟，回调 { error:'0', currentDate, data:{year,month,day,value} }）
+ * - 其余 jsapi                  -> 仅记录调用流水（调试面板）+ 通用成功回调，保证卡片代码不中断
+ *
+ * 回调统一遵循文档的通用结构：{ success, error, errorMessage, data }。
+ */
+import { reactive } from 'vue'
+import { openAlertCard, closeAlertCard } from '@/runtime/alert-card.js'
+
+/** 设备级模拟 UI 状态：dialog = 当前展示的 alertDialog，toast = 当前 Toast，picker = 当前选择器，datePicker = 当前日期选择器 */
+export const deviceUI = reactive({ dialog: null, toast: null, picker: null, datePicker: null })
+
+const dialogQueue = []
+let dialogSeq = 0
+let toastTimer = null
+const pickerQueue = []
+let pickerSeq = 0
+const datePickerQueue = []
+let datePickerSeq = 0
+
+/** Toast 自动消失时长（毫秒），对齐原生弱提示体验 */
+const TOAST_DURATION = 2200
+
+function safeCall(cb, res) {
+  if (typeof cb !== 'function') return
+  try {
+    cb(res)
+  } catch (_) {
+    /* 卡片回调内报错忽略，不影响桥接层 */
+  }
+}
+
+/** 从队列取下一个 dialog 展示（无则置空） */
+function shiftDialog() {
+  deviceUI.dialog = dialogQueue.length ? dialogQueue.shift() : null
+}
+
+/**
+ * alertDialog - 原生确认对话框（文档「alertDialog - 弹窗」）。
+ * 入参：title / message / okButton(默认"确定") / cancelButton(空串不显示) /
+ *       clickBgToHide(默认 false) / cancelGrayStyle(默认 false)
+ * 连续调用时排队依次弹出；回调 data：{ ok, dismissByClickBg }
+ */
+function mockAlertDialog(p, cb) {
+  const params = p || {}
+  dialogQueue.push({
+    id: ++dialogSeq,
+    title: params.title || '',
+    message: params.message == null ? '' : String(params.message),
+    okButton: params.okButton || '确定',
+    cancelButton: params.cancelButton || '',
+    clickBgToHide: params.clickBgToHide === true,
+    cancelGrayStyle: params.cancelGrayStyle === true,
+    callback: cb,
+  })
+  if (!deviceUI.dialog) shiftDialog()
+}
+
+/**
+ * 关闭当前 alertDialog 并把结果回调给卡片（由 DeviceOverlay 的按钮/遮罩点击触发）。
+ * @param {{ ok?: boolean, dismissByClickBg?: boolean }} result
+ */
+export function dismissDialog(result) {
+  const cur = deviceUI.dialog
+  if (!cur) return
+  deviceUI.dialog = null
+  safeCall(cur.callback, {
+    success: true,
+    data: { ok: !!result.ok, dismissByClickBg: !!result.dismissByClickBg },
+  })
+  shiftDialog()
+}
+
+/**
+ * showToast - 弱提示（文档「showToast - 显示弱提示」）。
+ * 入参：message(必选)，showIcon：'0'-错误 icon / '1'-正确 icon / '2'-不显示。
+ * 注意：不传 showIcon 时**不显示图标**（与真机默认行为一致；此前误默认 '0' 导致
+ * 不传参也带了 × 错误图标）。重复调用时替换当前 Toast 并重置计时。
+ */
+function mockShowToast(p, cb) {
+  const params = p || {}
+  // 不传 showIcon（null/undefined）→ 空串，渲染层据此不渲染图标；显式 '0'/'1'/'2' 仍生效
+  const raw = params.showIcon == null ? '' : String(params.showIcon)
+  const icon = raw === '1' ? 'ok' : raw === '0' ? 'err' : ''
+  if (toastTimer) {
+    clearTimeout(toastTimer)
+    toastTimer = null
+  }
+  deviceUI.toast = {
+    message: params.message == null ? '' : String(params.message),
+    icon,
+  }
+  toastTimer = setTimeout(() => {
+    deviceUI.toast = null
+    toastTimer = null
+  }, TOAST_DURATION)
+  safeCall(cb, { success: true, data: {} })
+}
+
+/**
+ * showPicker - 底部弹出级联选择器（文档「showPicker - 选择器」）。
+ * 入参：title(可选) / mode('single'单列 | 'multi'多列(级联)) / dataSource(必选，节点 {text,key,children?}) /
+ *       currentValue(可选，各列选中 key，如 ["2","lq"]；兼容 [["2","lq"]] 写法)。
+ * 回调 data.result：各列选中对象数组 [{key, value}]（value 取节点 text），如 [{key:'1',value:'文科'},{key:'lq',value:'篮球'}]。
+ * 连续调用时排队依次弹出（与 dialog 队列一致）。
+ */
+function mockShowPicker(p, cb) {
+  const params = p || {}
+  // 兼容 currentValue 的两种写法：["2","lq"] 与 [["2","lq"]]
+  let cv = Array.isArray(params.currentValue) ? params.currentValue : []
+  if (cv.length && Array.isArray(cv[0])) cv = cv[0]
+  pickerQueue.push({
+    id: ++pickerSeq,
+    title: params.title || '',
+    mode: params.mode === 'multi' ? 'multi' : 'single',
+    dataSource: Array.isArray(params.dataSource) ? params.dataSource : [],
+    currentValue: cv.map((x) => String(x)),
+    callback: cb,
+  })
+  if (!deviceUI.picker) shiftPicker()
+}
+
+/** 从队列取下一个 picker 展示（无则置空） */
+function shiftPicker() {
+  deviceUI.picker = pickerQueue.length ? pickerQueue.shift() : null
+}
+
+/**
+ * 关闭当前 showPicker 并把结果回调给卡片（由 PickerOverlay 的确定/取消触发）。
+ * @param {boolean} commit 是否确认选择（false=取消，不回传 result）
+ * @param {Array} result 确认时回传的选中对象数组 [{key, value}]
+ */
+export function dismissPicker(commit, result) {
+  const cur = deviceUI.picker
+  if (!cur) return
+  deviceUI.picker = null
+  if (commit) {
+    // 对齐真实 JSAPI 出参：error='0' 表示成功，卡片回调据此判断并回填 data。
+    const res = { success: true, error: '0', data: { result }, result }
+    safeCall(cur.callback, res)
+  } else {
+    safeCall(cur.callback, { success: true, data: {} })
+  }
+  shiftPicker()
+}
+
+/**
+ * showDatePicker - 底部弹出日期选择器（文档「showDatePicker - 时间选择器」）。
+ * 入参（对齐 docs/动态卡片方案详细说明.md）：
+ *   type        : 'year_month_day'(默认) | 'year_month' | 'month_day'
+ *   startDate   : 最小可选日期，默认 '1970-1-1'
+ *   endDate     : 最大可选日期，默认 '2100-12-31'
+ *   selectDate  : 默认选中日期，默认今天（受起止范围约束）
+ *   title       : 可选，选择器标题（transferPlan 实传 '选择日期'，文档入参表未列，兼容接受）
+ * 出参（对齐文档 + transferPlan 实际回调）：
+ *   success: true / error: '0'(成功) / currentDate: 完整日期串(transferPlan 回读 res.currentDate)
+ *   data: { year, month, day, value }（文档规定字段；不适用的分量置空串）
+ * 连续调用时排队依次弹出（与 picker 队列一致）。
+ */
+function mockShowDatePicker(p, cb) {
+  const params = p || {}
+  const VALID = ['year_month_day', 'year_month', 'month_day']
+  const type = VALID.includes(params.type) ? params.type : 'year_month_day'
+  datePickerQueue.push({
+    id: ++datePickerSeq,
+    title: params.title || '',
+    type,
+    startDate: params.startDate || '1970-1-1',
+    endDate: params.endDate || '2100-12-31',
+    selectDate: params.selectDate || '',
+    callback: cb,
+  })
+  if (!deviceUI.datePicker) shiftDatePicker()
+}
+
+/** 从队列取下一个 datePicker 展示（无则置空） */
+function shiftDatePicker() {
+  deviceUI.datePicker = datePickerQueue.length ? datePickerQueue.shift() : null
+}
+
+/**
+ * 关闭当前 showDatePicker 并把结果回调给卡片（由 DatePickerOverlay 的确定/取消触发）。
+ * @param {boolean} commit 是否确认选择（false=取消，不回传）
+ * @param {{ year:string, month:string, day:string, value:string }} sel 确认时回传的日期分量
+ */
+export function dismissDatePicker(commit, sel) {
+  const cur = deviceUI.datePicker
+  if (!cur) return
+  deviceUI.datePicker = null
+  if (commit) {
+    // error='0' 成功（transferPlan 据此 res.error==='0' 判断）；currentDate 同步 transferPlan 的 res.currentDate
+    const res = {
+      success: true,
+      error: '0',
+      currentDate: sel.value,
+      data: { year: sel.year, month: sel.month, day: sel.day, value: sel.value },
+    }
+    safeCall(cur.callback, res)
+  } else {
+    safeCall(cur.callback, { success: true, data: {} })
+  }
+  shiftDatePicker()
+}
+
+/** JSAPI 处理器注册表：需要真实模拟的 jsapi 全部在此登记 */
+const handlers = {
+  alertCard: (p, cb) => openAlertCard(p, cb),
+  closeAlertCard: (p, cb) => closeAlertCard(p, cb),
+  alertDialog: mockAlertDialog,
+  showToast: mockShowToast,
+  showPicker: mockShowPicker,
+  showDatePicker: mockShowDatePicker,
+}
+
+/**
+ * 安装统一桩：window.ynet.callJSAPI。预览启动时调用一次。
+ * @param {object} runtime 主卡片 runtime，用于记录 jsapi 调用流水（调试面板展示）
+ */
+export function installJsApiMock(runtime) {
+  if (typeof window === 'undefined') return
+  window.ynet = {
+    callJSAPI(api, p, cb) {
+      if (runtime && runtime.pushApiCall) runtime.pushApiCall(api, p)
+      const handler = handlers[api]
+      if (handler) {
+        handler(p, cb)
+        return
+      }
+      // 未模拟的 jsapi：通用成功回调，保证卡片后续逻辑可继续执行
+      safeCall(cb, { success: true, data: {} })
+    },
+  }
+}
+
+/** 切换主卡片时清理模拟 UI（对话框队列 + Toast + 选择器），避免残留旧上下文 */
+export function clearDeviceUI() {
+  dialogQueue.length = 0
+  deviceUI.dialog = null
+  deviceUI.toast = null
+  if (toastTimer) {
+    clearTimeout(toastTimer)
+    toastTimer = null
+  }
+  pickerQueue.length = 0
+  deviceUI.picker = null
+  datePickerQueue.length = 0
+  deviceUI.datePicker = null
+}