@lvce-editor/api 8.40.0 → 8.42.0

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export { executeSourceControlAcceptInput, executeSourceControlAdd, executeSource
 export { createViewInstance, dispatchViewEvent, disposeViewInstance, executeViewProvider, getViewRegistrySnapshot, renderViewInstance, registerView, resetViewRegistry, saveViewInstanceState, } from './parts/ViewRegistry/ViewRegistry.ts';
 export { createOutputChannel, getOutputChannelRegistrySnapshot, resetOutputChannelRegistry } from './parts/OutputChannel/OutputChannel.ts';
 export { getStatusBarItemProviderRegistrySnapshot, registerStatusBarItemProvider, resetStatusBarItemProviderRegistry, } from './parts/StatusBar/StatusBar.ts';
-export type { RegisteredView, View, ViewAction, ViewContext, ViewEvent, ViewKind, MenuEntry, ViewRegistrySnapshot, ViewRenderResult, VirtualDomViewInstance, } from './parts/View/View.ts';
+export type { RegisteredView, View, ViewAction, ViewCommand, ViewContext, ViewEvent, ViewKind, MenuEntry, ViewRegistrySnapshot, ViewRenderResult, VirtualDomViewInstance, } from './parts/View/View.ts';
 export { handleExtensionManagementMessagePort } from './parts/HandleExtensionManagementMessagePort/HandleExtensionManagementMessagePort.ts';
 export type { Command } from './parts/Command/Command.ts';
 export type { CommandCallback } from './parts/CommandCallback/CommandCallback.ts';

package/dist/parts/View/View.d.ts

@@ -42,10 +42,13 @@ export interface VirtualDomViewInstance {
     readonly render: () => readonly VirtualDomNode[] | Promise<readonly VirtualDomNode[]>;
     readonly renderActions?: () => readonly ViewAction[] | Promise<readonly ViewAction[]>;
     readonly renderFocus?: (oldContext: Readonly<Record<string, boolean>>, newContext: Readonly<Record<string, boolean>>) => string | Promise<string>;
+    readonly renderTitle?: () => string | Promise<string>;
     readonly saveState?: () => unknown;
 }
-export interface View {
-    readonly create: (context?: ViewContext) => unknown;
+export type ViewCommand<State = VirtualDomViewInstance, Args extends readonly any[] = readonly any[]> = (state: State, ...args: Args) => State | Promise<State>;
+export interface View<State = unknown> {
+    readonly commands?: Readonly<Record<string, ViewCommand<State>>>;
+    readonly create: (context?: ViewContext) => State | Promise<State>;
     readonly displayName?: string;
     readonly eventListeners?: readonly DomEventListener[];
     readonly icon?: string;
@@ -69,11 +72,13 @@ export interface ViewRegistrySnapshot {
 export interface ViewRenderResultDom {
     readonly dom: readonly VirtualDomNode[];
     readonly focusSelector?: string;
+    readonly title?: string;
     readonly type: 'setDom';
 }
 export interface ViewRenderResultPatches {
     readonly focusSelector?: string;
     readonly patches: readonly unknown[];
+    readonly title?: string;
     readonly type: 'setPatches';
 }
 export type ViewRenderResult = ViewRenderResultDom | ViewRenderResultPatches;

package/dist/parts/ViewRegistry/ViewRegistry.d.ts

@@ -1,6 +1,6 @@
 import type { Disposable } from '../Disposable/Disposable.ts';
 import type { MenuEntry, View, ViewAction, ViewContext, ViewEvent, ViewRegistrySnapshot, ViewRenderResult } from '../View/View.ts';
-export declare const registerView: (view: View) => Disposable;
+export declare const registerView: <State>(view: View<State>) => 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>;

package/dist/parts/ViewRegistry/ViewRegistry.js

@@ -1,11 +1,14 @@
 import { ExtensionManagementWorker } from '@lvce-editor/rpc-registry';
 import { diffTree } from '@lvce-editor/virtual-dom-worker';
+import { registerCommand } from "../CommandRegistry/CommandRegistry.js";
 import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
 const views = Object.create(null);
 const instances = Object.create(null);
+const instanceUidsByView = Object.create(null);
 const renderedDoms = Object.create(null);
 const contexts = Object.create(null);
 const contextViewIds = Object.create(null);
+const viewCommandDisposables = Object.create(null);
 const assertBoolean = (value, message) => {
     if (value !== undefined && typeof value !== 'boolean') {
         throw new ExtensionApiError(message);
@@ -48,6 +51,23 @@ const assertEventListeners = (view) => {
         assertEventListener(view.id, listener, index);
     }
 };
+const assertCommands = (view) => {
+    if (view.commands === undefined) {
+        return;
+    }
+    if (view.kind !== 'virtualDom') {
+        throw new ExtensionApiError(`view ${view.id} commands require virtualDom kind`);
+    }
+    if (!view.commands || typeof view.commands !== 'object' || Array.isArray(view.commands)) {
+        throw new ExtensionApiError(`view ${view.id} commands must be an object`);
+    }
+    for (const [id, command] of Object.entries(view.commands)) {
+        assertString(id, `view ${view.id} command is missing id`);
+        if (typeof command !== 'function') {
+            throw new ExtensionApiError(`view ${view.id} command ${id} must be a function`);
+        }
+    }
+};
 const assertView = (view) => {
     if (!view) {
         throw new ExtensionApiError('view is not defined');
@@ -61,6 +81,7 @@ const assertView = (view) => {
     if (view.id in views) {
         throw new ExtensionApiError(`view ${view.id} is already registered`);
     }
+    assertCommands(view);
     assertEventListeners(view);
 };
 const toRegisteredView = (view) => {
@@ -81,12 +102,61 @@ const toRegisteredView = (view) => {
     }
     return registeredView;
 };
+const getActiveViewInstance = (viewId) => {
+    const instanceUids = instanceUidsByView[viewId];
+    if (!instanceUids) {
+        return undefined;
+    }
+    const uid = [...instanceUids].at(-1);
+    if (uid === undefined) {
+        return undefined;
+    }
+    return [uid, instances[uid]];
+};
+const executeViewCommand = async (view, commandId, args) => {
+    const activeInstance = getActiveViewInstance(view.id);
+    if (!activeInstance) {
+        return;
+    }
+    const [uid, instance] = activeInstance;
+    const command = view.commands[commandId];
+    const newInstance = await command(instance, ...args);
+    assertVirtualDomViewInstance(view.id, newInstance);
+    instances[uid] = newInstance;
+    await ExtensionManagementWorker.invoke('Extensions.requestViewRerender', uid);
+};
+const registerViewCommands = (view) => {
+    const disposables = [];
+    try {
+        for (const id of Object.keys(view.commands || {})) {
+            disposables.push(registerCommand({
+                execute(...args) {
+                    return executeViewCommand(view, id, args);
+                },
+                id,
+            }));
+        }
+    }
+    catch (error) {
+        for (const disposable of disposables) {
+            disposable.dispose();
+        }
+        throw error;
+    }
+    return disposables;
+};
 export const registerView = (view) => {
     assertView(view);
+    const commandDisposables = registerViewCommands(view);
     views[view.id] = view;
+    viewCommandDisposables[view.id] = commandDisposables;
     return {
         dispose() {
+            for (const disposable of commandDisposables) {
+                disposable.dispose();
+            }
             delete views[view.id];
+            delete viewCommandDisposables[view.id];
         },
     };
 };
@@ -253,6 +323,23 @@ const withFocusSelector = async (result, instance, contextChange) => {
         focusSelector,
     };
 };
+const withTitle = async (result, instance) => {
+    if (typeof instance.renderTitle !== 'function') {
+        return result;
+    }
+    const title = await instance.renderTitle();
+    if (typeof title !== 'string') {
+        throw new ExtensionApiError('view renderTitle result must be a string');
+    }
+    return {
+        ...result,
+        title,
+    };
+};
+const withRenderMetadata = async (result, instance, contextChange) => {
+    const resultWithFocus = await withFocusSelector(result, instance, contextChange);
+    return withTitle(resultWithFocus, instance);
+};
 const maybeClearContext = async (uid, viewId) => {
     if (!contexts[uid]) {
         return;
@@ -284,6 +371,9 @@ export const createViewInstance = async (viewId, uid, context) => {
     });
     assertVirtualDomViewInstance(viewId, instance);
     instances[uid] = instance;
+    const instanceUids = instanceUidsByView[viewId] || new Set();
+    instanceUids.add(uid);
+    instanceUidsByView[viewId] = instanceUids;
     contextViewIds[uid] = viewId;
     const dom = await renderDom(instance);
     renderedDoms[uid] = dom;
@@ -292,22 +382,25 @@ export const createViewInstance = async (viewId, uid, context) => {
         type: 'setDom',
     };
     const contextChange = await maybeNotifyContextChanged(uid, viewId, instance);
-    return withFocusSelector(result, instance, contextChange);
+    return withRenderMetadata(result, instance, contextChange);
 };
 export const dispatchViewEvent = async (uid, event) => {
     const instance = getVirtualDomInstance(uid);
+    const instanceUids = instanceUidsByView[contextViewIds[uid]];
+    instanceUids.delete(uid);
+    instanceUids.add(uid);
     if (typeof instance.handleEvent === 'function') {
         await instance.handleEvent(event);
     }
     const result = await renderPatches(uid, instance);
     const contextChange = await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
-    return withFocusSelector(result, instance, contextChange);
+    return withRenderMetadata(result, instance, contextChange);
 };
 export const renderViewInstance = async (uid) => {
     const instance = getVirtualDomInstance(uid);
     const result = await renderPatches(uid, instance);
     const contextChange = await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
-    return withFocusSelector(result, instance, contextChange);
+    return withRenderMetadata(result, instance, contextChange);
 };
 export const disposeViewInstance = async (uid) => {
     const instance = instances[uid];
@@ -315,6 +408,12 @@ export const disposeViewInstance = async (uid) => {
         await instance.dispose();
     }
     await maybeClearContext(uid, contextViewIds[uid]);
+    const viewId = contextViewIds[uid];
+    const instanceUids = instanceUidsByView[viewId];
+    instanceUids?.delete(uid);
+    if (instanceUids?.size === 0) {
+        delete instanceUidsByView[viewId];
+    }
     delete instances[uid];
     delete renderedDoms[uid];
     delete contextViewIds[uid];
@@ -348,7 +447,11 @@ export const getViewRegistrySnapshot = () => {
 };
 export const resetViewRegistry = () => {
     for (const id of Object.keys(views)) {
+        for (const disposable of viewCommandDisposables[id] || []) {
+            disposable.dispose();
+        }
         delete views[id];
+        delete viewCommandDisposables[id];
     }
     for (const uid of Object.keys(instances)) {
         delete instances[Number(uid)];
@@ -362,4 +465,7 @@ export const resetViewRegistry = () => {
     for (const uid of Object.keys(contextViewIds)) {
         delete contextViewIds[Number(uid)];
     }
+    for (const viewId of Object.keys(instanceUidsByView)) {
+        delete instanceUidsByView[viewId];
+    }
 };

package/package.json

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