@openfin/core 25.68.26

package/src/api/view/Instance.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.View = void 0;
+/* eslint-disable import/prefer-default-export */
+const main_1 = require("../webcontents/main");
+const window_1 = require("../window");
+/**
+ * @typedef {object} View~options
+ * @summary View creation options.
+ * @desc This is the options object required by {@link View.create View.create}.
+ *
+ * Note that `name` and `target` are the only required properties — albeit the `url` property is usually provided as well
+ * (defaults to `"about:blank"` when omitted).
+ *
+ * @property {object} [experimental]
+ * Configurations for API injection.
+ *
+ * @property {boolean} [experimental.childWindows] Configure if the runtime should enable child windows for views.
+ *
+ * @property {object} [api]
+ * Configurations for API injection.
+ *
+ * @property {object} [api.iframe] Configure if the the API should be injected into iframes based on domain.
+ *
+ * @property {boolean} [api.iframe.crossOriginInjection=false] Controls if the `fin` API object is present for cross origin iframes.
+ * @property {boolean} [api.iframe.sameOriginInjection=true] Controls if the `fin` API object is present for same origin iframes.
+ *
+ * @property {object} [autoResize] AutoResize options
+ *
+ * @property {object} [bounds] initial bounds given relative to the window.
+ *
+ * @property {string} [backgroundColor="#FFF"] - _Updatable._
+ * The view’s _backfill_ color as a hexadecimal value. Not to be confused with the content background color
+ * (`document.body.style.backgroundColor`),
+ * this color briefly fills a view’s (a) content area before its content is loaded as well as (b) newly exposed
+ * areas when growing a window. Setting
+ * this value to the anticipated content background color can help improve user experience.
+ * Default is white.
+ *
+ * @property {object} [contentNavigation]
+ * Restrict navigation to URLs that match a whitelisted pattern.
+ * In the lack of a whitelist, navigation to URLs that match a blacklisted pattern would be prohibited.
+ * See [here](https://developer.chrome.com/extensions/match_patterns) for more details.
+ * @property {string[]} [contentNavigation.whitelist=[]] List of whitelisted URLs.
+ * @property {string[]} [contentNavigation.blacklist=[]] List of blacklisted URLs.
+ *
+ * @property {object} [contextMenuSettings] - _Updatable._
+ * Configure the context menu when right-clicking on a view.
+ * @property {boolean} [contextMenuSettings.enable=true] Should the context menu display on right click.
+ * @property {boolean} [contextMenuSettings.devtools=true] Should the context menu contain a button for opening devtools.
+ * @property {boolean} [contextMenuSettings.reload=true] Should the context menu contain a button for reloading the page.
+ *
+ * @property {any} [customData=""] - _Updatable._
+ * A field that the user can attach serializable data to to be ferried around with the view options.
+ * _When omitted, the default value of this property is the empty string (`""`)._
+ *
+ * When omitted, the default value of this property is the empty string (`""`).
+ * As opposed to customData this is meant for frequent updates and sharing with other contexts. [Example]{@tutorial customContext}
+ *
+ * @property {object[]} [hotkeys=[]] - _Updatable._
+ * Defines the list of hotkeys that will be emitted as a `hotkey` event on the view. For usage example see [example]{@tutorial hotkeys}.
+ * Within Platform, OpenFin also implements a set of pre-defined actions called
+ * [keyboard commands]{@link https://developers.openfin.co/docs/platform-api#section-5-3-using-keyboard-commands}
+ * that can be assigned to a specific hotkey in the platform manifest.
+ * @property {string} hotkeys.keys The key combination of the hotkey, i.e. "Ctrl+T"
+ * @property {boolean} [hotkeys.preventDefault=false] preventDefault will prevent the page keydown/keyup events from being emitted.
+ *
+ * @property {boolean} [isClosable=true] **Platforms Only.** If false, the view will be persistent and can't be closed through
+ * either UI or `Platform.closeView`. Note that the view will still be closed if the host window is closed or
+ * if the view isn't part of the new layout when running `Layout.replace`.
+ *
+ * @property {string} name
+ * The name of the view.
+ *
+ * @property {boolean} [detachOnClose=false] - _Updatable._
+ * Platforms Only.  If true, will hide and detach the View from the window for later use instead of closing,
+ * allowing the state of the View to be saved and the View to be immediately shown in a new Layout.
+ *
+ * @property {string} [manifestUrl] **Platforms Only.** Url to a manifest that contains View Options. Properties other than manifestUrl can still be used
+ * but the properties in the manifest will take precedence if there is any collision.
+ *
+ * @property {preloadScript[]} [preloadScripts] - _Inheritable_
+ * A list of scripts that are eval'ed before other scripts in the page. When omitted, _inherits_
+ * from the parent application.
+ *
+ * @property {boolean} [preventDragOut=false] **Platforms Only.** If true, the tab of the view can't be dragged out of its host window.
+ *
+ * @property {string} [processAffinity=<application uuid>]
+ * A string to attempt to group renderers together. Will only be used if pages are on the same origin.
+ *
+ * @property {Identity} [target]
+ * The identity of the window this view should be attached to.
+ *
+ * @property {string} [url="about:blank"]
+ * The URL of the view.
+ *
+ * @property {string} [uuid=<application uuid>]
+ * The `uuid` of the application, unique within the set of all `Application`s running in OpenFin Runtime.
+ * If omitted, defaults to the `uuid` of the application spawning the view.
+ * If given, must match the `uuid` of the application spawning the view.
+ * In other words, the application's `uuid` is the only acceptable value, but is the default, so there's
+ * really no need to provide it.
+ */
+/**
+ * @classdesc a View can be used to embed additional web content into a Window.
+ * It is like a child window, except it is positioned relative to its owning window.
+ * It has the ability to listen for <a href="tutorial-View.EventEmitter.html">View-specific events</a>.
+ *
+ * By default, a View will try to share the same renderer process as other Views owned by its parent Application.
+ * To change that behavior, see the processAffinity {@link View~options view option}.
+ *
+ * A View's lifecycle is tied to its owning window and can be re-attached to a different window at any point during its lifecycle.
+ * @class
+ * @alias View
+ * @hideconstructor
+ */
+class View extends main_1.WebContents {
+    constructor(wire, identity) {
+        super(wire, identity, 'view');
+        this.identity = identity;
+        /**
+         * Returns the zoom level of the view.
+         * @function getZoomLevel
+         * @memberOf View
+         * @instance
+         * @return {Promise.<number>}
+         * @tutorial View.getZoomLevel
+         */
+        /**
+         * Sets the zoom level of the view.
+         * @param { number } level The zoom level
+         * @function setZoomLevel
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.setZoomLevel
+         */
+        /**
+         * Find and highlight text on a page.
+         * @param { string } searchTerm Term to find in page
+         * @param { FindInPageOptions } options Search options
+         * @function findInPage
+         * @memberOf View
+         * @instance
+         * @return {Promise.<number>}
+         * @tutorial View.findInPage
+         */
+        /**
+         * Stops any findInPage call with the provided action.
+         * @param {string} action
+         * Action to execute when stopping a find in page:<br>
+         * "clearSelection" - Clear the selection.<br>
+         * "keepSelection" - Translate the selection into a normal selection.<br>
+         * "activateSelection" - Focus and click the selection node.<br>
+         * @function stopFindInPage
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.stopFindInPage
+         */
+        /**
+         * Navigates the view to a specified URL. The url must contain the protocol prefix such as http:// or https://.
+         * @param { string } url - The URL to navigate the view to.
+         * @return {Promise.<void>}
+         * @function navigate
+         * @memberof View
+         * @instance
+         * @tutorial View.navigate
+         * @experimental
+         */
+        /**
+         * Navigates the view back one page.
+         * @function navigateBack
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.navigateBack
+         */
+        /**
+         * Navigates the view forward one page.
+         * @function navigateForward
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.navigateForward
+         */
+        /**
+         * Stops any current navigation the view is performing.
+         * @function stopNavigation
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.stopNavigation
+         */
+        /**
+         * Reloads the view current page
+         * @function reload
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.reload
+         */
+        /**
+         * Prints the view's web page
+         * @param { PrintOptions } [options] Printer Options
+         * @function print
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.print
+         */
+        /**
+         * Returns an array with all system printers
+         * @function getPrinters
+         * @memberOf View
+         * @instance
+         * @return { Promise.Array.<PrinterInfo> }
+         * @tutorial View.getPrinters
+         */
+        /**
+         * Shows the Chromium Developer Tools
+         * @function showDeveloperTools
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.showDeveloperTools
+         */
+        /**
+         * Retrieves the process information associated with a view.
+         * @function getProcessInfo
+         * @memberOf View
+         * @instance
+         * @return {Promise.<EntityProcessDetails>}
+         * @tutorial View.getProcessInfo
+         */
+        /**
+         * Retrieves information on all Shared Workers.
+         * @function getSharedWorkers
+         * @memberOf View
+         * @instance
+         * @return {Promise.Array.<SharedWorkerInfo>}
+         * @tutorial View.getSharedWorkers
+         */
+        /**
+         * Opens the developer tools for the shared worker context.
+         * @function inspectSharedWorker
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.inspectSharedWorker
+         */
+        /**
+         * Inspects the shared worker based on its ID.
+         * @param { string } workerId - The id of the shared worker.
+         * @function inspectSharedWorkerById
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.inspectSharedWorkerById
+         */
+        /**
+         * Opens the developer tools for the service worker context.
+         * @function inspectServiceWorker
+         * @memberOf View
+         * @instance
+         * @return {Promise.<void>}
+         * @tutorial View.inspectServiceWorker
+         */
+        /**
+         * Attaches the current view to a the given window identity.
+         * Identity must be the identity of a window in the same application.
+         * This detaches the view from its current window, and sets the view to be destroyed when its new window closes.
+         * @param target {Identity}
+         * @return {Promise.<void>}
+         * @tutorial View.attach
+         * @experimental
+         */
+        this.attach = async (target) => {
+            await this.wire.sendAction('attach-view', { target, ...this.identity });
+        };
+        /**
+         * Destroys the current view
+         * @return {Promise.<void>}
+         * @tutorial View.destroy
+         * @experimental
+         */
+        this.destroy = async () => {
+            await this.wire.sendAction('destroy-view', { ...this.identity });
+        };
+        /**
+         * Shows the current view if it is currently hidden.
+         * @return {Promise.<void>}
+         * @tutorial View.show
+         * @experimental
+         */
+        this.show = async () => {
+            await this.wire.sendAction('show-view', { ...this.identity });
+        };
+        /**
+         * Hides the current view if it is currently visible.
+         * @return {Promise.<void>}
+         * @tutorial View.hide
+         * @experimental
+         */
+        this.hide = async () => {
+            await this.wire.sendAction('hide-view', { ...this.identity });
+        };
+        /**
+         * Sets the bounds (top, left, width, height) of the view relative to its window.
+         * @param bounds {ViewBounds}
+         * @return {Promise.<void>}
+         * @tutorial View.setBounds
+         * @experimental
+         */
+        this.setBounds = async (bounds) => {
+            await this.wire.sendAction('set-view-bounds', { bounds, ...this.identity });
+        };
+        /**
+         * Gets the bounds (top, left, width, height) of the view relative to its window.
+         * @return {Promise.<ViewBounds>}
+         * @tutorial View.getBounds
+         * @experimental
+         */
+        this.getBounds = async () => {
+            const ack = await this.wire.sendAction('get-view-bounds', { ...this.identity });
+            return ack.payload.data;
+        };
+        /**
+         * Gets the View's info.
+         * @return {Promise.<ViewInfo>}
+         * @tutorial View.getInfo
+         * @experimental
+         */
+        this.getInfo = async () => {
+            const ack = await this.wire.sendAction('get-view-info', { ...this.identity });
+            return ack.payload.data;
+        };
+        /**
+         * Retrieves the layout for the window the view is attached to.
+         * @return {Promise.<Layout>}
+         * @tutorial View.getParentLayout
+         * @experimental
+         */
+        this.getParentLayout = async () => {
+            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch((e) => {
+                // don't expose
+            });
+            const currentWindow = await this.getCurrentWindow();
+            return currentWindow.getLayout();
+        };
+        /**
+         * Gets the View's options.
+         * @return {Promise<ViewOptions>}
+         * @tutorial View.getOptions
+         * @experimental
+         */
+        this.getOptions = async () => {
+            return this.wire.sendAction('get-view-options', { ...this.identity }).then(({ payload }) => payload.data);
+        };
+        /**
+         * Updates the view's options.
+         * @param { Partial<ViewOptions> } options
+         * @return {Promise.<void>}
+         * @tutorial View.updateOptions
+         * @experimental
+         */
+        this.updateOptions = async (options) => {
+            return this.wire.sendAction('update-view-options', { options, ...this.identity }).then(() => undefined);
+        };
+        /**
+         * Retrieves the window the view is currently attached to.
+         * @return {Promise.<_Window>}
+         * @experimental
+         */
+        this.getCurrentWindow = async () => {
+            const { payload: { data } } = await this.wire.sendAction('get-view-window', { ...this.identity });
+            return new window_1._Window(this.wire, data);
+        };
+    }
+    /**
+     * Gets a base64 encoded image of the view or a part of it.
+     * @function capturePage
+     * @param { CapturePageOptions } [options] Options for the capturePage call.
+     * @memberOf View
+     * @instance
+     * @return {Promise.<string>}
+     * @tutorial View.capturePage
+     */
+    /**
+     * Executes Javascript on the view, restricted to contents you own or contents owned by
+     * applications you have created.
+     * @param { string } code JavaScript code to be executed on the view.
+     * @function executeJavaScript
+     * @memberOf View
+     * @instance
+     * @return {Promise.<void>}
+     * @tutorial View.executeJavaScript
+     */
+    /**
+     * Focuses the view
+     * @return {Promise.<void>}
+     * @function focus
+     * @memberof View
+     * @emits focused
+     * @instance
+     * @tutorial View.focus
+     * @experimental
+     */
+    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {
+        const win = await this.getCurrentWindow();
+        await win.focusedWebViewWasChanged();
+        await super.focus({ emitSynthFocused });
+    }
+}
+exports.View = View;

