@wailsio/runtime 3.0.0-alpha.9 → 3.0.0-alpha.95

package/dist/plugins/vite.js

@@ -0,0 +1,64 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+const TYPED_EVENTS_MODULE = "\0wailsio_runtime_events_typed";
+/**
+ * A plugin that extends the wails runtime with locally generated code
+ * to provide support for typed custom events.
+ * With the plugin installed, vite will fail to build the project
+ * unless wails bindings have been generated first.
+ *
+ * @param {string} [bindingsRoot] - The root import path for generated bindings
+ */
+export default function WailsTypedEvents(bindingsRoot) {
+    let bindingsId, runtimeId, eventsId;
+    return {
+        name: "wails-typed-events",
+        async buildStart() {
+            const bindingsPath = `${bindingsRoot}/github.com/wailsapp/wails/v3/internal/eventcreate`;
+            let resolution = await this.resolve(bindingsPath);
+            if (!resolution || resolution.external) {
+                this.error(`Event bindings module not found at import specifier '${bindingsPath}'. Please verify that the wails tool is up to date and the binding generator runs successfully. If you moved the bindings to a custom location, ensure you supplied the correct root path as the first argument to \`wailsTypedEventsPlugin\``);
+                return;
+            }
+            bindingsId = resolution.id;
+            resolution = await this.resolve("@wailsio/runtime");
+            if (!resolution || resolution.external) {
+                return;
+            }
+            runtimeId = resolution.id;
+            resolution = await this.resolve("./events.js", runtimeId);
+            if (!resolution || resolution.external) {
+                this.error("Could not resolve events module within @wailsio/runtime package. Please verify that the module is correctly installed and up to date.");
+                return;
+            }
+            eventsId = resolution.id;
+        },
+        resolveId: {
+            order: 'pre',
+            handler(id, importer) {
+                if (bindingsId !== null
+                    && runtimeId !== null
+                    && eventsId !== null
+                    && importer === runtimeId
+                    && id === "./events.js") {
+                    return TYPED_EVENTS_MODULE;
+                }
+                return undefined;
+            }
+        },
+        load(id) {
+            if (id === TYPED_EVENTS_MODULE) {
+                return (`import ${JSON.stringify(bindingsId)};\n`
+                    + `export * from ${JSON.stringify(eventsId)};`);
+            }
+            return undefined;
+        }
+    };
+}

package/dist/runtime.js

