1435 lines
45 KiB
TypeScript
Executable File
1435 lines
45 KiB
TypeScript
Executable File
/**
|
|
* Namespace: browser.tabs
|
|
* Generated from Mozilla sources. Do not manually edit!
|
|
*
|
|
* Use the <code>browser.tabs</code> API to interact with the browser's tab system. You can use this API to create, modify,
|
|
* and rearrange tabs in the browser.
|
|
*
|
|
* Comments found in source JSON schema files:
|
|
* Copyright (c) 2012 The Chromium Authors. All rights reserved.
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
import { Events } from "./events";
|
|
import { Runtime } from "./runtime";
|
|
import { Windows } from "./windows";
|
|
import { ExtensionTypes } from "./extensionTypes";
|
|
|
|
export namespace Tabs {
|
|
/**
|
|
* An event that caused a muted state change.
|
|
*
|
|
* "user": A user input action has set/overridden the muted state.
|
|
* "capture": Tab capture started, forcing a muted state change.
|
|
* "extension": An extension, identified by the extensionId field, set the muted state.
|
|
*/
|
|
type MutedInfoReason = "user" | "capture" | "extension";
|
|
|
|
/**
|
|
* Tab muted state and the reason for the last state change.
|
|
*/
|
|
interface MutedInfo {
|
|
/**
|
|
* Whether the tab is prevented from playing sound (but hasn't necessarily recently produced sound).
|
|
* Equivalent to whether the muted audio indicator is showing.
|
|
*/
|
|
muted: boolean;
|
|
|
|
/**
|
|
* The reason the tab was muted or unmuted. Not set if the tab's mute state has never been changed.
|
|
* Optional.
|
|
*/
|
|
reason?: MutedInfoReason;
|
|
|
|
/**
|
|
* The ID of the extension that changed the muted state. Not set if an extension was not the reason the muted state last
|
|
* changed.
|
|
* Optional.
|
|
*/
|
|
extensionId?: string;
|
|
}
|
|
|
|
/**
|
|
* Tab sharing state for screen, microphone and camera.
|
|
*/
|
|
interface SharingState {
|
|
/**
|
|
* If the tab is sharing the screen the value will be one of "Screen", "Window", or "Application",
|
|
* or undefined if not screen sharing.
|
|
* Optional.
|
|
*/
|
|
screen?: string;
|
|
|
|
/**
|
|
* True if the tab is using the camera.
|
|
*/
|
|
camera: boolean;
|
|
|
|
/**
|
|
* True if the tab is using the microphone.
|
|
*/
|
|
microphone: boolean;
|
|
}
|
|
|
|
interface Tab {
|
|
/**
|
|
* The ID of the tab. Tab IDs are unique within a browser session. Under some circumstances a Tab may not be assigned an ID,
|
|
* for example when querying foreign tabs using the $(ref:sessions) API, in which case a session ID may be present.
|
|
* Tab ID can also be set to $(ref:tabs.TAB_ID_NONE) for apps and devtools windows.
|
|
* Optional.
|
|
*/
|
|
id?: number;
|
|
|
|
/**
|
|
* The zero-based index of the tab within its window.
|
|
*/
|
|
index: number;
|
|
|
|
/**
|
|
* The ID of the window the tab is contained within.
|
|
* Optional.
|
|
*/
|
|
windowId?: number;
|
|
|
|
/**
|
|
* The ID of the tab that opened this tab, if any. This property is only present if the opener tab still exists.
|
|
* Optional.
|
|
*/
|
|
openerTabId?: number;
|
|
|
|
/**
|
|
* Whether the tab is highlighted. Works as an alias of active
|
|
*/
|
|
highlighted: boolean;
|
|
|
|
/**
|
|
* Whether the tab is active in its window. (Does not necessarily mean the window is focused.)
|
|
*/
|
|
active: boolean;
|
|
|
|
/**
|
|
* Whether the tab is pinned.
|
|
*/
|
|
pinned: boolean;
|
|
|
|
/**
|
|
* The last time the tab was accessed as the number of milliseconds since epoch.
|
|
* Optional.
|
|
*/
|
|
lastAccessed?: number;
|
|
|
|
/**
|
|
* Whether the tab has produced sound over the past couple of seconds (but it might not be heard if also muted).
|
|
* Equivalent to whether the speaker audio indicator is showing.
|
|
* Optional.
|
|
*/
|
|
audible?: boolean;
|
|
|
|
/**
|
|
* Current tab muted state and the reason for the last state change.
|
|
* Optional.
|
|
*/
|
|
mutedInfo?: MutedInfo;
|
|
|
|
/**
|
|
* The URL the tab is displaying. This property is only present if the extension's manifest includes the <code>"tabs"</code>
|
|
* permission.
|
|
* Optional.
|
|
*/
|
|
url?: string;
|
|
|
|
/**
|
|
* The title of the tab. This property is only present if the extension's manifest includes the <code>"tabs"</code>
|
|
* permission.
|
|
* Optional.
|
|
*/
|
|
title?: string;
|
|
|
|
/**
|
|
* The URL of the tab's favicon. This property is only present if the extension's manifest includes the <code>"tabs"</code>
|
|
* permission. It may also be an empty string if the tab is loading.
|
|
* Optional.
|
|
*/
|
|
favIconUrl?: string;
|
|
|
|
/**
|
|
* Either <em>loading</em> or <em>complete</em>.
|
|
* Optional.
|
|
*/
|
|
status?: string;
|
|
|
|
/**
|
|
* True while the tab is not loaded with content.
|
|
* Optional.
|
|
*/
|
|
discarded?: boolean;
|
|
|
|
/**
|
|
* Whether the tab is in an incognito window.
|
|
*/
|
|
incognito: boolean;
|
|
|
|
/**
|
|
* The width of the tab in pixels.
|
|
* Optional.
|
|
*/
|
|
width?: number;
|
|
|
|
/**
|
|
* The height of the tab in pixels.
|
|
* Optional.
|
|
*/
|
|
height?: number;
|
|
|
|
/**
|
|
* True if the tab is hidden.
|
|
* Optional.
|
|
*/
|
|
hidden?: boolean;
|
|
|
|
/**
|
|
* The session ID used to uniquely identify a Tab obtained from the $(ref:sessions) API.
|
|
* Optional.
|
|
*/
|
|
sessionId?: string;
|
|
|
|
/**
|
|
* The CookieStoreId used for the tab.
|
|
* Optional.
|
|
*/
|
|
cookieStoreId?: string;
|
|
|
|
/**
|
|
* Whether the document in the tab can be rendered in reader mode.
|
|
* Optional.
|
|
*/
|
|
isArticle?: boolean;
|
|
|
|
/**
|
|
* Whether the document in the tab is being rendered in reader mode.
|
|
* Optional.
|
|
*/
|
|
isInReaderMode?: boolean;
|
|
|
|
/**
|
|
* Current tab sharing state for screen, microphone and camera.
|
|
* Optional.
|
|
*/
|
|
sharingState?: SharingState;
|
|
|
|
/**
|
|
* Whether the tab is drawing attention.
|
|
* Optional.
|
|
*/
|
|
attention?: boolean;
|
|
|
|
/**
|
|
* The ID of this tab's successor, if any; $(ref:tabs.TAB_ID_NONE) otherwise.
|
|
* Optional.
|
|
*/
|
|
successorTabId?: number;
|
|
|
|
/**
|
|
* Whether the tab can be discarded automatically by the browser when resources are low.
|
|
* Optional.
|
|
*/
|
|
autoDiscardable?: boolean;
|
|
|
|
/**
|
|
* The URL the tab is navigating to, before it has committed. This property is only present if the extension's manifest
|
|
* includes the "tabs" permission and there is a pending navigation.
|
|
* Optional.
|
|
*/
|
|
pendingUrl?: string;
|
|
}
|
|
|
|
/**
|
|
* Defines how zoom changes are handled, i.e. which entity is responsible for the actual scaling of the page; defaults to
|
|
* <code>automatic</code>.
|
|
*
|
|
* "automatic": Zoom changes are handled automatically by the browser.
|
|
* "manual": Overrides the automatic handling of zoom changes. The <code>onZoomChange</code> event will still be dispatched,
|
|
* and it is the responsibility of the extension to listen for this event and manually scale the page.
|
|
* This mode does not support <code>per-origin</code> zooming, and will thus ignore the <code>scope</code>
|
|
* zoom setting and assume <code>per-tab</code>.
|
|
* "disabled": Disables all zooming in the tab. The tab will revert to the default zoom level,
|
|
* and all attempted zoom changes will be ignored.
|
|
*/
|
|
type ZoomSettingsMode = "automatic" | "manual" | "disabled";
|
|
|
|
/**
|
|
* Defines whether zoom changes will persist for the page's origin, or only take effect in this tab; defaults to <code>
|
|
* per-origin</code> when in <code>automatic</code> mode, and <code>per-tab</code> otherwise.
|
|
*
|
|
* "per-origin": Zoom changes will persist in the zoomed page's origin, i.e. all other tabs navigated to that same origin
|
|
* will be zoomed as well. Moreover, <code>per-origin</code> zoom changes are saved with the origin,
|
|
* meaning that when navigating to other pages in the same origin, they will all be zoomed to the same zoom factor.
|
|
* The <code>per-origin</code> scope is only available in the <code>automatic</code> mode.
|
|
* "per-tab": Zoom changes only take effect in this tab, and zoom changes in other tabs will not affect the zooming of this
|
|
* tab. Also, <code>per-tab</code> zoom changes are reset on navigation; navigating a tab will always load pages with their
|
|
* <code>per-origin</code> zoom factors.
|
|
*/
|
|
type ZoomSettingsScope = "per-origin" | "per-tab";
|
|
|
|
/**
|
|
* Defines how zoom changes in a tab are handled and at what scope.
|
|
*/
|
|
interface ZoomSettings {
|
|
/**
|
|
* Defines how zoom changes are handled, i.e. which entity is responsible for the actual scaling of the page; defaults to
|
|
* <code>automatic</code>.
|
|
* Optional.
|
|
*/
|
|
mode?: ZoomSettingsMode;
|
|
|
|
/**
|
|
* Defines whether zoom changes will persist for the page's origin, or only take effect in this tab; defaults to <code>
|
|
* per-origin</code> when in <code>automatic</code> mode, and <code>per-tab</code> otherwise.
|
|
* Optional.
|
|
*/
|
|
scope?: ZoomSettingsScope;
|
|
|
|
/**
|
|
* Used to return the default zoom level for the current tab in calls to tabs.getZoomSettings.
|
|
* Optional.
|
|
*/
|
|
defaultZoomFactor?: number;
|
|
}
|
|
|
|
/**
|
|
* Defines the page settings to be used when saving a page as a pdf file.
|
|
*/
|
|
interface PageSettings {
|
|
/**
|
|
* The name of the file. May include optional .pdf extension.
|
|
* Optional.
|
|
*/
|
|
toFileName?: string;
|
|
|
|
/**
|
|
* The page size unit: 0 = inches, 1 = millimeters. Default: 0.
|
|
* Optional.
|
|
*/
|
|
paperSizeUnit?: number;
|
|
|
|
/**
|
|
* The paper width in paper size units. Default: 8.5.
|
|
* Optional.
|
|
*/
|
|
paperWidth?: number;
|
|
|
|
/**
|
|
* The paper height in paper size units. Default: 11.0.
|
|
* Optional.
|
|
*/
|
|
paperHeight?: number;
|
|
|
|
/**
|
|
* The page content orientation: 0 = portrait, 1 = landscape. Default: 0.
|
|
* Optional.
|
|
*/
|
|
orientation?: number;
|
|
|
|
/**
|
|
* The page content scaling factor: 1.0 = 100% = normal size. Default: 1.0.
|
|
* Optional.
|
|
*/
|
|
scaling?: number;
|
|
|
|
/**
|
|
* Whether the page content should shrink to fit the page width (overrides scaling). Default: true.
|
|
* Optional.
|
|
*/
|
|
shrinkToFit?: boolean;
|
|
|
|
/**
|
|
* Whether the page background colors should be shown. Default: false.
|
|
* Optional.
|
|
*/
|
|
showBackgroundColors?: boolean;
|
|
|
|
/**
|
|
* Whether the page background images should be shown. Default: false.
|
|
* Optional.
|
|
*/
|
|
showBackgroundImages?: boolean;
|
|
|
|
/**
|
|
* The spacing between the left header/footer and the left edge of the paper (inches). Default: 0.
|
|
* Optional.
|
|
*/
|
|
edgeLeft?: number;
|
|
|
|
/**
|
|
* The spacing between the right header/footer and the right edge of the paper (inches). Default: 0.
|
|
* Optional.
|
|
*/
|
|
edgeRight?: number;
|
|
|
|
/**
|
|
* The spacing between the top of the headers and the top edge of the paper (inches). Default: 0
|
|
* Optional.
|
|
*/
|
|
edgeTop?: number;
|
|
|
|
/**
|
|
* The spacing between the bottom of the footers and the bottom edge of the paper (inches). Default: 0.
|
|
* Optional.
|
|
*/
|
|
edgeBottom?: number;
|
|
|
|
/**
|
|
* The margin between the page content and the left edge of the paper (inches). Default: 0.5.
|
|
* Optional.
|
|
*/
|
|
marginLeft?: number;
|
|
|
|
/**
|
|
* The margin between the page content and the right edge of the paper (inches). Default: 0.5.
|
|
* Optional.
|
|
*/
|
|
marginRight?: number;
|
|
|
|
/**
|
|
* The margin between the page content and the top edge of the paper (inches). Default: 0.5.
|
|
* Optional.
|
|
*/
|
|
marginTop?: number;
|
|
|
|
/**
|
|
* The margin between the page content and the bottom edge of the paper (inches). Default: 0.5.
|
|
* Optional.
|
|
*/
|
|
marginBottom?: number;
|
|
|
|
/**
|
|
* The text for the page's left header. Default: '&T'.
|
|
* Optional.
|
|
*/
|
|
headerLeft?: string;
|
|
|
|
/**
|
|
* The text for the page's center header. Default: ''.
|
|
* Optional.
|
|
*/
|
|
headerCenter?: string;
|
|
|
|
/**
|
|
* The text for the page's right header. Default: '&U'.
|
|
* Optional.
|
|
*/
|
|
headerRight?: string;
|
|
|
|
/**
|
|
* The text for the page's left footer. Default: '&PT'.
|
|
* Optional.
|
|
*/
|
|
footerLeft?: string;
|
|
|
|
/**
|
|
* The text for the page's center footer. Default: ''.
|
|
* Optional.
|
|
*/
|
|
footerCenter?: string;
|
|
|
|
/**
|
|
* The text for the page's right footer. Default: '&D'.
|
|
* Optional.
|
|
*/
|
|
footerRight?: string;
|
|
}
|
|
|
|
/**
|
|
* Whether the tabs have completed loading.
|
|
*/
|
|
type TabStatus = "loading" | "complete";
|
|
|
|
/**
|
|
* The type of window.
|
|
*/
|
|
type WindowType = "normal" | "popup" | "panel" | "app" | "devtools";
|
|
|
|
/**
|
|
* Event names supported in onUpdated.
|
|
*/
|
|
type UpdatePropertyName =
|
|
| "attention"
|
|
| "audible"
|
|
| "discarded"
|
|
| "favIconUrl"
|
|
| "hidden"
|
|
| "isArticle"
|
|
| "mutedInfo"
|
|
| "pinned"
|
|
| "sharingState"
|
|
| "status"
|
|
| "title"
|
|
| "url";
|
|
|
|
/**
|
|
* An object describing filters to apply to tabs.onUpdated events.
|
|
*/
|
|
interface UpdateFilter {
|
|
/**
|
|
* A list of URLs or URL patterns. Events that cannot match any of the URLs will be filtered out.
|
|
* Filtering with urls requires the <code>"tabs"</code> or <code>"activeTab"</code> permission.
|
|
* Optional.
|
|
*/
|
|
urls?: string[];
|
|
|
|
/**
|
|
* A list of property names. Events that do not match any of the names will be filtered out.
|
|
* Optional.
|
|
*/
|
|
properties?: UpdatePropertyName[];
|
|
|
|
/**
|
|
* Optional.
|
|
*/
|
|
tabId?: number;
|
|
|
|
/**
|
|
* Optional.
|
|
*/
|
|
windowId?: number;
|
|
}
|
|
|
|
interface ConnectConnectInfoType {
|
|
/**
|
|
* Will be passed into onConnect for content scripts that are listening for the connection event.
|
|
* Optional.
|
|
*/
|
|
name?: string;
|
|
|
|
/**
|
|
* Open a port to a specific $(topic:frame_ids)[frame] identified by <code>frameId</code> instead of all frames in the tab.
|
|
* Optional.
|
|
*/
|
|
frameId?: number;
|
|
}
|
|
|
|
interface SendMessageOptionsType {
|
|
/**
|
|
* Send a message to a specific $(topic:frame_ids)[frame] identified by <code>frameId</code>
|
|
* instead of all frames in the tab.
|
|
* Optional.
|
|
*/
|
|
frameId?: number;
|
|
}
|
|
|
|
interface CreateCreatePropertiesType {
|
|
/**
|
|
* The window to create the new tab in. Defaults to the $(topic:current-window)[current window].
|
|
* Optional.
|
|
*/
|
|
windowId?: number;
|
|
|
|
/**
|
|
* The position the tab should take in the window. The provided value will be clamped to between zero and the number of
|
|
* tabs in the window.
|
|
* Optional.
|
|
*/
|
|
index?: number;
|
|
|
|
/**
|
|
* The URL to navigate the tab to initially. Fully-qualified URLs must include a scheme (i.e. 'http://www.google.com',
|
|
* not 'www.google.com'). Relative URLs will be relative to the current page within the extension.
|
|
* Defaults to the New Tab Page.
|
|
* Optional.
|
|
*/
|
|
url?: string;
|
|
|
|
/**
|
|
* Whether the tab should become the active tab in the window. Does not affect whether the window is focused (see
|
|
* $(ref:windows.update)). Defaults to <var>true</var>.
|
|
* Optional.
|
|
*/
|
|
active?: boolean;
|
|
|
|
/**
|
|
* Whether the tab should be pinned. Defaults to <var>false</var>
|
|
* Optional.
|
|
*/
|
|
pinned?: boolean;
|
|
|
|
/**
|
|
* The ID of the tab that opened this tab. If specified, the opener tab must be in the same window as the newly created tab.
|
|
* Optional.
|
|
*/
|
|
openerTabId?: number;
|
|
|
|
/**
|
|
* The CookieStoreId for the tab that opened this tab.
|
|
* Optional.
|
|
*/
|
|
cookieStoreId?: string;
|
|
|
|
/**
|
|
* Whether the document in the tab should be opened in reader mode.
|
|
* Optional.
|
|
*/
|
|
openInReaderMode?: boolean;
|
|
|
|
/**
|
|
* Whether the tab is marked as 'discarded' when created.
|
|
* Optional.
|
|
*/
|
|
discarded?: boolean;
|
|
|
|
/**
|
|
* The title used for display if the tab is created in discarded mode.
|
|
* Optional.
|
|
*/
|
|
title?: string;
|
|
}
|
|
|
|
interface DuplicateDuplicatePropertiesType {
|
|
/**
|
|
* The position the new tab should take in the window. The provided value will be clamped to between zero and the number of
|
|
* tabs in the window.
|
|
* Optional.
|
|
*/
|
|
index?: number;
|
|
|
|
/**
|
|
* Whether the tab should become the active tab in the window. Does not affect whether the window is focused (see
|
|
* $(ref:windows.update)). Defaults to <var>true</var>.
|
|
* Optional.
|
|
*/
|
|
active?: boolean;
|
|
}
|
|
|
|
interface QueryQueryInfoType {
|
|
/**
|
|
* Whether the tabs are active in their windows.
|
|
* Optional.
|
|
*/
|
|
active?: boolean;
|
|
|
|
/**
|
|
* Whether the tabs are drawing attention.
|
|
* Optional.
|
|
*/
|
|
attention?: boolean;
|
|
|
|
/**
|
|
* Whether the tabs are pinned.
|
|
* Optional.
|
|
*/
|
|
pinned?: boolean;
|
|
|
|
/**
|
|
* Whether the tabs are audible.
|
|
* Optional.
|
|
*/
|
|
audible?: boolean;
|
|
|
|
/**
|
|
* Whether the tabs are muted.
|
|
* Optional.
|
|
*/
|
|
muted?: boolean;
|
|
|
|
/**
|
|
* Whether the tabs are highlighted. Works as an alias of active.
|
|
* Optional.
|
|
*/
|
|
highlighted?: boolean;
|
|
|
|
/**
|
|
* Whether the tabs are in the $(topic:current-window)[current window].
|
|
* Optional.
|
|
*/
|
|
currentWindow?: boolean;
|
|
|
|
/**
|
|
* Whether the tabs are in the last focused window.
|
|
* Optional.
|
|
*/
|
|
lastFocusedWindow?: boolean;
|
|
|
|
/**
|
|
* Whether the tabs have completed loading.
|
|
* Optional.
|
|
*/
|
|
status?: TabStatus;
|
|
|
|
/**
|
|
* True while the tabs are not loaded with content.
|
|
* Optional.
|
|
*/
|
|
discarded?: boolean;
|
|
|
|
/**
|
|
* True while the tabs are hidden.
|
|
* Optional.
|
|
*/
|
|
hidden?: boolean;
|
|
|
|
/**
|
|
* Match page titles against a pattern.
|
|
* Optional.
|
|
*/
|
|
title?: string;
|
|
|
|
/**
|
|
* Match tabs against one or more $(topic:match_patterns)[URL patterns]. Note that fragment identifiers are not matched.
|
|
* Optional.
|
|
*/
|
|
url?: string | string[];
|
|
|
|
/**
|
|
* The ID of the parent window, or $(ref:windows.WINDOW_ID_CURRENT) for the $(topic:current-window)[current window].
|
|
* Optional.
|
|
*/
|
|
windowId?: number;
|
|
|
|
/**
|
|
* The type of window the tabs are in.
|
|
* Optional.
|
|
*/
|
|
windowType?: WindowType;
|
|
|
|
/**
|
|
* The position of the tabs within their windows.
|
|
* Optional.
|
|
*/
|
|
index?: number;
|
|
|
|
/**
|
|
* The CookieStoreId used for the tab.
|
|
* Optional.
|
|
*/
|
|
cookieStoreId?: string;
|
|
|
|
/**
|
|
* The ID of the tab that opened this tab. If specified, the opener tab must be in the same window as this tab.
|
|
* Optional.
|
|
*/
|
|
openerTabId?: number;
|
|
|
|
/**
|
|
* True for any screen sharing, or a string to specify type of screen sharing.
|
|
* Optional.
|
|
*/
|
|
screen?: "Screen" | "Window" | "Application" | boolean;
|
|
|
|
/**
|
|
* True if the tab is using the camera.
|
|
* Optional.
|
|
*/
|
|
camera?: boolean;
|
|
|
|
/**
|
|
* True if the tab is using the microphone.
|
|
* Optional.
|
|
*/
|
|
microphone?: boolean;
|
|
|
|
/**
|
|
* Whether the tabs can be discarded automatically by the browser when resources are low.
|
|
* Optional.
|
|
*/
|
|
autoDiscardable?: boolean;
|
|
}
|
|
|
|
interface HighlightHighlightInfoType {
|
|
/**
|
|
* The window that contains the tabs.
|
|
* Optional.
|
|
*/
|
|
windowId?: number;
|
|
|
|
/**
|
|
* If true, the $(ref:windows.Window) returned will have a <var>tabs</var> property that contains a list of the $(ref:tabs.
|
|
* Tab) objects. The <code>Tab</code> objects only contain the <code>url</code>, <code>title</code> and <code>
|
|
* favIconUrl</code> properties if the extension's manifest file includes the <code>"tabs"</code> permission. If false,
|
|
* the $(ref:windows.Window) won't have the <var>tabs</var> property.
|
|
* Optional.
|
|
*/
|
|
populate?: boolean;
|
|
|
|
/**
|
|
* One or more tab indices to highlight.
|
|
*/
|
|
tabs: number[] | number;
|
|
}
|
|
|
|
interface UpdateUpdatePropertiesType {
|
|
/**
|
|
* A URL to navigate the tab to.
|
|
* Optional.
|
|
*/
|
|
url?: string;
|
|
|
|
/**
|
|
* Whether the tab should be active. Does not affect whether the window is focused (see $(ref:windows.update)).
|
|
* Optional.
|
|
*/
|
|
active?: boolean;
|
|
|
|
/**
|
|
* Adds or removes the tab from the current selection.
|
|
* Optional.
|
|
*/
|
|
highlighted?: boolean;
|
|
|
|
/**
|
|
* Whether the tab should be pinned.
|
|
* Optional.
|
|
*/
|
|
pinned?: boolean;
|
|
|
|
/**
|
|
* Whether the tab should be muted.
|
|
* Optional.
|
|
*/
|
|
muted?: boolean;
|
|
|
|
/**
|
|
* The ID of the tab that opened this tab. If specified, the opener tab must be in the same window as this tab.
|
|
* Optional.
|
|
*/
|
|
openerTabId?: number;
|
|
|
|
/**
|
|
* Whether the load should replace the current history entry for the tab.
|
|
* Optional.
|
|
*/
|
|
loadReplace?: boolean;
|
|
|
|
/**
|
|
* The ID of this tab's successor. If specified, the successor tab must be in the same window as this tab.
|
|
* Optional.
|
|
*/
|
|
successorTabId?: number;
|
|
|
|
/**
|
|
* Whether the tab should be discarded automatically by the browser when resources are low.
|
|
* Optional.
|
|
*/
|
|
autoDiscardable?: boolean;
|
|
}
|
|
|
|
interface MoveMovePropertiesType {
|
|
/**
|
|
* Defaults to the window the tab is currently in.
|
|
* Optional.
|
|
*/
|
|
windowId?: number;
|
|
|
|
/**
|
|
* The position to move the window to. -1 will place the tab at the end of the window.
|
|
*/
|
|
index: number;
|
|
}
|
|
|
|
interface ReloadReloadPropertiesType {
|
|
/**
|
|
* Whether using any local cache. Default is false.
|
|
* Optional.
|
|
*/
|
|
bypassCache?: boolean;
|
|
}
|
|
|
|
interface MoveInSuccessionOptionsType {
|
|
/**
|
|
* Whether to move the tabs before (false) or after (true) tabId in the succession. Defaults to false.
|
|
* Optional.
|
|
*/
|
|
append?: boolean;
|
|
|
|
/**
|
|
* Whether to link up the current predecessors or successor (depending on options.append)
|
|
* of tabId to the other side of the chain after it is prepended or appended. If true,
|
|
* one of the following happens: if options.append is false, the first tab in the array is set as the successor of any
|
|
* current predecessors of tabId; if options.append is true, the current successor of tabId is set as the successor of the
|
|
* last tab in the array. Defaults to false.
|
|
* Optional.
|
|
*/
|
|
insert?: boolean;
|
|
}
|
|
|
|
/**
|
|
* Lists the changes to the state of the tab that was updated.
|
|
*/
|
|
interface OnUpdatedChangeInfoType {
|
|
/**
|
|
* The tab's new attention state.
|
|
* Optional.
|
|
*/
|
|
attention?: boolean;
|
|
|
|
/**
|
|
* The tab's new audible state.
|
|
* Optional.
|
|
*/
|
|
audible?: boolean;
|
|
|
|
/**
|
|
* True while the tab is not loaded with content.
|
|
* Optional.
|
|
*/
|
|
discarded?: boolean;
|
|
|
|
/**
|
|
* The tab's new favicon URL. This property is only present if the extension's manifest includes the <code>"tabs"</code>
|
|
* permission.
|
|
* Optional.
|
|
*/
|
|
favIconUrl?: string;
|
|
|
|
/**
|
|
* The tab's new hidden state.
|
|
* Optional.
|
|
*/
|
|
hidden?: boolean;
|
|
|
|
/**
|
|
* Whether the document in the tab can be rendered in reader mode.
|
|
* Optional.
|
|
*/
|
|
isArticle?: boolean;
|
|
|
|
/**
|
|
* The tab's new muted state and the reason for the change.
|
|
* Optional.
|
|
*/
|
|
mutedInfo?: MutedInfo;
|
|
|
|
/**
|
|
* The tab's new pinned state.
|
|
* Optional.
|
|
*/
|
|
pinned?: boolean;
|
|
|
|
/**
|
|
* The tab's new sharing state for screen, microphone and camera.
|
|
* Optional.
|
|
*/
|
|
sharingState?: SharingState;
|
|
|
|
/**
|
|
* The status of the tab. Can be either <em>loading</em> or <em>complete</em>.
|
|
* Optional.
|
|
*/
|
|
status?: string;
|
|
|
|
/**
|
|
* The title of the tab if it has changed. This property is only present if the extension's manifest includes the <code>
|
|
* "tabs"</code> permission.
|
|
* Optional.
|
|
*/
|
|
title?: string;
|
|
|
|
/**
|
|
* The tab's URL if it has changed. This property is only present if the extension's manifest includes the <code>
|
|
* "tabs"</code> permission.
|
|
* Optional.
|
|
*/
|
|
url?: string;
|
|
}
|
|
|
|
interface OnMovedMoveInfoType {
|
|
windowId: number;
|
|
|
|
fromIndex: number;
|
|
|
|
toIndex: number;
|
|
}
|
|
|
|
interface OnActivatedActiveInfoType {
|
|
/**
|
|
* The ID of the tab that has become active.
|
|
*/
|
|
tabId: number;
|
|
|
|
/**
|
|
* The ID of the tab that was previously active, if that tab is still open.
|
|
* Optional.
|
|
*/
|
|
previousTabId?: number;
|
|
|
|
/**
|
|
* The ID of the window the active tab changed inside of.
|
|
*/
|
|
windowId: number;
|
|
}
|
|
|
|
interface OnHighlightedHighlightInfoType {
|
|
/**
|
|
* The window whose tabs changed.
|
|
*/
|
|
windowId: number;
|
|
|
|
/**
|
|
* All highlighted tabs in the window.
|
|
*/
|
|
tabIds: number[];
|
|
}
|
|
|
|
interface OnDetachedDetachInfoType {
|
|
oldWindowId: number;
|
|
|
|
oldPosition: number;
|
|
}
|
|
|
|
interface OnAttachedAttachInfoType {
|
|
newWindowId: number;
|
|
|
|
newPosition: number;
|
|
}
|
|
|
|
interface OnRemovedRemoveInfoType {
|
|
/**
|
|
* The window whose tab is closed.
|
|
*/
|
|
windowId: number;
|
|
|
|
/**
|
|
* True when the tab is being closed because its window is being closed.
|
|
*/
|
|
isWindowClosing: boolean;
|
|
}
|
|
|
|
interface OnZoomChangeZoomChangeInfoType {
|
|
tabId: number;
|
|
|
|
oldZoomFactor: number;
|
|
|
|
newZoomFactor: number;
|
|
|
|
zoomSettings: ZoomSettings;
|
|
}
|
|
|
|
/**
|
|
* Fired when a tab is updated.
|
|
*/
|
|
interface onUpdatedEvent
|
|
extends Events.Event<(tabId: number, changeInfo: OnUpdatedChangeInfoType, tab: Tab) => void> {
|
|
/**
|
|
* Registers an event listener <em>callback</em> to an event.
|
|
*
|
|
* @param callback Called when an event occurs. The parameters of this function depend on the type of event.
|
|
* @param filter Optional. A set of filters that restricts the events that will be sent to this listener.
|
|
*/
|
|
addListener(
|
|
callback: (tabId: number, changeInfo: OnUpdatedChangeInfoType, tab: Tab) => void,
|
|
filter?: UpdateFilter
|
|
): void;
|
|
}
|
|
|
|
interface Static {
|
|
/**
|
|
* Retrieves details about the specified tab.
|
|
*
|
|
* @param tabId
|
|
*/
|
|
get(tabId: number): Promise<Tab>;
|
|
|
|
/**
|
|
* Gets the tab that this script call is being made from. May be undefined if called from a non-tab context (for example: a
|
|
* background page or popup view).
|
|
*/
|
|
getCurrent(): Promise<Tab>;
|
|
|
|
/**
|
|
* Connects to the content script(s) in the specified tab. The $(ref:runtime.onConnect)
|
|
* event is fired in each content script running in the specified tab for the current extension. For more details,
|
|
* see $(topic:messaging)[Content Script Messaging].
|
|
*
|
|
* @param tabId
|
|
* @param connectInfo Optional.
|
|
* @returns A port that can be used to communicate with the content scripts running in the specified tab.
|
|
* The port's $(ref:runtime.Port) event is fired if the tab closes or does not exist.
|
|
*/
|
|
connect(tabId: number, connectInfo?: ConnectConnectInfoType): Runtime.Port;
|
|
|
|
/**
|
|
* Sends a single message to the content script(s) in the specified tab, with an optional callback to run when a response
|
|
* is sent back. The $(ref:runtime.onMessage) event is fired in each content script running in the specified tab for the
|
|
* current extension.
|
|
*
|
|
* @param tabId
|
|
* @param message
|
|
* @param options Optional.
|
|
*/
|
|
sendMessage(tabId: number, message: any, options?: SendMessageOptionsType): Promise<any>;
|
|
|
|
/**
|
|
* Creates a new tab.
|
|
*
|
|
* @param createProperties
|
|
*/
|
|
create(createProperties: CreateCreatePropertiesType): Promise<Tab>;
|
|
|
|
/**
|
|
* Duplicates a tab.
|
|
*
|
|
* @param tabId The ID of the tab which is to be duplicated.
|
|
* @param duplicateProperties Optional.
|
|
*/
|
|
duplicate(tabId: number, duplicateProperties?: DuplicateDuplicatePropertiesType): Promise<Tab>;
|
|
|
|
/**
|
|
* Gets all tabs that have the specified properties, or all tabs if no properties are specified.
|
|
*
|
|
* @param queryInfo
|
|
*/
|
|
query(queryInfo: QueryQueryInfoType): Promise<Tab[]>;
|
|
|
|
/**
|
|
* Highlights the given tabs.
|
|
*
|
|
* @param highlightInfo
|
|
*/
|
|
highlight(highlightInfo: HighlightHighlightInfoType): Promise<Windows.Window>;
|
|
|
|
/**
|
|
* Modifies the properties of a tab. Properties that are not specified in <var>updateProperties</var> are not modified.
|
|
*
|
|
* @param tabId Optional. Defaults to the selected tab of the $(topic:current-window)[current window].
|
|
* @param updateProperties
|
|
*/
|
|
update(tabId: number | undefined, updateProperties: UpdateUpdatePropertiesType): Promise<Tab>;
|
|
|
|
/**
|
|
* Modifies the properties of a tab. Properties that are not specified in <var>updateProperties</var> are not modified.
|
|
*
|
|
* @param updateProperties
|
|
*/
|
|
update(updateProperties: UpdateUpdatePropertiesType): Promise<Tab>;
|
|
|
|
/**
|
|
* Moves one or more tabs to a new position within its window, or to a new window. Note that tabs can only be moved to and
|
|
* from normal (window.type === "normal") windows.
|
|
*
|
|
* @param tabIds The tab or list of tabs to move.
|
|
* @param moveProperties
|
|
*/
|
|
move(tabIds: number | number[], moveProperties: MoveMovePropertiesType): Promise<Tab | Tab[]>;
|
|
|
|
/**
|
|
* Reload a tab.
|
|
*
|
|
* @param tabId Optional. The ID of the tab to reload; defaults to the selected tab of the current window.
|
|
* @param reloadProperties Optional.
|
|
*/
|
|
reload(tabId?: number, reloadProperties?: ReloadReloadPropertiesType): Promise<void>;
|
|
|
|
/**
|
|
* Warm up a tab
|
|
*
|
|
* @param tabId The ID of the tab to warm up.
|
|
*/
|
|
warmup(tabId: number): void;
|
|
|
|
/**
|
|
* Closes one or more tabs.
|
|
*
|
|
* @param tabIds The tab or list of tabs to close.
|
|
*/
|
|
remove(tabIds: number | number[]): Promise<void>;
|
|
|
|
/**
|
|
* discards one or more tabs.
|
|
*
|
|
* @param tabIds The tab or list of tabs to discard.
|
|
*/
|
|
discard(tabIds: number | number[]): Promise<void>;
|
|
|
|
/**
|
|
* Detects the primary language of the content in a tab.
|
|
*
|
|
* @param tabId Optional. Defaults to the active tab of the $(topic:current-window)[current window].
|
|
*/
|
|
detectLanguage(tabId?: number): Promise<string>;
|
|
|
|
/**
|
|
* Toggles reader mode for the document in the tab.
|
|
*
|
|
* @param tabId Optional. Defaults to the active tab of the $(topic:current-window)[current window].
|
|
*/
|
|
toggleReaderMode(tabId?: number): Promise<void>;
|
|
|
|
/**
|
|
* Captures an area of a specified tab. You must have $(topic:declare_permissions)[<all_urls>]
|
|
* permission to use this method.
|
|
*
|
|
* @param tabId Optional. The tab to capture. Defaults to the active tab of the current window.
|
|
* @param options Optional.
|
|
*/
|
|
captureTab(tabId?: number, options?: ExtensionTypes.ImageDetails): Promise<string>;
|
|
|
|
/**
|
|
* Captures an area of the currently active tab in the specified window. You must have $(topic:declare_permissions)
|
|
* [<all_urls>] permission to use this method.
|
|
*
|
|
* @param windowId Optional. The target window. Defaults to the $(topic:current-window)[current window].
|
|
* @param options Optional.
|
|
*/
|
|
captureVisibleTab(windowId?: number, options?: ExtensionTypes.ImageDetails): Promise<string>;
|
|
|
|
/**
|
|
* Injects JavaScript code into a page. For details, see the $(topic:content_scripts)[programmatic injection]
|
|
* section of the content scripts doc.
|
|
*
|
|
* @param tabId Optional. The ID of the tab in which to run the script; defaults to the active tab of the current window.
|
|
* @param details Details of the script to run.
|
|
* @returns Called after all the JavaScript has been executed.
|
|
*/
|
|
executeScript(tabId: number | undefined, details: ExtensionTypes.InjectDetails): Promise<any[]>;
|
|
|
|
/**
|
|
* Injects JavaScript code into a page. For details, see the $(topic:content_scripts)[programmatic injection]
|
|
* section of the content scripts doc.
|
|
*
|
|
* @param details Details of the script to run.
|
|
* @returns Called after all the JavaScript has been executed.
|
|
*/
|
|
executeScript(details: ExtensionTypes.InjectDetails): Promise<any[]>;
|
|
|
|
/**
|
|
* Injects CSS into a page. For details, see the $(topic:content_scripts)[programmatic injection]
|
|
* section of the content scripts doc.
|
|
*
|
|
* @param tabId Optional. The ID of the tab in which to insert the CSS; defaults to the active tab of the current window.
|
|
* @param details Details of the CSS text to insert.
|
|
* @returns Called when all the CSS has been inserted.
|
|
*/
|
|
insertCSS(tabId: number | undefined, details: ExtensionTypes.InjectDetails): Promise<void>;
|
|
|
|
/**
|
|
* Injects CSS into a page. For details, see the $(topic:content_scripts)[programmatic injection]
|
|
* section of the content scripts doc.
|
|
*
|
|
* @param details Details of the CSS text to insert.
|
|
* @returns Called when all the CSS has been inserted.
|
|
*/
|
|
insertCSS(details: ExtensionTypes.InjectDetails): Promise<void>;
|
|
|
|
/**
|
|
* Removes injected CSS from a page. For details, see the $(topic:content_scripts)[programmatic injection]
|
|
* section of the content scripts doc.
|
|
*
|
|
* @param tabId Optional. The ID of the tab from which to remove the injected CSS; defaults to the active tab of the
|
|
* current window.
|
|
* @param details Details of the CSS text to remove.
|
|
* @returns Called when all the CSS has been removed.
|
|
*/
|
|
removeCSS(tabId: number | undefined, details: ExtensionTypes.InjectDetails): Promise<void>;
|
|
|
|
/**
|
|
* Removes injected CSS from a page. For details, see the $(topic:content_scripts)[programmatic injection]
|
|
* section of the content scripts doc.
|
|
*
|
|
* @param details Details of the CSS text to remove.
|
|
* @returns Called when all the CSS has been removed.
|
|
*/
|
|
removeCSS(details: ExtensionTypes.InjectDetails): Promise<void>;
|
|
|
|
/**
|
|
* Zooms a specified tab.
|
|
*
|
|
* @param tabId Optional. The ID of the tab to zoom; defaults to the active tab of the current window.
|
|
* @param zoomFactor The new zoom factor. Use a value of 0 here to set the tab to its current default zoom factor.
|
|
* Values greater than zero specify a (possibly non-default) zoom factor for the tab.
|
|
* @returns Called after the zoom factor has been changed.
|
|
*/
|
|
setZoom(tabId: number | undefined, zoomFactor: number): Promise<void>;
|
|
|
|
/**
|
|
* Zooms a specified tab.
|
|
*
|
|
* @param zoomFactor The new zoom factor. Use a value of 0 here to set the tab to its current default zoom factor.
|
|
* Values greater than zero specify a (possibly non-default) zoom factor for the tab.
|
|
* @returns Called after the zoom factor has been changed.
|
|
*/
|
|
setZoom(zoomFactor: number): Promise<void>;
|
|
|
|
/**
|
|
* Gets the current zoom factor of a specified tab.
|
|
*
|
|
* @param tabId Optional. The ID of the tab to get the current zoom factor from; defaults to the active tab of the current
|
|
* window.
|
|
* @returns Called with the tab's current zoom factor after it has been fetched.
|
|
*/
|
|
getZoom(tabId?: number): Promise<number>;
|
|
|
|
/**
|
|
* Sets the zoom settings for a specified tab, which define how zoom changes are handled.
|
|
* These settings are reset to defaults upon navigating the tab.
|
|
*
|
|
* @param tabId Optional. The ID of the tab to change the zoom settings for; defaults to the active tab of the current
|
|
* window.
|
|
* @param zoomSettings Defines how zoom changes are handled and at what scope.
|
|
* @returns Called after the zoom settings have been changed.
|
|
*/
|
|
setZoomSettings(tabId: number | undefined, zoomSettings: ZoomSettings): Promise<void>;
|
|
|
|
/**
|
|
* Sets the zoom settings for a specified tab, which define how zoom changes are handled.
|
|
* These settings are reset to defaults upon navigating the tab.
|
|
*
|
|
* @param zoomSettings Defines how zoom changes are handled and at what scope.
|
|
* @returns Called after the zoom settings have been changed.
|
|
*/
|
|
setZoomSettings(zoomSettings: ZoomSettings): Promise<void>;
|
|
|
|
/**
|
|
* Gets the current zoom settings of a specified tab.
|
|
*
|
|
* @param tabId Optional. The ID of the tab to get the current zoom settings from; defaults to the active tab of the
|
|
* current window.
|
|
* @returns Called with the tab's current zoom settings.
|
|
*/
|
|
getZoomSettings(tabId?: number): Promise<ZoomSettings>;
|
|
|
|
/**
|
|
* Prints page in active tab.
|
|
*/
|
|
print(): void;
|
|
|
|
/**
|
|
* Shows print preview for page in active tab.
|
|
*
|
|
* @returns Called after print preview entered.
|
|
*/
|
|
printPreview(): Promise<void>;
|
|
|
|
/**
|
|
* Saves page in active tab as a PDF file.
|
|
*
|
|
* @param pageSettings The page settings used to save the PDF file.
|
|
* @returns Called after save as dialog closed.
|
|
*/
|
|
saveAsPDF(pageSettings: PageSettings): Promise<string>;
|
|
|
|
/**
|
|
* Shows one or more tabs.
|
|
*
|
|
* @param tabIds The TAB ID or list of TAB IDs to show.
|
|
*/
|
|
show(tabIds: number | number[]): Promise<void>;
|
|
|
|
/**
|
|
* Hides one or more tabs. The <code>"tabHide"</code> permission is required to hide tabs. Not all tabs are hidable.
|
|
* Returns an array of hidden tabs.
|
|
*
|
|
* @param tabIds The TAB ID or list of TAB IDs to hide.
|
|
*/
|
|
hide(tabIds: number | number[]): Promise<number[]>;
|
|
|
|
/**
|
|
* Removes an array of tabs from their lines of succession and prepends or appends them in a chain to another tab.
|
|
*
|
|
* @param tabIds An array of tab IDs to move in the line of succession. For each tab in the array,
|
|
* the tab's current predecessors will have their successor set to the tab's current successor,
|
|
* and each tab will then be set to be the successor of the previous tab in the array.
|
|
* Any tabs not in the same window as the tab indicated by the second argument (or the first tab in the array,
|
|
* if no second argument) will be skipped.
|
|
* @param tabId Optional. The ID of a tab to set as the successor of the last tab in the array, or $(ref:tabs.TAB_ID_NONE)
|
|
* to leave the last tab without a successor. If options.append is true, then this tab is made the predecessor of the
|
|
* first tab in the array instead.
|
|
* @param options Optional.
|
|
*/
|
|
moveInSuccession(tabIds: number[], tabId?: number, options?: MoveInSuccessionOptionsType): void;
|
|
|
|
/**
|
|
* Navigate to next page in tab's history, if available
|
|
*
|
|
* @param tabId Optional. The ID of the tab to navigate forward.
|
|
*/
|
|
goForward(tabId?: number): Promise<void>;
|
|
|
|
/**
|
|
* Navigate to previous page in tab's history, if available.
|
|
*
|
|
* @param tabId Optional. The ID of the tab to navigate backward.
|
|
*/
|
|
goBack(tabId?: number): Promise<void>;
|
|
|
|
/**
|
|
* Fired when a tab is created. Note that the tab's URL may not be set at the time this event fired,
|
|
* but you can listen to onUpdated events to be notified when a URL is set.
|
|
*
|
|
* @param tab Details of the tab that was created.
|
|
*/
|
|
onCreated: Events.Event<(tab: Tab) => void>;
|
|
|
|
/**
|
|
* Fired when a tab is updated.
|
|
*/
|
|
onUpdated: onUpdatedEvent;
|
|
|
|
/**
|
|
* Fired when a tab is moved within a window. Only one move event is fired, representing the tab the user directly moved.
|
|
* Move events are not fired for the other tabs that must move in response. This event is not fired when a tab is moved
|
|
* between windows. For that, see $(ref:tabs.onDetached).
|
|
*
|
|
* @param tabId
|
|
* @param moveInfo
|
|
*/
|
|
onMoved: Events.Event<(tabId: number, moveInfo: OnMovedMoveInfoType) => void>;
|
|
|
|
/**
|
|
* Fires when the active tab in a window changes. Note that the tab's URL may not be set at the time this event fired,
|
|
* but you can listen to onUpdated events to be notified when a URL is set.
|
|
*
|
|
* @param activeInfo
|
|
*/
|
|
onActivated: Events.Event<(activeInfo: OnActivatedActiveInfoType) => void>;
|
|
|
|
/**
|
|
* Fired when the highlighted or selected tabs in a window changes.
|
|
*
|
|
* @param highlightInfo
|
|
*/
|
|
onHighlighted: Events.Event<(highlightInfo: OnHighlightedHighlightInfoType) => void>;
|
|
|
|
/**
|
|
* Fired when a tab is detached from a window, for example because it is being moved between windows.
|
|
*
|
|
* @param tabId
|
|
* @param detachInfo
|
|
*/
|
|
onDetached: Events.Event<(tabId: number, detachInfo: OnDetachedDetachInfoType) => void>;
|
|
|
|
/**
|
|
* Fired when a tab is attached to a window, for example because it was moved between windows.
|
|
*
|
|
* @param tabId
|
|
* @param attachInfo
|
|
*/
|
|
onAttached: Events.Event<(tabId: number, attachInfo: OnAttachedAttachInfoType) => void>;
|
|
|
|
/**
|
|
* Fired when a tab is closed.
|
|
*
|
|
* @param tabId
|
|
* @param removeInfo
|
|
*/
|
|
onRemoved: Events.Event<(tabId: number, removeInfo: OnRemovedRemoveInfoType) => void>;
|
|
|
|
/**
|
|
* Fired when a tab is replaced with another tab due to prerendering or instant.
|
|
*
|
|
* @param addedTabId
|
|
* @param removedTabId
|
|
*/
|
|
onReplaced: Events.Event<(addedTabId: number, removedTabId: number) => void>;
|
|
|
|
/**
|
|
* Fired when a tab is zoomed.
|
|
*
|
|
* @param ZoomChangeInfo
|
|
*/
|
|
onZoomChange: Events.Event<(ZoomChangeInfo: OnZoomChangeZoomChangeInfoType) => void>;
|
|
|
|
/**
|
|
* An ID which represents the absence of a browser tab.
|
|
*/
|
|
TAB_ID_NONE: -1;
|
|
}
|
|
}
|