package/src/api/view/index.d.ts

@@ -0,0 +1,3 @@
+import ViewModule from './Factory';
+export default ViewModule;
+export * from './Instance';

package/src/api/view/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const Factory_1 = require("./Factory");
+exports.default = Factory_1.default;
+__exportStar(require("./Instance"), exports);

package/src/api/webcontents/main.d.ts

@@ -0,0 +1,36 @@
+import { EmitterBase } from '../base';
+import Transport from '../../transport/transport';
+import { WebContentsEventMapping } from '../events/webcontents';
+declare type ImageFormat = 'bmp' | 'jpg' | 'png';
+export interface CapturePageOptions {
+    area?: OpenFin.Rectangle;
+    format?: ImageFormat;
+    quality?: number;
+}
+export declare class WebContents<T extends WebContentsEventMapping> extends EmitterBase<T> {
+    entityType: string;
+    constructor(wire: Transport, identity: OpenFin.Identity, entityType: string);
+    capturePage(options?: CapturePageOptions): Promise<string>;
+    executeJavaScript(code: string): Promise<void>;
+    getZoomLevel(): Promise<number>;
+    setZoomLevel(level: number): Promise<void>;
+    navigate(url: string): Promise<void>;
+    navigateBack(): Promise<void>;
+    navigateForward(): Promise<void>;
+    stopNavigation(): Promise<void>;
+    reload(ignoreCache?: boolean): Promise<void>;
+    print(options?: OpenFin.PrintOptions): Promise<void>;
+    findInPage(searchTerm: string, options?: OpenFin.FindInPageOptions): Promise<void>;
+    stopFindInPage(action: string): Promise<void>;
+    getPrinters(): Promise<OpenFin.PrinterInfo>;
+    focus({ emitSynthFocused }?: {
+        emitSynthFocused: boolean;
+    }): Promise<void>;
+    showDeveloperTools(): Promise<void>;
+    getProcessInfo(): Promise<OpenFin.EntityProcessDetails>;
+    getSharedWorkers(): Promise<OpenFin.SharedWorkerInfo[]>;
+    inspectSharedWorker(): Promise<void>;
+    inspectSharedWorkerById(workerId: string): Promise<void>;
+    inspectServiceWorker(): Promise<void>;
+}
+export {};

