@lvce-editor/rpc-registry 2.72.0 → 3.0.0

package/dist/parts/BulkReplacementEdit/BulkReplacementEdit.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/Change/Change.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/ClipBoardProcess/ClipBoardProcess.js

@@ -0,0 +1,3 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.ClipBoardProcess);

package/dist/parts/ClipBoardProcessApi/ClipBoardProcessApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/ClipBoardWorker/ClipBoardWorker.js

@@ -0,0 +1,19 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.ClipBoardWorker);
+export const writeText = async (text) => {
+    // @ts-ignore
+    return invoke('ClipBoard.writeText', text);
+};
+export const readText = async () => {
+    // @ts-ignore
+    return invoke('ClipBoard.readText');
+};
+export const writeImage = async (image) => {
+    // @ts-ignore
+    return invoke('ClipBoard.writeImage', image);
+};
+export const readNativeFiles = async () => {
+    // @ts-ignore
+    return invoke('ClipBoard.readNativeFiles');
+};

package/dist/parts/ClipBoardWorkerApi/ClipBoardWorkerApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/ConfirmPromptOptions/ConfirmPromptOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/CreateLazyRpc/CreateLazyRpc.js

@@ -0,0 +1,25 @@
+import * as RpcRegistry from "../RpcRegistry/RpcRegistry.js";
+export const createLazyRpc = (rpcId) => {
+    let rpcPromise;
+    let factory;
+    const createRpc = async () => {
+        const rpc = await factory();
+        RpcRegistry.set(rpcId, rpc);
+    };
+    const ensureRpc = async () => {
+        if (!rpcPromise) {
+            rpcPromise = createRpc();
+        }
+        await rpcPromise;
+    };
+    return {
+        setFactory(value) {
+            factory = value;
+        },
+        async invoke(method, ...params) {
+            await ensureRpc();
+            const rpc = RpcRegistry.get(rpcId);
+            return rpc.invoke(method, ...params);
+        },
+    };
+};

package/dist/parts/DebugWorker/DebugWorker.js

@@ -0,0 +1,3 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.DebugWorker);

package/dist/parts/DebugWorkerApi/DebugWorkerApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/EditorWorker/EditorWorker.js

@@ -0,0 +1,68 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.EditorWorker);
+export const sendMessagePortToExtensionHostWorker = async (port) => {
+    const command = 'HandleMessagePort.handleMessagePort2';
+    await invokeAndTransfer(
+    // @ts-ignore
+    'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
+};
+// TODO add tests for this
+export const activateByEvent = async (event) => {
+    // @ts-ignore
+    await invoke('ActivateByEvent.activateByEvent', event);
+};
+export const applyEdit = async (editorUid, changes) => {
+    // @ts-ignore
+    await invoke('Editor.applyEdit2', editorUid, changes);
+};
+export const applyWorkspaceEdit = async (editorUid, changes) => {
+    // @ts-ignore
+    await invoke('Editor.applyWorkspaceEdit', editorUid, changes);
+};
+export const closeWidget = async (editorUid, widgetId, widgetName, focusId) => {
+    // @ts-ignore
+    await invoke('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
+};
+export const getWordAt = async (uid, rowIndex, columnIndex) => {
+    // @ts-ignore
+    const word = await invoke('Editor.getWordAt2', uid, rowIndex, columnIndex);
+    return word;
+};
+export const getLines = async (editorUid) => {
+    const lines = await invoke('Editor.getLines2', editorUid);
+    return lines;
+};
+export const getPositionAtCursor = async (parentUid) => {
+    const position = await invoke('Editor.getPositionAtCursor', parentUid);
+    return position;
+};
+export const getOffsetAtCursor = async (editorId) => {
+    // @ts-ignore
+    return await invoke('Editor.getOffsetAtCursor', editorId);
+};
+export const getSelections = async (editorUid) => {
+    const selections = await invoke('Editor.getSelections2', editorUid);
+    return selections;
+};
+export const getWordAtOffset2 = async (editorUid) => {
+    return invoke('Editor.getWordAtOffset2', editorUid);
+};
+export const getWordBefore = async (editorUid, rowIndex, columnIndex) => {
+    return invoke('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
+};
+export const updateDebugInfo = async (info) => {
+    await invoke('Editor.updateDebugInfo', info);
+};
+export const getUri = async (editorUid) => {
+    // @ts-ignore
+    return invoke('Editor.getUri', editorUid);
+};
+export const getLanguageId = async (editorUid) => {
+    // @ts-ignore
+    return invoke('Editor.getLanguageId', editorUid);
+};
+export const getProblems = async () => {
+    // @ts-ignore
+    return invoke('Editor.getProblems');
+};

package/dist/parts/EditorWorkerApi/EditorWorkerApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/EmbedsProcess/EmbedsProcess.js

@@ -0,0 +1,3 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.EmbedsProcess);

package/dist/parts/EmbedsProcessApi/EmbedsProcessApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/ErrorWorker/ErrorWorker.js

@@ -0,0 +1,3 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.ErrorWorker);

package/dist/parts/ErrorWorkerApi/ErrorWorkerApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/ExtensionHost/ExtensionHost.js

@@ -0,0 +1,15 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.ExtensionHostWorker);
+export const executeReferenceProvider = async (id, offset) => {
+    // @ts-ignore
+    return invoke('ExtensionHostReference.executeReferenceProvider', id, offset);
+};
+export const executeFileReferenceProvider = async (id) => {
+    // @ts-ignore
+    return invoke('ExtensionHostReference.executeFileReferenceProvider', id);
+};
+export const getRuntimeStatus = async (extensionId) => {
+    // @ts-ignore
+    return invoke('ExtensionHost.getRuntimeStatus', extensionId);
+};