@@ -0,0 +1,198 @@
+/*
+ _     __     _ __
+| |  / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+var _a;
+import { nanoid } from "./nanoid.js";
+import { hasDOM } from "./environment.js";
+// Resolved lazily: window does not exist when the module is imported during
+// server-side rendering (#4679), and nothing can call the runtime there.
+function runtimeURL() {
+    return window.location.origin + "/wails/runtime";
+}
+// Stay under WebView2's ~2MB request body buffering limit in WebResourceRequested.
+const CHUNK_THRESHOLD = 512 * 1024;
+// Re-export nanoid for custom transport implementations
+export { nanoid };
+// Object Names
+export const objectNames = Object.freeze({
+    Call: 0,
+    Clipboard: 1,
+    Application: 2,
+    Events: 3,
+    ContextMenu: 4,
+    Dialog: 5,
+    Window: 6,
+    Screens: 7,
+    System: 8,
+    Browser: 9,
+    CancelCall: 10,
+    IOS: 11,
+    Android: 12,
+});
+export let clientId = nanoid();
+/**
+ * Custom transport implementation (can be set by user)
+ */
+let customTransport = null;
+/**
+ * Set a custom transport for all Wails runtime calls.
+ * This allows you to replace the default HTTP fetch transport with
+ * WebSockets, custom protocols, or any other mechanism.
+ *
+ * @param transport - Your custom transport implementation
+ *
+ * @example
+ * ```typescript
+ * import { setTransport } from '/wails/runtime.js';
+ *
+ * const wsTransport = {
+ *   call: async (objectID, method, windowName, args) => {
+ *     // Your WebSocket implementation
+ *   }
+ * };
+ *
+ * setTransport(wsTransport);
+ * ```
+ */
+export function setTransport(transport) {
+    customTransport = transport;
+}
+/**
+ * Get the current transport (useful for extending/wrapping)
+ */
+export function getTransport() {
+    return customTransport;
+}
+/**
+ * Creates a new runtime caller with specified ID.
+ *
+ * @param object - The object to invoke the method on.
+ * @param windowName - The name of the window.
+ * @return The new runtime caller function.
+ */
+export function newRuntimeCaller(object, windowName = '') {
+    return function (method, args = null) {
+        return runtimeCallWithID(object, method, windowName, args);
+    };
+}
+async function runtimeCallWithID(objectID, method, windowName, args) {
+    var _a, _b;
+    // Use custom transport if available
+    if (customTransport) {
+        return customTransport.call(objectID, method, windowName, args);
+    }
+    // Default HTTP fetch transport
+    let url = new URL(runtimeURL());
+    let body = {
+        object: objectID,
+        method
+    };
+    if (args !== null && args !== undefined) {
+        body.args = args;
+    }
+    let headers = {
+        ["x-wails-client-id"]: clientId,
+        ["Content-Type"]: "application/json"
+    };
+    if (windowName) {
+        headers["x-wails-window-name"] = windowName;
+    }
+    const bodyStr = JSON.stringify(body);
+    let response;
+    if (bodyStr.length > CHUNK_THRESHOLD) {
+        response = await sendChunked(url, headers, bodyStr);
+    }
+    else {
+        response = await fetch(url, { method: 'POST', headers, body: bodyStr });
+    }
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    if (((_b = (_a = response.headers.get("Content-Type")) === null || _a === void 0 ? void 0 : _a.indexOf("application/json")) !== null && _b !== void 0 ? _b : -1) !== -1) {
+        return response.json();
+    }
+    else {
+        return response.text();
+    }
+}
+// sendChunked splits a large serialised request body into CHUNK_THRESHOLD-sized
+// byte chunks and sends them serially.  Encoding to UTF-8 bytes before slicing
+// prevents corruption of non-BMP characters (surrogate pairs) that would occur
+// when splitting at JavaScript string indices.  The Go transport assembles the
+// raw bytes before processing.  Only the final chunk's response carries the RPC result.
+async function sendChunked(url, headers, bodyStr) {
+    const chunkId = nanoid();
+    const bodyBytes = new TextEncoder().encode(bodyStr);
+    const totalChunks = Math.ceil(bodyBytes.length / CHUNK_THRESHOLD);
+    for (let i = 0; i < totalChunks - 1; i++) {
+        const chunk = bodyBytes.subarray(i * CHUNK_THRESHOLD, (i + 1) * CHUNK_THRESHOLD);
+        const resp = await fetch(url, {
+            method: 'POST',
+            headers: Object.assign(Object.assign({}, headers), { 'x-wails-chunk-id': chunkId, 'x-wails-chunk-index': String(i), 'x-wails-chunk-total': String(totalChunks) }),
+            body: chunk,
+        });
+        if (!resp.ok) {
+            throw new Error(await resp.text());
+        }
+    }
+    return fetch(url, {
+        method: 'POST',
+        headers: Object.assign(Object.assign({}, headers), { 'x-wails-chunk-id': chunkId, 'x-wails-chunk-index': String(totalChunks - 1), 'x-wails-chunk-total': String(totalChunks) }),
+        body: bodyBytes.subarray((totalChunks - 1) * CHUNK_THRESHOLD),
+    });
+}
+const androidBridge = hasDOM &&
+    typeof ((_a = window.wails) === null || _a === void 0 ? void 0 : _a.invokeAsync) === "function" ? window.wails : null;
+if (androidBridge) {
+    const pending = new Map();
+    window._wailsAndroidCallback = (id, response, error) => {
+        var _a;
+        const promise = pending.get(id);
+        if (!promise)
+            return;
+        pending.delete(id);
+        if (error) {
+            promise.reject(new Error(error));
+            return;
+        }
+        try {
+            const envelope = JSON.parse(response !== null && response !== void 0 ? response : "{}");
+            if (!envelope.ok) {
+                promise.reject(new Error((_a = envelope.error) !== null && _a !== void 0 ? _a : "unknown runtime call error"));
+                return;
+            }
+            promise.resolve("text" in envelope ? envelope.text : envelope.data);
+        }
+        catch (e) {
+            promise.reject(e);
+        }
+    };
+    customTransport = {
+        call(objectID, method, windowName, args) {
+            return new Promise((resolve, reject) => {
+                const id = nanoid();
+                pending.set(id, { resolve, reject });
+                try {
+                    androidBridge.invokeAsync(id, JSON.stringify({
+                        object: objectID,
+                        method: method,
+                        windowName: windowName,
+                        args: args !== null && args !== void 0 ? args : null,
+                        clientId: clientId,
+                    }));
+                }
+                catch (e) {
+                    // Don't leak the pending entry if dispatch throws synchronously
+                    pending.delete(id);
+                    reject(e);
+                }
+            });
+        },
+    };
+}