package/src/api/webcontents/main.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebContents = void 0;
+const base_1 = require("../base");
+class WebContents extends base_1.EmitterBase {
+    constructor(wire, identity, entityType) {
+        super(wire, entityType, identity.uuid, identity.name);
+        this.entityType = entityType;
+    }
+    capturePage(options) {
+        return this.wire.sendAction('capture-page', { options, ...this.identity }).then(({ payload }) => payload.data);
+    }
+    executeJavaScript(code) {
+        return this.wire
+            .sendAction('execute-javascript-in-window', { ...this.identity, code })
+            .then(({ payload }) => payload.data);
+    }
+    getZoomLevel() {
+        return this.wire.sendAction('get-zoom-level', this.identity).then(({ payload }) => payload.data);
+    }
+    setZoomLevel(level) {
+        return this.wire.sendAction('set-zoom-level', { ...this.identity, level }).then(() => undefined);
+    }
+    navigate(url) {
+        return this.wire.sendAction('navigate-window', { ...this.identity, url }).then(() => undefined);
+    }
+    navigateBack() {
+        return this.wire.sendAction('navigate-window-back', { ...this.identity }).then(() => undefined);
+    }
+    async navigateForward() {
+        await this.wire.sendAction('navigate-window-forward', { ...this.identity });
+    }
+    stopNavigation() {
+        return this.wire.sendAction('stop-window-navigation', { ...this.identity }).then(() => undefined);
+    }
+    reload(ignoreCache = false) {
+        return this.wire
+            .sendAction('reload-window', {
+            ignoreCache,
+            ...this.identity
+        })
+            .then(() => undefined);
+    }
+    print(options) {
+        return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);
+    }
+    findInPage(searchTerm, options) {
+        return this.wire
+            .sendAction('find-in-page', { ...this.identity, searchTerm, options })
+            .then(({ payload }) => payload.data);
+    }
+    stopFindInPage(action) {
+        return this.wire.sendAction('stop-find-in-page', { ...this.identity, action }).then(() => undefined);
+    }
+    getPrinters() {
+        return this.wire.sendAction('get-printers', { ...this.identity }).then(({ payload }) => payload.data);
+    }
+    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {
+        await this.wire.sendAction('focus-window', { emitSynthFocused, ...this.identity });
+    }
+    async showDeveloperTools() {
+        // Note this hits the system action map in core state for legacy reasons.
+        await this.wire.sendAction('show-developer-tools', this.identity);
+    }
+    async getProcessInfo() {
+        const { payload: { data } } = await this.wire.sendAction('get-process-info', this.identity);
+        return data;
+    }
+    async getSharedWorkers() {
+        return this.wire.sendAction('get-shared-workers', this.identity).then(({ payload }) => payload.data);
+    }
+    async inspectSharedWorker() {
+        await this.wire.sendAction('inspect-shared-worker', { ...this.identity });
+    }
+    async inspectSharedWorkerById(workerId) {
+        await this.wire.sendAction('inspect-shared-worker-by-id', { ...this.identity, workerId });
+    }
+    async inspectServiceWorker() {
+        await this.wire.sendAction('inspect-service-worker', { ...this.identity });
+    }
+}
+exports.WebContents = WebContents;