package/dist/parts/ExtensionHostWorkerApi/ExtensionHostWorkerApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/FileSystemProcess/FileSystemProcess.js

@@ -0,0 +1,56 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.FileSystemProcess);
+export const remove = async (uri) => {
+    return invoke('FileSystem.remove', uri);
+};
+export const readFile = async (uri) => {
+    return invoke('FileSystem.readFile', uri);
+};
+export const appendFile = async (uri, text) => {
+    // @ts-ignore
+    return invoke('FileSystem.appendFile', uri, text);
+};
+export const readDirWithFileTypes = async (uri) => {
+    return invoke('FileSystem.readDirWithFileTypes', uri);
+};
+export const getPathSeparator = async (root) => {
+    // @ts-ignore
+    return invoke('FileSystem.getPathSeparator', root);
+};
+export const readJson = async (root) => {
+    // @ts-ignore
+    return invoke('FileSystem.readJson', root);
+};
+export const getRealPath = async (path) => {
+    // @ts-ignore
+    return invoke('FileSystem.getRealPath', path);
+};
+export const stat = async (path) => {
+    // @ts-ignore
+    return invoke('FileSystem.stat', path);
+};
+export const writeFile = async (path, content) => {
+    // @ts-ignore
+    return invoke('FileSystem.writeFile', path, content);
+};
+export const mkdir = async (path) => {
+    // @ts-ignore
+    return invoke('FileSystem.mkdir', path);
+};
+export const rename = async (oldUri, newUri) => {
+    // @ts-ignore
+    return invoke('FileSystem.rename', oldUri, newUri);
+};
+export const copy = async (oldUri, newUri) => {
+    // @ts-ignore
+    return invoke('FileSystem.copy', oldUri, newUri);
+};
+export const getFolderSize = async (uri) => {
+    // @ts-ignore
+    return invoke('FileSystem.getFolderSize', uri);
+};
+export const exists = async (uri) => {
+    // @ts-ignore
+    return invoke('FileSystem.exists', uri);
+};

package/dist/parts/FileSystemProcessApi/FileSystemProcessApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/FileSystemWorker/FileSystemWorker.js

@@ -0,0 +1,53 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.FileSystemWorker);
+export const remove = async (dirent) => {
+    return invoke('FileSystem.remove', dirent);
+};
+export const readDirWithFileTypes = async (uri) => {
+    return invoke('FileSystem.readDirWithFileTypes', uri);
+};
+export const getPathSeparator = async (root) => {
+    // @ts-ignore
+    return invoke('FileSystem.getPathSeparator', root);
+};
+export const getRealPath = async (path) => {
+    return invoke('FileSystem.getRealPath', path);
+};
+export const stat = async (dirent) => {
+    return invoke('FileSystem.stat', dirent);
+};
+export const createFile = async (uri) => {
+    return invoke('FileSystem.writeFile', uri, '');
+};
+export const readFile = async (uri) => {
+    return invoke('FileSystem.readFile', uri);
+};
+export const writeFile = async (uri, content) => {
+    return invoke('FileSystem.writeFile', uri, content);
+};
+export const mkdir = async (uri) => {
+    return invoke('FileSystem.mkdir', uri);
+};
+export const rename = async (oldUri, newUri) => {
+    return invoke('FileSystem.rename', oldUri, newUri);
+};
+export const copy = async (oldUri, newUri) => {
+    return invoke('FileSystem.copy', oldUri, newUri);
+};
+export const exists = async (uri) => {
+    // @ts-ignore
+    return invoke('FileSystem.exists', uri);
+};
+export const getFolderSize = async (uri) => {
+    // @ts-ignore
+    return invoke('FileSystem.getFolderSize', uri);
+};
+export const readFileAsBlob = async (uri) => {
+    // @ts-ignore
+    return invoke('FileSystem.readFileAsBlob', uri);
+};
+export const appendFile = async (uri, text) => {
+    // @ts-ignore
+    return invoke('FileSystem.appendFile', uri, text);
+};

