@lvce-editor/rpc-registry 9.41.0 → 9.43.0

package/dist/parts/CreateLazyRpc/CreateLazyRpc.js

@@ -1,28 +1,71 @@
 import * as RpcRegistry from "../RpcRegistry/RpcRegistry.js";
 export const createLazyRpc = (rpcId) => {
-    let rpcPromise;
+    let activeRpc;
     let factory;
-    const createRpc = async () => {
+    let generation = 0;
+    let rpcPromise;
+    const resetListeners = new Set();
+    const createRpc = async (expectedGeneration) => {
         const rpc = await factory();
+        if (generation !== expectedGeneration) {
+            await rpc.dispose();
+            throw new Error('Lazy RPC launch was superseded');
+        }
+        activeRpc = rpc;
         RpcRegistry.set(rpcId, rpc);
+        return rpc;
     };
     const ensureRpc = async () => {
+        if (activeRpc) {
+            return activeRpc;
+        }
         if (!rpcPromise) {
-            rpcPromise = createRpc();
+            const pending = createRpc(generation);
+            rpcPromise = pending;
+            void pending.catch(() => {
+                if (rpcPromise === pending) {
+                    rpcPromise = undefined;
+                }
+            });
+        }
+        return rpcPromise;
+    };
+    const clear = async (reason, notify) => {
+        generation++;
+        const rpc = activeRpc;
+        activeRpc = undefined;
+        rpcPromise = undefined;
+        if (rpc && RpcRegistry.get(rpcId) === rpc) {
+            RpcRegistry.remove(rpcId);
+        }
+        if (notify) {
+            for (const listener of resetListeners) {
+                listener(reason);
+            }
         }
-        await rpcPromise;
+        await rpc?.dispose();
     };
     return {
+        dispose() {
+            return clear(undefined, false);
+        },
         async invoke(method, ...params) {
-            await ensureRpc();
-            const rpc = RpcRegistry.get(rpcId);
+            const rpc = await ensureRpc();
             return rpc.invoke(method, ...params);
         },
         async invokeAndTransfer(method, ...params) {
-            await ensureRpc();
-            const rpc = RpcRegistry.get(rpcId);
+            const rpc = await ensureRpc();
             return rpc.invokeAndTransfer(method, ...params);
         },
+        onDidReset(listener) {
+            resetListeners.add(listener);
+            return () => {
+                resetListeners.delete(listener);
+            };
+        },
+        reset(reason) {
+            return clear(reason, true);
+        },
         setFactory(value) {
             factory = value;
         },

package/dist/parts/FindWidgetWorker/FindWidgetWorker.d.ts

@@ -0,0 +1,6 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly any[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly any[]) => Promise<any>, onDidReset: (listener: (reason: unknown) => void) => () => void, reset: (reason?: unknown) => Promise<void>, setFactory: (value: () => Promise<import("@lvce-editor/rpc").Rpc>) => void;
+export declare const createInstance: (instanceId: string, rendererUid: number, x: number, y: number, width: number, height: number, editorUid: number) => Promise<void>;
+export declare const loadContentInstance: (instanceId: string) => Promise<void>;
+export declare const diffInstance: (instanceId: string) => Promise<readonly number[]>;
+export declare const renderInstance: (instanceId: string, diffResult: readonly number[]) => Promise<readonly (readonly any[])[]>;
+export declare const disposeInstance: (instanceId: string) => Promise<void>;

package/dist/parts/FindWidgetWorker/FindWidgetWorker.js

@@ -0,0 +1,19 @@
+import { RpcId } from '@lvce-editor/constants';
+import { createLazyRpc } from "../CreateLazyRpc/CreateLazyRpc.js";
+const rpc = createLazyRpc(RpcId.FindWidgetWorker);
+export const { dispose, invoke, invokeAndTransfer, onDidReset, reset, setFactory } = rpc;
+export const createInstance = async (instanceId, rendererUid, x, y, width, height, editorUid) => {
+    await invoke('FindWidget.createInstance', instanceId, rendererUid, x, y, width, height, editorUid);
+};
+export const loadContentInstance = async (instanceId) => {
+    await invoke('FindWidget.loadContentInstance', instanceId);
+};
+export const diffInstance = async (instanceId) => {
+    return invoke('FindWidget.diffInstance', instanceId);
+};
+export const renderInstance = async (instanceId, diffResult) => {
+    return invoke('FindWidget.renderInstance', instanceId, diffResult);
+};
+export const disposeInstance = async (instanceId) => {
+    await invoke('FindWidget.disposeInstance', instanceId);
+};

package/dist/parts/LazyRpc/LazyRpc.d.ts

@@ -1,6 +1,9 @@
 import type { Rpc } from '@lvce-editor/rpc';
 export interface LazyRpc {
+    readonly dispose: () => Promise<void>;
     readonly invoke: (method: string, ...params: readonly any[]) => Promise<any>;
     readonly invokeAndTransfer: (method: string, ...params: readonly any[]) => Promise<any>;
+    readonly onDidReset: (listener: (reason: unknown) => void) => () => void;
+    readonly reset: (reason?: unknown) => Promise<void>;
     readonly setFactory: (value: () => Promise<Rpc>) => void;
 }

package/dist/parts/Main/Main.d.ts

@@ -24,6 +24,7 @@ export * as FilePermissionProcess from '../FilePermissionProcess/FilePermissionP
 export * as FileSearchWorker from '../FileSearchWorker/FileSearchWorker.ts';
 export * as FileSystemProcess from '../FileSystemProcess/FileSystemProcess.ts';
 export * as FileSystemWorker from '../FileSystemWorker/FileSystemWorker.ts';
+export * as FindWidgetWorker from '../FindWidgetWorker/FindWidgetWorker.ts';
 export * as IconThemeWorker from '../IconThemeWorker/IconThemeWorker.ts';
 export * as IframeWorker from '../IframeWorker/IframeWorker.ts';
 export * as IpcType from '../IpcType/IpcType.ts';
@@ -55,4 +56,5 @@ export type * from '../MockRpc/MockRpc.ts';
 export type * from '../SearchResult/SearchResult.ts';
 export type * from '../Change/Change.ts';
 export type * from '../TextEdit/TextEdit.ts';
+export type * from '../WidgetLifecycleRequest/WidgetLifecycleRequest.ts';
 export type * from '../DisposableMockRpc/DisposableMockRpc.ts';

package/dist/parts/Main/Main.js

@@ -23,6 +23,7 @@ export * as FilePermissionProcess from "../FilePermissionProcess/FilePermissionP
 export * as FileSearchWorker from "../FileSearchWorker/FileSearchWorker.js";
 export * as FileSystemProcess from "../FileSystemProcess/FileSystemProcess.js";
 export * as FileSystemWorker from "../FileSystemWorker/FileSystemWorker.js";
+export * as FindWidgetWorker from "../FindWidgetWorker/FindWidgetWorker.js";
 export * as IconThemeWorker from "../IconThemeWorker/IconThemeWorker.js";
 export * as IframeWorker from "../IframeWorker/IframeWorker.js";
 export * as IpcType from "../IpcType/IpcType.js";

package/dist/parts/RendererWorker/RendererWorker.d.ts

@@ -1,4 +1,10 @@
+import type { WidgetLifecycleAttachRequest, WidgetLifecycleRemoveRequest } from '../WidgetLifecycleRequest/WidgetLifecycleRequest.ts';
 export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const allocateWidgetRendererId: () => Promise<number>;
+export declare const attachWidget: (request: WidgetLifecycleAttachRequest) => Promise<boolean>;
+export declare const removeWidget: (request: WidgetLifecycleRemoveRequest) => Promise<void>;
+export declare const removeWidgets: (requests: readonly WidgetLifecycleRemoveRequest[]) => Promise<void>;
+export declare const updateWidget: (request: WidgetLifecycleAttachRequest) => Promise<boolean>;
 export declare const searchFileHtml: (uri: string) => Promise<readonly string[]>;
 export declare const getFilePathElectron: (file: File) => Promise<string>;
 export declare const handleModifiedStatusChange: (uri: string, modified: boolean) => Promise<void>;
@@ -28,6 +34,7 @@ export declare const sendMessagePortToChatMessageParsingWorker: (port: MessagePo
 export declare const sendMessagePortToMainAreaWorker: (port: MessagePort, rpcId: number) => Promise<void>;
 export declare const sendMessagePortToTerminalProcess: (port: MessagePort, rpcId: number) => Promise<void>;
 export declare const sendMessagePortToTextSearchWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const sendMessagePortToDialogWorker: (port: MessagePort) => Promise<void>;
 export declare const sendMessagePortToAuthWorker: (port: MessagePort, rpcId: number) => Promise<void>;
 export declare const sendMessagePortToAuthProcess: (port: MessagePort, rpcId: number) => Promise<void>;
 export declare const sendMessagePortToFilePermissionProcess: (port: MessagePort, rpcId: number) => Promise<void>;

package/dist/parts/RendererWorker/RendererWorker.js

@@ -7,6 +7,21 @@ import * as ProcessExplorer from "../ProcessExplorer/ProcessExplorer.js";
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
 import * as TextMeasurementWorker from "../TextMeasurementWorker/TextMeasurementWorker.js";
 export const { dispose, invoke, invokeAndTransfer, registerMockRpc, set } = RpcFactory.create(RpcId.RendererWorker);
+export const allocateWidgetRendererId = async () => {
+    return invoke('WidgetLifecycle.allocateRendererId');
+};
+export const attachWidget = async (request) => {
+    return invoke('WidgetLifecycle.attach', request);
+};
+export const removeWidget = async (request) => {
+    await invoke('WidgetLifecycle.remove', request);
+};
+export const removeWidgets = async (requests) => {
+    await invoke('WidgetLifecycle.removeMany', requests);
+};
+export const updateWidget = async (request) => {
+    return invoke('WidgetLifecycle.update', request);
+};
 export const searchFileHtml = async (uri) => {
     return invoke('ExtensionHost.searchFileWithHtml', uri);
 };
@@ -103,6 +118,10 @@ export const sendMessagePortToTextSearchWorker = async (port, rpcId) => {
     const command = 'HandleMessagePort.handleMessagePort';
     await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextSearchWorker', port, command, rpcId);
 };
+export const sendMessagePortToDialogWorker = async (port) => {
+    const command = 'HandleMessagePort.handleMessagePort';
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToDialogWorker', port, command);
+};
 export const sendMessagePortToAuthWorker = async (port, rpcId) => {
     const command = 'HandleMessagePort.handleMessagePort';
     await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToAuthWorker', port, command, rpcId);

package/dist/parts/RendererWorkerApi/RendererWorkerApi.d.ts

@@ -1,6 +1,7 @@
 import type { BulkReplacementEdit } from '../BulkReplacementEdit/BulkReplacementEdit.ts';
 import type { ConfirmPromptOptions } from '../ConfirmPromptOptions/ConfirmPromptOptions.ts';
 import type { SearchResult } from '../SearchResult/SearchResult.ts';
+import type { WidgetLifecycleAttachRequest, WidgetLifecycleRemoveRequest } from '../WidgetLifecycleRequest/WidgetLifecycleRequest.ts';
 export interface RendererWorkerApi {
     readonly 'About.focusNext': () => Promise<void>;
     readonly 'About.focusPrevious': () => Promise<void>;
@@ -272,6 +273,11 @@ export interface RendererWorkerApi {
     readonly 'WebView.registerInterceptor': (id: number, port: MessagePort) => Promise<void>;
     readonly 'WebView.setPort': (id: number, port: MessagePort, origin: string, portType: string) => Promise<void>;
     readonly 'WebView.unregisterInterceptor': (id: number) => Promise<void>;
+    readonly 'WidgetLifecycle.allocateRendererId': () => Promise<number>;
+    readonly 'WidgetLifecycle.attach': (request: WidgetLifecycleAttachRequest) => Promise<boolean>;
+    readonly 'WidgetLifecycle.remove': (request: WidgetLifecycleRemoveRequest) => Promise<void>;
+    readonly 'WidgetLifecycle.removeMany': (requests: readonly WidgetLifecycleRemoveRequest[]) => Promise<void>;
+    readonly 'WidgetLifecycle.update': (request: WidgetLifecycleAttachRequest) => Promise<boolean>;
     readonly 'Workspace.getPath': () => Promise<string>;
     readonly 'Workspace.setPath': (uri: string) => Promise<void>;
 }

package/dist/parts/WidgetLifecycleRequest/WidgetLifecycleRequest.d.ts

@@ -0,0 +1,15 @@
+export interface WidgetLifecycleAttachRequest {
+    readonly commands: readonly (readonly any[])[];
+    readonly editorUid: number;
+    readonly instanceId: string;
+    readonly intentSequence: number;
+    readonly kind: string;
+    readonly rendererUid: number;
+}
+export interface WidgetLifecycleRemoveRequest {
+    readonly editorUid: number;
+    readonly instanceId: string;
+    readonly intentSequence: number;
+    readonly kind: string;
+    readonly rendererUid: number;
+}

package/dist/parts/WidgetLifecycleRequest/WidgetLifecycleRequest.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/rpc-registry",
-  "version": "9.41.0",
+  "version": "9.43.0",
   "description": "Rpc Registry",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
   "main": "dist/index.js",
   "dependencies": {
     "@lvce-editor/assert": "^1.5.1",
-    "@lvce-editor/constants": "^5.22.0",
+    "@lvce-editor/constants": "^5.23.0",
     "@lvce-editor/rpc": "^6.4.0"
   },
   "exports": "./dist/index.js",