google-closure-compiler 20250412.0.0-nightly → 20250413.0.0

package/externs/browser/webkit_notifications.js

@@ -0,0 +1,258 @@
+/*
+ * Copyright 2010 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @fileoverview Definitions for W3C's Notifications specification.
+ * @externs
+ */
+
+/**
+ * @typedef {{
+ *     dir: (string|undefined),
+ *     lang: (string|undefined),
+ *     body: (string|undefined),
+ *     tag: (string|undefined),
+ *     image: (string|undefined),
+ *     icon: (string|undefined),
+ *     badge: (string|undefined),
+ *     vibrate: (!Array<number>|undefined),
+ *     timestamp: (number|undefined),
+ *     renotify: (boolean|undefined),
+ *     silent: (boolean|undefined),
+ *     requireInteraction: (boolean|undefined),
+ *     data: (*|undefined),
+ *     actions: (!Array<!NotificationAction>|undefined),
+ * }}
+ * TODO(user): change the type of data to a serializable object
+ * (https://html.spec.whatwg.org/multipage/structured-data.html).
+ *
+ * @see http://notifications.spec.whatwg.org/#notification
+ */
+var NotificationOptions;
+
+/**
+ * @typedef {{action: string, title: string, icon: (string|undefined)}}
+ * @see https://notifications.spec.whatwg.org/#dictdef-notificationoptions
+ */
+var NotificationAction;
+
+/**
+ * @typedef {{tag: (string|undefined)}}
+ * @see https://notifications.spec.whatwg.org/#dictdef-getnotificationoptions
+ */
+var GetNotificationOptions;
+
+/** @interface */
+var NotificationOptionsInterface_ = function() {}
+/** @type {string} */ NotificationOptionsInterface_.prototype.dir;
+/** @type {string} */ NotificationOptionsInterface_.prototype.lang;
+/** @type {string} */ NotificationOptionsInterface_.prototype.body;
+/** @type {string} */ NotificationOptionsInterface_.prototype.tag;
+/** @type {string} */ NotificationOptionsInterface_.prototype.icon;
+/** @type {boolean} */
+  NotificationOptionsInterface_.prototype.requireInteraction;
+
+/**
+ * @param {string} title
+ * @param {NotificationOptions=} opt_options
+ * @constructor
+ * @implements {EventTarget}
+ * @see http://notifications.spec.whatwg.org/#notification
+ */
+function Notification(title, opt_options) {}
+
+/**
+ * @type {string}
+ */
+Notification.permission;
+
+/**
+ * @param {NotificationPermissionCallback=} opt_callback
+ * @return {!Promise<string>}
+ */
+Notification.requestPermission = function(opt_callback) {};
+
+/** @override */
+Notification.prototype.addEventListener = function(
+    type, listener, opt_options) {};
+
+/** @override */
+Notification.prototype.removeEventListener = function(
+    type, listener, opt_options) {};
+
+/** @override */
+Notification.prototype.dispatchEvent = function(evt) {};
+
+/**
+ * @type {string}
+ */
+Notification.prototype.title;
+
+/**
+ * @type {string}
+ */
+Notification.prototype.body;
+
+/**
+ * @type {string}
+ */
+Notification.prototype.icon;
+
+/**
+ * The string used by clients to identify the notification.
+ * @type {string}
+ */
+Notification.prototype.tag;
+
+/**
+ * The ID used by clients to uniquely identify notifications to eliminate
+ * duplicate notifications.
+ * @type {string}
+ * @deprecated Use NotificationOptions.tag instead.
+ */
+Notification.prototype.replaceId;
+
+/**
+ * @type {*}
+ */
+Notification.prototype.data;
+
+/**
+ * The string used by clients to specify the directionality (rtl/ltr) of the
+ * notification.
+ * @type {string}
+ * @deprecated Use NotificationOptions.titleDir and bodyDir instead.
+ */
+Notification.prototype.dir;
+
+/**
+ * Displays the notification.
+ * @return {undefined}
+ */
+Notification.prototype.show = function() {};
+
+/**
+ * Prevents the notification from being displayed, or closes it if it is already
+ * displayed.
+ * @return {undefined}
+ */
+Notification.prototype.cancel = function() {};
+
+/**
+ * Prevents the notification from being displayed, or closes it if it is already
+ * displayed.
+ * @return {undefined}
+ */
+Notification.prototype.close = function() {};
+
+/**
+ * An event handler called when notification is closed.
+ * @type {?function(Event)}
+ */
+Notification.prototype.onclose;
+
+/**
+ * An event handler called if the notification could not be displayed due to
+ * an error (i.e. resource could not be loaded).
+ * @type {?function(Event)}
+ */
+Notification.prototype.onerror;
+
+/**
+ * An event handler called when the notification has become visible.
+ * @type {?function(Event)}
+ * @deprecated Use onshow instead.
+ */
+Notification.prototype.ondisplay;
+
+/**
+ * An event handler called when the notification has become visible.
+ * @type {?function(Event)}
+ */
+Notification.prototype.onshow;
+
+/**
+ * An event handler called when the notification has been clicked on.
+ * @type {?function(Event)}
+ */
+Notification.prototype.onclick;
+
+
+
+/**
+ * @typedef {function(string)}
+ * @see http://notifications.spec.whatwg.org/#notificationpermissioncallback
+ */
+var NotificationPermissionCallback;
+
+/**
+ * @constructor
+ * @see http://dev.w3.org/2006/webapi/WebNotifications/publish/#dialog-if
+ * @deprecated Use Notification instead.
+ */
+function NotificationCenter() {}
+
+/**
+ * Creates a text+icon notification and displays it to the user.
+ * @param {string} iconUrl
+ * @param {string} title
+ * @param {string} body
+ * @return {Notification}
+ */
+NotificationCenter.prototype.createNotification =
+    function(iconUrl, title, body) {};
+
+/**
+ * Creates an HTML notification and displays it to the user.
+ * @param {string} url
+ * @return {Notification}
+ */
+NotificationCenter.prototype.createHTMLNotification = function(url) {};
+
+/**
+ * Checks if the user has permission to display notifications.
+ * @return {number}
+ */
+NotificationCenter.prototype.checkPermission = function() {};
+
+/**
+ * Requests permission from the user to display notifications.
+ * @param {Function=} opt_callback
+ * @return {void}
+ */
+NotificationCenter.prototype.requestPermission = function(opt_callback) {};
+
+/**
+ * WebKit browsers expose the NotificationCenter API through
+ * window.webkitNotifications.
+ * @type {NotificationCenter}
+ */
+Window.prototype.webkitNotifications;
+
+
+/**
+ * @see https://notifications.spec.whatwg.org/#notificationevent
+ * @constructor
+ * @param {string} type
+ * @param {!ExtendableEventInit=} opt_eventInitDict
+ * @extends {ExtendableEvent}
+ */
+function NotificationEvent(type, opt_eventInitDict) {}
+
+/** @type {!Notification} */
+NotificationEvent.prototype.notification;
+
+/** @type {string} */
+NotificationEvent.prototype.action;

