genshinwidget_fast.js

// Variables used by Scriptable.
// These must be at the very top of the file. Do not edit.
// icon-color: deep-gray; icon-glyph: moon;

// ========= ↓将生成的配置粘贴这以下↓=========

// ========= ↑将生成的配置粘贴这以上↑ ========

/**
 * @typedef {Object} ResinResponse
 * @property {number} total_task_num - 每日委托任务
 * @property {number} finished_task_num - 每日委托完成数
 * @property {number} max_resin - 树脂上限
 * @property {number} current_resin - 当前树脂
 * @property {number} max_home_coin - 洞天宝钱上限
 * @property {number} current_home_coin - 当前洞天宝钱
 * @property {string} resin_recovery_time - 树脂预计恢复时间
 * @property {string} home_coin_recovery_time - 洞天宝钱预计恢复时间
 * @property {number} resin_discount_num_limit - 强敌每周减半次数上限
 * @property {number} remain_resin_discount_num - 强敌每周减半次数剩余
 * @property {number} max_expedition_num - 探索派遣限制
 * @property {number} current_expedition_num - 当前探索派遣人数
 * @property {Array<{ status: string, avatar_side_icon: string, remained_time: string }>} expeditions - 派遣人员详情 
 */
let resin = {}
try {
    if (config[1].startsWith("os")) {
        resin = await getDataOs()
    } else {
        resin = await getData()
    }
    resin = resin || {}
} catch (error) {
    console.error(error)
}

const resinIcon = await loadResinIcon()
const coinIcon = await loadCoinIcon()
const discountIcon = await loadDiscountIcon()
const taskIcon = await loadTaskIcon()
const avatorIcon = await loadAvatorIcon()
const transformerIcon = await loadTransformerIcon()

let widget = await createWidget()
if (config.runsInWidget) {
    Script.setWidget(widget)
} else {
    widget.presentMedium()
}

Script.complete()


async function createWidget() {
    let widget = new ListWidget();

    widget.backgroundColor = Color.dynamic(
        new Color('#fff5e5'),
        new Color('#181e28')
    );

    if (config.widgetFamily === 'small') {
        return await renderSmall(widget);
    } else if (config.widgetFamily === 'medium') {
        return await renderMedium(widget);
    } else {
        return await renderMedium(widget);
    }
}

/**
 * 渲染小尺寸组件
 */