package/src/api/window/Factory.d.ts

@@ -0,0 +1,44 @@
+import { Base } from '../base';
+/**
+ * @lends Window
+ */
+export default class _WindowModule extends Base {
+    /**
+     * Asynchronously returns a Window object that represents an existing window.
+     * @param { Identity } identity
+     * @return {Promise.<_Window>}
+     * @tutorial Window.wrap
+     * @static
+     */
+    wrap(identity: OpenFin.Identity): Promise<OpenFin.Window>;
+    /**
+     * Synchronously returns a Window object that represents an existing window.
+     * @param { Identity } identity
+     * @return {_Window}
+     * @tutorial Window.wrapSync
+     * @static
+     */
+    wrapSync(identity: OpenFin.Identity): OpenFin.Window;
+    /**
+     * Creates a new Window.
+     * @param { Window~options } options - Window creation options
+     * @return {Promise.<_Window>}
+     * @tutorial Window.create
+     * @static
+     */
+    create(options: OpenFin.WindowCreationOptions): Promise<OpenFin.Window>;
+    /**
+     * Asynchronously returns a Window object that represents the current window
+     * @return {Promise.<_Window>}
+     * @tutorial Window.getCurrent
+     * @static
+     */
+    getCurrent(): Promise<OpenFin.Window>;
+    /**
+     * Synchronously returns a Window object that represents the current window
+     * @return {_Window}
+     * @tutorial Window.getCurrentSync
+     * @static
+     */
+    getCurrentSync(): OpenFin.Window;
+}