package/dist/parts/FileSystemWorkerApi/FileSystemWorkerApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/GetIpcType/GetIpcType.js

@@ -0,0 +1,13 @@
+import { ElectronUtilityProcess, NodeForkedProcess, NodeWorker } from "../IpcType/IpcType.js";
+export const getIpcType = (argv) => {
+    if (argv.includes('--ipc-type=node-worker')) {
+        return NodeWorker;
+    }
+    if (argv.includes('--ipc-type=node-forked-process')) {
+        return NodeForkedProcess;
+    }
+    if (argv.includes('--ipc-type=electron-utility-process')) {
+        return ElectronUtilityProcess;
+    }
+    throw new Error(`[file-system-process] unknown ipc type`);
+};

package/dist/parts/IpcType/IpcType.js

@@ -0,0 +1,5 @@
+export const NodeWorker = 1;
+export const NodeForkedProcess = 2;
+export const ElectronUtilityProcess = 3;
+export const ElectronMessagePort = 4;
+export const WebSocket = 6;

package/dist/parts/LazyRpc/LazyRpc.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/Main/Main.js

@@ -0,0 +1,21 @@
+export * as ClipBoardProcess from "../ClipBoardProcess/ClipBoardProcess.js";
+export * as ClipBoardWorker from "../ClipBoardWorker/ClipBoardWorker.js";
+export * as DebugWorker from "../DebugWorker/DebugWorker.js";
+export * as EditorWorker from "../EditorWorker/EditorWorker.js";
+export * as EmbedsProcess from "../EmbedsProcess/EmbedsProcess.js";
+export * as ErrorWorker from "../ErrorWorker/ErrorWorker.js";
+export * as ExtensionHost from "../ExtensionHost/ExtensionHost.js";
+export * as FileSystemProcess from "../FileSystemProcess/FileSystemProcess.js";
+export * as FileSystemWorker from "../FileSystemWorker/FileSystemWorker.js";
+export * as IpcType from "../IpcType/IpcType.js";
+export * as MainProcess from "../MainProcess/MainProcess.js";
+export * as MarkdownWorker from "../MarkdownWorker/MarkdownWorker.js";
+export * as RendererProcess from "../RendererProcess/RendererProcess.js";
+export * as RendererWorker from "../RendererWorker/RendererWorker.js";
+export * as RpcId from "../RpcId/RpcId.js";
+export * as SearchProcess from "../SearchProcess/SearchProcess.js";
+export * as SharedProcess from "../SharedProcess/SharedProcess.js";
+export * as SyntaxHighlightingWorker from "../SyntaxHighlightingWorker/SyntaxHighlightingWorker.js";
+export * from "../CreateLazyRpc/CreateLazyRpc.js";
+export * from "../GetIpcType/GetIpcType.js";
+export * from "../RpcRegistry/RpcRegistry.js";

package/dist/parts/MainProcess/MainProcess.js

@@ -0,0 +1,3 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.MainProcess);

package/dist/parts/MainProcessApi/MainProcessApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/MarkdownWorker/MarkdownWorker.js

@@ -0,0 +1,11 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.MarkdownWorker);
+export const getVirtualDom = async (html) => {
+    // @ts-ignore
+    return invoke('Markdown.getVirtualDom', html);
+};
+export const render = async (markdown, options) => {
+    // @ts-ignore
+    return invoke('Markdown.render', markdown, options);
+};

package/dist/parts/MarkdownWorkerApi/MarkdownWorkerApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/PositionAtCursor/PositionAtCursor.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/RendererProcess/RendererProcess.js

@@ -0,0 +1,15 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.RendererProcess);
+export const readClipBoardText = async () => {
+    // @ts-ignore
+    return await invoke('ClipBoard.readText');
+};
+export const readClipBoard = async () => {
+    // @ts-ignore
+    return await invoke('ClipBoard.read');
+};
+export const writeClipBoard = async (options) => {
+    // @ts-ignore
+    await invoke('ClipBoard.write', options);
+};

package/dist/parts/RendererProcessApi/RendererProcessApi.js

@@ -0,0 +1 @@
+export {};

