cardbuddy 0.11.0 → 0.12.1

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

@@ -1,300 +0,0 @@
-/**
- * 事件编辑模型：对齐线上编辑器「事件」页签，节点持有 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

@@ -1,31 +0,0 @@
-// 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

@@ -1,256 +0,0 @@
-/**
- * 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
-}