ewvjs 1.0.8 → 1.0.10

package/dist/window.js

@@ -1,34 +1,29 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Window = void 0;
-const utils_1 = require("./utils");
-class Window {
+import { getParamNames, generateId } from "./utils.js";
+export class Window {
+    platform;
+    options;
+    controller;
+    _closedPromise;
+    _resolveClosed;
+    _menuCallbacks = new Map();
+    _exposedFunctions;
+    _isClosed = false;
+    _pendingApiInjection = null;
+    on_context_menu = () => null;
     constructor(platform, options, exposedFunctions) {
-        this._menuCallbacks = new Map();
-        this._isClosed = false;
-        this.on_context_menu = () => null;
         this.platform = platform;
-        this.options = Object.assign({}, options);
+        this.options = { ...options };
         this._exposedFunctions = exposedFunctions;
         this._closedPromise = new Promise((resolve) => {
             this._resolveClosed = resolve;
         });
         const originalCallback = this.options.jsCallback;
-        this.options.jsCallback = (msg) => __awaiter(this, void 0, void 0, function* () {
-            const result = yield this._on_message(msg, this._exposedFunctions);
+        this.options.jsCallback = async (msg) => {
+            const result = await this._on_message(msg, this._exposedFunctions);
             if (originalCallback)
-                yield originalCallback(msg);
+                await originalCallback(msg);
             return result;
-        });
+        };
     }
     get closed() {
         return this._closedPromise;
@@ -36,239 +31,190 @@ class Window {
     get is_closed() {
         return this._isClosed;
     }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.controller = yield this.platform.createWindow(this.options);
-            // Inject exposed functions API
-            const funcList = Object.keys(this._exposedFunctions).map(name => {
-                return { func: name, params: (0, utils_1.getParamNames)(this._exposedFunctions[name]) };
-            });
-            if (funcList.length > 0) {
-                const code = `if (window.ewvjs) { window.ewvjs._createApi(${JSON.stringify(funcList)}); }`;
-                setTimeout(() => this.evaluate_js(code).catch((err) => {
-                    console.error('Failed to inject exposed functions API:', err);
-                }), 500);
-            }
-            return this.controller;
+    async run() {
+        this.controller = await this.platform.createWindow(this.options);
+        // Inject exposed functions API after DOM is ready
+        const funcList = Object.keys(this._exposedFunctions).map((name) => {
+            return {
+                func: name,
+                params: getParamNames(this._exposedFunctions[name]),
+            };
         });
+        if (funcList.length > 0) {
+            const code = `window.ewvjs._createApi(${JSON.stringify(funcList)});`;
+            this._pendingApiInjection = code;
+        }
+        return this.controller;
     }
-    _call(method_1) {
-        return __awaiter(this, arguments, void 0, function* (method, payload = null) {
-            if (this._isClosed) {
-                console.warn(`Cannot call ${method}: Window is closed`);
-                return null;
-            }
-            if (!this.controller || !this.controller[method]) {
-                throw new Error(`Window not running or ${method} not supported`);
+    async _call(method, payload = null) {
+        if (this._isClosed) {
+            console.warn(`Cannot call ${method}: Window is closed`);
+            return null;
+        }
+        if (!this.controller || !this.controller[method]) {
+            throw new Error(`Window not running or ${method} not supported`);
+        }
+        try {
+            const result = this.controller[method](payload);
+            // Check if method returns a Promise (node-api-dotnet JSCallback style)
+            if (result && typeof result.then === "function") {
+                return result;
             }
-            try {
-                const result = this.controller[method](payload);
-                // Check if method returns a Promise (node-api-dotnet JSCallback style)
-                if (result && typeof result.then === 'function') {
-                    return result;
-                }
-                else {
-                    return result;
-                }
+            else {
+                return result;
             }
-            catch (err) {
-                // If window was closed mid-operation, mark as closed and return null
-                if (err && err.message && err.message.includes('Window not initialized')) {
-                    this._isClosed = true;
-                    console.warn(`Window was closed during ${method} call`);
-                    return null;
-                }
-                throw err;
+        }
+        catch (err) {
+            // If window was closed mid-operation, mark as closed and return null
+            if (err &&
+                err.message &&
+                err.message.includes("Window not initialized")) {
+                this._isClosed = true;
+                console.warn(`Window was closed during ${method} call`);
+                return null;
             }
-        });
+            throw err;
+        }
     }
     // Core methods
-    evaluate_js(script) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('evaluate', script);
-        });
-    }
-    evaluate(script) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.evaluate_js(script);
-        });
+    async evaluate(script) {
+        return this._call("evaluate", script);
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._isClosed)
-                return;
-            this._isClosed = true;
-            const result = yield this._call('close');
-            this._resolveClosed();
-            return result;
-        });
+    async close() {
+        if (this._isClosed)
+            return;
+        this._isClosed = true;
+        const result = await this._call("close");
+        this._resolveClosed();
+        return result;
     }
-    destroy() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('close');
-        });
+    async destroy() {
+        return this._call("close");
     }
     // Window state methods