async function renderSmall(widget) {
    const ThemeConfig = Device.isPad() ? {
        titleSize: 7,
        coinSize: 12,
        iconSize: 12,
        iconRadius: 6,
        coinRadius: 5,
        iconSpacer: 4,
        textSize: 11,
        infoSize: 25,
        info2Size: 16,
        tipSize: 9,
        avatarSize: 20,
        topSpacer: 30,
        bottomSpacer: 15,
    } : {
        titleSize: 7,
        coinSize: 12,
        iconSize: 12,
        iconRadius: 6,
        coinRadius: 5,
        iconSpacer: 4,
        textSize: 11,
        infoSize: 25,
        info2Size: 16,
        tipSize: 9,
        avatarSize: 20,
        topSpacer: 30,
        bottomSpacer: 15,
    }

    //添加标题栏
    let stackHeader = widget.addStack()
    stackHeader.centerAlignContent()
    // 添加UID
    var textItem = stackHeader.addText(` UID：${config[0]}`)
    textItem.font = Font.boldRoundedSystemFont(ThemeConfig.titleSize)
    textItem.textColor = Color.dynamic(new Color("#995c00"), Color.white())
    // 添加更新时间
    stackHeader.addSpacer()
    var myDate = new Date();
    var textItem = stackHeader.addText(`${myDate.getHours().toString().padStart(2, '0')}:${myDate.getMinutes().toString().padStart(2, '0')}更新`)
    textItem.font = Font.boldRoundedSystemFont(ThemeConfig.titleSize)
    textItem.textColor = Color.dynamic(new Color("#995c00"), Color.white())
    textItem.rightAlignText()

    // 页面共分为 1*2 个模块，首先建立横向布局
    // 横向布局 - 第一行
    let topHorizon = widget.addStack()
    topHorizon.layoutHorizontally()
    topHorizon.centerAlignContent()
    widget.addSpacer(1)
    // 横向布局 - 第二行
    let bottomHorizon = widget.addStack()
    bottomHorizon.layoutHorizontally()
    bottomHorizon.centerAlignContent()

    // 纵向布局 - 第一行左侧
    let topLeftStack = topHorizon.addStack()
    topLeftStack.layoutVertically()
    topLeftStack.size = new Size(120, 60)
    topLeftStack.centerAlignContent()
    // 纵向布局 - 第二行右侧
    let bottomLeftStack = bottomHorizon.addStack()
    bottomLeftStack.layoutVertically()
    bottomLeftStack.size = new Size(120, 60)
    bottomLeftStack.centerAlignContent()

    // 树脂获取
    let resinStack = topLeftStack.addStack()
    let resinStack2 = topLeftStack.addStack()
    let resinTipStack = topLeftStack.addStack()
    let ResinIconElement = resinStack.addImage(resinIcon)
    ResinIconElement.imageSize = new Size(ThemeConfig.iconSize, ThemeConfig.iconSize)
    ResinIconElement.cornerRadius = ThemeConfig.iconRadius
    resinStack.addSpacer(ThemeConfig.iconSpacer)
    let ResinElement = resinStack.addText(`当前树脂：`)
    ResinElement.textColor = Color.dynamic(Color.black(), Color.white())
    ResinElement.textOpacity = 0.6
    ResinElement.font = Font.mediumSystemFont(ThemeConfig.textSize)
    let ResinElement2 = resinStack2.addText(`${resin.current_resin}`)
    let ResinElement3 = resinStack2.addText(` / ${resin.max_resin}`)
    resinStack2.centerAlignContent()
    if (resin.current_resin >= resin.max_resin * 0.9) {
        ResinElement2.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
        ResinElement3.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
    } else {
        ResinElement2.textColor = Color.dynamic(new Color("#995c00"), Color.white())
        ResinElement3.textColor = Color.dynamic(new Color("#995c00"), Color.white())
    }
    ResinElement2.textOpacity = 1
    ResinElement2.font = Font.boldRoundedSystemFont(ThemeConfig.infoSize)
    ResinElement3.textOpacity = 1
    ResinElement3.font = Font.boldRoundedSystemFont(ThemeConfig.info2Size)
    let ResinTipElement = resinTipStack.addText(`- ${await getTime(resin.resin_recovery_time)} (${await getClock(resin.resin_recovery_time)} )`)
    ResinTipElement.textColor = Color.dynamic(Color.black(), Color.white())
    ResinTipElement.textOpacity = 0.5
    ResinTipElement.font = Font.mediumRoundedSystemFont(ThemeConfig.tipSize)
    resinStack.centerAlignContent()

    // 宝钱获取
    let coinStack = bottomLeftStack.addStack()
    let coinStack2 = bottomLeftStack.addStack()
    let coinTipStack = bottomLeftStack.addStack()
    let CoinIconElement = coinStack.addImage(coinIcon)
    CoinIconElement.imageSize = new Size(ThemeConfig.coinSize, ThemeConfig.coinSize)
    CoinIconElement.cornerRadius = ThemeConfig.coinRadius
    coinStack.addSpacer(5)
    let CoinElement = coinStack.addText(`洞天宝钱：`)
    CoinElement.textColor = Color.dynamic(Color.black(), Color.white())
    CoinElement.textOpacity = 0.6
    CoinElement.font = Font.mediumSystemFont(ThemeConfig.textSize)
    let CoinElement2 = coinStack2.addText(`${resin.current_home_coin}`)
    let CoinElement3 = coinStack2.addText(` / ${resin.max_home_coin}`)
    coinStack2.centerAlignContent()
    if (resin.current_home_coin >= resin.max_home_coin * 0.9) {
        CoinElement2.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
        CoinElement3.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
    } else {
        CoinElement2.textColor = Color.dynamic(new Color("#995c00"), Color.white())
        CoinElement3.textColor = Color.dynamic(new Color("#995c00"), Color.white())
    }
    CoinElement2.textOpacity = 1
    CoinElement2.font = Font.boldRoundedSystemFont(ThemeConfig.infoSize)
    CoinElement3.textOpacity = 1
    CoinElement3.font = Font.boldRoundedSystemFont(ThemeConfig.info2Size)
    let CoinTipElement = coinTipStack.addText(`- ${await getTime(resin.home_coin_recovery_time)} (${await getClock(resin.home_coin_recovery_time)} )`)
    CoinTipElement.textColor = Color.dynamic(Color.black(), Color.white())
    CoinTipElement.textOpacity = 0.5
    CoinTipElement.font = Font.mediumRoundedSystemFont(ThemeConfig.tipSize)
    coinStack.centerAlignContent()

    return widget
}

