2019-11-17 18:19:55 +09:00

663 lines
22 KiB
TypeScript

// type NotificationEvent = any;
// type InstallEvent = any;
// type FetchEvent = any;
// type PushEvent = any;
// type ServiceWorkerGlobalScope = any;
// Type definitions for service_worker_api 0.0
// Project: https://developer.mozilla.org/fr/docs/Web/API/ServiceWorker_API
// Definitions by: Tristan Caron <https://github.com/tristancaron>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
// TypeScript Version: 2.1
/**
* An CacheOptions object allowing you to set specific control options for the
* matching done in the match operation.
*
* @property [ignoreSearch] A Boolean that specifies whether the matching
* process should ignore the query string in the url. If set to true,
* the ?value=bar part of http://foo.com/?value=bar would be ignored when
* performing a match. It defaults to false.
*
* @property [ignoreMethod] A Boolean that, when set to true, prevents matching
* operations from validating the Request http method (normally only GET
* and HEAD are allowed.) It defaults to false.
*
* @property [ignoreVary] A Boolean that when set to true tells the matching
* operation not to perform VARY header matching — i.e. if the URL matches you
* will get a match regardless of the Response object having a VARY header or
* not. It defaults to false.
*
* @property [cacheName] A DOMString that represents a specific cache to search
* within. Note that this option is ignored by Cache.match().
*/
interface CacheOptions {
ignoreSearch?: boolean;
ignoreMethod?: boolean;
ignoreVary?: boolean;
cacheName?: string;
}
/**
* Represents the storage for Request / Response object pairs that are cached as
* part of the ServiceWorker life cycle.
*/
interface Cache {
/**
* Returns a Promise that resolves to the response associated with the first
* matching request in the Cache object.
*
* @param request The Request you are attempting to find in the Cache.
* @param [options] An object that sets options for the match operation.
*/
match(request: Request | string, options?: CacheOptions): Promise<Response>;
/**
* Returns a Promise that resolves to an array of all matching responses in
* the Cache object.
*
* @param request The Request you are attempting to find in the Cache.
* @param [options] An object that sets options for the match operation.
*/
matchAll(request: Request | string, options?: CacheOptions): Promise<Response[]>;
/**
* Returns a Promise that resolves to a new Cache entry whose key
* is the request.
*
* @param request The Request you want to add to the cache.
*/
add(request: Request | string): Promise<void>;
/**
* Returns a Promise that resolves to a new array of Cache entries whose
* keys are the requests.
*
* @param request An array of Request objects you want to add to the cache.
*/
addAll(requests: Array<Request | string>): Promise<void>;
/**
* Adds additional key/value pairs to the current Cache object.
*
* @param request The Request you want to add to the cache.
* @param response The response you want to match up to the request.
*/
put(request: Request, response: Response): Promise<void>;
/**
* Finds the Cache entry whose key is the request, and if found, deletes the
* Cache entry and returns a Promise that resolves to true. If no Cache
* entry is found, it returns false.
*
* @param request The Request you are looking to delete.
* @param [options] An object that sets options for the match operation.
*/
delete(request: Request | string, options?: CacheOptions): Promise<boolean>;
/**
* Returns a Promise that resolves to an array of Cache keys.
*
* @param request The Request want to return, if a specific key is desired.
* @param [options] An object that sets options for the match operation.
*/
keys(request?: Request, options?: CacheOptions): Promise<Request[]>;
}
/**
* Represents the storage for Cache objects. It provides a master directory of
* all the named caches that a ServiceWorker can access and maintains a mapping
* of string names to corresponding Cache objects.
*/
interface CacheStorage {
/**
* Checks if a given Request is a key in any of the Cache objects that the
* CacheStorage object tracks and returns a Promise that resolves
* to that match.
*
* @param request The Request you are looking for a match for in the CacheStorage.
* @param [options] An object that sets options for the match operation.
*/
match(request: Request | string, options?: CacheOptions): Promise<Response>;
/**
* Returns a Promise that resolves to true if a Cache object matching
* the cacheName exists.
*
* @param cacheName The Request you are looking for a match for in the
* CacheStorage.
*/
has(cacheName: string): Promise<boolean>;
/**
* Returns a Promise that resolves to the Cache object matching
* the cacheName.
*
* @param cacheName The name of the cache you want to open.
*/
open(cacheName: string): Promise<Cache>;
/**
* Finds the Cache object matching the cacheName, and if found, deletes the
* Cache object and returns a Promise that resolves to true. If no
* Cache object is found, it returns false.
*
* @param cacheName The name of the cache you want to delete.
*/
delete(cacheName: string): Promise<boolean>;
/**
* Returns a Promise that will resolve with an array containing strings
* corresponding to all of the named Cache objects tracked by the
* CacheStorage. Use this method to iterate over a list of all the
* Cache objects.
*/
keys(): Promise<string[]>;
}
/**
* Represents the scope of a service worker client. A service worker client is
* either a document in a browser context or a SharedWorker, which is controlled
* by an active worker.
*/
interface ServiceWorkerClient {
/**
* Allows a service worker client to send a message to a ServiceWorker.
*
* @param message The message to send to the service worker.
* @param [transfer] A transferable object such as, for example, a reference
* to a port.
*/
postMessage(message: any, transfer?: any): void;
/**
* Indicates the type of browsing context of the current client.
* This value can be one of auxiliary, top-level, nested, or none.
*/
readonly frameType: string;
/**
* Returns the id of the Client object.
*/
readonly id: string;
/**
* The URL of the current service worker client.
*/
readonly url: string;
}
interface WindowClient extends ServiceWorkerClient {
/**
* Gives user input focus to the current client.
*/
focus(): Promise<WindowClient>;
/**
* A boolean that indicates whether the current client has focus.
*/
readonly focused: boolean;
/**
* Indicates the visibility of the current client. This value can be one of
* hidden, visible, prerender, or unloaded.
*/
readonly visibilityState: string;
}
interface ServiceWorkerClientsMatchOptions {
includeUncontrolled?: boolean;
type?: string;
}
/**
* Represents a container for a list of Client objects; the main way to access
* the active service worker clients at the current origin.
*/
interface ServiceWorkerClients {
/**
* Gets a service worker client matching a given id and returns it in a Promise.
* @param clientId The ID of the client you want to get.
*/
get(clientId: string): Promise<ServiceWorkerClient>;
/**
* Gets a list of service worker clients and returns them in a Promise.
* Include the options parameter to return all service worker clients whose
* origin is the same as the associated service worker's origin. If options
* are not included, the method returns only the service worker clients
* controlled by the service worker.
*
* @param [options] An options object allowing you to set options for the matching operation.
*/
matchAll(options?: ServiceWorkerClientsMatchOptions): Promise<ServiceWorkerClient[]>;
/**
* Opens a service worker Client in a new browser window.
*
* @param url A string representing the URL of the client you want to open
* in the window.
*/
openWindow(url: string): Promise<WindowClient>;
/**
* Allows an active Service Worker to set itself as the active worker for a
* client page when the worker and the page are in the same scope.
*/
claim(): Promise<void>;
}
/**
* Represents a service worker. Multiple browsing contexts (e.g. pages, workers,
* etc.) can be associated with the same ServiceWorker object.
*/
interface ServiceWorker extends Worker {
/**
* Returns the ServiceWorker serialized script URL defined as part of
* ServiceWorkerRegistration. The URL must be on the same origin as the
* document that registers the ServiceWorker.
*/
readonly scriptURL: string;
}
/**
* The PushMessageData interface of the Push API provides
* methods which let you retrieve the push data sent by a server in various formats.
*/
interface PushMessageData {
/**
* Extracts the data as an ArrayBuffer object.
*/
arrayBuffer(): ArrayBuffer;
/**
* Extracts the data as a Blob object.
*/
blob(): Blob;
/**
* Extracts the data as a JSON object.
*/
json(): any;
json<T>(): T;
/**
* Extracts the data as a plain text string.
*/
text(): string;
}
/**
* The PushSubscription interface provides a subcription's URL endpoint and
* subscription ID.
*/
interface PushSubscription {
/**
* The endpoint associated with the push subscription.
*/
readonly endpoint: string;
/**
* The subscription ID associated with the push subscription.
*/
readonly subscriptionId: any;
}
/**
* Object containing optional subscribe parameters.
*/
interface PushSubscriptionOptions {
/**
* A boolean indicating that the returned push subscription will only be used for
* messages whose effect is made visible to the user.
*/
readonly userVisibleOnly: boolean;
}
/**
* The PushManager interface provides a way to receive notifications from
* third-party servers as well as request URLs for push notifications.
* This interface has replaced functionality offered by the obsolete
* PushRegistrationManager.
*/
interface PushManager {
/**
* Returns a promise that resolves to a PushSubscription with details of a
* new push subscription.
*
* @param [options] An object containing optional configuration parameters.
*/
subscribe(options?: PushSubscriptionOptions): Promise<PushSubscription>;
/**
* Returns a promise that resolves to a PushSubscription details of
* the retrieved push subscription.
*/
getSubscription(): Promise<PushSubscription>;
/**
* Returns a promise that resolves to the PushPermissionStatus of the
* requesting webapp, which will be one of granted, denied, or default.
*/
hasPermission(): Promise<any>;
}
/////// Service Worker Events ///////
/**
* Extends the lifetime of the install and activate events dispatched on the
* ServiceWorkerGlobalScope as part of the service worker lifecycle. This
* ensures that any functional events (like FetchEvent) are not dispatched to
* the ServiceWorker until it upgrades database schemas, deletes outdated cache
* entries, etc.
*/
interface ExtendableEvent extends Event {
/**
* Extends the lifetime of the event.
* It is intended to be called in the install EventHandler for the
* installing worker and on the active EventHandler for the active worker.
*
* @param promise
*/
waitUntil(promise: Promise<any>): void;
}
/**
* The parameter passed into the ServiceWorkerGlobalScope.onfetch handler,
* FetchEvent represents a fetch action that is dispatched on the
* ServiceWorkerGlobalScope of a ServiceWorker. It contains information about
* the request and resulting response, and provides the FetchEvent.respondWith()
* method, which allows us to provide an arbitrary response back to the
* controlled page.
*/
interface FetchEvent extends Event {
/**
* Returns a Boolean that is true if the event was dispatched with the
* user's intention for the page to reload, and false otherwise. Typically,
* pressing the refresh button in a browser is a reload, while clicking a
* link and pressing the back button is not.
*/
readonly isReload: boolean;
/**
* Returns the Request that triggered the event handler.
*/
readonly request: Request;
/**
* Returns the id of the client that the current service worker is controlling.
*/
readonly clientId: string;
/**
* Resolves by returning a Response or a network error to Fetch.
*
* @param all Any custom response-generating code.
*/
respondWith(all: any): any;
waitUntil(promise: Promise<any>): void;
}
/**
* The ExtendableMessageEvent interface of the ServiceWorker API represents
* the event object of a message event fired on
* a service worker (when a channel message is received on
* the ServiceWorkerGlobalScope from another context)
* — extends the lifetime of such events.
*/
interface ExtendableMessageEvent extends ExtendableEvent {
/**
* Returns the event's data. It can be any data type.
*/
readonly data: any;
/**
* Returns the origin of the ServiceWorkerClient that sent the message
*/
readonly origin: string;
/**
* Represents, in server-sent events, the last event ID of the event source.
*/
readonly lastEventId: string;
/**
* Returns a reference to the service worker that sent the message.
*/
readonly source: ServiceWorkerClient;
/**
* Returns the array containing the MessagePort objects
* representing the ports of the associated message channel.
*/
readonly ports: MessagePort[];
}
/**
* The parameter passed into the oninstall handler, the InstallEvent interface
* represents an install action that is dispatched on the
* ServiceWorkerGlobalScope of a ServiceWorker. As a child of ExtendableEvent,
* it ensures that functional events such as FetchEvent are not dispatched
* during installation.
*/
interface InstallEvent extends ExtendableEvent {
/**
* Returns the ServiceWorker that is currently actively controlling the page.
*/
readonly activeWorker: ServiceWorker;
}
/**
* The parameter passed into the onnotificationclick handler,
* the NotificationEvent interface represents
* a notification click event that is dispatched on
* the ServiceWorkerGlobalScope of a ServiceWorker.
*/
interface NotificationEvent extends ExtendableEvent {
/**
* Returns a Notification object representing
* the notification that was clicked to fire the event.
*/
notification: any; // need to be replaced with `Notification` when possible
/**
* Returns the string ID of the notification button the user clicked.
* This value returns undefined if the user clicked
* the notification somewhere other than an action button,
* or the notification does not have a button.
*/
action: string;
}
/**
* The PushEvent interface of the Push API represents
* a push message that has been received.
* This event is sent to the global scope of a ServiceWorker.
* It contains the information sent from an application server to a PushSubscription.
*/
interface PushEvent extends ExtendableEvent {
/**
* Returns a reference to a PushMessageData object containing
* data sent to the PushSubscription.
*/
readonly data: PushMessageData;
}
interface ServiceWorkerContainerEventMap {
"error": ErrorEvent;
"controllerchange": Event;
}
interface ServiceWorkerEventMap {
"activate": ExtendableEvent;
"fetch": FetchEvent;
"install": InstallEvent;
// "message": ExtendableMessageEvent;
"message": MessageEvent;
"notificationclick": NotificationEvent;
"push": PushEvent;
"pushsubscriptionchang": PushEvent;
}
/**
* An options object to provide options upon a ServiceWorkerRegistration.
* @param [scope] A USVString representing a URL that defines a service worker's registration scope; what range of
* URLs a service worker can control. This is usually a relative URL, and it defaults to '/' when not specified.
*/
interface ServiceWorkerRegisterOptions {
scope: string;
}
/**
* Action to display in a notification.
* @param [action] A DOMString identifying a user action to be displayed on the notification.
* @param [title] A DOMString containing action text to be shown to the user.
* @param [icon] A USVString containg the URL of an icon to display with the action.
*/
interface NotificationAction { // TODO: Maybe need to moved if NotificationApi types are defined
action: string;
title: string;
icon?: string;
}
/**
* Object that allows to configure a notification.
* @param [actions] An array of actions to display in the notification.
* Appropriate responses are built using event.action within the notificationclick event.
* @param [badge] The URL of an image to represent the notification when there is not enough space to display the
* notification itself such as, for example, the Android Notification Bar. On Android devices, the badge should
* accommodate devices up to 4x resolution, about 96 by 96 px, and the image will be automatically masked.
* @param [body] A string representing an extra content to display within the notification.
* @param [dir] The direction of the notification; it can be auto, ltr, or rtl.
* @param [icon] The URL of an image to be used as an icon by the notification.
* @param [image] A USVSTring containing the URL of an image to be displayed in the notification.
* @param [lang] Specify the lang used within the notification. This string must be a valid BCP 47 language tag.
* @param [renotify] A boolean that indicates whether to supress vibrations and audible alerts when resusing a tag
* value. The default is false.
* @param [requireInteraction] Indicates that on devices with sufficiently large screens, a notification should remain
* active until the user clicks or dismisses it. If this value is absent or false, the desktop version of Chrome
* will auto-minimize notifications after approximately twenty seconds. The default value is false.
* @param [tag] An ID for a given notification that allows you to find, replace, or remove the notification using
* script if necessary.
* @param [vibrate] A vibration pattern to run with the display of the notification. A vibration pattern can be an
* array with as few as one member. The values are times in milliseconds where the even indices (0, 2, 4, etc.) indicate
* how long to vibrate and the odd indices indicate how long to pause. For example [300, 100, 400] would vibrate
* 300ms, pause 100ms, then vibrate 400ms.
* @param [data] Arbitrary data that you want associated with the notification. This can be of any data type.
*/
interface ServiceWorkerNotificationOptions {
actions?: NotificationAction[];
badge?: string;
body?: string;
dir?: 'auto' | 'ltr' | 'rtl';
icon?: string;
lang?: string;
renotify?: boolean;
requireInteraction?: boolean;
tag?: string;
vibrate?: number[];
data?: any;
}
/**
* An options object that can contain options to filter notifications.
* @param [tag] A DOMString representing a notification tag. If specified, only notifications that have this tag
* will be returned.
*/
interface ServiceWorkerGetNotificationOptions {
tag: string;
}
interface ServiceWorkerGlobalScope extends EventTarget {
/**
* Contains the CacheStorage object associated with the service worker.
*/
readonly caches: CacheStorage;
/**
* Contains the Clients object associated with the service worker.
*/
readonly clients: ServiceWorkerClients;
/**
* Contains the ServiceWorkerRegistration object that represents the
* service worker's registration.
*/
readonly registration: ServiceWorkerRegistration;
/**
* An event handler fired whenever an activate event occurs — when a
* ServiceWorkerRegistration acquires a new ServiceWorkerRegistration.active
* worker.
*/
onactivate: (activateevent: ExtendableEvent) => void;
/**
* An event handler fired whenever a fetch event occurs — when a fetch()
* is called.
*/
onfetch: (fetchevent: FetchEvent) => void;
/**
* An event handler fired whenever an install event occurs — when a
* ServiceWorkerRegistration acquires a new
* ServiceWorkerRegistration.installing worker.
*/
oninstall: (installevent: InstallEvent) => void;
/**
* An event handler fired whenever a message event occurs — when incoming
* messages are received. Controlled pages can use the
* MessagePort.postMessage() method to send messages to service workers.
* The service worker can optionally send a response back via the
* MessagePort exposed in event.data.port, corresponding to the controlled
* page.
*
* `onmessage` is actually fired with `ExtendableMessageEvent`, but
* since we are merging the interface into `Window`, we should
* make sure it's compatible with `window.onmessage`
*/
// onmessage: (messageevent: ExtendableMessageEvent) => void;
//onmessage: (messageevent: MessageEvent) => void;
/**
* An event handler fired whenever a notificationclick event occurs — when
* a user clicks on a displayed notification.
*/
onnotificationclick: (notificationclickevent: NotificationEvent) => void;
/**
* An event handler fired whenever a push event occurs — when a server
* push notification is received.
*/
onpush: (onpushevent: PushEvent) => void;
/**
* An event handler fired whenever a pushsubscriptionchange event occurs —
* when a push subscription has been invalidated, or is about to be
* invalidated (e.g. when a push service sets an expiration time).
*/
onpushsubscriptionchange: (pushsubscriptionchangeevent: PushEvent) => void;
/**
* Allows the current service worker registration to progress from waiting
* to active state while service worker clients are using it.
*/
skipWaiting(): Promise<void>;
addEventListener<K extends keyof ServiceWorkerEventMap>(
type: K,
listener: (event: ServiceWorkerEventMap[K]) => any,
useCapture?: boolean
): void;
}
interface NotificationOptions {
image?: string;
data?: any;
badge?: string;
}
// tslint:disable-next-line no-empty-interface
interface Window extends ServiceWorkerGlobalScope {}