-    maximize() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('maximize'); });
+    async maximize() {
+        return this._call("maximize");
     }
-    restore() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('restore'); });
+    async restore() {
+        return this._call("restore");
     }
-    minimize() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('minimize'); });
+    async minimize() {
+        return this._call("minimize");
     }
-    focus() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('focus'); });
+    async focus() {
+        return this._call("focus");
     }
-    show() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('show'); });
+    async show() {
+        return this._call("show");
     }
-    hide() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('hide'); });
+    async hide() {
+        return this._call("hide");
     }
     // Size and position methods
-    getSize() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('getSize'); });
-    }
-    setSize(width, height) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('setSize', { width, height });
-        });
+    async getSize() {
+        return this._call("getSize");
     }
-    resize(width, height) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('setSize', { width, height });
-        });
+    async setSize(width, height) {
+        return this._call("setSize", { width, height });
     }
-    getMinSize() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('getMinSize'); });
+    async resize(width, height) {
+        return this._call("setSize", { width, height });
     }
-    setMinSize(width, height) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('setMinSize', { width, height });
-        });
+    async getMinSize() {
+        return this._call("getMinSize");
     }
-    set_min_size(width, height) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('setMinSize', { width, height });
-        });
+    async setMinSize(width, height) {
+        return this._call("setMinSize", { width, height });
     }
-    getPosition() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('getPosition'); });
+    async getPosition() {
+        return this._call("getPosition");
     }
-    setPosition(x, y) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('setPosition', { x, y });
-        });
+    async setPosition(x, y) {
+        return this._call("setPosition", { x, y });
     }
-    move(x, y) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('move', { x, y });
-        });
-    }
-    get_position() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('getPosition'); });
-    }
-    set_position(x, y) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('setPosition', { x, y });
-        });
-    }
-    get_width() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const size = yield this._call('getSize');
-            return size.width;
-        });
-    }
-    get_height() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const size = yield this._call('getSize');
-            return size.height;
-        });
+    async move(x, y) {
+        return this._call("move", { x, y });
     }
     // Title methods
-    setTitle(title) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('setTitle', title);
-        });
-    }
-    set_title(title) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('setTitle', title);
-        });
+    async setTitle(title) {
+        return this._call("setTitle", title);
     }
     // Title bar methods
-    show_titlebar() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('setTitleBar', true); });
+    async showTitlebar() {
+        return this._call("setTitleBar", true);
     }
-    hide_titlebar() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('setTitleBar', false); });
+    async hideTitlebar() {
+        return this._call("setTitleBar", false);
     }
     // Icon methods
-    setIcon(iconPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._call('setIcon', iconPath);
-        });
+    async setIcon(iconPath) {
+        return this._call("setIcon", iconPath);
     }
     // Cookie methods
-    get_cookies() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('getCookies'); });
+    async getCookies() {
+        return this._call("getCookies");
     }
