8000 flow/lib/bom.js at v0.200 · dominictobias/flow · GitHub
[go: up one dir, main page]
Skip to content

bom.js

Latest commit

 

History

History
2174 lines (1911 loc) · 54.8 KB

bom.js

File metadata and controls

2174 lines (1911 loc) · 54.8 KB
Raw
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow
*/
/* BOM */
declare class Screen {
+availHeight: number;
+availWidth: number;
+availLeft: number;
+availTop: number;
+top: number;
+left: number;
+colorDepth: number;
+pixelDepth: number;
+width: number;
+height: number;
+orientation?: {
lock(): Promise<void>;
unlock(): void;
angle: number;
onchange: () => mixed;
type: 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';
...
};
// deprecated
mozLockOrientation?: (orientation: string | Array<string>) => boolean;
mozUnlockOrientation?: () => void;
mozOrientation?: string;
onmozorientationchange?: (...args: any[]) => mixed;
}
declare var screen: Screen;
declare var window: any;
type GamepadButton = {
pressed: boolean,
value: number,
...
}
type GamepadHapticActuator = {
type: 'vibration',
pulse(value: number, duration: number): Promise<boolean>,
...
}
type GamepadPose = {
angularAcceleration: null | Float32Array,
angularVelocity: null | Float32Array,
hasOrientation: boolean,
hasPosition: boolean,
linearAcceleration: null | Float32Array,
linearVelocity: null | Float32Array,
orientation: null | Float32Array,
position: null | Float32Array,
...
}
type Gamepad = {
axes: number[],
buttons: GamepadButton[],
connected: boolean,
displayId?: number,
hapticActuators?: GamepadHapticActuator[],
hand?: '' | 'left' | 'right',
id: string,
index: number,
mapping: string,
pose?: null | GamepadPose,
timestamp: number,
...
}
// deprecated
type BatteryManager = {
+charging: boolean,
+chargingTime: number,
+dischargingTime: number,
+level: number,
onchargingchange: ?((event: any) => mixed),
onchargingtimechange: ?((event: any) => mixed),
ondischargingtimechange: ?((event: any) => mixed),
onlevelchange: ?((event: any) => mixed),
...
}
// https://wicg.github.io/web-share
type ShareData = {
title?: string,
text?: string,
url?: string,
...
}
type PermissionName =
| "geolocation"
| "notifications"
| "push"
| "midi"
| "camera"
| "microphone"
| "speaker"
| "device-info"
| "background-sync"
| "bluetooth"
| "persistent-storage"
| "ambient-light-sensor"
| "accelerometer"
| "gyroscope"
| "magnetometer"
| "clipboard-read"
| "clipboard-write";
type PermissionState =
| "granted"
| "denied"
| "prompt";
type PermissionDescriptor = {|
name: PermissionName;
|}
type DevicePermissionDescriptor = {|
deviceId?: string;
name: "camera" | "microphone" | "speaker";
|}
type MidiPermissionDescriptor = {|
name: "midi";
sysex?: boolean;
|}
type PushPermissionDescriptor = {|
name: "push";
userVisibleOnly?: boolean;
|}
type ClipboardPermissionDescriptor = {|
name: "clipboard-read" | "clipboard-write";
allowWithoutGesture: boolean;
|}
declare class PermissionStatus extends EventTarget {
onchange: ?((event: any) => mixed);
+state: PermissionState;
}
declare class Permissions {
query(
permissionDesc:
| DevicePermissionDescriptor
| MidiPermissionDescriptor
| PushPermissionDescriptor
| ClipboardPermissionDescriptor
| PermissionDescriptor
): Promise<PermissionStatus>;
}
type MIDIPortType = 'input' | 'output';
type MIDIPortDeviceState = 'connected' | 'disconnected';
type MIDIPortConnectionState = 'open' | 'closed' | 'pending';
type MIDIOptions = {|
sysex: boolean;
software: boolean;
|}
type MIDIMessageEvent$Init = Event$Init & {
data: Uint8Array;
...
}
declare class MIDIMessageEvent extends Event {
constructor(type: string, eventInitDict: MIDIMessageEvent$Init): void;
+data: Uint8Array;
}
type MIDIConnectionEvent$Init = Event$Init & {
port: MIDIPort;
...
}
declare class MIDIConnectionEvent extends Event {
constructor(type: string, eventInitDict: MIDIConnectionEvent$Init): void;
+port: MIDIPort;
}
declare class MIDIPort extends EventTarget {
+id: string;
+manufacturer?: string;
+name?: string;
+type: MIDIPortType;
+version?: string;
+state: MIDIPortDeviceState;
+connection: MIDIPortConnectionState;
onstatechange: ?((ev: MIDIConnectionEvent) => mixed);
open(): Promise<MIDIPort>;
close(): Promise<MIDIPort>;
}
declare class MIDIInput extends MIDIPort {
onmidimessage: ?((ev: MIDIMessageEvent) => mixed);
}
declare class MIDIOutput extends MIDIPort {
send(data: Iterable<number>, timestamp?: number): void;
clear(): void;
}
declare class MIDIInputMap extends $ReadOnlyMap<string, MIDIInput> {}
declare class MIDIOutputMap extends $ReadOnlyMap<string, MIDIOutput> {}
declare class MIDIAccess extends EventTarget {
+inputs: MIDIInputMap;
+outputs: MIDIOutputMap;
+sysexEnabled: boolean;
onstatechange: ?((ev: MIDIConnectionEvent) => mixed);
}
declare class NavigatorID {
appName: 'Netscape';
appCodeName: 'Mozilla';
product: 'Gecko';
appVersion: string;
platform: string;
userAgent: string;
}
declare class NavigatorLanguage {
+language: string;
+languages: $ReadOnlyArray<string>;
}
declare class NavigatorContentUtils {
registerContentHandler(mimeType: string, uri: string, title: string): void;
registerProtocolHandler(protocol: string, uri: string, title: string): void;
}
declare class NavigatorCookies {
+cookieEnabled: boolean;
}
declare class NavigatorPlugins {
+plugins: PluginArray;
+mimeTypes: MimeTypeArray;
javaEnabled(): boolean;
}
declare class NavigatorOnLine {
+onLine: boolean;
}
declare class NavigatorConcurrentHardware {
+hardwareConcurrency: number;
}
declare class Navigator mixins
NavigatorID,
NavigatorLanguage,
NavigatorOnLine,
NavigatorContentUtils,
NavigatorCookies,
NavigatorPlugins,
NavigatorConcurrentHardware {
productSub: '20030107' | '20100101';
vendor: '' | 'Google Inc.' | 'Apple Computer, Inc';
vendorSub: '';
activeVRDisplays?: VRDisplay[];
appCodeName: 'Mozilla';
buildID: string;
doNotTrack: string | null;
geolocation: Geolocation;
mediaDevices?: MediaDevices;
maxTouchPoints: number;
permissions: Permissions;
serviceWorker?: ServiceWorkerContainer;
getGamepads?: () => Array<Gamepad | null>;
webkitGetGamepads?: Function;
mozGetGamepads?: Function;
mozGamepads?: any;
gamepads?: any;
webkitGamepads?: any;
getVRDisplays?: () => Promise<VRDisplay[]>;
registerContentHandler(mimeType: string, uri: string, title: string): void;
registerProtocolHandler(protocol: string, uri: string, title: string): void;
requestMIDIAccess?: (options?: MIDIOptions) => Promise<MIDIAccess>;
requestMediaKeySystemAccess?: (keySystem: string, supportedConfigurations: any[]) => Promise<any>;
sendBeacon?: (url: string, data?: BodyInit) => boolean;
vibrate?: (pattern: number | number[]) => boolean;
mozVibrate?: (pattern: number | number[]) => boolean;
webkitVibrate?: (pattern: number | number[]) => boolean;
canShare?: (shareData?: ShareData) => boolean;
share?: (shareData: ShareData) => Promise<void>;
clipboard: Clipboard;
credentials?: CredMgmtCredentialsContainer;
// deprecated
getBattery?: () => Promise<BatteryManager>;
mozGetBattery?: () => Promise<BatteryManager>;
// deprecated
getUserMedia?: Function;
webkitGetUserMedia?: Function;
mozGetUserMedia?: Function;
msGetUserMedia?: Function;
// Gecko
taintEnabled?: () => false;
oscpu: string;
}
declare class Clipboard extends EventTarget {
read(): Promise<DataTransfer>;
readText(): Promise<string>;
write(data: $ReadOnlyArray<ClipboardItem>): Promise<void>;
writeText(data: string): Promise<void>;
}
declare var navigator: Navigator;
declare class MimeType {
type: string;
description: string;
suffixes: string;
enabledPlugin: Plugin;
}
declare class MimeTypeArray {
length: number;
item(index: number): MimeType;
namedItem(name: string): MimeType;
[key: number | string]: MimeType;
}
declare class Plugin {
description: string;
filename: string;
name: string;
version?: string; // Gecko only
length: number;
item(index: number): MimeType;
namedItem(name: string): MimeType;
[key: number | string]: MimeType;
}
declare class PluginArray {
length: number;
item(index: number): Plugin;
namedItem(name: string): Plugin;
refresh(): void;
[key: number | string]: Plugin;
}
// https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp
// https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp
declare type DOMHighResTimeStamp = number;
// https://www.w3.org/TR/navigation-timing-2/
declare class PerformanceTiming {
connectEnd: number;
connectStart: number;
domainLookupEnd: number;
domainLookupStart: number;
domComplete: number;
domContentLoadedEventEnd: number;
domContentLoadedEventStart: number;
domInteractive: number;
domLoading: number;
fetchStart: number;
loadEventEnd: number;
loadEventStart: number;
navigationStart: number;
redirectEnd: number;
redirectStart: number;
requestStart: number;
responseEnd: number;
responseStart: number;
secureConnectionStart: number;
unloadEventEnd: number;
unloadEventStart: number;
}
declare class PerformanceNavigation {
TYPE_NAVIGATE: 0;
TYPE_RELOAD: 1;
TYPE_BACK_FORWARD: 2;
TYPE_RESERVED: 255;
type: 0 | 1 | 2 | 255;
redirectCount: number;
}
type PerformanceEntryFilterOptions = {
name: string,
entryType: string,
initiatorType: string,
...
}
// https://www.w3.org/TR/performance-timeline-2/
declare class PerformanceEntry {
name: string;
entryType: string;
startTime: DOMHighResTimeStamp;
duration: DOMHighResTimeStamp;
toJSON(): string;
}
// https://w3c.github.io/server-timing/#the-performanceservertiming-interface
declare class PerformanceServerTiming {
description: string;
duration: DOMHighResTimeStamp;
name: string;
toJSON(): string;
}
// https://www.w3.org/TR/resource-timing-2/#sec-performanceresourcetiming
// https://w3c.github.io/server-timing/#extension-to-the-performanceresourcetiming-interface
declare class PerformanceResourceTiming extends PerformanceEntry {
initiatorType: string;
nextHopProtocol: string;
workerStart: number;
redirectStart: number;
redirectEnd: number;
fetchStart: number;
domainLookupStart: number;
domainLookupEnd: number;
connectStart: number;
connectEnd: number;
secureConnectionStart: number;
requestStart: number;
responseStart: number;
responseEnd: number;
transferSize: string;
encodedBodySize: number;
decodedBodySize: number;
serverTiming: Array<PerformanceServerTiming>;
}
// https://www.w3.org/TR/navigation-timing-2/
declare class PerformanceNavigationTiming extends PerformanceResourceTiming {
unloadEventStart: number;
unloadEventEnd: number;
domInteractive: number;
domContentLoadedEventStart: number;
domContentLoadedEventEnd: number;
domComplete: number;
loadEventStart: number;
loadEventEnd: number;
type: 'navigate' | 'reload' | 'back_forward' | 'prerender';
redirectCount: number;
}
declare class Performance {
// deprecated
navigation: PerformanceNavigation;
timing: PerformanceTiming;
onresourcetimingbufferfull: (ev: any) => mixed;
clearMarks(name?: string): void;
clearMeasures(name?: string): void;
clearResourceTimings(): void;
getEntries(options?: PerformanceEntryFilterOptions): Array<PerformanceEntry>;
getEntriesByName(name: string, type?: string): Array<PerformanceEntry>;
getEntriesByType(type: string): Array<PerformanceEntry>;
mark(name: string): void;
measure(name: string, startMark?: string, endMark?: string): void;
now(): DOMHighResTimeStamp;
setResourceTimingBufferSize(maxSize: number): void;
toJSON(): string;
}
declare var performance: Performance;
type PerformanceEntryList = PerformanceEntry[];
declare interface PerformanceObserverEntryList {
getEntries(): PerformanceEntryList;
getEntriesByType(type: string): PerformanceEntryList;
getEntriesByName(name: string, type: ?string): PerformanceEntryList;
}
type PerformanceObserverInit = {
entryTypes?: string[];
type?: string;
buffered?: boolean;
...
}
declare class PerformanceObserver {
constructor(callback: (entries: PerformanceObserverEntryList, observer: PerformanceObserver) => mixed): void;
observe(options: ?PerformanceObserverInit): void;
disconnect(): void;
takeRecords(): PerformanceEntryList;
static supportedEntryTypes: string[];
}
declare class History {
length: number;
scrollRestoration: 'auto' | 'manual';
state: any;
back(): void;
forward(): void;
go(delta?: number): void;
pushState(statedata: any, title: string, url?: string): void;
replaceState(statedata: any, title: string, url?: string): void;
}
declare var history: History;
declare class Location {
ancestorOrigins: string[];
hash: string;
host: string;
hostname: string;
href: string;
origin: string;
pathname: string;
port: string;
protocol: string;
search: string;
assign(url: string): void;
reload(flag?: boolean): void;
replace(url: string): void;
toString(): string;
}
declare var location: Location;
///////////////////////////////////////////////////////////////////////////////
declare class DOMParser {
parseFromString(source: string, mimeType: string): Document;
}
type FormDataEntryValue = string | File
declare class FormData {
constructor(form?: HTMLFormElement): void;
has(name: string): boolean;
get(name: string): ?FormDataEntryValue;
getAll(name: string): Array<FormDataEntryValue>;
set(name: string, value: string): void;
set(name: string, value: Blob, filename?: string): void;
set(name: string, value: File, filename?: string): void;
append(name: string, value: string): void;
append(name: string, value: Blob, filename?: string): void;
append(name: string, value: File, filename?: string): void;
delete(name: string): void;
keys(): Iterator<string>;
values(): Iterator<FormDataEntryValue>;
entries(): Iterator<[string, FormDataEntryValue]>;
}
declare class MutationRecord {
type: 'attributes' | 'characterData' | 'childList';
target: Node;
addedNodes: NodeList<Node>;
removedNodes: NodeList<Node>;
previousSibling: ?Node;
nextSibling: ?Node;
attributeName: ?string;
attributeNamespace: ?string;
oldValue: ?string;
}
type MutationObserverInitRequired =
| { childList: true, ... }
| { attributes: true, ... }
| { characterData: true, ... }
declare type MutationObserverInit = MutationObserverInitRequired & {
subtree?: boolean,
attributeOldValue?: boolean,
characterDataOldValue?: boolean,
attributeFilter?: Array<string>,
...
}
declare class MutationObserver {
constructor(callback: (arr: Array<MutationRecord>, observer: MutationObserver) => mixed): void;
observe(target: Node, options: MutationObserverInit): void;
takeRecords(): Array<MutationRecord>;
disconnect(): void;
}
declare class DOMRectReadOnly {
static fromRect(rectangle?: {
x: number,
y: number,
width: number,
height: number,
...
}): DOMRectReadOnly;
constructor(x: number, y: number, width: number, height: number): void;
+bottom: number;
+height: number;
+left: number;
+right: number;
+top: number;
+width: number;
+x: number;
+y: number;
}
declare class DOMRect extends DOMRectReadOnly {
static fromRect(rectangle?: {
x: number,
y: number,
width: number,
height: number,
...
}): DOMRect;
bottom: number;
height: number;
left: number;
right: number;
top: number;
width: number;
x: number;
y: number;
}
declare class DOMRectList {
@@iterator(): Iterator<DOMRect>;
length: number;
item(index: number): DOMRect;
[index: number]: DOMRect;
}
declare type IntersectionObserverEntry = {
boundingClientRect: DOMRectReadOnly,
intersectionRatio: number,
intersectionRect: DOMRectReadOnly,
isIntersecting: boolean,
rootBounds: DOMRectReadOnly,
target: HTMLElement,
time: DOMHighResTimeStamp,
...
};
declare type IntersectionObserverCallback = (
entries: Array<IntersectionObserverEntry>,
observer: IntersectionObserver,
) => mixed;
declare type IntersectionObserverOptions = {
root?: Node | null,
rootMargin?: string,
threshold?: number | Array<number>,
...
};
declare class IntersectionObserver {
constructor(
callback: IntersectionObserverCallback,
options?: IntersectionObserverOptions
): void,
observe(target: HTMLElement): void,
unobserve(target: HTMLElement): void,
takeRecords(): Array<IntersectionObserverEntry>,
disconnect(): void,
}
declare interface ResizeObserverSize {
+inlineSize: number;
+blockSize: number;
}
declare interface ResizeObserverEntry {
/**
* The Element whose size has changed.
*/
+target: Element;
/**
* Element's content rect when ResizeObserverCallback is invoked.
*
* Legacy, may be deprecated in the future.
*/
+contentRect: DOMRectReadOnly;
/**
* An array containing the Element's border box size when
* ResizeObserverCallback is invoked.
*/
+borderBoxSize: $ReadOnlyArray<ResizeObserverSize>;
/**
* An array containing the Element's content rect size when
* ResizeObserverCallback is invoked.
*/
+contentBoxSize: $ReadOnlyArray<ResizeObserverSize>;
/**
* An array containing the Element's content rect size in integral device
* pixels when ResizeObserverCallback is invoked.
*
* Not implemented in Firefox or Safari as of July 2021
*/
+devicePixelContentBoxSize?: $ReadOnlyArray<ResizeObserverSize> | void;
}
/**
* ResizeObserver can observe different kinds of CSS sizes:
* - border-box : size of box border area as defined in CSS2.
* - content-box : size of content area as defined in CSS2.
* - device-pixel-content-box : size of content area as defined in CSS2, in device
* pixels, before applying any CSS transforms on the element or its ancestors.
* This size must contain integer values.
*/
type ResizeObserverBoxOptions = "border-box" | "content-box" | "device-pixel-content-box";
declare type ResizeObserverOptions = {
box?: ResizeObserverBoxOptions;
...
};
/**
* The ResizeObserver interface is used to observe changes to Element's size.
*/
declare class ResizeObserver {
constructor(callback: (entries: ResizeObserverEntry[], observer: ResizeObserver) => mixed): void;
/**
* Adds target to the list of observed elements.
*/
observe(target: Element, options?: ResizeObserverOptions): void;
/**
* Removes target from the list of observed elements.
*/
unobserve(target: Element): void;
disconnect(): void;
}
declare var NodeFilter: {
acceptNode(n: Node): number,
SHOW_ENTITY_REFERENCE: number,
SHOW_NOTATION: number,
SHOW_ENTITY: number,
SHOW_DOCUMENT: number,
SHOW_PROCESSING_INSTRUCTION: number,
FILTER_REJECT: number,
SHOW_CDATA_SECTION: number,
FILTER_ACCEPT: number,
SHOW_ALL: number,
SHOW_DOCUMENT_TYPE: number,
SHOW_TEXT: number,
SHOW_ELEMENT: number,
SHOW_COMMENT: number,
FILTER_SKIP: number,
SHOW_ATTRIBUTE: number,
SHOW_DOCUMENT_FRAGMENT: number,
...
};
declare class CloseEvent extends Event {
code: number;
reason: string;
wasClean: boolean;
}
declare class WebSocket extends EventTarget {
static CONNECTING: 0;
static OPEN: 1;
static CLOSING: 2;
static CLOSED: 3;
constructor(url: string, protocols?: string | Array<string>): void;
protocol: string;
readyState: number;
bufferedAmount: number;
extensions: string;
onopen: (ev: any) => mixed;
onmessage: (ev: MessageEvent) => mixed;
onclose: (ev: CloseEvent) => mixed;
onerror: (ev: any) => mixed;
binaryType: 'blob' | 'arraybuffer';
url: string;
close(code?: number, reason?: string): void;
send(data: string): void;
send(data: Blob): void;
send(data: ArrayBuffer): void;
send(data: $ArrayBufferView): void;
CONNECTING: 0;
OPEN: 1;
CLOSING: 2;
CLOSED: 3;
}
type WorkerOptions = {
type?: WorkerType,
credentials?: CredentialsType,
name?: string,
...
}
declare class Worker extends EventTarget {
constructor(stringUrl: string, workerOptions?: WorkerOptions): void;
onerror: null | (ev: any) => mixed;
onmessage: null | (ev: MessageEvent) => mixed;
onmessageerror: null | (ev: MessageEvent) => mixed;
postMessage(message: any, ports?: any): void;
terminate(): void;
}
declare class SharedWorker extends EventTarget {
constructor(stringUrl: string, name?: string): void;
constructor(stringUrl: string, workerOptions?: WorkerOptions): void;
port: MessagePort;
onerror: (ev: any) => mixed;
}
declare function importScripts(...urls: Array<string>): void;
declare class WorkerGlobalScope extends EventTarget {
self: this;
location: WorkerLocation;
navigator: WorkerNavigator;
close(): void;
importScripts(...urls: Array<string>): void;
onerror: (ev: any) => mixed;
onlanguagechange: (ev: any) => mixed;
onoffline: (ev: any) => mixed;
ononline: (ev: any) => mixed;
onrejectionhandled: (ev: PromiseRejectionEvent) => mixed;
onunhandledrejection: (ev: PromiseRejectionEvent) => mixed;
}
declare class DedicatedWorkerGlobalScope extends WorkerGlobalScope {
onmessage: (ev: MessageEvent) => mixed;
onmessageerror: (ev: MessageEvent) => mixed;
postMessage(message: any, transfer?: Iterable<any>): void;
}
declare class SharedWorkerGlobalScope extends WorkerGlobalScope {
name: string;
onconnect: (ev: MessageEvent) => mixed;
}
declare class WorkerLocation {
origin: string;
protocol: string;
host: string;
hostname: string;
port: string;
pathname: string;
search: string;
hash: string;
}
declare class WorkerNavigator mixins
NavigatorID,
NavigatorLanguage,
NavigatorOnLine,
NavigatorConcurrentHardware {
permissions: Permissions;
}
// deprecated
declare class XDomainRequest {
timeout: number;
onerror: () => mixed;
onload: () => mixed;
onprogress: () => mixed;
ontimeout: () => mixed;
+responseText: string;
+contentType: string;
open(method: "GET" | "POST", url: string): void;
abort(): void;
send(data?: string): void;
statics: { create(): XDomainRequest, ... }
}
declare class XMLHttpRequest extends EventTarget {
static LOADING: number;
static DONE: number;
static UNSENT: number;
static OPENED: number;
static HEADERS_RECEIVED: number;
responseBody: any;
status: number;
readyState: number;
responseText: string;
responseXML: any;
responseURL: string;
ontimeout: ProgressEventHandler;
statusText: string;
onreadystatechange: (ev: any) => mixed;
timeout: number;
onload: ProgressEventHandler;
response: any;
withCredentials: boolean;
onprogress: ProgressEventHandler;
onabort: ProgressEventHandler;
responseType: string;
onloadend: ProgressEventHandler;
upload: XMLHttpRequestEventTarget;
onerror: ProgressEventHandler;
onloadstart: ProgressEventHandler;
msCaching: string;
open(method: string, url: string, async?: boolean, user?: string, password?: string): void;
send(data?: any): void;
abort(): void;
getAllResponseHeaders(): string;
setRequestHeader(header: string, value: string): void;
getResponseHeader(header: string): string;
msCachingEnabled(): boolean;
overrideMimeType(mime: string): void;
LOADING: number;
DONE: number;
UNSENT: number;
OPENED: number;
HEADERS_RECEIVED: number;
statics: { create(): XMLHttpRequest, ... }
}
declare class XMLHttpRequestEventTarget extends EventTarget {
onprogress: ProgressEventHandler;
onerror: ProgressEventHandler;
onload: ProgressEventHandler;
ontimeout: ProgressEventHandler;
onabort: ProgressEventHandler;
onloadstart: ProgressEventHandler;
onloadend: ProgressEventHandler;
}
declare class XMLSerializer {
serializeToString(target: Node): string;
}
declare class Geolocation {
getCurrentPosition(
success: (position: Position) => mixed,
error?: (error: PositionError) => mixed,
options?: PositionOptions
): void;
watchPosition(
success: (position: Position) => mixed,
error?: (error: PositionError) => mixed,
options?: PositionOptions
): number;
clearWatch(id: number): void;
}
declare class Position {
coords: Coordinates;
timestamp: number;
}
declare class Coordinates {
latitude: number;
longitude: number;
altitude?: number;
accuracy: number;
altitudeAccuracy?: number;
heading?: number;
speed?: number;
}
declare class PositionError {
code: number;
message: string;
PERMISSION_DENIED: 1;
POSITION_UNAVAILABLE: 2;
TIMEOUT: 3;
}
type PositionOptions = {
enableHighAccuracy?: boolean,
timeout?: number,
maximumAge?: number,
...
}
type AudioContextState = 'suspended' | 'running' | 'closed';
// deprecated
type AudioProcessingEvent$Init = Event$Init & {
playbackTime: number;
inputBuffer: AudioBuffer;
outputBuffer: AudioBuffer;
...
}
// deprecated
declare class AudioProcessingEvent extends Event {
constructor(type: string, eventInitDict: AudioProcessingEvent$Init): void;
+playbackTime: number;
+inputBuffer: AudioBuffer;
View remainder of file in raw view
0