/**
 * 渲染中尺寸组件
 */
async function renderMedium(widget) {
    const ThemeConfig = Device.isPad() ? {
        titleSize: 7,
        coinSize: 12,
        iconSize: 12,
        iconRadius: 6,
        coinRadius: 5,
        iconSpacer: 4,
        textSize: 11,
        infoSize: 25,
        info2Size: 16,
        tipSize: 10,
        avatarSize: 20,
        topSpacer: 30,
        bottomSpacer: 15,
    } : {
        titleSize: 7,
        coinSize: 12,
        iconSize: 12,
        iconRadius: 6,
        coinRadius: 5,
        iconSpacer: 4,
        textSize: 11,
        infoSize: 25,
        info2Size: 16,
        tipSize: 10,
        avatarSize: 20,
        topSpacer: 30,
        bottomSpacer: 15,
    }

    //添加标题栏
    let stackHeader = widget.addStack()
    stackHeader.centerAlignContent()
    // 添加UID
    var textItem = stackHeader.addText(` UID：${config[0]}`)
    textItem.font = Font.boldRoundedSystemFont(ThemeConfig.titleSize)
    textItem.textColor = Color.dynamic(new Color("#995c00"), Color.white())
    // 添加更新时间
    stackHeader.addSpacer()
    var myDate = new Date();
    var textItem = stackHeader.addText(`${myDate.getHours().toString().padStart(2, '0')}:${myDate.getMinutes().toString().padStart(2, '0')}更新      `)
    textItem.font = Font.boldRoundedSystemFont(ThemeConfig.titleSize)
    textItem.textColor = Color.dynamic(new Color("#995c00"), Color.white())

    // 页面共分为 2*2 个模块，首先建立横向布局
    // 横向布局 - 第一行
    let topHorizon = widget.addStack()
    topHorizon.layoutHorizontally()
    topHorizon.centerAlignContent()
    widget.addSpacer(4)
    // 横向布局 - 第二行
    let bottomHorizon = widget.addStack()
    bottomHorizon.layoutHorizontally()
    bottomHorizon.centerAlignContent()

    // 纵向布局 - 第一行左侧
    let topLeftStack = topHorizon.addStack()
    topLeftStack.layoutVertically()
    topLeftStack.size = new Size(140, 60)
    topLeftStack.centerAlignContent()
    // 左侧与右侧间的间距
    topHorizon.addSpacer()
    // 纵向布局 - 第一行右侧
    let topRightStack = topHorizon.addStack()
    topRightStack.size = new Size(105, 60)
    topRightStack.layoutVertically()
    topRightStack.centerAlignContent()

    // 纵向布局 - 第二行左侧
    let bottomLeftStack = bottomHorizon.addStack()
    bottomLeftStack.layoutVertically()
    bottomLeftStack.size = new Size(140, 60)
    bottomLeftStack.centerAlignContent()
    // 左侧与右侧间的间距
    bottomHorizon.addSpacer()
    // 纵向布局 - 第二行右侧
    let bottomRightStack = bottomHorizon.addStack()
    bottomRightStack.layoutVertically()
    bottomRightStack.size = new Size(105, 60)
    bottomRightStack.centerAlignContent()

    // 树脂获取
    let resinStack = topLeftStack.addStack()
    let resinStack2 = topLeftStack.addStack()
    let resinTipStack = topLeftStack.addStack()
    let ResinIconElement = resinStack.addImage(resinIcon)
    ResinIconElement.imageSize = new Size(ThemeConfig.iconSize, ThemeConfig.iconSize)
    ResinIconElement.cornerRadius = ThemeConfig.iconRadius
    resinStack.addSpacer(ThemeConfig.iconSpacer)
    let ResinElement = resinStack.addText(`当前树脂：`)
    ResinElement.textColor = Color.dynamic(Color.black(), Color.white())
    ResinElement.textOpacity = 0.6
    ResinElement.font = Font.mediumSystemFont(ThemeConfig.textSize)
    let ResinElement2 = resinStack2.addText(`${resin.current_resin}`)
    let ResinElement3 = resinStack2.addText(` / ${resin.max_resin}`)
    resinStack2.centerAlignContent()
    if (resin.current_resin >= resin.max_resin * 0.9) {
        ResinElement2.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
        ResinElement3.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
    } else {
        ResinElement2.textColor = Color.dynamic(new Color("#995c00"), Color.white())
        ResinElement3.textColor = Color.dynamic(new Color("#995c00"), Color.white())
    }
    ResinElement2.textOpacity = 1
    ResinElement2.font = Font.boldRoundedSystemFont(ThemeConfig.infoSize)
    ResinElement3.textOpacity = 1
    ResinElement3.font = Font.boldRoundedSystemFont(ThemeConfig.info2Size)
    let ResinTipElement = resinTipStack.addText(`- ${await getTime(resin.resin_recovery_time)} (${await getClock(resin.resin_recovery_time)} )`)
    ResinTipElement.textColor = Color.dynamic(Color.black(), Color.white())
    ResinTipElement.textOpacity = 0.5
    ResinTipElement.font = Font.mediumRoundedSystemFont(ThemeConfig.tipSize)
    resinStack.centerAlignContent()

    // 宝钱获取
    let coinStack = bottomLeftStack.addStack()
    let coinStack2 = bottomLeftStack.addStack()
    let coinTipStack = bottomLeftStack.addStack()
    let CoinIconElement = coinStack.addImage(coinIcon)
    CoinIconElement.imageSize = new Size(ThemeConfig.coinSize, ThemeConfig.coinSize)
    CoinIconElement.cornerRadius = ThemeConfig.coinRadius
    coinStack.addSpacer(5)
    let CoinElement = coinStack.addText(`洞天宝钱：`)
    CoinElement.textColor = Color.dynamic(Color.black(), Color.white())
    CoinElement.textOpacity = 0.6
    CoinElement.font = Font.mediumSystemFont(ThemeConfig.textSize)
    let CoinElement2 = coinStack2.addText(`${resin.current_home_coin}`)
    let CoinElement3 = coinStack2.addText(` / ${resin.max_home_coin}`)
    coinStack2.centerAlignContent()
    if (resin.current_home_coin >= resin.max_home_coin * 0.9) {
        CoinElement2.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
        CoinElement3.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
    } else {
        CoinElement2.textColor = Color.dynamic(new Color("#995c00"), Color.white())
        CoinElement3.textColor = Color.dynamic(new Color("#995c00"), Color.white())
    }
    CoinElement2.textOpacity = 1
    CoinElement2.font = Font.boldRoundedSystemFont(ThemeConfig.infoSize)
    CoinElement3.textOpacity = 1
    CoinElement3.font = Font.boldRoundedSystemFont(ThemeConfig.info2Size)
    let CoinTipElement = coinTipStack.addText(`- ${await getTime(resin.home_coin_recovery_time)} (${await getClock(resin.home_coin_recovery_time)} )`)
    CoinTipElement.textColor = Color.dynamic(Color.black(), Color.white())
    CoinTipElement.textOpacity = 0.5
    CoinTipElement.font = Font.mediumRoundedSystemFont(ThemeConfig.tipSize)
    coinStack.centerAlignContent()

    // 周本获取
    let resinDiscountStack = topRightStack.addStack()
    let ResinDiscountIconElement = resinDiscountStack.addImage(discountIcon)
    ResinDiscountIconElement.imageSize = new Size(ThemeConfig.iconSize, ThemeConfig.iconSize)
    ResinDiscountIconElement.cornerRadius = ThemeConfig.iconRadius
    resinDiscountStack.addSpacer(ThemeConfig.iconSpacer)
    let ResinDiscountTextElement = resinDiscountStack.addText(`半价周本：`)
    ResinDiscountTextElement.textColor = Color.dynamic(Color.black(), Color.white())
    ResinDiscountTextElement.textOpacity = 0.6
    ResinDiscountTextElement.font = Font.mediumSystemFont(ThemeConfig.textSize)
    let done_resin_discount_num = resin.resin_discount_num_limit - resin.remain_resin_discount_num
    let ResinDiscountTextElement2 = resinDiscountStack.addText(`${done_resin_discount_num} / ${resin.resin_discount_num_limit}`)
    if (resin.remain_resin_discount_num != 0) {
        ResinDiscountTextElement2.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
    } else {
        ResinDiscountTextElement2.textColor = Color.dynamic(new Color("#995c00"), Color.white())
    }
    ResinDiscountTextElement2.textOpacity = 1
    ResinDiscountTextElement2.font = Font.boldRoundedSystemFont(ThemeConfig.textSize)
    resinDiscountStack.centerAlignContent()

    //每日委托获取
    let taskStack = topRightStack.addStack()
    let TaskIconElement = taskStack.addImage(taskIcon)
    TaskIconElement.imageSize = new Size(ThemeConfig.iconSize, ThemeConfig.iconSize)
    TaskIconElement.cornerRadius = ThemeConfig.iconRadius
    taskStack.addSpacer(ThemeConfig.iconSpacer)
    let TaskElement = taskStack.addText(`每日委托：`)
    TaskElement.textColor = Color.dynamic(Color.black(), Color.white())
    TaskElement.textOpacity = 0.6
    TaskElement.font = Font.mediumSystemFont(ThemeConfig.textSize)
    let TaskElement2 = taskStack.addText(`${resin.finished_task_num} / ${resin.total_task_num}`)
    if (resin.finished_task_num != resin.total_task_num) {
        TaskElement2.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
    } else {
        TaskElement2.textColor = Color.dynamic(new Color("#995c00"), Color.white())
    }
    TaskElement2.textOpacity = 1
    TaskElement2.font = Font.boldRoundedSystemFont(ThemeConfig.textSize)
    taskStack.centerAlignContent()

    // 参量质变仪
    var stackText = topRightStack.addStack()
    var transformIcon = stackText.addImage(transformerIcon)
    transformIcon.imageSize = new Size(ThemeConfig.iconSize, ThemeConfig.iconSize)
    stackText.addSpacer(ThemeConfig.iconSpacer)
    var textItem = stackText.addText("参量质变：")
    textItem.font = Font.mediumSystemFont(ThemeConfig.textSize)
    textItem.textColor = Color.dynamic(Color.black(), Color.white())
    textItem.textOpacity = 0.6
    const transformer_recovery_time = resin.transformer && resin.transformer.recovery_time || {}
    if (transformer_recovery_time.reached) {
        var textItem = stackText.addText(`可使用`)
        textItem.font = Font.boldRoundedSystemFont(10)
        textItem.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
    } else {
        if (+transformer_recovery_time.Day > 0) {
            var textItem = stackText.addText(`${transformer_recovery_time.Day} 天`)
            textItem.font = Font.boldRoundedSystemFont(ThemeConfig.textSize)
            textItem.textColor = Color.dynamic(new Color("#995c00"), Color.white())
        }
        if (+transformer_recovery_time.Hour > 0) {
            var textItem = stackText.addText(`${transformer_recovery_time.Hour} 时`)
            textItem.font = Font.boldRoundedSystemFont(ThemeConfig.textSize)
            textItem.textColor = Color.dynamic(new Color("#995c00"), Color.white())
        }
        if (+transformer_recovery_time.Minute > 0) {
            var textItem = stackText.addText(`${transformer_recovery_time.Minute} 分`)
            textItem.font = Font.boldRoundedSystemFont(ThemeConfig.textSize)
            textItem.textColor = Color.dynamic(new Color("#995c00"), Color.white())
        }
        if (+transformer_recovery_time.Second > 0) {
            var textItem = stackText.addText(`${transformer_recovery_time.Second} 秒`)
            textItem.font = Font.boldRoundedSystemFont(ThemeConfig.textSize)
            textItem.textColor = Color.dynamic(new Color("#995c00"), Color.white())
        }
    }

    // 派遣任务获取
    let expeditionsTitleStack = topRightStack.addStack()
    let isHasFinished = false
    let minCoverTime = 0
    let AvatorIconElement = expeditionsTitleStack.addImage(avatorIcon)
    AvatorIconElement.imageSize = new Size(ThemeConfig.iconSize, ThemeConfig.iconSize)
    AvatorIconElement.cornerRadius = ThemeConfig.iconRadius
    expeditionsTitleStack.addSpacer(ThemeConfig.iconSpacer)
    let expeditionsTitleElement = expeditionsTitleStack.addText(`探索派遣：`)
    expeditionsTitleElement.textColor = Color.dynamic(Color.black(), Color.white())
    expeditionsTitleElement.textOpacity = 0.6
    expeditionsTitleElement.font = Font.mediumSystemFont(ThemeConfig.textSize)
    let expeditionsStack = bottomRightStack.addStack()
    bottomRightStack.addSpacer(6)
    let expeditionsStack2 = bottomRightStack.addStack()
    bottomRightStack.addSpacer(4)
    let expeditionsStack3 = bottomRightStack.addStack()
    const expeditions = resin.expeditions || []
    await Promise.all(expeditions.map(async (expedition) => {
        let req = new Request(expedition.avatar_side_icon)
        expedition.icon = await req.loadImage()
    }));
    minCoverTime = expeditions[0] ? +expeditions[0].remained_time : 0
    for (let i = -1; i++ < resin.max_expedition_num;) {
        let expeditionStack = expeditionsStack.addStack()
        expeditionStack.layoutHorizontally()
        let isOngoing = !!expeditions[i]
        if (isOngoing) {
            const { status, icon, remained_time } = expeditions[i]
            if (+remained_time < minCoverTime) minCoverTime = +remained_time
            let avatarImgElement = expeditionStack.addImage(icon)
            avatarImgElement.imageSize = new Size(ThemeConfig.avatarSize, ThemeConfig.avatarSize)
            avatarImgElement.cornerRadius = 0
            expeditionStack.bottomAlignContent()
            if (status === 'Finished') {
                isHasFinished = true
            }
        }
    }

    if (isHasFinished) {
        let expeditionsTitleElement2 = expeditionsTitleStack.addText(`${resin.current_expedition_num} / ${resin.max_expedition_num}`)
        expeditionsTitleElement2.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
        expeditionsTitleElement2.textOpacity = 1
        expeditionsTitleElement2.font = Font.boldRoundedSystemFont(ThemeConfig.textSize)
        let minCoverTimeElemnet = expeditionsStack2.addText(` -  最快剩余 ${await getTime(minCoverTime)} `)
        minCoverTimeElemnet.textColor = Color.dynamic(Color.black(), Color.white())
        minCoverTimeElemnet.textOpacity = 0.5
        minCoverTimeElemnet.font = Font.mediumRoundedSystemFont(ThemeConfig.tipSize)
        let minCoverTimeElemnet2 = expeditionsStack3.addText(` -  已有角色完成 `)
        minCoverTimeElemnet2.textColor = Color.dynamic(new Color("#FC766A"), new Color("#FC766A"))
        minCoverTimeElemnet2.textOpacity = 1
        minCoverTimeElemnet2.font = Font.mediumRoundedSystemFont(ThemeConfig.tipSize)
    } else {
        let expeditionsTitleElement2 = expeditionsTitleStack.addText(`${resin.current_expedition_num} / ${resin.max_expedition_num}`)
        expeditionsTitleElement2.textColor = Color.dynamic(new Color("#995c00"), Color.white())
        expeditionsTitleElement2.textOpacity = 1
        expeditionsTitleElement2.font = Font.boldRoundedSystemFont(ThemeConfig.textSize)
        let minCoverTimeElemnet = expeditionsStack2.addText(` -  最快剩余 ${await getTime(minCoverTime)} `)
        minCoverTimeElemnet.textColor = Color.dynamic(Color.black(), Color.white())
        minCoverTimeElemnet.textOpacity = 0.5
        minCoverTimeElemnet.font = Font.mediumRoundedSystemFont(ThemeConfig.tipSize)
        let minCoverTimeElemnet2 = expeditionsStack3.addText(` - ${await getClock(minCoverTime)} `)
        minCoverTimeElemnet2.textColor = Color.dynamic(Color.black(), Color.white())
        minCoverTimeElemnet2.textOpacity = 0.5
        minCoverTimeElemnet2.font = Font.mediumRoundedSystemFont(ThemeConfig.tipSize)
    }

    return widget

}

