@lvce-editor/extension-host-worker 8.40.0 → 8.42.0

package/dist/extension-api/index.js

@@ -2404,9 +2404,11 @@ var diffTree = (oldNodes, newNodes) => {
 // packages/extension-api/src/parts/ViewRegistry/ViewRegistry.ts
 var views = /* @__PURE__ */ Object.create(null);
 var instances = /* @__PURE__ */ Object.create(null);
+var instanceUidsByView = /* @__PURE__ */ Object.create(null);
 var renderedDoms = /* @__PURE__ */ Object.create(null);
 var contexts = /* @__PURE__ */ Object.create(null);
 var contextViewIds = /* @__PURE__ */ Object.create(null);
+var viewCommandDisposables = /* @__PURE__ */ Object.create(null);
 var assertBoolean = (value, message) => {
   if (value !== void 0 && typeof value !== "boolean") {
     throw new ExtensionApiError(message);
@@ -2449,6 +2451,23 @@ var assertEventListeners = (view) => {
     assertEventListener(view.id, listener, index);
   }
 };
+var assertCommands = (view) => {
+  if (view.commands === void 0) {
+    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 [id2, command] of Object.entries(view.commands)) {
+    assertString(id2, `view ${view.id} command is missing id`);
+    if (typeof command !== "function") {
+      throw new ExtensionApiError(`view ${view.id} command ${id2} must be a function`);
+    }
+  }
+};
 var assertView = (view) => {
   if (!view) {
     throw new ExtensionApiError("view is not defined");
@@ -2462,6 +2481,7 @@ var assertView = (view) => {
   if (view.id in views) {
     throw new ExtensionApiError(`view ${view.id} is already registered`);
   }
+  assertCommands(view);
   assertEventListeners(view);
 };
 var toRegisteredView = (view) => {
@@ -2482,12 +2502,62 @@ var toRegisteredView = (view) => {
   }
   return registeredView;
 };
+var getActiveViewInstance = (viewId) => {
+  const instanceUids = instanceUidsByView[viewId];
+  if (!instanceUids) {
+    return void 0;
+  }
+  const uid = [...instanceUids].at(-1);
+  if (uid === void 0) {
+    return void 0;
+  }
+  return [uid, instances[uid]];
+};
+var 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_exports.invoke("Extensions.requestViewRerender", uid);
+};
+var registerViewCommands = (view) => {
+  const disposables = [];
+  try {
+    for (const id2 of Object.keys(view.commands || {})) {
+      disposables.push(
+        registerCommand({
+          execute(...args) {
+            return executeViewCommand(view, id2, args);
+          },
+          id: id2
+        })
+      );
+    }
+  } catch (error) {
+    for (const disposable of disposables) {
+      disposable.dispose();
+    }
+    throw error;
+  }
+  return disposables;
+};
 var 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];
     }
   };
 };
@@ -2653,6 +2723,23 @@ var withFocusSelector = async (result, instance, contextChange) => {
     focusSelector
   };
 };