package/dist/screens.js

@@ -0,0 +1,58 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { newRuntimeCaller, objectNames } from "./runtime.js";
+const call = newRuntimeCaller(objectNames.Screens);
+const getAll = 0;
+const getPrimary = 1;
+const getCurrent = 2;
+const getByID = 3;
+const getByIndex = 4;
+/**
+ * Gets all screens.
+ *
+ * @returns A promise that resolves to an array of Screen objects.
+ */
+export function GetAll() {
+    return call(getAll);
+}
+/**
+ * Gets the primary screen.
+ *
+ * @returns A promise that resolves to the primary screen.
+ */
+export function GetPrimary() {
+    return call(getPrimary);
+}
+/**
+ * Gets the current active screen.
+ *
+ * @returns A promise that resolves with the current active screen.
+ */
+export function GetCurrent() {
+    return call(getCurrent);
+}
+/**
+ * Gets a screen by its unique display ID.
+ *
+ * @param id - The unique identifier of the screen.
+ * @returns A promise that resolves to the matching Screen.
+ */
+export function GetByID(id) {
+    return call(getByID, { id });
+}
+/**
+ * Gets a screen by its index in the screen list.
+ *
+ * @param index - The zero-based index of the screen.
+ * @returns A promise that resolves to the matching Screen.
+ */
+export function GetByIndex(index) {
+    return call(getByIndex, { index });
+}

package/dist/system.js

