@lvce-editor/api 8.46.0 → 8.47.0

package/README.md

@@ -21,3 +21,13 @@ export const main = () => {
 ```
 
 The package is published as unbundled ESM with TypeScript declaration files, so extensions can bundle it with their own build tooling.
+
+Electron extensions can create an off-screen web contents view. It stays hidden for the lifetime of the handle, and disposing the handle destroys its web contents.
+
+```ts
+import { createElectronWebContentsView } from '@lvce-editor/api'
+
+const view = await createElectronWebContentsView({ url: 'https://example.com' })
+const title = await view.executeJavaScript<string>('document.title')
+await view.dispose()
+```

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { activate } from './parts/Activation/Activation.ts';
+export { createElectronWebContentsView } from './parts/ElectronWebContentsView/ElectronWebContentsView.ts';
 export { executeCommand } from './parts/ExecuteCommand/ExecuteCommand.ts';
 export { showQuickPick } from './parts/QuickPick/QuickPick.ts';
 export { getPreference, setPreference } from './parts/Preferences/Preferences.ts';
@@ -24,6 +25,7 @@ export type { CommandRegistrySnapshot } from './parts/CommandRegistrySnapshot/Co
 export type { CompletionItem, CompletionProvider, CompletionProviderRegistrySnapshot, RegisteredCompletionProvider, } from './parts/Completion/Completion.ts';
 export type { Diagnostic, DiagnosticProvider, DiagnosticProviderRegistrySnapshot, RegisteredDiagnosticProvider, } from './parts/Diagnostic/Diagnostic.ts';
 export type { Disposable } from './parts/Disposable/Disposable.ts';
+export type { CreateElectronWebContentsViewOptions, ElectronWebContentsView, ElectronWebContentsViewStats, } from './parts/ElectronWebContentsView/ElectronWebContentsView.ts';
 export type { FormattingEdit, FormattingProvider, FormattingProviderRegistrySnapshot, RegisteredFormattingProvider, } from './parts/Formatting/Formatting.ts';
 export type { FileSystemDirent } from './parts/FileSystem/FileSystem.ts';
 export type { HandleExtensionManagementMessagePortOptions } from './parts/HandleExtensionManagementMessagePort/HandleExtensionManagementMessagePort.ts';

package/dist/index.js

@@ -1,4 +1,5 @@
 export { activate } from "./parts/Activation/Activation.js";
+export { createElectronWebContentsView } from "./parts/ElectronWebContentsView/ElectronWebContentsView.js";
 export { executeCommand } from "./parts/ExecuteCommand/ExecuteCommand.js";
 export { showQuickPick } from "./parts/QuickPick/QuickPick.js";
 export { getPreference, setPreference } from "./parts/Preferences/Preferences.js";

package/dist/parts/ElectronWebContentsView/ElectronWebContentsView.d.ts

@@ -0,0 +1,17 @@
+export interface CreateElectronWebContentsViewOptions {
+    readonly url?: string;
+}
+export interface ElectronWebContentsViewStats {
+    readonly canGoBack: boolean;
+    readonly canGoForward: boolean;
+    readonly title: string;
+    readonly url: string;
+}
+export interface ElectronWebContentsView {
+    readonly dispose: () => Promise<void>;
+    readonly executeJavaScript: <T = unknown>(code: string) => Promise<T>;
+    readonly getStats: () => Promise<ElectronWebContentsViewStats>;
+    readonly loadUrl: (url: string) => Promise<void>;
+    readonly reload: () => Promise<void>;
+}
+export declare const createElectronWebContentsView: ({ url }?: CreateElectronWebContentsViewOptions) => Promise<ElectronWebContentsView>;

package/dist/parts/ElectronWebContentsView/ElectronWebContentsView.js

@@ -0,0 +1,59 @@
+import { LazyTransferMessagePortRpcParent } from '@lvce-editor/rpc';
+import { ExtensionManagementWorker } from '@lvce-editor/rpc-registry';
+const sendMessagePortToEmbedsProcess = async (port) => {
+    await ExtensionManagementWorker.invokeAndTransfer('Extensions.sendMessagePortToElectron', port, 'HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess');
+};
+const disposeAfterCreateError = async (rpc, id) => {
+    try {
+        await rpc.invoke('ElectronWebContentsView.disposeWebContentsView', id);
+    }
+    finally {
+        await rpc.dispose();
+    }
+};
+export const createElectronWebContentsView = async ({ url } = {}) => {
+    const rpc = await LazyTransferMessagePortRpcParent.create({
+        commandMap: {},
+        send: sendMessagePortToEmbedsProcess,
+    });
+    let id;
+    try {
+        id = (await rpc.invoke('ElectronWebContentsView.createWebContentsView', 0, []));
+    }
+    catch (error) {
+        await rpc.dispose();
+        throw error;
+    }
+    let disposed = false;
+    const loadUrl = async (nextUrl) => {
+        await rpc.invoke('ElectronWebContentsView.setIframeSrc', id, nextUrl);
+    };
+    try {
+        if (url) {
+            await loadUrl(url);
+        }
+    }
+    catch (error) {
+        await disposeAfterCreateError(rpc, id);
+        throw error;
+    }
+    return {
+        async dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            await disposeAfterCreateError(rpc, id);
+        },
+        async executeJavaScript(code) {
+            return (await rpc.invoke('ElectronWebContentsView.insertJavaScript', id, code));
+        },
+        async getStats() {
+            return (await rpc.invoke('ElectronWebContentsView.getStats', id));
+        },
+        loadUrl,
+        async reload() {
+            await rpc.invoke('ElectronWebContentsView.reload', id);
+        },
+    };
+};

package/dist/parts/ExtensionApiWorkerListen/ExtensionApiWorkerListen.js

@@ -1,6 +1,10 @@
 import { WebWorkerRpcClient } from '@lvce-editor/rpc';
 import * as ExtensionApiWorkerCommandMap from "../ExtensionApiWorkerCommandMap/ExtensionApiWorkerCommandMap.js";
+import * as HandleUnhandledError from "../HandleUnhandledError/HandleUnhandledError.js";
+import * as HandleUnhandledRejection from "../HandleUnhandledRejection/HandleUnhandledRejection.js";
 export const listen = async () => {
+    globalThis.addEventListener('error', HandleUnhandledError.handleUnhandledError);
+    globalThis.addEventListener('unhandledrejection', HandleUnhandledRejection.handleUnhandledRejection);
     const rpc = WebWorkerRpcClient.create({
         commandMap: ExtensionApiWorkerCommandMap.commandMap,
     });

package/dist/parts/HandleUncaughtExtensionError/HandleUncaughtExtensionError.d.ts

@@ -0,0 +1 @@
+export declare const handleUncaughtExtensionError: (error: unknown) => Promise<void>;

package/dist/parts/HandleUncaughtExtensionError/HandleUncaughtExtensionError.js

@@ -0,0 +1,6 @@
+import { ExtensionManagementWorker } from '@lvce-editor/rpc-registry';
+import * as SerializeError from "../SerializeError/SerializeError.js";
+export const handleUncaughtExtensionError = async (error) => {
+    const serializedError = SerializeError.serializeError(error);
+    await ExtensionManagementWorker.invoke('Extensions.handleUncaughtExtensionError', serializedError);
+};

package/dist/parts/HandleUnhandledError/HandleUnhandledError.d.ts

@@ -0,0 +1 @@
+export declare const handleUnhandledError: (event: ErrorEvent) => Promise<void>;

package/dist/parts/HandleUnhandledError/HandleUnhandledError.js

@@ -0,0 +1,23 @@
+import * as HandleUncaughtExtensionError from "../HandleUncaughtExtensionError/HandleUncaughtExtensionError.js";
+const getError = (event) => {
+    if (event.error) {
+        return event.error;
+    }
+    return {
+        constructor: {
+            name: 'Error',
+        },
+        message: event.message,
+        stack: `${event.message}\n    at ${event.filename}:${event.lineno}:${event.colno}`,
+    };
+};
+export const handleUnhandledError = async (event) => {
+    event.preventDefault();
+    const error = getError(event);
+    try {
+        await HandleUncaughtExtensionError.handleUncaughtExtensionError(error);
+    }
+    catch {
+        console.error(error);
+    }
+};

package/dist/parts/HandleUnhandledRejection/HandleUnhandledRejection.d.ts

@@ -0,0 +1 @@
+export declare const handleUnhandledRejection: (event: PromiseRejectionEvent) => Promise<void>;

package/dist/parts/HandleUnhandledRejection/HandleUnhandledRejection.js

@@ -0,0 +1,10 @@
+import * as HandleUncaughtExtensionError from "../HandleUncaughtExtensionError/HandleUncaughtExtensionError.js";
+export const handleUnhandledRejection = async (event) => {
+    event.preventDefault();
+    try {
+        await HandleUncaughtExtensionError.handleUncaughtExtensionError(event.reason);
+    }
+    catch {
+        console.error(event.reason);
+    }
+};

package/dist/parts/SerializeError/SerializeError.d.ts

@@ -0,0 +1,11 @@
+export interface SerializedError {
+    readonly code?: unknown;
+    readonly codeFrame?: unknown;
+    readonly constructor: {
+        readonly name: string;
+    };
+    readonly message?: unknown;
+    readonly name?: unknown;
+    readonly stack?: unknown;
+}
+export declare const serializeError: (error: unknown) => SerializedError | unknown;

package/dist/parts/SerializeError/SerializeError.js

@@ -0,0 +1,19 @@
+const getConstructorName = (error) => {
+    return error.constructor?.name || 'Error';
+};
+export const serializeError = (error) => {
+    if (!error || (typeof error !== 'object' && typeof error !== 'function')) {
+        return error;
+    }
+    const value = error;
+    return {
+        code: value.code,
+        codeFrame: value.codeFrame,
+        constructor: {
+            name: getConstructorName(value),
+        },
+        message: value.message,
+        name: value.name,
+        stack: value.stack,
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/api",
-  "version": "8.46.0",
+  "version": "8.47.0",
   "description": "Tree-shakeable extension API for Lvce Editor extensions.",
   "keywords": [
     "lvce-editor",