@lvce-editor/extension-host-worker 8.20.0 → 8.25.0

package/extension-api/dist/parts/ExtensionApiWorkerCommandMap/ExtensionApiWorkerCommandMap.d.ts

@@ -1,16 +1,23 @@
 export declare const commandMap: {
     'HandleMessagePort.handleExtensionManagementMessagePort': (port: MessagePort) => Promise<void>;
     initialize(type: string, port: MessagePort): Promise<void>;
+    'ExtensionApi.createViewInstance': (viewId: string, uid: number, context?: import("../View/View.ts").ViewContext) => Promise<import("../View/View.ts").ViewRenderResult>;
+    'ExtensionApi.dispatchViewEvent': (uid: number, event: import("../View/View.ts").ViewEvent) => Promise<import("../View/View.ts").ViewRenderResult>;
+    'ExtensionApi.disposeViewInstance': (uid: number) => Promise<void>;
     'ExtensionApi.executeCommand': (id: string, ...args: readonly unknown[]) => Promise<unknown>;
     'ExtensionApi.executeCompletionProvider': (textDocument: import("../CompletionTextDocument/CompletionTextDocument.ts").TextDocument, offset: number, ...args: readonly unknown[]) => Promise<readonly import("../CompletionItem/CompletionItem.ts").CompletionItem[]>;
     'ExtensionApi.executeDiagnosticProvider': (textDocument: import("../DiagnosticTextDocument/DiagnosticTextDocument.ts").TextDocument, ...args: readonly unknown[]) => Promise<readonly import("../DiagnosticResult/DiagnosticResult.ts").Diagnostic[]>;
     'ExtensionApi.executeFormattingProvider': (textDocument: import("../FormattingTextDocument/FormattingTextDocument.ts").TextDocument, ...args: readonly unknown[]) => Promise<readonly import("../FormattingEdit/FormattingEdit.ts").FormattingEdit[]>;
     'ExtensionApi.executeHoverProvider': (textDocument: import("../HoverTextDocument/HoverTextDocument.ts").TextDocument, offset: number, ...args: readonly unknown[]) => Promise<import("../HoverResult/HoverResult.ts").HoverResult | undefined>;
     'ExtensionApi.executeResolveCompletionItemProvider': (textDocument: import("../CompletionTextDocument/CompletionTextDocument.ts").TextDocument, offset: number, name: string, completionItem: import("../CompletionItem/CompletionItem.ts").CompletionItem, ...args: readonly unknown[]) => Promise<import("../CompletionItem/CompletionItem.ts").CompletionItem | undefined>;
+    'ExtensionApi.executeViewProvider': (id: string) => unknown;
     'ExtensionApi.getCommandRegistrySnapshot': () => import("../CommandRegistrySnapshot/CommandRegistrySnapshot.ts").CommandRegistrySnapshot;
     'ExtensionApi.getCompletionProviderRegistrySnapshot': () => import("../CompletionProviderRegistrySnapshot/CompletionProviderRegistrySnapshot.ts").CompletionProviderRegistrySnapshot;
     'ExtensionApi.getDiagnosticProviderRegistrySnapshot': () => import("../DiagnosticProviderRegistrySnapshot/DiagnosticProviderRegistrySnapshot.ts").DiagnosticProviderRegistrySnapshot;
     'ExtensionApi.getFormattingProviderRegistrySnapshot': () => import("../FormattingProviderRegistrySnapshot/FormattingProviderRegistrySnapshot.ts").FormattingProviderRegistrySnapshot;
     'ExtensionApi.getHoverProviderRegistrySnapshot': () => import("../HoverProviderRegistrySnapshot/HoverProviderRegistrySnapshot.ts").HoverProviderRegistrySnapshot;
+    'ExtensionApi.getOutputChannelRegistrySnapshot': () => import("../OutputChannelRegistrySnapshot/OutputChannelRegistrySnapshot.ts").OutputChannelRegistrySnapshot;
     'ExtensionApi.getStatusBarItems': () => readonly import("../StatusBarItem/StatusBarItem.ts").StatusBarItem[];
+    'ExtensionApi.getViewRegistrySnapshot': () => import("../View/View.ts").ViewRegistrySnapshot;
+    'ExtensionApi.saveViewInstanceState': (uid: number) => Promise<unknown>;
 };