-    set_cookie(name_1, value_1) {
-        return __awaiter(this, arguments, void 0, function* (name, value, domain = '', path = '/') {
-            return this._call('setCookie', { name, value, domain, path });
-        });
+    async setCookie(name, value, domain = "", path = "/") {
+        return this._call("setCookie", { name, value, domain, path });
     }
-    clear_cookies() {
-        return __awaiter(this, void 0, void 0, function* () { return this._call('clearCookies'); });
-    }
-    _on_message(message, exposedFunctions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const data = typeof message === 'string' ? JSON.parse(message) : message;
-                if (!Array.isArray(data))
-                    return null;
-                const funcName = data[0];
-                const rawParams = data[1];
-                const id = data[2];
-                const params = this._parseParams(rawParams);
-                // Handle special messages
-                if (funcName === 'closed') {
-                    this._isClosed = true;
-                    this._resolveClosed();
-                    return null;
-                }
-                if (funcName === 'console') {
-                    console.log('WebView Console:', ...params);
-                    return null;
-                }
-                if (funcName === 'menu_click') {
-                    return this._handleMenuClick(params);
-                }
-                if (funcName === 'context_menu_requested') {
-                    return this._handleContextMenu(params);
-                }
-                // Handle window state methods
-                if (funcName.startsWith('window_')) {
-                    const method = funcName.substring(7); // Remove 'window_' prefix
-                    if (typeof this[method] === 'function') {
-                        yield this[method]();
-                    }
-                    return null;
+    async clearCookies() {
+        return this._call("clearCookies");
+    }
+    async _on_message(message, exposedFunctions) {
+        try {
+            const data = typeof message === "string" ? JSON.parse(message) : message;
+            if (!Array.isArray(data))
+                return null;
+            const funcName = data[0];
+            const rawParams = data[1];
+            const id = data[2];
+            const params = this._parseParams(rawParams);
+            // Handle special messages
+            if (funcName === "closed") {
+                this._isClosed = true;
+                this._resolveClosed();
+                return null;
+            }
+            if (funcName === "dom_ready") {
+                // DOM is ready, inject the API now
+                if (this._pendingApiInjection) {
+                    await this.evaluate(this._pendingApiInjection).catch((err) => {
+                        console.error("Failed to inject exposed functions API:", err);
+                    });
+                    this._pendingApiInjection = null;
                 }
-                // Handle exposed function calls
-                return this._handleExposedFunction(funcName, params, id, exposedFunctions);
+                return null;
             }
-            catch (e) {
+            if (funcName === "console") {
+                console.log("WebView Console:", ...params);
                 return null;
             }
-        });
+            if (funcName === "menu_click") {
+                return this._handleMenuClick(params);
+            }
+            if (funcName === "context_menu_requested") {
+                return this._handleContextMenu(params);
+            }
+            // Handle window state methods
+            if (funcName.startsWith("window_")) {
+                const method = funcName.substring(7); // Remove 'window_' prefix
+                if (typeof this[method] === "function") {
+                    await this[method]();
+                }
+                return null;
+            }
+            // Handle exposed function calls
+            return this._handleExposedFunction(funcName, params, id, exposedFunctions);
+        }
+        catch (e) {
+            return null;
+        }
     }
     _parseParams(rawParams) {
         let params = [];
         if (rawParams) {
-            if (typeof rawParams === 'string' && (rawParams.startsWith('[') || rawParams.startsWith('{'))) {
+            if (typeof rawParams === "string" &&
+                (rawParams.startsWith("[") || rawParams.startsWith("{"))) {
                 try {
                     const parsed = JSON.parse(rawParams);
                     params = Array.isArray(parsed) ? parsed : [parsed];
@@ -290,52 +236,44 @@ class Window {
             callback();
         return null;
     }
-    _handleContextMenu(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.on_context_menu) {
-                const customMenu = yield this.on_context_menu(params);
-                if (customMenu) {
-                    return this._processMenu(customMenu);
-                }
+    async _handleContextMenu(params) {
+        if (this.on_context_menu) {
+            const customMenu = await this.on_context_menu(params);
+            if (customMenu) {
+                return this._processMenu(customMenu);
             }
-            return null;
-        });
+        }
+        return null;
     }
-    _handleExposedFunction(funcName, params, id, exposedFunctions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const func = exposedFunctions[funcName];
-            if (!func)
-                return null;
-            try {
-                const result = yield func(...params);
-                yield this._sendSuccessResponse(funcName, id, result);
-                return result !== undefined ? result : null;
-            }
-            catch (err) {
-                yield this._sendErrorResponse(funcName, id, err);
-                return null;
-            }
-        });
+    async _handleExposedFunction(funcName, params, id, exposedFunctions) {
+        const func = exposedFunctions[funcName];
+        if (!func)
+            return null;
+        try {
+            const result = await func(...params);
+            await this._sendSuccessResponse(funcName, id, result);
+            return result !== undefined ? result : null;
+        }
+        catch (err) {
+            await this._sendErrorResponse(funcName, id, err);
+            return null;
+        }
     }
-    _sendSuccessResponse(funcName, id, result) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const resJson = JSON.stringify(result);
-            const code = `window.ewvjs._returnValuesCallbacks["${funcName}"]["${id}"]({value: ${JSON.stringify(resJson)}, isError: false})`;
-            yield this.evaluate_js(code);
-        });
+    async _sendSuccessResponse(funcName, id, result) {
+        const resJson = JSON.stringify(result);
+        const code = `window.ewvjs._returnValuesCallbacks["${funcName}"]["${id}"]({value: ${JSON.stringify(resJson)}, isError: false})`;
+        await this.evaluate(code);
     }
-    _sendErrorResponse(funcName, id, err) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const errObj = { message: err.message, name: err.name, stack: err.stack };
-            const code = `window.ewvjs._returnValuesCallbacks["${funcName}"]["${id}"]({value: ${JSON.stringify(JSON.stringify(errObj))}, isError: true})`;
-            yield this.evaluate_js(code);
-        });
+    async _sendErrorResponse(funcName, id, err) {
+        const errObj = { message: err.message, name: err.name, stack: err.stack };
+        const code = `window.ewvjs._returnValuesCallbacks["${funcName}"]["${id}"]({value: ${JSON.stringify(JSON.stringify(errObj))}, isError: true})`;
+        await this.evaluate(code);
     }
     _processMenu(menu) {
         return menu.map((item) => {
-            const newItem = Object.assign({}, item);
+            const newItem = { ...item };
             if (newItem.click) {
-                const id = newItem.id || (0, utils_1.generateId)();
+                const id = newItem.id || generateId();
                 newItem.id = id;
                 this._menuCallbacks.set(id, newItem.click);
                 delete newItem.click;
@@ -347,4 +285,3 @@ class Window {
         });
     }
 }
-exports.Window = Window;

package/native/WebView.cjs

@@ -2,7 +2,7 @@
 // Generated by: Microsoft.JavaScript.NodeApi.Generator 0.9.0.0
 /* eslint-disable */
 
-const dotnet = require('node-api-dotnet/net10.0');
+const dotnet = require('node-api-dotnet/net472');
 const path = require('node:path');
 // @ts-ignore - https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/65252
 const { dlopen, platform, arch } = require('node:process');