+var 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
+  };
+};
+var withRenderMetadata = async (result, instance, contextChange) => {
+  const resultWithFocus = await withFocusSelector(result, instance, contextChange);
+  return withTitle(resultWithFocus, instance);
+};
 var maybeClearContext = async (uid, viewId) => {
   if (!contexts[uid]) {
     return;
@@ -2684,6 +2771,9 @@ var createViewInstance = async (viewId, uid, context) => {
   });
   assertVirtualDomViewInstance(viewId, instance);
   instances[uid] = instance;
+  const instanceUids = instanceUidsByView[viewId] || /* @__PURE__ */ new Set();
+  instanceUids.add(uid);
+  instanceUidsByView[viewId] = instanceUids;
   contextViewIds[uid] = viewId;
   const dom = await renderDom(instance);
   renderedDoms[uid] = dom;
@@ -2692,22 +2782,25 @@ var createViewInstance = async (viewId, uid, context) => {
     type: "setDom"
   };
   const contextChange = await maybeNotifyContextChanged(uid, viewId, instance);
-  return withFocusSelector(result, instance, contextChange);
+  return withRenderMetadata(result, instance, contextChange);
 };
 var 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);
 };
 var 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);
 };
 var disposeViewInstance = async (uid) => {
   const instance = instances[uid];
@@ -2715,6 +2808,12 @@ var 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];
@@ -2748,7 +2847,11 @@ var getViewRegistrySnapshot = () => {
 };
 var resetViewRegistry = () => {
   for (const id2 of Object.keys(views)) {
+    for (const disposable of viewCommandDisposables[id2] || []) {
+      disposable.dispose();
+    }
     delete views[id2];
+    delete viewCommandDisposables[id2];
   }
   for (const uid of Object.keys(instances)) {
     delete instances[Number(uid)];
@@ -2762,6 +2865,9 @@ var resetViewRegistry = () => {
   for (const uid of Object.keys(contextViewIds)) {
     delete contextViewIds[Number(uid)];
   }
+  for (const viewId of Object.keys(instanceUidsByView)) {
+    delete instanceUidsByView[viewId];
+  }
 };
 
 // packages/extension-api/src/parts/ExtensionApiCommandMap/ExtensionApiCommandMap.ts

package/dist/extension-api/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 = /* @__PURE__ */ Object.create(null);
 const instances = /* @__PURE__ */ Object.create(null);
+const instanceUidsByView = /* @__PURE__ */ Object.create(null);
 const renderedDoms = /* @__PURE__ */ Object.create(null);
 const contexts = /* @__PURE__ */ Object.create(null);
 const contextViewIds = /* @__PURE__ */ Object.create(null);
+const viewCommandDisposables = /* @__PURE__ */ Object.create(null);
 const assertBoolean = (value, message) => {
   if (value !== void 0 && 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 === void 0) {
+    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,62 @@ const toRegisteredView = (view) => {
   }
   return registeredView;
 };
+const getActiveViewInstance = (viewId) => {
+  const instanceUids = instanceUidsByView[viewId];
+  if (!instanceUids) {
+    return void 0;
+  }
+  const uid = [...instanceUids].at(-1);
+  if (uid === void 0) {
+    return void 0;
+  }
+  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;
+};
 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];
     }
   };
 };
@@ -252,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;
@@ -283,6 +371,9 @@ const createViewInstance = async (viewId, uid, context) => {
   });
   assertVirtualDomViewInstance(viewId, instance);
   instances[uid] = instance;
+  const instanceUids = instanceUidsByView[viewId] || /* @__PURE__ */ new Set();
+  instanceUids.add(uid);
+  instanceUidsByView[viewId] = instanceUids;
   contextViewIds[uid] = viewId;
   const dom = await renderDom(instance);
   renderedDoms[uid] = dom;
@@ -291,22 +382,25 @@ 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);
 };
 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);
 };
 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);
 };
 const disposeViewInstance = async (uid) => {
   const instance = instances[uid];
@@ -314,6 +408,12 @@ 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];
@@ -347,7 +447,11 @@ const getViewRegistrySnapshot = () => {
 };
 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)];
@@ -361,6 +465,9 @@ const resetViewRegistry = () => {
   for (const uid of Object.keys(contextViewIds)) {
     delete contextViewIds[Number(uid)];
   }
+  for (const viewId of Object.keys(instanceUidsByView)) {
+    delete instanceUidsByView[viewId];
+  }
 };
 export {
   createViewInstance,

package/dist/extensionHostWorkerMain.js

@@ -3855,6 +3855,19 @@ const renderDom = async instance => {
   }
   return dom;
 };
+const withTitle = async (result, instance) => {
+  if (typeof instance.renderTitle !== 'function') {
+    return result;
+  }
+  const title = await instance.renderTitle();
+  if (typeof title !== 'string') {
+    throw new TypeError('view renderTitle result must be a string');
+  }
+  return {
+    ...result,
+    title
+  };
+};
 const createViewInstance = async (viewId, uid, context) => {
   const view = state$6.views[viewId];
   if (!view) {
@@ -3872,10 +3885,10 @@ const createViewInstance = async (viewId, uid, context) => {
   state$6.instances[uid] = instance;
   const dom = await renderDom(instance);
   state$6.renderedDoms[uid] = dom;
-  return {
+  return withTitle({
     dom,
     type: 'setDom'
-  };
+  }, instance);
 };
 const dispatchViewEvent = async (uid, event) => {
   const instance = getVirtualDomInstance(uid);
@@ -3886,10 +3899,10 @@ const dispatchViewEvent = async (uid, event) => {
   const newDom = await renderDom(instance);
   state$6.renderedDoms[uid] = newDom;
   const patches = diffTree(oldDom, newDom);
-  return {
+  return withTitle({
     patches,
     type: 'setPatches'
-  };
+  }, instance);
 };
 const saveViewInstanceState = async uid => {
   const instance = getVirtualDomInstance(uid);

package/extension-api/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/extension-api/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/extension-api/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>;