@wailsio/runtime 3.0.0-alpha.20 → 3.0.0-alpha.22

package/src/window.js

@@ -1,316 +1,638 @@
-/*
- _	   __	  _ __
-| |	 / /___ _(_) /____
-| | /| / / __ `/ / / ___/
-| |/ |/ / /_/ / / (__  )
-|__/|__/\__,_/_/_/____/
-The electron alternative for Go
-(c) Lea Anthony 2019-present
-*/
-
-/* jshint esversion: 9 */
-
-// Import screen jsdoc definition from ./screens.js
-/**
- * @typedef {import("./screens").Screen} Screen
- */
-
-import {newRuntimeCallerWithID, objectNames} from "./runtime";
-
-const center = 0;
-const setTitle = 1;
-const fullscreen = 2;
-const unFullscreen = 3;
-const setSize = 4;
-const size = 5;
-const setMaxSize = 6;
-const setMinSize = 7;
-const setAlwaysOnTop = 8;
-const setRelativePosition = 9;
-const relativePosition = 10;
-const screen = 11;
-const hide = 12;
-const maximise = 13;
-const unMaximise = 14;
-const toggleMaximise = 15;
-const minimise = 16;
-const unMinimise = 17;
-const restore = 18;
-const show = 19;
-const close = 20;
-const setBackgroundColour = 21;
-const setResizable = 22;
-const width = 23;
-const height = 24;
-const zoomIn = 25;
-const zoomOut = 26;
-const zoomReset = 27;
-const getZoomLevel = 28;
-const setZoomLevel = 29;
-
-const thisWindow = Get('');
-
-function createWindow(call) {
-    return {
-        Get: (windowName) => createWindow(newRuntimeCallerWithID(objectNames.Window, windowName)),
-        Center: () => call(center),
-        SetTitle: (title) => call(setTitle, {title}),
-        Fullscreen: () => call(fullscreen),
-        UnFullscreen: () => call(unFullscreen),
-        SetSize: (width, height) => call(setSize, {width, height}),
-        Size: () => call(size),
-        SetMaxSize: (width, height) => call(setMaxSize, {width, height}),
-        SetMinSize: (width, height) => call(setMinSize, {width, height}),
-        SetAlwaysOnTop: (onTop) => call(setAlwaysOnTop, {alwaysOnTop: onTop}),
-        SetRelativePosition: (x, y) => call(setRelativePosition, {x, y}),
-        RelativePosition: () => call(relativePosition),
-        Screen: () => call(screen),
-        Hide: () => call(hide),
-        Maximise: () => call(maximise),
-        UnMaximise: () => call(unMaximise),
-        ToggleMaximise: () => call(toggleMaximise),
-        Minimise: () => call(minimise),
-        UnMinimise: () => call(unMinimise),
-        Restore: () => call(restore),
-        Show: () => call(show),
-        Close: () => call(close),
-        SetBackgroundColour: (r, g, b, a) => call(setBackgroundColour, {r, g, b, a}),
-        SetResizable: (resizable) => call(setResizable, {resizable}),
-        Width: () => call(width),
-        Height: () => call(height),
-        ZoomIn: () => call(zoomIn),
-        ZoomOut: () => call(zoomOut),
-        ZoomReset: () => call(zoomReset),
-        GetZoomLevel: () => call(getZoomLevel),
-        SetZoomLevel: (zoomLevel) => call(setZoomLevel, {zoomLevel}),
-    };
-}
-
-/**
- * Gets the specified window.
- *
- * @param {string} windowName - The name of the window to get.
- * @return {Object} - The specified window object.
- */
-export function Get(windowName) {
-    return createWindow(newRuntimeCallerWithID(objectNames.Window, windowName));
-}
-
-/**
- * Centers the window on the screen.
- */
-export function Center() {
-    thisWindow.Center();
-}
-
-/**
- * Sets the title of the window.
- * @param {string} title - The title to set.
- */
-export function SetTitle(title) {
-    thisWindow.SetTitle(title);
-}
-
-/**
- * Sets the window to fullscreen.
- */
-export function Fullscreen() {
-    thisWindow.Fullscreen();
-}
-
-/**
- * Sets the size of the window.
- * @param {number} width - The width of the window.
- * @param {number} height - The height of the window.
- */
-export function SetSize(width, height) {
-    thisWindow.SetSize(width, height);
-}
-
-/**
- * Gets the size of the window.
- */
-export function Size() {
-    return thisWindow.Size();
-}
-
-/**
- * Sets the maximum size of the window.
- * @param {number} width - The maximum width of the window.
- * @param {number} height - The maximum height of the window.
- */
-export function SetMaxSize(width, height) {
-    thisWindow.SetMaxSize(width, height);
-}
-
-/**
- * Sets the minimum size of the window.
- * @param {number} width - The minimum width of the window.
- * @param {number} height - The minimum height of the window.
- */
-export function SetMinSize(width, height) {
-    thisWindow.SetMinSize(width, height);
-}
-
-/**
- * Sets the window to always be on top.
- * @param {boolean} onTop - Whether the window should always be on top.
- */
-export function SetAlwaysOnTop(onTop) {
-    thisWindow.SetAlwaysOnTop(onTop);
-}
-
-/**
- * Sets the relative position of the window.
- * @param {number} x - The x-coordinate of the window's position.
- * @param {number} y - The y-coordinate of the window's position.
- */
-export function SetRelativePosition(x, y) {
-    thisWindow.SetRelativePosition(x, y);
-}
-
-/**
- * Gets the relative position of the window.
- */
-export function RelativePosition() {
-    return thisWindow.RelativePosition();
-}
-
-/**
- * Gets the screen that the window is on.
- */
-export function Screen() {
-    return thisWindow.Screen();
-}
-
-/**
- * Hides the window.
- */
-export function Hide() {
-    thisWindow.Hide();
-}
-
-/**
- * Maximises the window.
- */
-export function Maximise() {
-    thisWindow.Maximise();
-}
-
-/**
- * Un-maximises the window.
- */
-export function UnMaximise() {
-    thisWindow.UnMaximise();
-}
-
-/**
- * Toggles the maximisation of the window.
- */
-export function ToggleMaximise() {
-    thisWindow.ToggleMaximise();
-}
-
-/**
- * Minimises the window.
- */
-export function Minimise() {
-    thisWindow.Minimise();
-}
-
-/**
- * Un-minimises the window.
- */
-export function UnMinimise() {
-    thisWindow.UnMinimise();
-}
-
-/**
- * Restores the window.
- */
-export function Restore() {
-    thisWindow.Restore();
-}
-
-/**
- * Shows the window.
- */
-export function Show() {
-    thisWindow.Show();
-}
-
-/**
- * Closes the window.
- */
-export function Close() {
-    thisWindow.Close();
-}
-
-/**
- * Sets the background colour of the window.
- * @param {number} r - The red component of the colour.
- * @param {number} g - The green component of the colour.
- * @param {number} b - The blue component of the colour.
- * @param {number} a - The alpha component of the colour.
- */
-export function SetBackgroundColour(r, g, b, a) {
-    thisWindow.SetBackgroundColour(r, g, b, a);
-}
-
-/**
- * Sets whether the window is resizable.
- * @param {boolean} resizable - Whether the window should be resizable.
- */
-export function SetResizable(resizable) {
-    thisWindow.SetResizable(resizable);
-}
-
-/**
- * Gets the width of the window.
- */
-export function Width() {
-    return thisWindow.Width();
-}
-
-/**
- * Gets the height of the window.
- */
-export function Height() {
-    return thisWindow.Height();
-}
-
-/**
- * Zooms in the window.
- */
-export function ZoomIn() {
-    thisWindow.ZoomIn();
-}
-
-/**
- * Zooms out the window.
- */
-export function ZoomOut() {
-    thisWindow.ZoomOut();
-}
-
-/**
- * Resets the zoom of the window.
- */
-export function ZoomReset() {
-    thisWindow.ZoomReset();
-}
-
-/**
- * Gets the zoom level of the window.
- */
-export function GetZoomLevel() {
-    return thisWindow.GetZoomLevel();
-}
-
-/**
- * Sets the zoom level of the window.
- * @param {number} zoomLevel - The zoom level to set.
- */
-export function SetZoomLevel(zoomLevel) {
-    thisWindow.SetZoomLevel(zoomLevel);
-}
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+// Import screen jsdoc definition from ./screens.js
+/**
+ * @typedef {import("./screens").Screen} Screen
+ */
+
+
+/**
+ * A record describing the position of a window.
+ *
+ * @typedef {Object} Position
+ * @property {number} x - The horizontal position of the window
+ * @property {number} y - The vertical position of the window
+ */
+
+
+/**
+ * A record describing the size of a window.
+ *
+ * @typedef {Object} Size
+ * @property {number} width - The width of the window
+ * @property {number} height - The height of the window
+ */
+
+
+import {newRuntimeCallerWithID, objectNames} from "./runtime";
+
+const AbsolutePositionMethod            = 0;
+const CenterMethod                      = 1;
+const CloseMethod                       = 2;
+const DisableSizeConstraintsMethod      = 3;
+const EnableSizeConstraintsMethod       = 4;
+const FocusMethod                       = 5;
+const ForceReloadMethod                 = 6;
+const FullscreenMethod                  = 7;
+const GetScreenMethod                   = 8;
+const GetZoomMethod                     = 9;
+const HeightMethod                      = 10;
+const HideMethod                        = 11;
+const IsFocusedMethod                   = 12;
+const IsFullscreenMethod                = 13;
+const IsMaximisedMethod                 = 14;
+const IsMinimisedMethod                 = 15;
+const MaximiseMethod                    = 16;
+const MinimiseMethod                    = 17;
+const NameMethod                        = 18;
+const OpenDevToolsMethod                = 19;
+const RelativePositionMethod            = 20;
+const ReloadMethod                      = 21;
+const ResizableMethod                   = 22;
+const RestoreMethod                     = 23;
+const SetAbsolutePositionMethod         = 24;
+const SetAlwaysOnTopMethod              = 25;
+const SetBackgroundColourMethod         = 26;
+const SetFramelessMethod                = 27;
+const SetFullscreenButtonEnabledMethod  = 28;
+const SetMaxSizeMethod                  = 29;
+const SetMinSizeMethod                  = 30;
+const SetRelativePositionMethod         = 31;
+const SetResizableMethod                = 32;
+const SetSizeMethod                     = 33;
+const SetTitleMethod                    = 34;
+const SetZoomMethod                     = 35;
+const ShowMethod                        = 36;
+const SizeMethod                        = 37;
+const ToggleFullscreenMethod            = 38;
+const ToggleMaximiseMethod              = 39;
+const UnFullscreenMethod                = 40;
+const UnMaximiseMethod                  = 41;
+const UnMinimiseMethod                  = 42;
+const WidthMethod                       = 43;
+const ZoomMethod                        = 44;
+const ZoomInMethod                      = 45;
+const ZoomOutMethod                     = 46;
+const ZoomResetMethod                   = 47;
+
+/**
+ * @type {symbol}
+ */
+const caller = Symbol();
+
+class Window {
+    /**
+     * Initialises a window object with the specified name.
+     *
+     * @private
+     * @param {string} name - The name of the target window.
+     */
+    constructor(name = '') {
+        /**
+         * @private
+         * @name {@link caller}
+         * @type {(...args: any[]) => any}
+         */
+        this[caller] = newRuntimeCallerWithID(objectNames.Window, name)
+
+        // bind instance method to make them easily usable in event handlers
+        for (const method of Object.getOwnPropertyNames(Window.prototype)) {
+            if (
+                method !== "constructor"
+                && typeof this[method] === "function"
+            ) {
+                this[method] = this[method].bind(this);
+            }
+        }
+    }
+
+    /**
+     * Gets the specified window.
+     *
+     * @public
+     * @param {string} name - The name of the window to get.
+     * @return {Window} - The corresponding window object.
+     */
+    Get(name) {
+        return new Window(name);
+    }
+
+    /**
+     * Returns the absolute position of the window to the screen.
+     *
+     * @public
+     * @return {Promise<Position>} - The current absolute position of the window.
+     */
+    AbsolutePosition() {
+        return this[caller](AbsolutePositionMethod);
+    }
+
+    /**
+     * Centers the window on the screen.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Center() {
+        return this[caller](CenterMethod);
+    }
+
+    /**
+     * Closes the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Close() {
+        return this[caller](CloseMethod);
+    }
+
+    /**
+     * Disables min/max size constraints.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    DisableSizeConstraints() {
+        return this[caller](DisableSizeConstraintsMethod);
+    }
+
+    /**
+     * Enables min/max size constraints.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    EnableSizeConstraints() {
+        return this[caller](EnableSizeConstraintsMethod);
+    }
+
+    /**
+     * Focuses the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Focus() {
+        return this[caller](FocusMethod);
+    }
+
+    /**
+     * Forces the window to reload the page assets.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    ForceReload() {
+        return this[caller](ForceReloadMethod);
+    }
+
+    /**
+     * Doc.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Fullscreen() {
+        return this[caller](FullscreenMethod);
+    }
+
+    /**
+     * Returns the screen that the window is on.
+     *
+     * @public
+     * @return {Promise<Screen>} - The screen the window is currently on
+     */
+    GetScreen() {
+        return this[caller](GetScreenMethod);
+    }
+
+    /**
+     * Returns the current zoom level of the window.
+     *
+     * @public
+     * @return {Promise<number>} - The current zoom level
+     */
+    GetZoom() {
+        return this[caller](GetZoomMethod);
+    }
+
+    /**
+     * Returns the height of the window.
+     *
+     * @public
+     * @return {Promise<number>} - The current height of the window
+     */
+    Height() {
+        return this[caller](HeightMethod);
+    }
+
+    /**
+     * Hides the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Hide() {
+        return this[caller](HideMethod);
+    }
+
+    /**
+     * Returns true if the window is focused.
+     *
+     * @public
+     * @return {Promise<boolean>} - Whether the window is currently focused
+     */
+    IsFocused() {
+        return this[caller](IsFocusedMethod);
+    }
+
+    /**
+     * Returns true if the window is fullscreen.
+     *
+     * @public
+     * @return {Promise<boolean>} - Whether the window is currently fullscreen
+     */
+    IsFullscreen() {
+        return this[caller](IsFullscreenMethod);
+    }
+
+    /**
+     * Returns true if the window is maximised.
+     *
+     * @public
+     * @return {Promise<boolean>} - Whether the window is currently maximised
+     */
+    IsMaximised() {
+        return this[caller](IsMaximisedMethod);
+    }
+
+    /**
+     * Returns true if the window is minimised.
+     *
+     * @public
+     * @return {Promise<boolean>} - Whether the window is currently minimised
+     */
+    IsMinimised() {
+        return this[caller](IsMinimisedMethod);
+    }
+
+    /**
+     * Maximises the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Maximise() {
+        return this[caller](MaximiseMethod);
+    }
+
+    /**
+     * Minimises the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Minimise() {
+        return this[caller](MinimiseMethod);
+    }
+
+    /**
+     * Returns the name of the window.
+     *
+     * @public
+     * @return {Promise<string>} - The name of the window
+     */
+    Name() {
+        return this[caller](NameMethod);
+    }
+
+    /**
+     * Opens the development tools pane.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    OpenDevTools() {
+        return this[caller](OpenDevToolsMethod);
+    }
+
+    /**
+     * Returns the relative position of the window to the screen.
+     *
+     * @public
+     * @return {Promise<Position>} - The current relative position of the window
+     */
+    RelativePosition() {
+        return this[caller](RelativePositionMethod);
+    }
+
+    /**
+     * Reloads the page assets.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Reload() {
+        return this[caller](ReloadMethod);
+    }
+
+    /**
+     * Returns true if the window is resizable.
+     *
+     * @public
+     * @return {Promise<boolean>} - Whether the window is currently resizable
+     */
+    Resizable() {
+        return this[caller](ResizableMethod);
+    }
+
+    /**
+     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Restore() {
+        return this[caller](RestoreMethod);
+    }
+
+    /**
+     * Sets the absolute position of the window to the screen.
+     *
+     * @public
+     * @param {number} x - The desired horizontal absolute position of the window
+     * @param {number} y - The desired vertical absolute position of the window
+     * @return {Promise<void>}
+     */
+    SetAbsolutePosition(x, y) {
+        return this[caller](SetAbsolutePositionMethod, { x, y });
+    }
+
+    /**
+     * Sets the window to be always on top.
+     *
+     * @public
+     * @param {boolean} alwaysOnTop - Whether the window should stay on top
+     * @return {Promise<void>}
+     */
+    SetAlwaysOnTop(alwaysOnTop) {
+        return this[caller](SetAlwaysOnTopMethod, { alwaysOnTop });
+    }
+
+    /**
+     * Sets the background colour of the window.
+     *
+     * @public
+     * @param {number} r - The desired red component of the window background
+     * @param {number} g - The desired green component of the window background
+     * @param {number} b - The desired blue component of the window background
+     * @param {number} a - The desired alpha component of the window background
+     * @return {Promise<void>}
+     */
+    SetBackgroundColour(r, g, b, a) {
+        return this[caller](SetBackgroundColourMethod, { r, g, b, a });
+    }
+
+    /**
+     * Removes the window frame and title bar.
+     *
+     * @public
+     * @param {boolean} frameless - Whether the window should be frameless
+     * @return {Promise<void>}
+     */
+    SetFrameless(frameless) {
+        return this[caller](SetFramelessMethod, { frameless });
+    }
+
+    /**
+     * Disables the system fullscreen button.
+     *
+     * @public
+     * @param {boolean} enabled - Whether the fullscreen button should be enabled
+     * @return {Promise<void>}
+     */
+    SetFullscreenButtonEnabled(enabled) {
+        return this[caller](SetFullscreenButtonEnabledMethod, { enabled });
+    }
+
+    /**
+     * Sets the maximum size of the window.
+     *
+     * @public
+     * @param {number} width - The desired maximum width of the window
+     * @param {number} height - The desired maximum height of the window
+     * @return {Promise<void>}
+     */
+    SetMaxSize(width, height) {
+        return this[caller](SetMaxSizeMethod, { width, height });
+    }
+
+    /**
+     * Sets the minimum size of the window.
+     *
+     * @public
+     * @param {number} width - The desired minimum width of the window
+     * @param {number} height - The desired minimum height of the window
+     * @return {Promise<void>}
+     */
+    SetMinSize(width, height) {
+        return this[caller](SetMinSizeMethod, { width, height });
+    }
+
+    /**
+     * Sets the relative position of the window to the screen.
+     *
+     * @public
+     * @param {number} x - The desired horizontal relative position of the window
+     * @param {number} y - The desired vertical relative position of the window
+     * @return {Promise<void>}
+     */
+    SetRelativePosition(x, y) {
+        return this[caller](SetRelativePositionMethod, { x, y });
+    }
+
+    /**
+     * Sets whether the window is resizable.
+     *
+     * @public
+     * @param {boolean} resizable - Whether the window should be resizable
+     * @return {Promise<void>}
+     */
+    SetResizable(resizable) {
+        return this[caller](SetResizableMethod, { resizable });
+    }
+
+    /**
+     * Sets the size of the window.
+     *
+     * @public
+     * @param {number} width - The desired width of the window
+     * @param {number} height - The desired height of the window
+     * @return {Promise<void>}
+     */
+    SetSize(width, height) {
+        return this[caller](SetSizeMethod, { width, height });
+    }
+
+    /**
+     * Sets the title of the window.
+     *
+     * @public
+     * @param {string} title - The desired title of the window
+     * @return {Promise<void>}
+     */
+    SetTitle(title) {
+        return this[caller](SetTitleMethod, { title });
+    }
+
+    /**
+     * Sets the zoom level of the window.
+     *
+     * @public
+     * @param {number} zoom - The desired zoom level
+     * @return {Promise<void>}
+     */
+    SetZoom(zoom) {
+        return this[caller](SetZoomMethod, { zoom });
+    }
+
+    /**
+     * Shows the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Show() {
+        return this[caller](ShowMethod);
+    }
+
+    /**
+     * Returns the size of the window.
+     *
+     * @public
+     * @return {Promise<Size>} - The current size of the window
+     */
+    Size() {
+        return this[caller](SizeMethod);
+    }
+
+    /**
+     * Toggles the window between fullscreen and normal.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    ToggleFullscreen() {
+        return this[caller](ToggleFullscreenMethod);
+    }
+
+    /**
+     * Toggles the window between maximised and normal.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    ToggleMaximise() {
+        return this[caller](ToggleMaximiseMethod);
+    }
+
+    /**
+     * Un-fullscreens the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    UnFullscreen() {
+        return this[caller](UnFullscreenMethod);
+    }
+
+    /**
+     * Un-maximises the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    UnMaximise() {
+        return this[caller](UnMaximiseMethod);
+    }
+
+    /**
+     * Un-minimises the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    UnMinimise() {
+        return this[caller](UnMinimiseMethod);
+    }
+
+    /**
+     * Returns the width of the window.
+     *
+     * @public
+     * @return {Promise<number>} - The current width of the window
+     */
+    Width() {
+        return this[caller](WidthMethod);
+    }
+
+    /**
+     * Zooms the window.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    Zoom() {
+        return this[caller](ZoomMethod);
+    }
+
+    /**
+     * Increases the zoom level of the webview content.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    ZoomIn() {
+        return this[caller](ZoomInMethod);
+    }
+
+    /**
+     * Decreases the zoom level of the webview content.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    ZoomOut() {
+        return this[caller](ZoomOutMethod);
+    }
+
+    /**
+     * Resets the zoom level of the webview content.
+     *
+     * @public
+     * @return {Promise<void>}
+     */
+    ZoomReset() {
+        return this[caller](ZoomResetMethod);
+    }
+}
+
+/**
+ * The window within which the script is running.
+ *
+ * @type {Window}
+ */
+const thisWindow = new Window('');
+
+export default thisWindow;