package/externs/browser/webkit_usercontent.js

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2016 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @fileoverview Definitions for WKWebView's User Content interface.
+ *   https://developer.apple.com/library/prerelease/ios/documentation/WebKit/Reference/WKUserContentController_Ref/
+ *   https://trac.webkit.org/browser/trunk/Source/WebCore/page/WebKitNamespace.h
+ *
+ * @externs
+ */
+
+/** @constructor */
+function WebKitNamespace() {}
+
+
+/**
+ * @type {!UserMessageHandlersNamespace}
+ */
+WebKitNamespace.prototype.messageHandlers;
+
+
+/**
+ * @constructor
+ * @implements {IObject<string, UserMessageHandler>}
+ */
+function UserMessageHandlersNamespace() {}
+
+
+/** @constructor */
+function UserMessageHandler() {}
+
+
+/**
+ * @param {*} message
+ * @return {undefined}
+ */
+UserMessageHandler.prototype.postMessage = function(message) {};
+
+
+/**
+ * @const {!WebKitNamespace}
+ */
+var webkit;

package/externs/browser/weblocksapi.js

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2018 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @fileoverview Definitions for objects in the Web Locks API. Details of the
+ * API are at:
+ * @see https://w3c.github.io/web-locks/
+ *
+ * @externs
+ * @author ohsnapitscolin@google.com (Colin Dunn)
+ */
+
+/**
+ * Possible values are "shared" and "exclusive".
+ * @typedef {string}
+ * @see https://w3c.github.io/web-locks/#enumdef-lockmode
+ */
+var LockMode;
+
+
+/**
+ * @interface
+ * @see https://w3c.github.io/web-locks/#lock
+ */
+function Lock() {}
+
+/**
+ * @const {string}
+ * @see https://w3c.github.io/web-locks/#lock-concept-name
+ */
+Lock.prototype.name;
+
+/**
+ * @const {!LockMode}
+ * @see https://w3c.github.io/web-locks/#lock-concept-mode
+ */
+Lock.prototype.mode;
+
+
+/**
+ * @typedef {{
+ *   name: string,
+ *   mode: !LockMode,
+ *   clientId: string
+ * }}
+ * @see https://w3c.github.io/web-locks/#dictdef-lockinfo
+ */
+var LockInfo;
+
+
+/**
+ * @typedef {{
+ *   mode: (!LockMode|undefined),
+ *   ifAvailable: (boolean|undefined),
+ *   steal: (boolean|undefined),
+ *   signal: (!AbortSignal|undefined)
+ * }}
+ * @see https://w3c.github.io/web-locks/#dictdef-lockoptions
+ */
+var LockOptions;
+
+
+/**
+ * @typedef {{
+ *   held: !Array<!LockInfo>,
+ *   pending: !Array<!LockInfo>
+ * }}
+ * @see https://w3c.github.io/web-locks/#dictdef-lockmanagersnapshot
+ */
+var LockManagerSnapshot;
+
+
+/**
+ * @typedef {(function(?Lock) : !Promise<*>)}
+ * @see https://w3c.github.io/web-locks/#callbackdef-lockgrantedcallback
+ */
+var LockGrantedCallback;
+
+
+/**
+ * @interface
+ * @see https://w3c.github.io/web-locks/#lockmanager
+ */
+function LockManager() {}
+
+/**
+ * @see https://w3c.github.io/web-locks/#dom-lockmanager-request
+ * @param {string} name
+ * @param {(!LockOptions|!LockGrantedCallback)} optionsOrCallback
+ * @param {!LockGrantedCallback=} callback
+ * @return {!Promise<*>}
+ */
+LockManager.prototype.request = function(name, optionsOrCallback, callback) {};
+
+/**
+ * @see https://w3c.github.io/web-locks/#dom-lockmanager-query
+ * @return {!Promise<!LockManagerSnapshot>}
+ */
+LockManager.prototype.query = function() {};
+
+
+/**
+ * @type {!LockManager}
+ * @see https://w3c.github.io/web-locks/#lockmanager
+ */
+Navigator.prototype.locks;
+
+
+/**
+ * @type {!LockManager}
+ * @see https://w3c.github.io/web-locks/#lockmanager
+ */
+WorkerNavigator.prototype.locks;