package/extension-api/dist/parts/FormattingProviderRegistry/FormattingProviderRegistry.js

@@ -28,7 +28,10 @@ export const executeFormattingProvider = async (textDocument, ...args) => {
 export const getFormattingProviders = registry.getProviders;
 export const getFormattingProviderRegistrySnapshot = () => {
     return {
-        providers: registry.getProviders(),
+        providers: registry.getProviders().map((provider) => ({
+            id: provider.id,
+            languageId: provider.languageId,
+        })),
     };
 };
 export const resetFormattingProviderRegistry = registry.reset;

package/extension-api/dist/parts/FormattingProviderRegistrySnapshot/FormattingProviderRegistrySnapshot.d.ts

@@ -1,4 +1,6 @@
-import type { RegisteredFormattingProvider } from '../RegisteredFormattingProvider/RegisteredFormattingProvider.ts';
 export interface FormattingProviderRegistrySnapshot {
-    readonly providers: readonly RegisteredFormattingProvider[];
+    readonly providers: readonly {
+        readonly id: string;
+        readonly languageId: string;
+    }[];
 }

package/extension-api/dist/parts/HoverProviderRegistry/HoverProviderRegistry.js

@@ -50,7 +50,10 @@ export const executeHoverProvider = async (textDocument, offset, ...args) => {
 export const getHoverProviders = registry.getProviders;
 export const getHoverProviderRegistrySnapshot = () => {
     return {
-        providers: registry.getProviders(),
+        providers: registry.getProviders().map((provider) => ({
+            id: provider.id,
+            languageId: provider.languageId,
+        })),
     };
 };
 export const resetHoverProviderRegistry = registry.reset;

package/extension-api/dist/parts/HoverProviderRegistrySnapshot/HoverProviderRegistrySnapshot.d.ts

@@ -1,4 +1,6 @@
-import type { RegisteredHoverProvider } from '../RegisteredHoverProvider/RegisteredHoverProvider.ts';
 export interface HoverProviderRegistrySnapshot {
-    readonly providers: readonly RegisteredHoverProvider[];
+    readonly providers: readonly {
+        readonly id: string;
+        readonly languageId: string;
+    }[];
 }

package/extension-api/dist/parts/NotifyStatusBarChange/NotifyStatusBarChange.js

@@ -1,4 +1,4 @@
-import * as Rpc from "../Rpc/Rpc.js";
+import { ExtensionManagementWorker } from '@lvce-editor/rpc-registry';
 export const notifyStatusBarChange = async (id) => {
-    await Rpc.invoke('StatusBar.handleChange', id);
+    await ExtensionManagementWorker.invoke('StatusBar.handleChange', id);
 };

package/extension-api/dist/parts/OutputChannel/OutputChannel.d.ts

@@ -0,0 +1,9 @@
+import type { OutputChannel } from '../OutputChannelHandle/OutputChannelHandle.ts';
+import type { OutputChannelRegistrySnapshot } from '../OutputChannelRegistrySnapshot/OutputChannelRegistrySnapshot.ts';
+export declare const activateOutputChannels: () => void;
+export declare const createOutputChannel: (id: string) => OutputChannel;
+export declare const getOutputChannelRegistrySnapshot: () => OutputChannelRegistrySnapshot;
+export declare const resetOutputChannelRegistry: () => void;
+export type { OutputChannel } from '../OutputChannelHandle/OutputChannelHandle.ts';
+export type { OutputChannelRegistrySnapshot } from '../OutputChannelRegistrySnapshot/OutputChannelRegistrySnapshot.ts';
+export type { RegisteredOutputChannel } from '../RegisteredOutputChannel/RegisteredOutputChannel.ts';

package/extension-api/dist/parts/OutputChannel/OutputChannel.js

@@ -0,0 +1,64 @@
+import { ExtensionManagementWorker } from '@lvce-editor/rpc-registry';
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const outputChannels = Object.create(null);
+let isActivated = false;
+const RE_DASH_CASE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const assertOutputChannelId = (id) => {
+    if (typeof id !== 'string' || id.length === 0) {
+        throw new ExtensionApiError('output channel id is required');
+    }
+    if (!RE_DASH_CASE.test(id)) {
+        throw new ExtensionApiError(`output channel id ${id} must be dash-case`);
+    }
+};
+const assertCanWrite = (id) => {
+    if (!isActivated) {
+        throw new ExtensionApiError(`output channel ${id} cannot be written before activate`);
+    }
+};
+class ExtensionOutputChannel {
+    #id;
+    constructor(id) {
+        this.#id = id;
+    }
+    async append(text) {
+        assertCanWrite(this.#id);
+        await ExtensionManagementWorker.invoke('ExtensionApi.appendOutputChannel', this.#id, text);
+    }
+    async appendLine(text) {
+        assertCanWrite(this.#id);
+        await ExtensionManagementWorker.invoke('ExtensionApi.appendOutputChannel', this.#id, `${text}\n`);
+    }
+    async clear() {
+        assertCanWrite(this.#id);
+        await ExtensionManagementWorker.invoke('ExtensionApi.clearOutputChannel', this.#id);
+    }
+    async replace(text) {
+        assertCanWrite(this.#id);
+        await ExtensionManagementWorker.invoke('ExtensionApi.replaceOutputChannel', this.#id, text);
+    }
+}
+export const activateOutputChannels = () => {
+    isActivated = true;
+};
+export const createOutputChannel = (id) => {
+    assertOutputChannelId(id);
+    if (id in outputChannels) {
+        throw new ExtensionApiError(`output channel ${id} is already created`);
+    }
+    outputChannels[id] = {
+        id,
+    };
+    return new ExtensionOutputChannel(id);
+};
+export const getOutputChannelRegistrySnapshot = () => {
+    return {
+        outputChannels: Object.values(outputChannels),
+    };
+};
+export const resetOutputChannelRegistry = () => {
+    for (const id of Object.keys(outputChannels)) {
+        delete outputChannels[id];
+    }
+    isActivated = false;
+};

package/extension-api/dist/parts/OutputChannelHandle/OutputChannelHandle.d.ts

@@ -0,0 +1,6 @@
+export interface OutputChannel {
+    append(text: string): Promise<void>;
+    appendLine(text: string): Promise<void>;
+    clear(): Promise<void>;
+    replace(text: string): Promise<void>;
+}

package/extension-api/dist/parts/OutputChannelHandle/OutputChannelHandle.js

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

package/extension-api/dist/parts/OutputChannelRegistrySnapshot/OutputChannelRegistrySnapshot.d.ts

@@ -0,0 +1,4 @@
+import type { RegisteredOutputChannel } from '../RegisteredOutputChannel/RegisteredOutputChannel.ts';
+export interface OutputChannelRegistrySnapshot {
+    readonly outputChannels: readonly RegisteredOutputChannel[];
+}

package/extension-api/dist/parts/OutputChannelRegistrySnapshot/OutputChannelRegistrySnapshot.js

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

package/extension-api/dist/parts/QuickPick/QuickPick.js

@@ -1,4 +1,4 @@
-import * as Rpc from "../Rpc/Rpc.js";
+import { ExtensionManagementWorker } from '@lvce-editor/rpc-registry';
 export const showQuickPick = async (options) => {
-    return Rpc.invoke('ExtensionHostQuickPick.showQuickPick', options);
+    return ExtensionManagementWorker.invoke('ExtensionHostQuickPick.showQuickPick', options);
 };

package/extension-api/dist/parts/RegisteredOutputChannel/RegisteredOutputChannel.d.ts

@@ -0,0 +1,3 @@
+export interface RegisteredOutputChannel {
+    readonly id: string;
+}

package/extension-api/dist/parts/RegisteredOutputChannel/RegisteredOutputChannel.js

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

package/extension-api/dist/parts/StatusBarItemProviderRegistry/StatusBarItemProviderRegistry.js

@@ -38,7 +38,9 @@ export const getStatusBarItems = () => {
 };
 export const getStatusBarItemProviderRegistrySnapshot = () => {
     return {
-        providers: registry.getProviders(),
+        providers: registry.getProviders().map((provider) => ({
+            id: provider.id,
+        })),
     };
 };
 export const resetStatusBarItemProviderRegistry = registry.reset;

package/extension-api/dist/parts/StatusBarItemProviderRegistrySnapshot/StatusBarItemProviderRegistrySnapshot.d.ts

@@ -1,4 +1,5 @@
-import type { RegisteredStatusBarItemProvider } from '../RegisteredStatusBarItemProvider/RegisteredStatusBarItemProvider.ts';
 export interface StatusBarItemProviderRegistrySnapshot {
-    readonly providers: readonly RegisteredStatusBarItemProvider[];
+    readonly providers: readonly {
+        readonly id: string;
+    }[];
 }

package/extension-api/dist/parts/View/View.d.ts

@@ -0,0 +1,43 @@
+import type { VirtualDomNode } from '@lvce-editor/virtual-dom-worker';
+export type ViewKind = 'virtualDom';
+export interface ViewContext {
+    readonly state?: unknown;
+    readonly uid: number;
+    readonly viewId: string;
+}
+export interface ViewEvent {
+    readonly name?: string;
+    readonly type: string;
+    readonly value?: unknown;
+}
+export interface VirtualDomViewInstance {
+    readonly dispose?: () => unknown;
+    readonly handleEvent?: (event: ViewEvent) => unknown;
+    readonly render: () => readonly VirtualDomNode[] | Promise<readonly VirtualDomNode[]>;
+    readonly saveState?: () => unknown;
+}
+export interface View {
+    readonly create: (context?: ViewContext) => unknown;
+    readonly icon?: string;
+    readonly id: string;
+    readonly kind?: ViewKind;
+    readonly title?: string;
+}
+export interface RegisteredView {
+    readonly icon?: string;
+    readonly id: string;
+    readonly kind?: ViewKind;
+    readonly title?: string;
+}
+export interface ViewRegistrySnapshot {
+    readonly views: readonly RegisteredView[];
+}
+export interface ViewRenderResultDom {
+    readonly dom: readonly VirtualDomNode[];
+    readonly type: 'setDom';
+}
+export interface ViewRenderResultPatches {
+    readonly patches: readonly unknown[];
+    readonly type: 'setPatches';
+}
+export type ViewRenderResult = ViewRenderResultDom | ViewRenderResultPatches;

package/extension-api/dist/parts/View/View.js

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

package/extension-api/dist/parts/ViewRegistry/ViewRegistry.d.ts

@@ -0,0 +1,10 @@
+import type { Disposable } from '../Disposable/Disposable.ts';
+import type { View, ViewContext, ViewEvent, ViewRegistrySnapshot, ViewRenderResult } from '../View/View.ts';
+export declare const registerView: (view: View) => Disposable;
+export declare const executeViewProvider: (id: string) => unknown;
+export declare const createViewInstance: (viewId: string, uid: number, context?: ViewContext) => Promise<ViewRenderResult>;
+export declare const dispatchViewEvent: (uid: number, event: ViewEvent) => Promise<ViewRenderResult>;
+export declare const disposeViewInstance: (uid: number) => Promise<void>;
+export declare const saveViewInstanceState: (uid: number) => Promise<unknown>;
+export declare const getViewRegistrySnapshot: () => ViewRegistrySnapshot;
+export declare const resetViewRegistry: () => void;

package/extension-api/dist/parts/ViewRegistry/ViewRegistry.js

@@ -0,0 +1,138 @@
+import { diffTree } from '@lvce-editor/virtual-dom-worker';
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const views = Object.create(null);
+const instances = Object.create(null);
+const renderedDoms = Object.create(null);
+const assertView = (view) => {
+    if (!view) {
+        throw new ExtensionApiError('view is not defined');
+    }
+    if (typeof view.id !== 'string' || view.id.length === 0) {
+        throw new ExtensionApiError('view is missing id');
+    }
+    if (typeof view.create !== 'function') {
+        throw new ExtensionApiError(`view ${view.id} is missing create function`);
+    }
+    if (view.id in views) {
+        throw new ExtensionApiError(`view ${view.id} is already registered`);
+    }
+};
+const toRegisteredView = (view) => {
+    const registeredView = {
+        icon: view.icon,
+        id: view.id,
+        title: view.title,
+    };
+    if (view.kind) {
+        return {
+            ...registeredView,
+            kind: view.kind,
+        };
+    }
+    return registeredView;
+};
+export const registerView = (view) => {
+    assertView(view);
+    views[view.id] = view;
+    return {
+        dispose() {
+            delete views[view.id];
+        },
+    };
+};
+export const executeViewProvider = (id) => {
+    const view = views[id];
+    if (!view) {
+        throw new ExtensionApiError(`view ${id} not found`);
+    }
+    return view.create();
+};
+const assertVirtualDomViewInstance = (id, instance) => {
+    if (!instance || typeof instance !== 'object') {
+        throw new ExtensionApiError(`view ${id} did not return a view instance`);
+    }
+    if (typeof instance.render !== 'function') {
+        throw new ExtensionApiError(`view ${id} instance is missing render function`);
+    }
+};
+const getVirtualDomInstance = (uid) => {
+    const instance = instances[uid];
+    if (!instance) {
+        throw new ExtensionApiError(`view instance ${uid} not found`);
+    }
+    return instance;
+};
+const renderDom = async (instance) => {
+    const dom = await instance.render();
+    if (!Array.isArray(dom)) {
+        throw new ExtensionApiError('view render result must be an array');
+    }
+    return dom;
+};
+export const createViewInstance = async (viewId, uid, context) => {
+    const view = views[viewId];
+    if (!view) {
+        throw new ExtensionApiError(`view ${viewId} not found`);
+    }
+    if (view.kind !== 'virtualDom') {
+        throw new ExtensionApiError(`view ${viewId} is not a virtual dom view`);
+    }
+    const instance = await view.create({
+        ...context,
+        uid,
+        viewId,
+    });
+    assertVirtualDomViewInstance(viewId, instance);
+    instances[uid] = instance;
+    const dom = await renderDom(instance);
+    renderedDoms[uid] = dom;
+    return {
+        dom,
+        type: 'setDom',
+    };
+};
+export const dispatchViewEvent = async (uid, event) => {
+    const instance = getVirtualDomInstance(uid);
+    if (typeof instance.handleEvent === 'function') {
+        await instance.handleEvent(event);
+    }
+    const oldDom = renderedDoms[uid] || [];
+    const newDom = await renderDom(instance);
+    renderedDoms[uid] = newDom;
+    const patches = diffTree(oldDom, newDom);
+    return {
+        patches,
+        type: 'setPatches',
+    };
+};
+export const disposeViewInstance = async (uid) => {
+    const instance = instances[uid];
+    if (instance && typeof instance.dispose === 'function') {
+        await instance.dispose();
+    }
+    delete instances[uid];
+    delete renderedDoms[uid];
+};
+export const saveViewInstanceState = async (uid) => {
+    const instance = getVirtualDomInstance(uid);
+    if (typeof instance.saveState !== 'function') {
+        return undefined;
+    }
+    return instance.saveState();
+};
+export const getViewRegistrySnapshot = () => {
+    return {
+        views: Object.values(views).map(toRegisteredView),
+    };
+};
+export const resetViewRegistry = () => {
+    for (const id of Object.keys(views)) {
+        delete views[id];
+    }
+    for (const uid of Object.keys(instances)) {
+        delete instances[Number(uid)];
+    }
+    for (const uid of Object.keys(renderedDoms)) {
+        delete renderedDoms[Number(uid)];
+    }
+};

package/extension-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/api",
-  "version": "8.20.0",
+  "version": "8.25.0",
   "description": "Tree-shakeable extension API for Lvce Editor extensions.",
   "keywords": [
     "lvce-editor",
@@ -27,6 +27,8 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@lvce-editor/rpc": "^6.4.0"
+    "@lvce-editor/rpc": "^6.4.0",
+    "@lvce-editor/rpc-registry": "^9.24.0",
+    "@lvce-editor/virtual-dom-worker": "^10.0.0"
   }
 }