/**
* 返回原神便笺信息
*
* @return {Promise<ResinResponse>} 便笺数据
*/
async function getData() {
    let randomStr = randomIntFromInterval(100000, 200000)
    let timestamp = Math.floor(Date.now() / 1000)
    let sign = md5("salt=xV8v4Qu54lUKrEYFZkJhB8cuOh9Asafs&t=" + timestamp + "&r=" + randomStr + "&b=&q=role_id=" + config[0] + "&server=" + config[1])
    let req = new Request("https://api-takumi-record.mihoyo.com/game_record/app/genshin/api/dailyNote?server=" + config[1] + "&role_id=" + config[0])
    req.method = "get"
    req.headers = {
        "DS": timestamp + "," + randomStr + "," + sign,
        "x-rpc-app_version": "2.40.1",
        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) miHoYoBBS/2.11.1",
        "x-rpc-client_type": "5",
        "Referer": "https://webstatic.mihoyo.com/",
        "Cookie": config[2],
    }

    let resp = await req.loadJSON()
    let data = resp.data

    return data
}

/**
 * 返回原神便笺信息(国际服)
 *
 * @return {Promise<ResinResponse>} 便笺数据
 */
async function getDataOs() {
    let randomStr = randomStrGen(6)
    let timestamp = Math.floor(Date.now() / 1000)
    let sign = md5("salt=6s25p5ox5y14umn1p61aqyyvbvvl3lrt&t=" + timestamp + "&r=" + randomStr)

    let req = new Request("https://bbs-api-os.hoyolab.com/game_record/genshin/api/dailyNote?server=" + config[1] + "&role_id=" + config[0])
    req.method = "GET"
    req.headers = {
        "DS": timestamp + "," + randomStr + "," + sign,
        "x-rpc-client_type": "5",
        "x-rpc-app_version": "2.9.1",
        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 15_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) miHoYoBBSOversea/2.9.1",
        "Origin": "https://act.hoyolab.com",
        "Referer": "https://act.hoyolab.com/",
        "Cookie": config[2]
    }

    let resp = await req.loadJSON()
    let data = resp.data

    return data
}