package/externs/browser/webstorage.js

@@ -0,0 +1,171 @@
+/*
+ * Copyright 2009 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @fileoverview Definitions for W3C's WebStorage specification.
+ * This file depends on w3c_dom1.js and w3c_event.js.
+ * @externs
+ */
+
+/**
+ * @interface
+ * @see https://www.w3.org/TR/webstorage/#the-storage-interface
+ */
+function Storage() {}
+
+/**
+ * @const {number}
+ */
+Storage.prototype.length;
+
+/**
+ * @param {number} index
+ * @return {?string}
+ */
+Storage.prototype.key = function(index) {};
+
+/**
+ * @param {string} key
+ * @return {?string}
+ */
+Storage.prototype.getItem = function(key) {};
+
+/**
+ * @param {string} key
+ * @param {string} data
+ * @return {void}
+ */
+Storage.prototype.setItem = function(key, data) {};
+
+/**
+ * @param {string} key
+ * @return {void}
+ */
+Storage.prototype.removeItem = function(key) {};
+
+/**
+ * @return {void}
+ */
+Storage.prototype.clear = function() {};
+
+/**
+ * @interface
+ * @see https://www.w3.org/TR/webstorage/#the-sessionstorage-attribute
+ */
+function WindowSessionStorage() {}
+
+/**
+ * @type {!Storage}
+ */
+WindowSessionStorage.prototype.sessionStorage;
+
+/**
+ * Window implements WindowSessionStorage
+ *
+ * @type {!Storage}
+ */
+Window.prototype.sessionStorage;
+
+/**
+ * @interface
+ * @see https://www.w3.org/TR/webstorage/#the-localstorage-attribute
+ */
+function WindowLocalStorage() {}
+
+/**
+ * @type {!Storage}
+ */
+WindowLocalStorage.prototype.localStorage;
+
+/**
+ * Window implements WindowLocalStorage
+ *
+ * @type {!Storage}
+ */
+Window.prototype.localStorage;
+
+/**
+ * @record
+ * @extends {EventInit}
+ * @see https://www.w3.org/TR/webstorage/#the-storageevent-interface
+ */
+function StorageEventInit() {}
+
+/** @type {undefined|string} */
+StorageEventInit.prototype.key;
+
+/** @type {undefined|string} */
+StorageEventInit.prototype.oldValue;
+
+/** @type {undefined|string} */
+StorageEventInit.prototype.newValue;
+
+/** @type {string} */
+StorageEventInit.prototype.url;
+
+/** @type {undefined|!Storage} */
+StorageEventInit.prototype.storageArea;
+
+/**
+ * This is the storage event interface.
+ * @see https://www.w3.org/TR/webstorage/#the-storage-event
+ * @extends {Event}
+ * @param {string} type
+ * @param {!StorageEventInit=} eventInitDict
+ * @constructor
+ */
+function StorageEvent(type, eventInitDict) {}
+
+/**
+ * @type {string}
+ */
+StorageEvent.prototype.key;
+
+/**
+ * @type {?string}
+ */
+StorageEvent.prototype.oldValue;
+
+/**
+ * @type {?string}
+ */
+StorageEvent.prototype.newValue;
+
+/**
+ * @type {string}
+ */
+StorageEvent.prototype.url;
+
+/**
+ * @type {?Storage}
+ */
+StorageEvent.prototype.storageArea;
+
+/**
+ * @param {string} typeArg
+ * @param {boolean} canBubbleArg
+ * @param {boolean} cancelableArg
+ * @param {string} keyArg
+ * @param {?string} oldValueArg
+ * @param {?string} newValueArg
+ * @param {!URL|string} urlArg
+ * @param {?Storage} storageAreaArg
+ * @return {void}
+ */
+StorageEvent.prototype.initStorageEvent = function(typeArg, canBubbleArg,
+                                                   cancelableArg, keyArg,
+                                                   oldValueArg, newValueArg,
+                                                   urlArg, storageAreaArg) {};
+

package/externs/browser/whatwg_bitmap_context.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2021 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for ImageBitmapRenderingContext.
+ *     https://html.spec.whatwg.org/multipage/canvas.html#the-imagebitmaprenderingcontext-interface
+ * @externs
+ */
+
+/**
+ * @constructor
+ * @see https://html.spec.whatwg.org/multipage/canvas.html#the-imagebitmaprenderingcontext-interface
+ */
+function ImageBitmapRenderingContext() {}
+
+/**
+ * @param {?ImageBitmap} bitmap
+ * @return {undefined}
+ */
+ImageBitmapRenderingContext.prototype.transferFromImageBitmap = function(
+    bitmap) {};
+
+/** @const {!HTMLCanvasElement|!OffscreenCanvas} */
+ImageBitmapRenderingContext.prototype.canvas;