TypeScript browser.tabs.query方法代码示例

async function onTabRemoved(id: number, info: Tabs.OnRemovedRemoveInfoType) {
    const state = getWindowState(info.windowId);

    // Since we don't have a good way of determining whether the removed tab was
    // previously the active tab, make an educated guess based on the fact that
    // the browser may focus some other tab before we get this message, so the
    // removed tab will be either:
    // 1. The most-recent tab in the window's history
    // 2. The second most-recent tab in the window's history, and the active
    //    window was just changed.
    const browserChangedFocus = activeChanged && id === state.history.second;

    const wasActive = browserChangedFocus || id === state.history.first;

    logger.enabled && logger.log(
        `wasActive = ${wasActive}, activeChanged = ${activeChanged}, browserChangedFocus = ${browserChangedFocus}`);

    // If we are overriding which tab gets focused after removing a tab, and the
    // browser focused some other tab before telling us which tab was removed,
    // rewind the state by one to ignore the unwanted change made by the browser.
    if (browserChangedFocus && settings.onClose !== 'default') {
        state.rewind();
    }

    state.removeTab(id);

    // If the removed tab was active, override which tab gets focus next.
    if (wasActive) {
        switch (settings.onClose) {
            case 'lastfocused':
                const newTab = state.history.first;
                logger.enabled && logger.log(`focusing last-focused tab ${newTab}`);

                if (newTab !== undefined) {
                    await focusTab(newTab);
                }
                break;

            case 'next':
            case 'previous':
                // If 'next', the next tab will be in the closing tab's old position.
                // If 'previous', focus the tab right before that, or the leftmost tab.
                let index = state.activeTabIndex;

                logger.enabled && logger.log(`focusing ${settings.onClose} tab from position ${index}`);

                if (index !== undefined) {
                    if (settings.onClose === 'previous') {
                        index = Math.max(0, index - 1);
                    }

                    const tabs = await browser.tabs.query({ windowId: info.windowId, index });
                    if (tabs.length > 0) {
                        await focusTab(tabs[0]);
                    }
                }
                break;
        }
    }
}

async function initActiveTabs() {
    const activeTabs = await browser.tabs.query({ active: true});

    for (const tab of activeTabs) {
        if (tab.windowId === undefined || tab.id === undefined) {
            continue;
        }

        const state = getWindowState(tab.windowId);
        state.addTab(tab.id);
    }
}

export const moveTab = async (direction: tabbo.Direction): Promise<void> => {
	const tabs: browser.tabs.Tab[] = await browser.tabs.query({currentWindow: true});
	const pinnedTabs: browser.tabs.Tab[] = tabs.filter(
		(e: browser.tabs.Tab): boolean => e.pinned
	);
	/*
	 *const unpinnedTabs: browser.tabs.Tab[] = tabs.filter(
	 *    (e: browser.tabs.Tab): boolean => !e.pinned
	 *);
	 *const highlightedTabs: browser.tabs.Tab[] = tabs.filter(
	 *    (e: browser.tabs.Tab): boolean => e.highlighted
	 *);
	 *const nonHighlightedTabs: browser.tabs.Tab[] = tabs.filter(
	 *    (e: browser.tabs.Tab): boolean => !e.highlighted
	 *);
	 */

	const tab: browser.tabs.Tab = await utils.tabs.getCurrent();

	const currentIndex: number = tab.index;
	let newIndex: number = 0;
	let lowerBound: number = 0;
	let upperBound: number = 0;

	if (tab.pinned) {
		lowerBound = 0;
		upperBound = pinnedTabs.length - 1;
	} else {
		lowerBound = pinnedTabs.length;
		upperBound = tabs.length - 1;
	}

	if (direction === tabbo.Direction.LEFT) {
		newIndex = (currentIndex === lowerBound) ? upperBound : currentIndex - 1;
	} else {
		newIndex = (currentIndex === upperBound) ? lowerBound : currentIndex + 1;
	}

	try {
		await browser.tabs.move(tab.id, {index: newIndex});
	} catch (e) {
		logging.error(e.message);
	}
};

	getCurrent: async (): Promise<browser.tabs.Tab> => {
		return (await browser.tabs.query({active: true, currentWindow: true}))[0];
	},