async function getTime(time) {
    let hh = ~~(time / 3600)
    let mm = ~~((time % 3600) / 60)

    return hh + ":" + mm
}

async function getClock(time) {
    if (+time <= 0) return "已满"

    let timeNow = Date.now()
    let now = new Date(timeNow)
    let hoursNow = now.getHours()
    let minutesNow = now.getMinutes() * 60 * 1000
    let secondsNow = now.getSeconds() * 1000
    let timeRecovery = new Date(timeNow + time * 1000)

    let tillTommorow = (24 - hoursNow) * 3600 * 1000
    let tommorow = timeNow + tillTommorow - minutesNow - secondsNow

    let str = ""
    if (timeRecovery < tommorow) {
        str = "本日"
    } else if (timeRecovery - tommorow > 86400000) {
        str = `周${'日一二三四五六'.charAt(timeRecovery.getDay())}`
    } else {
        str = "次日"
    }

    return " " + str + ", " + timeRecovery.getHours() + "点" + timeRecovery.getMinutes() + "分"
}

function randomIntFromInterval(min, max) {
    return Math.floor(Math.random() * (max - min + 1) + min)
}

function randomStrGen(length) {
    let result = '';
    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    const charactersLength = characters.length;
    for (var i = 0; i < length; i++) {
        result += characters.charAt(Math.floor(Math.random() * charactersLength));
    }
    return result;
}