package/dist/parts/RendererWorker/RendererWorker.js

@@ -0,0 +1,257 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+import * as RpcId from "../RpcId/RpcId.js";
+export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.RendererWorker);
+export const searchFileHtml = async (uri) => {
+    return invoke('ExtensionHost.searchFileWithHtml', uri);
+};
+export const getFilePathElectron = async (file) => {
+    return invoke('FileSystemHandle.getFilePathElectron', file);
+};
+export const showContextMenu = async (x, y, id, ...args) => {
+    return invoke('ContextMenu.show', x, y, id, ...args);
+};
+export const getElectronVersion = async () => {
+    return invoke('Process.getElectronVersion');
+};
+export const applyBulkReplacement = async (bulkEdits) => {
+    await invoke('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+export const setColorTheme = async (id) => {
+    // @ts-ignore
+    return invoke(/* ColorTheme.setColorTheme */ 'ColorTheme.setColorTheme', /* colorThemeId */ id);
+};
+export const getNodeVersion = async () => {
+    return invoke('Process.getNodeVersion');
+};
+export const getChromeVersion = async () => {
+    return invoke('Process.getChromeVersion');
+};
+export const getV8Version = async () => {
+    return invoke('Process.getV8Version');
+};
+export const getFileHandles = async (fileIds) => {
+    const files = await invoke('FileSystemHandle.getFileHandles', fileIds);
+    return files;
+};
+export const setWorkspacePath = async (path) => {
+    await invoke('Workspace.setPath', path);
+};
+export const registerWebViewInterceptor = async (id, port) => {
+    await invokeAndTransfer('WebView.registerInterceptor', id, port);
+};
+export const unregisterWebViewInterceptor = async (id) => {
+    await invoke('WebView.unregisterInterceptor', id);
+};
+export const sendMessagePortToEditorWorker = async (port, rpcId) => {
+    const command = 'HandleMessagePort.handleMessagePort';
+    // @ts-ignore
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+export const sendMessagePortToErrorWorker = async (port, rpcId) => {
+    const command = 'Errors.handleMessagePort';
+    // @ts-ignore
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+export const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+    const command = 'Markdown.handleMessagePort';
+    // @ts-ignore
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+export const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+    const command = 'FileSystem.handleMessagePort';
+    // @ts-ignore
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+export const readFile = async (uri) => {
+    return invoke('FileSystem.readFile', uri);
+};
+export const getWebViewSecret = async (key) => {
+    // @ts-ignore
+    return invoke('WebView.getSecret', key);
+};
+export const setWebViewPort = async (uid, port, origin, portType) => {
+    return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+};
+export const setFocus = (key) => {
+    return invoke('Focus.setFocus', key);
+};
+export const getFileIcon = async (options) => {
+    return invoke('IconTheme.getFileIcon', options);
+};
+export const getColorThemeNames = async () => {
+    return invoke('ColorTheme.getColorThemeNames');
+};
+export const disableExtension = async (id) => {
+    return invoke('ExtensionManagement.disable', id);
+};
+export const enableExtension = async (id) => {
+    // @ts-ignore
+    return invoke('ExtensionManagement.enable', id);
+};
+export const handleDebugChange = async (params) => {
+    // @ts-ignore
+    return invoke('Run And Debug.handleChange', params);
+};
+export const getFolderIcon = async (options) => {
+    return invoke('IconTheme.getFolderIcon', options);
+};
+export const closeWidget = async (widgetId) => {
+    return invoke('Viewlet.closeWidget', widgetId);
+};
+export const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+    const command = 'HandleMessagePort.handleMessagePort2';
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+export const sendMessagePortToSearchProcess = async (port) => {
+    await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+export const confirm = async (message, options) => {
+    // @ts-ignore
+    const result = await invoke('Confirmprompt.prompt', message, options);
+    return result;
+};
+export const getRecentlyOpened = async () => {
+    return invoke(/* RecentlyOpened.getRecentlyOpened */ 'RecentlyOpened.getRecentlyOpened');
+};
+export const getKeyBindings = async () => {
+    return invoke('KeyBindingsInitial.getKeyBindings');
+};
+export const writeClipBoardText = async (text) => {
+    await invoke('ClipBoard.writeText', /* text */ text);
+};
+export const writeClipBoardImage = async (blob) => {
+    // @ts-ignore
+    await invoke('ClipBoard.writeImage', /* text */ blob);
+};
+export const searchFileMemory = async (uri) => {
+    // @ts-ignore
+    return invoke('ExtensionHost.searchFileWithMemory', uri);
+};
+export const searchFileFetch = async (uri) => {
+    return invoke('ExtensionHost.searchFileWithFetch', uri);
+};
+export const showMessageBox = async (options) => {
+    return invoke('ElectronDialog.showMessageBox', options);
+};
+export const handleDebugResumed = async (params) => {
+    await invoke('Run And Debug.handleResumed', params);
+};
+export const openWidget = async (name) => {
+    await invoke('Viewlet.openWidget', name);
+};
+export const getIcons = async (requests) => {
+    const icons = await invoke('IconTheme.getIcons', requests);
+    return icons;
+};
+export const activateByEvent = (event) => {
+    return invoke('ExtensionHostManagement.activateByEvent', event);
+};
+export const setAdditionalFocus = (focusKey) => {
+    // @ts-ignore
+    return invoke('Focus.setAdditionalFocus', focusKey);
+};
+export const getActiveEditorId = () => {
+    // @ts-ignore
+    return invoke('GetActiveEditor.getActiveEditorId');
+};
+export const getWorkspacePath = () => {
+    return invoke('Workspace.getPath');
+};
+export const sendMessagePortToRendererProcess = async (port) => {
+    const command = 'HandleMessagePort.handleMessagePort';
+    // @ts-ignore
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, RpcId.DebugWorker);
+};
+export const getPreference = async (key) => {
+    return await invoke('Preferences.get', key);
+};
+export const getAllExtensions = async () => {
+    return invoke('ExtensionManagement.getAllExtensions');
+};
+export const rerenderEditor = async (key) => {
+    // @ts-ignore
+    return invoke('Editor.rerender', key);
+};
+export const handleDebugPaused = async (params) => {
+    await invoke('Run And Debug.handlePaused', params);
+};
+export const openUri = async (uri, focus, options) => {
+    await invoke('Main.openUri', uri, focus, options);
+};
+export const sendMessagePortToSyntaxHighlightingWorker = async (port) => {
+    await invokeAndTransfer(
+    // @ts-ignore
+    'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+export const handleDebugScriptParsed = async (script) => {
+    await invoke('Run And Debug.handleScriptParsed', script);
+};
+export const getWindowId = async () => {
+    return invoke('GetWindowId.getWindowId');
+};
+export const getBlob = async (uri) => {
+    // @ts-ignore
+    return invoke('FileSystem.getBlob', uri);
+};
+export const getExtensionCommands = async () => {
+    return invoke('ExtensionHost.getCommands');
+};
+export const showErrorDialog = async (errorInfo) => {
+    // @ts-ignore
+    await invoke('ErrorHandling.showErrorDialog', errorInfo);
+};
+export const getFolderSize = async (uri) => {
+    // @ts-ignore
+    return await invoke('FileSystem.getFolderSize', uri);
+};
+export const getExtension = async (id) => {
+    // @ts-ignore
+    return invoke('ExtensionManagement.getExtension', id);
+};
+export const getMarkdownDom = async (html) => {
+    // @ts-ignore
+    return invoke('Markdown.getVirtualDom', html);
+};
+export const renderMarkdown = async (markdown, options) => {
+    // @ts-ignore
+    return invoke('Markdown.renderMarkdown', markdown, options);
+};
+export const openNativeFolder = async (uri) => {
+    // @ts-ignore
+    await invoke('OpenNativeFolder.openNativeFolder', uri);
+};
+export const uninstallExtension = async (id) => {
+    return invoke('ExtensionManagement.uninstall', id);
+};
+export const installExtension = async (id) => {
+    // @ts-ignore
+    return invoke('ExtensionManagement.install', id);
+};
+export const openExtensionSearch = async () => {
+    // @ts-ignore
+    return invoke('SideBar.openViewlet', 'Extensions');
+};
+export const setExtensionsSearchValue = async (searchValue) => {
+    // @ts-ignore
+    return invoke('Extensions.handleInput', searchValue);
+};
+export const openExternal = async (uri) => {
+    // @ts-ignore
+    await invoke('Open.openExternal', uri);
+};
+export const openUrl = async (uri) => {
+    // @ts-ignore
+    await invoke('Open.openUrl', uri);
+};
+export const getAllPreferences = async () => {
+    // @ts-ignore
+    return invoke('Preferences.getAll');
+};
+export const showSaveFilePicker = async () => {
+    // @ts-ignore
+    return invoke('FilePicker.showSaveFilePicker');
+};
+export const getLogsDir = async () => {
+    // @ts-ignore
+    return invoke('PlatformPaths.getLogsDir');
+};

package/dist/parts/RendererWorkerApi/RendererWorkerApi.js

@@ -0,0 +1 @@
+export {};