package/src/api/window/Factory.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const validate_1 = require("../../util/validate");
+const Instance_1 = require("./Instance");
+/**
+ * @lends Window
+ */
+class _WindowModule extends base_1.Base {
+    /**
+     * Asynchronously returns a Window object that represents an existing window.
+     * @param { Identity } identity
+     * @return {Promise.<_Window>}
+     * @tutorial Window.wrap
+     * @static
+     */
+    async wrap(identity) {
+        this.wire.sendAction('window-wrap').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const errorMsg = validate_1.validateIdentity(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        return new Instance_1._Window(this.wire, identity);
+    }
+    /**
+     * Synchronously returns a Window object that represents an existing window.
+     * @param { Identity } identity
+     * @return {_Window}
+     * @tutorial Window.wrapSync
+     * @static
+     */
+    wrapSync(identity) {
+        this.wire.sendAction('window-wrap-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const errorMsg = validate_1.validateIdentity(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        return new Instance_1._Window(this.wire, identity);
+    }
+    /**
+     * Creates a new Window.
+     * @param { Window~options } options - Window creation options
+     * @return {Promise.<_Window>}
+     * @tutorial Window.create
+     * @static
+     */
+    create(options) {
+        this.wire.sendAction('create-window').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const win = new Instance_1._Window(this.wire, { uuid: this.me.uuid, name: options.name });
+        return win.createWindow(options);
+    }
+    /**
+     * Asynchronously returns a Window object that represents the current window
+     * @return {Promise.<_Window>}
+     * @tutorial Window.getCurrent
+     * @static
+     */
+    getCurrent() {
+        this.wire.sendAction('get-current-window').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        if (!this.wire.me.isWindow) {
+            throw new Error('You are not in a Window context');
+        }
+        const { uuid, name } = this.wire.me;
+        return this.wrap({ uuid, name });
+    }
+    /**
+     * Synchronously returns a Window object that represents the current window
+     * @return {_Window}
+     * @tutorial Window.getCurrentSync
+     * @static
+     */
+    getCurrentSync() {
+        this.wire.sendAction('get-current-window-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        if (!this.wire.me.isWindow) {
+            throw new Error('You are not in a Window context');
+        }
+        const { uuid, name } = this.wire.me;
+        return this.wrapSync({ uuid, name });
+    }
+}
+exports.default = _WindowModule;