Electron.NET/src/ElectronNET.Host/api/webContents.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
const fs = __importStar(require("fs"));
const electron_1 = require("electron");
const browserView_1 = require("./browserView");
let electronSocket;
module.exports = (socket) => {
    electronSocket = socket;
    // The crashed event has been removed in Electron 29
    socket.on("register-webContents-crashed", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.removeAllListeners("crashed");
        // @ts-expect-error No overload matches this call
        browserWindow.webContents.on("crashed", (event, killed) => {
            electronSocket.emit("webContents-crashed" + id, killed);
        });
    });
    socket.on("register-webContents-didFinishLoad", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.removeAllListeners("did-finish-load");
        browserWindow.webContents.on("did-finish-load", () => {
            electronSocket.emit("webContents-didFinishLoad" + id);
        });
    });
    socket.on("register-webContents-didStartNavigation", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.removeAllListeners("did-start-navigation");
        browserWindow.webContents.on("did-start-navigation", (_, url) => {
            electronSocket.emit("webContents-didStartNavigation" + id, url);
        });
    });
    socket.on("register-webContents-didNavigate", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.removeAllListeners("did-navigate");
        browserWindow.webContents.on("did-navigate", (_, url, httpResponseCode) => {
            electronSocket.emit("webContents-didNavigate" + id, {
                url,
                httpResponseCode,
            });
        });
    });
    socket.on("register-webContents-willRedirect", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.removeAllListeners("will-redirect");
        browserWindow.webContents.on("will-redirect", (_, url) => {
            electronSocket.emit("webContents-willRedirect" + id, url);
        });
    });
    socket.on("register-webContents-didFailLoad", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.removeAllListeners("did-fail-load");
        browserWindow.webContents.on("did-fail-load", (_, errorCode, validatedUrl) => {
            electronSocket.emit("webContents-didFailLoad" + id, {
                errorCode,
                validatedUrl,
            });
        });
    });
    socket.on("register-webContents-didRedirectNavigation", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.removeAllListeners("did-redirect-navigation");
        browserWindow.webContents.on("did-redirect-navigation", (_, url) => {
            electronSocket.emit("webContents-didRedirectNavigation" + id, url);
        });
    });
    socket.on("register-webContents-input-event", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.removeAllListeners("input-event");
        browserWindow.webContents.on("input-event", (_, eventArgs) => {
            if (eventArgs.type !== "char") {
                electronSocket.emit("webContents-input-event" + id, eventArgs);
            }
        });
    });
    socket.on("register-webContents-domReady", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.removeAllListeners("dom-ready");
        browserWindow.webContents.on("dom-ready", () => {
            electronSocket.emit("webContents-domReady" + id);
        });
    });
    socket.on("webContents-openDevTools", (id, options) => {
        if (options) {
            getWindowById(id).webContents.openDevTools(options);
        }
        else {
            getWindowById(id).webContents.openDevTools();
        }
    });
    socket.on("webContents-getPrinters", async (id) => {
        const printers = await getWindowById(id).webContents.getPrintersAsync();
        electronSocket.emit("webContents-getPrinters-completed", printers);
    });
    socket.on("webContents-print", async (id, options = {}) => {
        await getWindowById(id).webContents.print(options);
        electronSocket.emit("webContents-print-completed", true);
    });
    socket.on("webContents-printToPDF", async (id, options = {}, path) => {
        const buffer = await getWindowById(id).webContents.printToPDF(options);
        fs.writeFile(path, buffer, (error) => {
            if (error) {
                electronSocket.emit("webContents-printToPDF-completed", false);
            }
            else {
                electronSocket.emit("webContents-printToPDF-completed", true);
            }
        });
    });
    socket.on("webContents-executeJavaScript", async (id, code, userGesture = false) => {
        const result = await getWindowById(id).webContents.executeJavaScript(code, userGesture);
        electronSocket.emit("webContents-executeJavaScript-completed", result);
    });
    socket.on("webContents-getUrl", function (id) {
        const browserWindow = getWindowById(id);
        electronSocket.emit("webContents-getUrl" + id, browserWindow.webContents.getURL());
    });
    socket.on("webContents-session-allowNTLMCredentialsForDomains", (id, domains) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.allowNTLMCredentialsForDomains(domains);
    });
    socket.on("webContents-session-clearAuthCache", async (...args) => {
        // Overload support: (id, guid) OR (id, options, guid)
        const browserWindow = getWindowById(args[0]);
        let guid;
        if (args.length === 2) {
            // No options
            guid = args[1];
            await browserWindow.webContents.session.clearAuthCache();
        }
        else if (args.length === 3) {
            const options = args[1];
            guid = args[2];
            try {
                // @ts-ignore
                await browserWindow.webContents.session.clearAuthCache(options);
            }
            catch {
                // Fallback to clearing without options if Electron version rejects custom options
                await browserWindow.webContents.session.clearAuthCache();
            }
        }
        else {
            return; // invalid invocation
        }
        electronSocket.emit("webContents-session-clearAuthCache-completed" + guid);
    });
    socket.on("webContents-session-clearCache", async (id, guid) => {
        const browserWindow = getWindowById(id);
        await browserWindow.webContents.session.clearCache();
        electronSocket.emit("webContents-session-clearCache-completed" + guid);
    });
    socket.on("webContents-session-clearHostResolverCache", async (id, guid) => {
        const browserWindow = getWindowById(id);
        await browserWindow.webContents.session.clearHostResolverCache();
        electronSocket.emit("webContents-session-clearHostResolverCache-completed" + guid);
    });
    socket.on("webContents-session-clearStorageData", async (id, guid) => {
        const browserWindow = getWindowById(id);
        await browserWindow.webContents.session.clearStorageData({});
        electronSocket.emit("webContents-session-clearStorageData-completed" + guid);
    });
    socket.on("webContents-session-clearStorageData-options", async (id, options, guid) => {
        const browserWindow = getWindowById(id);
        await browserWindow.webContents.session.clearStorageData(options);
        electronSocket.emit("webContents-session-clearStorageData-options-completed" + guid);
    });
    socket.on("webContents-session-createInterruptedDownload", (id, options) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.createInterruptedDownload(options);
    });
    socket.on("webContents-session-disableNetworkEmulation", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.disableNetworkEmulation();
    });
    socket.on("webContents-session-enableNetworkEmulation", (id, options) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.enableNetworkEmulation(options);
    });
    socket.on("webContents-session-flushStorageData", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.flushStorageData();
    });
    socket.on("webContents-session-getBlobData", async (id, identifier, guid) => {
        const browserWindow = getWindowById(id);
        const buffer = await browserWindow.webContents.session.getBlobData(identifier);
        electronSocket.emit("webContents-session-getBlobData-completed" + guid, buffer.buffer);
    });
    socket.on("webContents-session-getCacheSize", async (id, guid) => {
        const browserWindow = getWindowById(id);
        const size = await browserWindow.webContents.session.getCacheSize();
        electronSocket.emit("webContents-session-getCacheSize-completed" + guid, size);
    });
    socket.on("webContents-session-getPreloads", (id, guid) => {
        const browserWindow = getWindowById(id);
        const preloads = browserWindow.webContents.session.getPreloads();
        electronSocket.emit("webContents-session-getPreloads-completed" + guid, preloads);
    });
    socket.on("webContents-session-getUserAgent", (id, guid) => {
        const browserWindow = getWindowById(id);
        const userAgent = browserWindow.webContents.session.getUserAgent();
        electronSocket.emit("webContents-session-getUserAgent-completed" + guid, userAgent);
    });
    socket.on("webContents-session-resolveProxy", async (id, url, guid) => {
        const browserWindow = getWindowById(id);
        const proxy = await browserWindow.webContents.session.resolveProxy(url);
        electronSocket.emit("webContents-session-resolveProxy-completed" + guid, proxy);
    });
    socket.on("webContents-session-setDownloadPath", (id, path) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.setDownloadPath(path);
    });
    socket.on("webContents-session-setPreloads", (id, preloads) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.setPreloads(preloads);
    });
    socket.on("webContents-session-setProxy", async (id, configuration, guid) => {
        const browserWindow = getWindowById(id);
        await browserWindow.webContents.session.setProxy(configuration);
        electronSocket.emit("webContents-session-setProxy-completed" + guid);
    });
    socket.on("webContents-session-setUserAgent", (id, userAgent, acceptLanguages) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.setUserAgent(userAgent, acceptLanguages);
    });
    socket.on("register-webContents-session-webRequest-onBeforeRequest", (id, filter) => {
        const browserWindow = getWindowById(id);
        const session = browserWindow.webContents.session;
        session.webRequest.onBeforeRequest(filter, (details, callback) => {
            socket.emit(`webContents-session-webRequest-onBeforeRequest${id}`, details);
            // Listen for a response from C# to continue the request
            electronSocket.once(`webContents-session-webRequest-onBeforeRequest-response${id}`, (response) => {
                callback(response);
            });
        });
    });
    socket.on("register-webContents-session-cookies-changed", (id) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.cookies.removeAllListeners("changed");
        browserWindow.webContents.session.cookies.on("changed", (event, cookie, cause, removed) => {
            electronSocket.emit("webContents-session-cookies-changed" + id, [
                cookie,
                cause,
                removed,
            ]);
        });
    });
    socket.on("webContents-session-cookies-get", async (id, filter, guid) => {
        const browserWindow = getWindowById(id);
        const cookies = await browserWindow.webContents.session.cookies.get(filter);
        electronSocket.emit("webContents-session-cookies-get-completed" + guid, cookies);
    });
    socket.on("webContents-session-cookies-set", async (id, details, guid) => {
        const browserWindow = getWindowById(id);
        await browserWindow.webContents.session.cookies.set(details);
        electronSocket.emit("webContents-session-cookies-set-completed" + guid);
    });
    socket.on("webContents-session-cookies-remove", async (id, url, name, guid) => {
        const browserWindow = getWindowById(id);
        await browserWindow.webContents.session.cookies.remove(url, name);
        electronSocket.emit("webContents-session-cookies-remove-completed" + guid);
    });
    socket.on("webContents-session-cookies-flushStore", async (id, guid) => {
        const browserWindow = getWindowById(id);
        await browserWindow.webContents.session.cookies.flushStore();
        electronSocket.emit("webContents-session-cookies-flushStore-completed" + guid);
    });
    socket.on("webContents-loadURL", (id, url, options) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents
            .loadURL(url, options)
            .then(() => {
            electronSocket.emit("webContents-loadURL-complete" + id);
        })
            .catch((error) => {
            console.error(error);
            electronSocket.emit("webContents-loadURL-error" + id, error);
        });
    });
    socket.on("webContents-insertCSS", (id, isBrowserWindow, path) => {
        if (isBrowserWindow) {
            const browserWindow = getWindowById(id);
            if (browserWindow) {
                browserWindow.webContents.insertCSS(fs.readFileSync(path, "utf8"));
            }
        }
        else {
            const browserViews = (global["browserViews"] =
                global["browserViews"] || []);
            let view = null;
            for (let i = 0; i < browserViews.length; i++) {
                if (browserViews[i]["id"] + 1000 === id) {
                    view = browserViews[i];
                    break;
                }
            }
            if (view) {
                view.webContents.insertCSS(fs.readFileSync(path, "utf8"));
            }
        }
    });
    socket.on("webContents-session-getAllExtensions", (id) => {
        const browserWindow = getWindowById(id);
        const extensionsList = browserWindow.webContents.session.getAllExtensions();
        const chromeExtensionInfo = [];
        Object.keys(extensionsList).forEach((key) => {
            chromeExtensionInfo.push(extensionsList[key]);
        });
        electronSocket.emit("webContents-session-getAllExtensions-completed", chromeExtensionInfo);
    });
    socket.on("webContents-session-removeExtension", (id, name) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.session.removeExtension(name);
    });
    socket.on("webContents-session-loadExtension", async (id, path, allowFileAccess = false) => {
        const browserWindow = getWindowById(id);
        const extension = await browserWindow.webContents.session.loadExtension(path, { allowFileAccess: allowFileAccess });
        electronSocket.emit("webContents-session-loadExtension-completed", extension);
    });
    socket.on("webContents-getZoomFactor", (id) => {
        const browserWindow = getWindowById(id);
        const text = browserWindow.webContents.getZoomFactor();
        electronSocket.emit("webContents-getZoomFactor-completed", text);
    });
    socket.on("webContents-setZoomFactor", (id, factor) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.setZoomFactor(factor);
    });
    socket.on("webContents-getZoomLevel", (id) => {
        const browserWindow = getWindowById(id);
        const content = browserWindow.webContents.getZoomLevel();
        electronSocket.emit("webContents-getZoomLevel-completed", content);
    });
    socket.on("webContents-setZoomLevel", (id, level) => {
        const browserWindow = getWindowById(id);
        browserWindow.webContents.setZoomLevel(level);
    });
    socket.on("webContents-setVisualZoomLevelLimits", async (id, minimumLevel, maximumLevel) => {
        const browserWindow = getWindowById(id);
        await browserWindow.webContents.setVisualZoomLevelLimits(minimumLevel, maximumLevel);
        electronSocket.emit("webContents-setVisualZoomLevelLimits-completed");
    });
    socket.on("webContents-toggleDevTools", (id) => {
        getWindowById(id).webContents.toggleDevTools();
    });
    socket.on("webContents-closeDevTools", (id) => {
        getWindowById(id).webContents.closeDevTools();
    });
    socket.on("webContents-isDevToolsOpened", function (id) {
        const browserWindow = getWindowById(id);
        electronSocket.emit("webContents-isDevToolsOpened-completed", browserWindow.webContents.isDevToolsOpened());
    });
    socket.on("webContents-isDevToolsFocused", function (id) {
        const browserWindow = getWindowById(id);
        electronSocket.emit("webContents-isDevToolsFocused-completed", browserWindow.webContents.isDevToolsFocused());
    });
    socket.on("webContents-setAudioMuted", (id, muted) => {
        getWindowById(id).webContents.setAudioMuted(muted);
    });
    socket.on("webContents-isAudioMuted", function (id) {
        const browserWindow = getWindowById(id);
        electronSocket.emit("webContents-isAudioMuted-completed", browserWindow.webContents.isAudioMuted());
    });
    socket.on("webContents-isCurrentlyAudible", function (id) {
        const browserWindow = getWindowById(id);
        electronSocket.emit("webContents-isCurrentlyAudible-completed", browserWindow.webContents.isCurrentlyAudible());
    });
    socket.on("webContents-getUserAgent", function (id) {
        const browserWindow = getWindowById(id);
        electronSocket.emit("webContents-getUserAgent-completed", browserWindow.webContents.getUserAgent());
    });
    socket.on("webContents-setUserAgent", (id, userAgent) => {
        getWindowById(id).webContents.setUserAgent(userAgent);
    });
    function getWindowById(id) {
        if (id >= 1000) {
            return (0, browserView_1.browserViewMediateService)(id - 1000);
        }
        return electron_1.BrowserWindow.fromId(id);
    }
};
//# sourceMappingURL=webContents.js.map