@lvce-editor/extension-host-worker 8.34.0 → 8.36.0

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

@@ -2,6 +2,7 @@ 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;
@@ -10,16 +11,37 @@ 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 renderFocus?: (oldContext: Readonly<Record<string, boolean>>, newContext: Readonly<Record<string, boolean>>) => string | Promise<string>;
     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;
@@ -28,6 +50,7 @@ export interface View {
 }
 export interface RegisteredView {
     readonly displayName?: string;
+    readonly eventListeners?: readonly DomEventListener[];
     readonly icon?: string;
     readonly id: string;
     readonly kind?: ViewKind;
@@ -39,9 +62,11 @@ export interface ViewRegistrySnapshot {
 }
 export interface ViewRenderResultDom {
     readonly dom: readonly VirtualDomNode[];
+    readonly focusSelector?: string;
     readonly type: 'setDom';
 }
 export interface ViewRenderResultPatches {
+    readonly focusSelector?: string;
     readonly patches: readonly unknown[];
     readonly type: 'setPatches';
 }

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

@@ -1,5 +1,5 @@
 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>;
@@ -7,5 +7,6 @@ export declare const dispatchViewEvent: (uid: number, event: ViewEvent) => Promi
 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

@@ -4,6 +4,50 @@ 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');
@@ -17,11 +61,13 @@ 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,
         name: view.name,
@@ -73,6 +119,34 @@ 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);
@@ -83,6 +157,89 @@ const renderPatches = async (uid, instance) => {
         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 unchangedContext = {
+    changed: false,
+    newContext: {},
+    oldContext: {},
+};
+const maybeNotifyContextChanged = async (uid, viewId, instance) => {
+    if (typeof instance.getContext !== 'function') {
+        return unchangedContext;
+    }
+    const oldContext = contexts[uid] || {};
+    const newContext = normalizeContext(instance.getContext());
+    if (isSameContext(oldContext, newContext)) {
+        return {
+            changed: false,
+            newContext,
+            oldContext,
+        };
+    }
+    if (Object.keys(newContext).length === 0) {
+        delete contexts[uid];
+    }
+    else {
+        contexts[uid] = newContext;
+    }
+    await ExtensionManagementWorker.invoke('Extensions.handleViewContextChange', uid, viewId, newContext);
+    return {
+        changed: true,
+        newContext,
+        oldContext,
+    };
+};
+const renderFocus = async (instance, contextChange) => {
+    if (!contextChange.changed || typeof instance.renderFocus !== 'function') {
+        return '';
+    }
+    const focusSelector = await instance.renderFocus(contextChange.oldContext, contextChange.newContext);
+    if (typeof focusSelector !== 'string') {
+        throw new ExtensionApiError('view renderFocus result must be a string');
+    }
+    return focusSelector;
+};
+const withFocusSelector = async (result, instance, contextChange) => {
+    const focusSelector = await renderFocus(instance, contextChange);
+    if (!focusSelector) {
+        return result;
+    }
+    return {
+        ...result,
+        focusSelector,
+    };
+};
+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) {
@@ -96,36 +253,51 @@ export const createViewInstance = async (viewId, uid, 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;
-    return {
+    const result = {
         dom,
         type: 'setDom',
     };
+    const contextChange = await maybeNotifyContextChanged(uid, viewId, instance);
+    return withFocusSelector(result, instance, contextChange);
 };
 export const dispatchViewEvent = async (uid, event) => {
     const instance = getVirtualDomInstance(uid);
     if (typeof instance.handleEvent === 'function') {
         await instance.handleEvent(event);
     }
-    return renderPatches(uid, instance);
+    const result = await renderPatches(uid, instance);
+    const contextChange = await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
+    return withFocusSelector(result, instance, contextChange);
 };
 export const renderViewInstance = async (uid) => {
     const instance = getVirtualDomInstance(uid);
-    return renderPatches(uid, instance);
+    const result = await renderPatches(uid, instance);
+    const contextChange = await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
+    return withFocusSelector(result, instance, contextChange);
 };
 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);
@@ -134,6 +306,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),
@@ -149,4 +329,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.34.0",
+  "version": "8.36.0",
   "description": "Tree-shakeable extension API for Lvce Editor extensions.",
   "keywords": [
     "lvce-editor",