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

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,55 @@ 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 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) {
@@ -96,13 +219,21 @@ 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;
+    await maybeNotifyContextChanged(uid, viewId, instance);
     return {
         dom,
         type: 'setDom',
@@ -113,19 +244,25 @@ export const dispatchViewEvent = async (uid, event) => {
     if (typeof instance.handleEvent === 'function') {
         await instance.handleEvent(event);
     }
-    return renderPatches(uid, instance);
+    const result = await renderPatches(uid, instance);
+    await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
+    return result;
 };
 export const renderViewInstance = async (uid) => {
     const instance = getVirtualDomInstance(uid);
-    return renderPatches(uid, instance);
+    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);
@@ -134,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),
@@ -149,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.34.0",
+  "version": "8.35.0",
   "description": "Tree-shakeable extension API for Lvce Editor extensions.",
   "keywords": [
     "lvce-editor",