@@ -0,0 +1,158 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { newRuntimeCaller, objectNames } from "./runtime.js";
+const call = newRuntimeCaller(objectNames.System);
+const SystemIsDarkMode = 0;
+const SystemEnvironment = 1;
+const SystemCapabilities = 2;
+const _invoke = (function () {
+    var _a, _b, _c, _d, _e, _f;
+    try {
+        // Windows WebView2
+        if ((_b = (_a = window.chrome) === null || _a === void 0 ? void 0 : _a.webview) === null || _b === void 0 ? void 0 : _b.postMessage) {
+            return window.chrome.webview.postMessage.bind(window.chrome.webview);
+        }
+        // macOS/iOS WKWebView
+        else if ((_e = (_d = (_c = window.webkit) === null || _c === void 0 ? void 0 : _c.messageHandlers) === null || _d === void 0 ? void 0 : _d['external']) === null || _e === void 0 ? void 0 : _e.postMessage) {
+            return window.webkit.messageHandlers['external'].postMessage.bind(window.webkit.messageHandlers['external']);
+        }
+        // Android WebView - uses addJavascriptInterface which exposes window.wails.invoke
+        else if ((_f = window.wails) === null || _f === void 0 ? void 0 : _f.invoke) {
+            return (msg) => window.wails.invoke(typeof msg === 'string' ? msg : JSON.stringify(msg));
+        }
+    }
+    catch (e) { }
+    console.warn('\n%c⚠️ Browser Environment Detected %c\n\n%cOnly UI previews are available in the browser. For full functionality, please run the application in desktop mode.\nMore information at: https://v3.wails.io/learn/build/#using-a-browser-for-development\n', 'background: #ffffff; color: #000000; font-weight: bold; padding: 4px 8px; border-radius: 4px; border: 2px solid #000000;', 'background: transparent;', 'color: #ffffff; font-style: italic; font-weight: bold;');
+    return null;
+})();
+export function invoke(msg) {
+    _invoke === null || _invoke === void 0 ? void 0 : _invoke(msg);
+}
+/**
+ * Retrieves the system dark mode status.
+ *
+ * @returns A promise that resolves to a boolean value indicating if the system is in dark mode.
+ */
+export function IsDarkMode() {
+    return call(SystemIsDarkMode);
+}
+/**
+ * Fetches the capabilities of the application from the server.
+ *
+ * @returns A promise that resolves to an object containing the capabilities.
+ */
+export async function Capabilities() {
+    return call(SystemCapabilities);
+}
+/**
+ * Retrieves environment details.
+ *
+ * @returns A promise that resolves to an object containing OS and system architecture.
+ */
+export function Environment() {
+    return call(SystemEnvironment);
+}
+/**
+ * Checks if the current operating system is Windows.
+ *
+ * @return True if the operating system is Windows, otherwise false.
+ */
+export function IsWindows() {
+    var _a, _b;
+    return ((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.OS) === "windows";
+}
+/**
+ * Checks if the current operating system is Linux.
+ *
+ * @returns Returns true if the current operating system is Linux, false otherwise.
+ */
+export function IsLinux() {
+    var _a, _b;
+    return ((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.OS) === "linux";
+}
+/**
+ * Checks if the current environment is a macOS operating system.
+ *
+ * @returns True if the environment is macOS, false otherwise.
+ */
+export function IsMac() {
+    var _a, _b;
+    return ((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.OS) === "darwin";
+}
+/**
+ * Checks if the current operating system is iOS.
+ *
+ * @returns True if the operating system is iOS, otherwise false.
+ */
+export function IsIOS() {
+    var _a, _b;
+    return ((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.OS) === "ios";
+}
+/**
+ * Checks if the current operating system is Android.
+ *
+ * @returns True if the operating system is Android, otherwise false.
+ */
+export function IsAndroid() {
+    var _a, _b;
+    return ((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.OS) === "android";
+}
+/**
+ * Checks if the app is running on a mobile OS (iOS or Android).
+ *
+ * @returns True on iOS or Android, otherwise false.
+ */
+export function IsMobile() {
+    return IsIOS() || IsAndroid();
+}
+/**
+ * Checks if the app is running on a desktop OS (macOS, Windows or Linux).
+ *
+ * @returns True on macOS, Windows or Linux, otherwise false.
+ */
+export function IsDesktop() {
+    return IsMac() || IsWindows() || IsLinux();
+}
+/**
+ * Checks if the current environment architecture is AMD64.
+ *
+ * @returns True if the current environment architecture is AMD64, false otherwise.
+ */
+export function IsAMD64() {
+    var _a, _b;
+    return ((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.Arch) === "amd64";
+}
+/**
+ * Checks if the current architecture is ARM.
+ *
+ * @returns True if the current architecture is ARM, false otherwise.
+ */
+export function IsARM() {
+    var _a, _b;
+    return ((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.Arch) === "arm";
+}
+/**
+ * Checks if the current environment is ARM64 architecture.
+ *
+ * @returns Returns true if the environment is ARM64 architecture, otherwise returns false.
+ */
+export function IsARM64() {
+    var _a, _b;
+    return ((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.Arch) === "arm64";
+}
+/**
+ * Reports whether the app is being run in debug mode.
+ *
+ * @returns True if the app is being run in debug mode.
+ */
+export function IsDebug() {
+    var _a, _b;
+    return Boolean((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.Debug);
+}

package/dist/updater.js

@@ -0,0 +1,74 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+/**
+ * Updater event name constants.
+ *
+ * Use these instead of hard-coding string literals when subscribing to
+ * updater events from JavaScript:
+ *
+ *     import { Events, Updater } from "@wailsio/runtime";
+ *
+ *     Events.On(Updater.Events.UpdateAvailable, (e) => {
+ *         console.log("update found:", e.data.version);
+ *     });
+ *
+ *     Events.On(Updater.Events.DownloadProgress, (e) => {
+ *         const p = e.data;
+ *         console.log(`${p.written} / ${p.total} bytes`);
+ *     });
+ *
+ * Mirrors the Go-side constants in `pkg/updater/events.go` and the
+ * user-action constants in `pkg/updater/window_lifecycle.go`. Any
+ * changes here must stay in sync with those files — there's an
+ * integration test that asserts the strings match.
+ */
+export const Events = Object.freeze({
+    /** A Check round-trip is starting. Payload: null. */
+    CheckStarted: "wails:updater:check-started",
+    /** Check found a newer release. Payload: Release. */
+    UpdateAvailable: "wails:updater:update-available",
+    /** Check confirmed the caller is up to date. Payload: null. */
+    NoUpdate: "wails:updater:no-update",
+    /** Download is starting. Payload: Release. */
+    DownloadStarted: "wails:updater:download-started",
+    /** Periodic progress tick during download (~10 Hz). Payload: Progress. */
+    DownloadProgress: "wails:updater:download-progress",
+    /** All bytes are on disk, but verification has not yet started. Payload: Release. */
+    DownloadComplete: "wails:updater:download-complete",
+    /** Signature / digest verification has started. Payload: Release. */
+    Verifying: "wails:updater:verifying",
+    /** The Updater is swapping the binary into place. Payload: Release. */
+    Installing: "wails:updater:installing",
+    /** Update is staged and a restart is pending. Payload: Release. */
+    UpdateReady: "wails:updater:update-ready",
+    /** Something failed. Payload: ErrorInfo { stage, message, provider }. */
+    Error: "wails:updater:error",
+    /** Host-side context delivered once per session. Payload: Meta { currentVersion, skippedVersion }. */
+    Meta: "wails:updater:meta",
+    /** Sub-namespace: user-action events that the UI emits BACK to the host. */
+    User: Object.freeze({
+        /** User clicked Install on an Available update. */
+        Install: "wails:updater:user:install",
+        /** User clicked Restart & Apply on a Ready update. */
+        Restart: "wails:updater:user:restart",
+        /** User clicked Skip This Version. */
+        Skip: "wails:updater:user:skip",
+        /** User clicked Remind Me Later. */
+        Remind: "wails:updater:user:remind",
+        /** User clicked Close / Cancel. */
+        Cancel: "wails:updater:user:cancel",
+    }),
+    /** Sub-namespace: framework-internal events the UI emits to coordinate
+     *  with the host. Most app code can ignore these. */
+    Window: Object.freeze({
+        /** The window finished loading and asks the host to replay current state. */
+        Ready: "wails:updater:window:ready",
+    }),
+});

package/dist/utils.js

@@ -0,0 +1,98 @@
+/*
+ _     __     _ __
+| |  / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+/**
+ * Logs a message to the console with custom formatting.
+ *
+ * @param message - The message to be logged.
+ */
+export function debugLog(message) {
+    // eslint-disable-next-line
+    console.log('%c wails3 %c ' + message + ' ', 'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem', 'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem');
+}
+/**
+ * Checks whether the webview supports the {@link MouseEvent#buttons} property.
+ * Looking at you macOS High Sierra!
+ */
+export function canTrackButtons() {
+    return (new MouseEvent('mousedown')).buttons === 0;
+}
+/**
+ * Checks whether the browser supports removing listeners by triggering an AbortSignal
+ * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal).
+ */
+export function canAbortListeners() {
+    if (!EventTarget || !AbortSignal || !AbortController)
+        return false;
+    let result = true;
+    const target = new EventTarget();
+    const controller = new AbortController();
+    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });
+    controller.abort();
+    target.dispatchEvent(new CustomEvent('test'));
+    return result;
+}
+/**
+ * Resolves the closest HTMLElement ancestor of an event's target.
+ */
+export function eventTarget(event) {
+    var _a;
+    if (event.target instanceof HTMLElement) {
+        return event.target;
+    }
+    else if (!(event.target instanceof HTMLElement) && event.target instanceof Node) {
+        return (_a = event.target.parentElement) !== null && _a !== void 0 ? _a : document.body;
+    }
+    else {
+        return document.body;
+    }
+}
+/***
+ This technique for proper load detection is taken from HTMX:
+
+ BSD 2-Clause License
+
+ Copyright (c) 2020, Big Sky Software
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ***/
+let isReady = false;
+import { hasDOM } from "./environment.js";
+if (hasDOM) {
+    document.addEventListener('DOMContentLoaded', () => { isReady = true; });
+}
+export function whenReady(callback) {
+    if (isReady || document.readyState === 'complete') {
+        callback();
+    }
+    else {
+        document.addEventListener('DOMContentLoaded', callback);
+    }
+}