mirror of
https://github.com/ElectronNET/Electron.NET.git
synced 2026-02-12 21:25:06 +00:00
381 lines
18 KiB
JavaScript
381 lines
18 KiB
JavaScript
"use strict";
|
|
const electron_1 = require("electron");
|
|
const fs = require("fs");
|
|
const browserView_1 = require("./browserView");
|
|
const { logger } = require("../logger");
|
|
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
|