@lvce-editor/extension-host-worker 8.33.0 → 8.35.0

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

@@ -1,6 +1,8 @@
 import type { VirtualDomNode } from '@lvce-editor/virtual-dom-worker';
 export type ViewKind = 'virtualDom';
 export interface ViewContext {
+    readonly requestRerender: () => Promise<void>;
+    readonly showContextMenu: (menuId: string, x: number, y: number) => Promise<void>;
     readonly state?: unknown;
     readonly uid: number;
     readonly viewId: string;
@@ -9,24 +11,49 @@ export interface ViewEvent {
     readonly name?: string;
     readonly type: string;
     readonly value?: unknown;
+    readonly x?: number;
+    readonly y?: number;
+}
+export interface MenuEntry {
+    readonly args?: readonly unknown[];
+    readonly command: string;
+    readonly flags?: number;
+    readonly id: string;
+    readonly label: string;
+}
+export interface DomEventListener {
+    readonly capture?: boolean;
+    readonly name: string | number;
+    readonly params: readonly string[];
+    readonly passive?: boolean;
+    readonly preventDefault?: boolean;
+    readonly stopPropagation?: boolean;
 }
 export interface VirtualDomViewInstance {
     readonly dispose?: () => unknown;
+    readonly getContext?: () => Readonly<Record<string, boolean>>;
+    readonly getMenuEntries?: (menuId: string) => readonly MenuEntry[] | Promise<readonly MenuEntry[]>;
     readonly handleEvent?: (event: ViewEvent) => unknown;
     readonly render: () => readonly VirtualDomNode[] | Promise<readonly VirtualDomNode[]>;
     readonly saveState?: () => unknown;
 }
 export interface View {
     readonly create: (context?: ViewContext) => unknown;
+    readonly displayName?: string;
+    readonly eventListeners?: readonly DomEventListener[];
     readonly icon?: string;
     readonly id: string;
     readonly kind?: ViewKind;
+    readonly name?: string;
     readonly title?: string;
 }
 export interface RegisteredView {
+    readonly displayName?: string;
+    readonly eventListeners?: readonly DomEventListener[];
     readonly icon?: string;
     readonly id: string;
     readonly kind?: ViewKind;
+    readonly name?: string;
     readonly title?: string;
 }
 export interface ViewRegistrySnapshot {

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

@@ -1,10 +1,12 @@
 import type { Disposable } from '../Disposable/Disposable.ts';
-import type { View, ViewContext, ViewEvent, ViewRegistrySnapshot, ViewRenderResult } from '../View/View.ts';
+import type { MenuEntry, 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 renderViewInstance: (uid: number) => Promise<ViewRenderResult>;
 export declare const disposeViewInstance: (uid: number) => Promise<void>;
 export declare const saveViewInstanceState: (uid: number) => Promise<unknown>;
+export declare const getViewMenuEntries: (uid: number, menuId: string) => Promise<readonly MenuEntry[]>;
 export declare const getViewRegistrySnapshot: () => ViewRegistrySnapshot;
 export declare const resetViewRegistry: () => void;

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

@@ -1,8 +1,53 @@
+import { ExtensionManagementWorker } from '@lvce-editor/rpc-registry';
 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 contexts = Object.create(null);
+const contextViewIds = Object.create(null);
+const assertBoolean = (value, message) => {
+    if (value !== undefined && typeof value !== 'boolean') {
+        throw new ExtensionApiError(message);
+    }
+};
+const assertNumber = (value, message) => {
+    if (typeof value !== 'number') {
+        throw new ExtensionApiError(message);
+    }
+};
+const assertString = (value, message) => {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new ExtensionApiError(message);
+    }
+};
+const assertEventListener = (viewId, listener, index) => {
+    if (!listener || typeof listener !== 'object') {
+        throw new ExtensionApiError(`view ${viewId} event listener ${index} must be an object`);
+    }
+    const eventListener = listener;
+    if (typeof eventListener.name !== 'string' && typeof eventListener.name !== 'number') {
+        throw new ExtensionApiError(`view ${viewId} event listener ${index} is missing name`);
+    }
+    if (!Array.isArray(eventListener.params) || eventListener.params.some((param) => typeof param !== 'string')) {
+        throw new ExtensionApiError(`view ${viewId} event listener ${index} is missing params`);
+    }
+    assertBoolean(eventListener.capture, `view ${viewId} event listener ${index} has invalid capture`);
+    assertBoolean(eventListener.passive, `view ${viewId} event listener ${index} has invalid passive`);
+    assertBoolean(eventListener.preventDefault, `view ${viewId} event listener ${index} has invalid preventDefault`);
+    assertBoolean(eventListener.stopPropagation, `view ${viewId} event listener ${index} has invalid stopPropagation`);
+};
+const assertEventListeners = (view) => {
+    if (view.eventListeners === undefined) {
+        return;
+    }
+    if (!Array.isArray(view.eventListeners)) {
+        throw new ExtensionApiError(`view ${view.id} eventListeners must be an array`);
+    }
+    for (const [index, listener] of view.eventListeners.entries()) {
+        assertEventListener(view.id, listener, index);
+    }
+};
 const assertView = (view) => {
     if (!view) {
         throw new ExtensionApiError('view is not defined');
@@ -16,12 +61,17 @@ const assertView = (view) => {
     if (view.id in views) {
         throw new ExtensionApiError(`view ${view.id} is already registered`);
     }
+    assertEventListeners(view);
 };
 const toRegisteredView = (view) => {
+    const displayName = view.displayName || view.name || view.title;
     const registeredView = {
+        displayName,
+        ...(view.eventListeners && { eventListeners: view.eventListeners }),
         icon: view.icon,
         id: view.id,
-        title: view.title,
+        name: view.name,
+        title: displayName,
     };
     if (view.kind) {
         return {
@@ -69,6 +119,93 @@ const renderDom = async (instance) => {
     }
     return dom;
 };
+const normalizeMenuEntry = (entry, index) => {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        throw new ExtensionApiError(`menu entry ${index} must be an object`);
+    }
+    const menuEntry = entry;
+    assertString(menuEntry.id, `menu entry ${index} is missing id`);
+    assertString(menuEntry.label, `menu entry ${index} is missing label`);
+    assertString(menuEntry.command, `menu entry ${index} is missing command`);
+    if (menuEntry.flags !== undefined && typeof menuEntry.flags !== 'number') {
+        throw new ExtensionApiError(`menu entry ${index} has invalid flags`);
+    }
+    if (menuEntry.args !== undefined && !Array.isArray(menuEntry.args)) {
+        throw new ExtensionApiError(`menu entry ${index} has invalid args`);
+    }
+    return {
+        command: menuEntry.command,
+        flags: menuEntry.flags ?? 0,
+        id: menuEntry.id,
+        label: menuEntry.label,
+        ...(menuEntry.args && { args: menuEntry.args }),
+    };
+};
+const normalizeMenuEntries = (entries) => {
+    if (!Array.isArray(entries)) {
+        throw new ExtensionApiError('view menu entries must be an array');
+    }
+    return entries.map(normalizeMenuEntry);
+};
+const renderPatches = async (uid, instance) => {
+    const oldDom = renderedDoms[uid] || [];
+    const newDom = await renderDom(instance);
+    renderedDoms[uid] = newDom;
+    const patches = diffTree(oldDom, newDom);
+    return {
+        patches,
+        type: 'setPatches',
+    };
+};
+const normalizeContext = (context) => {
+    if (!context || typeof context !== 'object' || Array.isArray(context)) {
+        return {};
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(context)) {
+        if (typeof value === 'boolean') {
+            normalized[key] = value;
+        }
+    }
+    return normalized;
+};
+const isSameContext = (oldContext, newContext) => {
+    const oldKeys = Object.keys(oldContext);
+    const newKeys = Object.keys(newContext);
+    if (oldKeys.length !== newKeys.length) {
+        return false;
+    }
+    for (const key of oldKeys) {
+        if (oldContext[key] !== newContext[key]) {
+            return false;
+        }
+    }
+    return true;
+};
+const maybeNotifyContextChanged = async (uid, viewId, instance) => {
+    if (typeof instance.getContext !== 'function') {
+        return;
+    }
+    const oldContext = contexts[uid] || {};
+    const newContext = normalizeContext(instance.getContext());
+    if (isSameContext(oldContext, newContext)) {
+        return;
+    }
+    if (Object.keys(newContext).length === 0) {
+        delete contexts[uid];
+    }
+    else {
+        contexts[uid] = newContext;
+    }
+    await ExtensionManagementWorker.invoke('Extensions.handleViewContextChange', uid, viewId, newContext);
+};
+const maybeClearContext = async (uid, viewId) => {
+    if (!contexts[uid]) {
+        return;
+    }
+    delete contexts[uid];
+    await ExtensionManagementWorker.invoke('Extensions.handleViewContextChange', uid, viewId, {});
+};
 export const createViewInstance = async (viewId, uid, context) => {
     const view = views[viewId];
     if (!view) {
@@ -79,13 +216,24 @@ export const createViewInstance = async (viewId, uid, context) => {
     }
     const instance = await view.create({
         ...context,
+        requestRerender() {
+            return ExtensionManagementWorker.invoke('Extensions.requestViewRerender', uid);
+        },
+        showContextMenu(menuId, x, y) {
+            assertString(menuId, 'menuId must be a string');
+            assertNumber(x, 'x must be a number');
+            assertNumber(y, 'y must be a number');
+            return ExtensionManagementWorker.invoke('Extensions.showViewContextMenu', uid, viewId, menuId, x, y);
+        },
         uid,
         viewId,
     });
     assertVirtualDomViewInstance(viewId, instance);
     instances[uid] = instance;
+    contextViewIds[uid] = viewId;
     const dom = await renderDom(instance);
     renderedDoms[uid] = dom;
+    await maybeNotifyContextChanged(uid, viewId, instance);
     return {
         dom,
         type: 'setDom',
@@ -96,22 +244,25 @@ export const dispatchViewEvent = async (uid, event) => {
     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',
-    };
+    const result = await renderPatches(uid, instance);
+    await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
+    return result;
+};
+export const renderViewInstance = async (uid) => {
+    const instance = getVirtualDomInstance(uid);
+    const result = await renderPatches(uid, instance);
+    await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
+    return result;
 };
 export const disposeViewInstance = async (uid) => {
     const instance = instances[uid];
     if (instance && typeof instance.dispose === 'function') {
         await instance.dispose();
     }
+    await maybeClearContext(uid, contextViewIds[uid]);
     delete instances[uid];
     delete renderedDoms[uid];
+    delete contextViewIds[uid];
 };
 export const saveViewInstanceState = async (uid) => {
     const instance = getVirtualDomInstance(uid);
@@ -120,6 +271,14 @@ export const saveViewInstanceState = async (uid) => {
     }
     return instance.saveState();
 };
+export const getViewMenuEntries = async (uid, menuId) => {
+    assertString(menuId, 'menuId must be a string');
+    const instance = getVirtualDomInstance(uid);
+    if (typeof instance.getMenuEntries !== 'function') {
+        return [];
+    }
+    return normalizeMenuEntries(await instance.getMenuEntries(menuId));
+};
 export const getViewRegistrySnapshot = () => {
     return {
         views: Object.values(views).map(toRegisteredView),
@@ -135,4 +294,10 @@ export const resetViewRegistry = () => {
     for (const uid of Object.keys(renderedDoms)) {
         delete renderedDoms[Number(uid)];
     }
+    for (const uid of Object.keys(contexts)) {
+        delete contexts[Number(uid)];
+    }
+    for (const uid of Object.keys(contextViewIds)) {
+        delete contextViewIds[Number(uid)];
+    }
 };

package/extension-api/package.json

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