tab.ts

/**
 * Copyright (c) 2023-present Hengyang Zhang
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */

import { IS_MV3 } from '@util/constant/environment'
import { handleError } from "./common"

export function getTab(id: number): Promise<ChromeTab | undefined> {
    if (id < 0) {
        return Promise.resolve(undefined)
    }
    return new Promise(resolve => chrome.tabs.get(id, tab => {
        handleError("getTab")
        resolve(tab)
    }))
}

function getCurrentTab(): Promise<ChromeTab | undefined> {
    return new Promise(resolve => chrome.tabs.getCurrent(tab => {
        handleError("getCurrentTab")
        resolve(tab)
    }))
}

export function createTab(param: chrome.tabs.CreateProperties | string): Promise<ChromeTab> {
    const prop: chrome.tabs.CreateProperties = typeof param === 'string' ? { url: param } : param
    return new Promise(resolve => chrome.tabs.create(prop, tab => {
        handleError("getTab")
        resolve(tab)
    }))
}

/**
 * Create one tab after current tab.
 *
 * Must not be invoked in background.js
 */
export async function createTabAfterCurrent(url: string, currentTab?: ChromeTab): Promise<ChromeTab> {
    if (!currentTab) {
        currentTab = await getCurrentTab()
    }
    if (!currentTab) {
        // Current tab not found
        return createTab(url)
    } else {
        const { windowId, index: currentIndex } = currentTab
        return createTab({
            url,
            windowId,
            index: (currentIndex ?? -1) + 1
        })
    }
}

export function listTabs(query?: chrome.tabs.QueryInfo): Promise<ChromeTab[]> {
    query = query || {}
    return new Promise(resolve => chrome.tabs.query(query, tabs => {
        handleError("listTabs")
        resolve(tabs || [])
    }))
}

export function sendMsg2Tab<C extends tt4b.tab.ReqCode>(tabId: number, code: C, data?: tt4b.tab.ReqData<C>): Promise<tt4b.tab.ResData<C> | undefined> {
    const request: tt4b.tab.Request<C> = { code, data: data as tt4b.tab.ReqData<C> }
    return new Promise((resolve, reject) => {
        const timeout = setTimeout(() => reject('sendMsg2Tab timeout'), 2000)
        chrome.tabs.sendMessage<tt4b.tab.Request<C>, tt4b.tab.Response<C>>(tabId, request, response => {
            const sendError = handleError('sendMsg2Tab')
            clearTimeout(timeout)
            if (response?.code === 'success') {
                resolve(response.data as tt4b.tab.ResData<C> | undefined)
                return
            }
            if (response?.code === 'fail') {
                reject(new Error(response.msg ?? sendError ?? 'Unknown error'))
                return
            }
            reject(new Error(sendError ?? 'Unknown error'))
        })
    })
}

export async function trySendMsg2Tab<C extends tt4b.tab.ReqCode>(
    tabId: number,
    code: C,
    data?: tt4b.tab.ReqData<C>
): Promise<tt4b.tab.ResData<C> | undefined> {
    try {
        return await sendMsg2Tab(tabId, code, data)
    } catch (e) {
        console.warn(`Errored to send message to tab: tabId=${tabId}, code=${code}, data=${JSON.stringify(data)}`, e)
        return Promise.resolve(undefined)
    }
}

type TabHandler<Event> = (tabId: number, ev: Event, tab: ChromeTab) => void

export function onTabActivated(handler: (tabId: number, info: ChromeTabActiveInfo) => void): void {
    chrome.tabs.onActivated.addListener(activeInfo => {
        handleError("tabActivated")
        handler(activeInfo.tabId, activeInfo)
    })
}

export function onTabUpdated(handler: TabHandler<ChromeTabUpdatedInfo>): void {
    chrome.tabs.onUpdated.addListener((tabId: number, changeInfo: ChromeTabUpdatedInfo, tab: ChromeTab) => {
        handleError("tabUpdated")
        handler(tabId, changeInfo, tab)
    })
}

export function updateTab(tabId: number, updateProperties: chrome.tabs.UpdateProperties): Promise<ChromeTab | undefined> {
    if (IS_MV3) {
        return chrome.tabs.update(tabId, updateProperties)
    }
    return new Promise((resolve) => {
        chrome.tabs.update(tabId, updateProperties, (tab) => {
            handleError("updateTab")
            resolve(tab)
        })
    })
}