function md5(string) {
    function md5_RotateLeft(lValue, iShiftBits) {
        return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
    }
    function md5_AddUnsigned(lX, lY) {
        var lX4, lY4, lX8, lY8, lResult;
        lX8 = (lX & 0x80000000);
        lY8 = (lY & 0x80000000);
        lX4 = (lX & 0x40000000);
        lY4 = (lY & 0x40000000);
        lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
        if (lX4 & lY4) {
            return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
        }
        if (lX4 | lY4) {
            if (lResult & 0x40000000) {
                return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
            } else {
                return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
            }
        } else {
            return (lResult ^ lX8 ^ lY8);
        }
    }
    function md5_F(x, y, z) {
        return (x & y) | ((~x) & z);
    }
    function md5_G(x, y, z) {
        return (x & z) | (y & (~z));
    }
    function md5_H(x, y, z) {
        return (x ^ y ^ z);
    }
    function md5_I(x, y, z) {
        return (y ^ (x | (~z)));
    }
    function md5_FF(a, b, c, d, x, s, ac) {
        a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_F(b, c, d), x), ac));
        return md5_AddUnsigned(md5_RotateLeft(a, s), b);
    };
    function md5_GG(a, b, c, d, x, s, ac) {
        a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_G(b, c, d), x), ac));
        return md5_AddUnsigned(md5_RotateLeft(a, s), b);
    };
    function md5_HH(a, b, c, d, x, s, ac) {
        a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_H(b, c, d), x), ac));
        return md5_AddUnsigned(md5_RotateLeft(a, s), b);
    };
    function md5_II(a, b, c, d, x, s, ac) {
        a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_I(b, c, d), x), ac));
        return md5_AddUnsigned(md5_RotateLeft(a, s), b);
    };
    function md5_ConvertToWordArray(string) {
        var lWordCount;
        var lMessageLength = string.length;
        var lNumberOfWords_temp1 = lMessageLength + 8;
        var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
        var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
        var lWordArray = Array(lNumberOfWords - 1);
        var lBytePosition = 0;
        var lByteCount = 0;
        while (lByteCount < lMessageLength) {
            lWordCount = (lByteCount - (lByteCount % 4)) / 4;
            lBytePosition = (lByteCount % 4) * 8;
            lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition));
            lByteCount++;
        }
        lWordCount = (lByteCount - (lByteCount % 4)) / 4;
        lBytePosition = (lByteCount % 4) * 8;
        lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
        lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
        lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
        return lWordArray;
    };
    function md5_WordToHex(lValue) {
        var WordToHexValue = "", WordToHexValue_temp = "", lByte, lCount;
        for (lCount = 0; lCount <= 3; lCount++) {
            lByte = (lValue >>> (lCount * 8)) & 255;
            WordToHexValue_temp = "0" + lByte.toString(16);
            WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
        }
        return WordToHexValue;
    };
    function md5_Utf8Encode(string) {
        string = string.replace(/\r\n/g, "\n");
        var utftext = "";
        for (var n = 0; n < string.length; n++) {
            var c = string.charCodeAt(n);
            if (c < 128) {
                utftext += String.fromCharCode(c);
            } else if ((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            } else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }
        }
        return utftext;
    };
    var x = Array();
    var k, AA, BB, CC, DD, a, b, c, d;
    var S11 = 7, S12 = 12, S13 = 17, S14 = 22;
    var S21 = 5, S22 = 9, S23 = 14, S24 = 20;
    var S31 = 4, S32 = 11, S33 = 16, S34 = 23;
    var S41 = 6, S42 = 10, S43 = 15, S44 = 21;
    string = md5_Utf8Encode(string);
    x = md5_ConvertToWordArray(string);
    a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
    for (k = 0; k < x.length; k += 16) {
        AA = a; BB = b; CC = c; DD = d;
        a = md5_FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
        d = md5_FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
        c = md5_FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
        b = md5_FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
        a = md5_FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
        d = md5_FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
        c = md5_FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
        b = md5_FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
        a = md5_FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
        d = md5_FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
        c = md5_FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
        b = md5_FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
        a = md5_FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
        d = md5_FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
        c = md5_FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
        b = md5_FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
        a = md5_GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
        d = md5_GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
        c = md5_GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
        b = md5_GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
        a = md5_GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
        d = md5_GG(d, a, b, c, x[k + 10], S22, 0x2441453);
        c = md5_GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
        b = md5_GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
        a = md5_GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
        d = md5_GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
        c = md5_GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
        b = md5_GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
        a = md5_GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
        d = md5_GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
        c = md5_GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
        b = md5_GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
        a = md5_HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
        d = md5_HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
        c = md5_HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
        b = md5_HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
        a = md5_HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
        d = md5_HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
        c = md5_HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
        b = md5_HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
        a = md5_HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
        d = md5_HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
        c = md5_HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
        b = md5_HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
        a = md5_HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
        d = md5_HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
        c = md5_HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
        b = md5_HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
        a = md5_II(a, b, c, d, x[k + 0], S41, 0xF4292244);
        d = md5_II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
        c = md5_II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
        b = md5_II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
        a = md5_II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
        d = md5_II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
        c = md5_II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
        b = md5_II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
        a = md5_II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
        d = md5_II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
        c = md5_II(c, d, a, b, x[k + 6], S43, 0xA3014314);
        b = md5_II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
        a = md5_II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
        d = md5_II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
        c = md5_II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
        b = md5_II(b, c, d, a, x[k + 9], S44, 0xEB86D391);
        a = md5_AddUnsigned(a, AA);
        b = md5_AddUnsigned(b, BB);
        c = md5_AddUnsigned(c, CC);
        d = md5_AddUnsigned(d, DD);
    }
    return (md5_WordToHex(a) + md5_WordToHex(b) + md5_WordToHex(c) + md5_WordToHex(d)).toLowerCase();
}

async function loadResinIcon() {
    const url = "data:image/png;base64,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"

    let req = new Request(url)
    let icon = await req.loadImage()
    return icon
}

async function loadCoinIcon() {
    const url = "data:image/png;base64,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";


    let req = new Request(url)
    let icon = await req.loadImage()
    return icon
}

async function loadDiscountIcon() {
    const url = "data:image/png;base64,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"

    let req = new Request(url)
    let icon = await req.loadImage()
    return icon
}

async function loadTaskIcon() {
    const url = "data:image/png;base64,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"

    let req = new Request(url)
    let icon = await req.loadImage()
    return icon
}

async function loadAvatorIcon() {
    const url = "data:image/png;base64,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"

    let req = new Request(url)
    let icon = await req.loadImage()
    return icon
}

async function loadTransformerIcon() {
    const url = "data:image/png;base64,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"

    let req = new Request(url)
    let icon = await req.loadImage()
    return icon
}