@lvce-editor/extension-host-worker 8.20.0 → 8.25.0

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

@@ -1,12 +1,14 @@
+import { ExtensionManagementWorker } from "@lvce-editor/rpc-registry";
 import { listen } from "../ExtensionApiWorkerListen/ExtensionApiWorkerListen.js";
-import * as Rpc from "../Rpc/Rpc.js";
+import { activateOutputChannels } from "../OutputChannel/OutputChannel.js";
 let rpcPromise;
 const activate = async () => {
   if (!rpcPromise) {
     rpcPromise = listen();
   }
   const rpc = await rpcPromise;
-  Rpc.set(rpc);
+  ExtensionManagementWorker.set(rpc);
+  activateOutputChannels();
 };
 export {
   activate

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

@@ -30,7 +30,9 @@ const registerCommand = (command) => {
 };
 const getCommandRegistrySnapshot = () => {
   return {
-    commands: Object.values(commands)
+    commands: Object.values(commands).map((command) => ({
+      id: command.id
+    }))
   };
 };
 const executeCommand = async (id, ...args) => {

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

@@ -9,16 +9,40 @@ const getType = (value) => {
   }
   return typeof value;
 };
+const sanitizeCompletionItem = (item) => {
+  const sanitizedItem = {};
+  for (const [key, value] of Object.entries(item)) {
+    if (typeof value !== "function") {
+      sanitizedItem[key] = value;
+    }
+  }
+  const { kind: itemKind, type } = item;
+  let kind = 0;
+  if (typeof itemKind === "number") {
+    kind = itemKind;
+  } else if (typeof type === "number") {
+    kind = type;
+  }
+  return {
+    ...sanitizedItem,
+    flags: typeof item.flags === "number" ? item.flags : 0,
+    kind,
+    label: typeof item.label === "string" ? item.label : "",
+    matches: Array.isArray(item.matches) ? item.matches : []
+  };
+};
 const validateCompletionResult = (completion) => {
   if (!Array.isArray(completion)) {
     throw new ExtensionApiError(`invalid completion result: completion must be of type array but is ${getType(completion)}`);
   }
+  const completionItems = [];
   for (const item of completion) {
     if (!item || typeof item !== "object" || Array.isArray(item)) {
       throw new ExtensionApiError(`invalid completion result: expected completion item to be of type object but was of type ${getType(item)}`);
     }
+    completionItems.push(sanitizeCompletionItem(item));
   }
-  return completion;
+  return completionItems;
 };
 const registry = createProviderRegistry({
   mapProvider(provider) {
@@ -63,7 +87,10 @@ const executeResolveCompletionItemProvider = async (textDocument, offset, name,
 const getCompletionProviders = registry.getProviders;
 const getCompletionProviderRegistrySnapshot = () => {
   return {
-    providers: registry.getProviders()
+    providers: registry.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 const resetCompletionProviderRegistry = registry.reset;

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

@@ -52,7 +52,10 @@ const executeDiagnosticProvider = async (textDocument, ...args) => {
 const getDiagnosticProviders = registry.getProviders;
 const getDiagnosticProviderRegistrySnapshot = () => {
   return {
-    providers: registry.getProviders()
+    providers: registry.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 const resetDiagnosticProviderRegistry = registry.reset;

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

@@ -1,6 +1,6 @@
-import * as Rpc from "../Rpc/Rpc.js";
+import { ExtensionManagementWorker } from "@lvce-editor/rpc-registry";
 const executeCommand = async (id, ...args) => {
-  return Rpc.invoke("Extensions.executeCommand", id, ...args);
+  return ExtensionManagementWorker.invoke("Extensions.executeCommand", id, ...args);
 };
 export {
   executeCommand

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

@@ -4,19 +4,35 @@ import { executeDiagnosticProvider, getDiagnosticProviderRegistrySnapshot } from
 import { executeFormattingProvider, getFormattingProviderRegistrySnapshot } from "../Formatting/Formatting.js";
 import { getStatusBarItems } from "../GetStatusBarItems/GetStatusBarItems.js";
 import { executeHoverProvider, getHoverProviderRegistrySnapshot } from "../Hover/Hover.js";
+import { getOutputChannelRegistrySnapshot } from "../OutputChannel/OutputChannel.js";
+import {
+  createViewInstance,
+  dispatchViewEvent,
+  disposeViewInstance,
+  executeViewProvider,
+  getViewRegistrySnapshot,
+  saveViewInstanceState
+} from "../ViewRegistry/ViewRegistry.js";
 const commandMap = {
+  "ExtensionApi.createViewInstance": createViewInstance,
+  "ExtensionApi.dispatchViewEvent": dispatchViewEvent,
+  "ExtensionApi.disposeViewInstance": disposeViewInstance,
   "ExtensionApi.executeCommand": executeCommand,
   "ExtensionApi.executeCompletionProvider": executeCompletionProvider,
   "ExtensionApi.executeDiagnosticProvider": executeDiagnosticProvider,
   "ExtensionApi.executeFormattingProvider": executeFormattingProvider,
   "ExtensionApi.executeHoverProvider": executeHoverProvider,
   "ExtensionApi.executeResolveCompletionItemProvider": executeResolveCompletionItemProvider,
+  "ExtensionApi.executeViewProvider": executeViewProvider,
   "ExtensionApi.getCommandRegistrySnapshot": getCommandRegistrySnapshot,
   "ExtensionApi.getCompletionProviderRegistrySnapshot": getCompletionProviderRegistrySnapshot,
   "ExtensionApi.getDiagnosticProviderRegistrySnapshot": getDiagnosticProviderRegistrySnapshot,
   "ExtensionApi.getFormattingProviderRegistrySnapshot": getFormattingProviderRegistrySnapshot,
   "ExtensionApi.getHoverProviderRegistrySnapshot": getHoverProviderRegistrySnapshot,
-  "ExtensionApi.getStatusBarItems": getStatusBarItems
+  "ExtensionApi.getOutputChannelRegistrySnapshot": getOutputChannelRegistrySnapshot,
+  "ExtensionApi.getStatusBarItems": getStatusBarItems,
+  "ExtensionApi.getViewRegistrySnapshot": getViewRegistrySnapshot,
+  "ExtensionApi.saveViewInstanceState": saveViewInstanceState
 };
 export {
   commandMap

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

@@ -28,7 +28,10 @@ const executeFormattingProvider = async (textDocument, ...args) => {
 const getFormattingProviders = registry.getProviders;
 const getFormattingProviderRegistrySnapshot = () => {
   return {
-    providers: registry.getProviders()
+    providers: registry.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 const resetFormattingProviderRegistry = registry.reset;

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

@@ -50,7 +50,10 @@ const executeHoverProvider = async (textDocument, offset, ...args) => {
 const getHoverProviders = registry.getProviders;
 const getHoverProviderRegistrySnapshot = () => {
   return {
-    providers: registry.getProviders()
+    providers: registry.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 const resetHoverProviderRegistry = registry.reset;

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

@@ -1,6 +1,6 @@
-import * as Rpc from "../Rpc/Rpc.js";
+import { ExtensionManagementWorker } from "@lvce-editor/rpc-registry";
 const notifyStatusBarChange = async (id) => {
-  await Rpc.invoke("StatusBar.handleChange", id);
+  await ExtensionManagementWorker.invoke("StatusBar.handleChange", id);
 };
 export {
   notifyStatusBarChange

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

@@ -0,0 +1,71 @@
+import { ExtensionManagementWorker } from "@lvce-editor/rpc-registry";
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const outputChannels = /* @__PURE__ */ Object.create(null);
+let isActivated = false;
+const RE_DASH_CASE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const assertOutputChannelId = (id) => {
+  if (typeof id !== "string" || id.length === 0) {
+    throw new ExtensionApiError("output channel id is required");
+  }
+  if (!RE_DASH_CASE.test(id)) {
+    throw new ExtensionApiError(`output channel id ${id} must be dash-case`);
+  }
+};
+const assertCanWrite = (id) => {
+  if (!isActivated) {
+    throw new ExtensionApiError(`output channel ${id} cannot be written before activate`);
+  }
+};
+class ExtensionOutputChannel {
+  #id;
+  constructor(id) {
+    this.#id = id;
+  }
+  async append(text) {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker.invoke("ExtensionApi.appendOutputChannel", this.#id, text);
+  }
+  async appendLine(text) {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker.invoke("ExtensionApi.appendOutputChannel", this.#id, `${text}
+`);
+  }
+  async clear() {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker.invoke("ExtensionApi.clearOutputChannel", this.#id);
+  }
+  async replace(text) {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker.invoke("ExtensionApi.replaceOutputChannel", this.#id, text);
+  }
+}
+const activateOutputChannels = () => {
+  isActivated = true;
+};
+const createOutputChannel = (id) => {
+  assertOutputChannelId(id);
+  if (id in outputChannels) {
+    throw new ExtensionApiError(`output channel ${id} is already created`);
+  }
+  outputChannels[id] = {
+    id
+  };
+  return new ExtensionOutputChannel(id);
+};
+const getOutputChannelRegistrySnapshot = () => {
+  return {
+    outputChannels: Object.values(outputChannels)
+  };
+};
+const resetOutputChannelRegistry = () => {
+  for (const id of Object.keys(outputChannels)) {
+    delete outputChannels[id];
+  }
+  isActivated = false;
+};
+export {
+  activateOutputChannels,
+  createOutputChannel,
+  getOutputChannelRegistrySnapshot,
+  resetOutputChannelRegistry
+};

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

@@ -1,6 +1,6 @@
-import * as Rpc from "../Rpc/Rpc.js";
+import { ExtensionManagementWorker } from "@lvce-editor/rpc-registry";
 const showQuickPick = async (options) => {
-  return Rpc.invoke("ExtensionHostQuickPick.showQuickPick", options);
+  return ExtensionManagementWorker.invoke("ExtensionHostQuickPick.showQuickPick", options);
 };
 export {
   showQuickPick

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

@@ -38,7 +38,9 @@ const getStatusBarItems = () => {
 };
 const getStatusBarItemProviderRegistrySnapshot = () => {
   return {
-    providers: registry.getProviders()
+    providers: registry.getProviders().map((provider) => ({
+      id: provider.id
+    }))
   };
 };
 const resetStatusBarItemProviderRegistry = registry.reset;

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

@@ -0,0 +1,148 @@
+import { diffTree } from "@lvce-editor/virtual-dom-worker";
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const views = /* @__PURE__ */ Object.create(null);
+const instances = /* @__PURE__ */ Object.create(null);
+const renderedDoms = /* @__PURE__ */ Object.create(null);
+const assertView = (view) => {
+  if (!view) {
+    throw new ExtensionApiError("view is not defined");
+  }
+  if (typeof view.id !== "string" || view.id.length === 0) {
+    throw new ExtensionApiError("view is missing id");
+  }
+  if (typeof view.create !== "function") {
+    throw new ExtensionApiError(`view ${view.id} is missing create function`);
+  }
+  if (view.id in views) {
+    throw new ExtensionApiError(`view ${view.id} is already registered`);
+  }
+};
+const toRegisteredView = (view) => {
+  const registeredView = {
+    icon: view.icon,
+    id: view.id,
+    title: view.title
+  };
+  if (view.kind) {
+    return {
+      ...registeredView,
+      kind: view.kind
+    };
+  }
+  return registeredView;
+};
+const registerView = (view) => {
+  assertView(view);
+  views[view.id] = view;
+  return {
+    dispose() {
+      delete views[view.id];
+    }
+  };
+};
+const executeViewProvider = (id) => {
+  const view = views[id];
+  if (!view) {
+    throw new ExtensionApiError(`view ${id} not found`);
+  }
+  return view.create();
+};
+const assertVirtualDomViewInstance = (id, instance) => {
+  if (!instance || typeof instance !== "object") {
+    throw new ExtensionApiError(`view ${id} did not return a view instance`);
+  }
+  if (typeof instance.render !== "function") {
+    throw new ExtensionApiError(`view ${id} instance is missing render function`);
+  }
+};
+const getVirtualDomInstance = (uid) => {
+  const instance = instances[uid];
+  if (!instance) {
+    throw new ExtensionApiError(`view instance ${uid} not found`);
+  }
+  return instance;
+};
+const renderDom = async (instance) => {
+  const dom = await instance.render();
+  if (!Array.isArray(dom)) {
+    throw new ExtensionApiError("view render result must be an array");
+  }
+  return dom;
+};
+const createViewInstance = async (viewId, uid, context) => {
+  const view = views[viewId];
+  if (!view) {
+    throw new ExtensionApiError(`view ${viewId} not found`);
+  }
+  if (view.kind !== "virtualDom") {
+    throw new ExtensionApiError(`view ${viewId} is not a virtual dom view`);
+  }
+  const instance = await view.create({
+    ...context,
+    uid,
+    viewId
+  });
+  assertVirtualDomViewInstance(viewId, instance);
+  instances[uid] = instance;
+  const dom = await renderDom(instance);
+  renderedDoms[uid] = dom;
+  return {
+    dom,
+    type: "setDom"
+  };
+};
+const dispatchViewEvent = async (uid, event) => {
+  const instance = getVirtualDomInstance(uid);
+  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 disposeViewInstance = async (uid) => {
+  const instance = instances[uid];
+  if (instance && typeof instance.dispose === "function") {
+    await instance.dispose();
+  }
+  delete instances[uid];
+  delete renderedDoms[uid];
+};
+const saveViewInstanceState = async (uid) => {
+  const instance = getVirtualDomInstance(uid);
+  if (typeof instance.saveState !== "function") {
+    return void 0;
+  }
+  return instance.saveState();
+};
+const getViewRegistrySnapshot = () => {
+  return {
+    views: Object.values(views).map(toRegisteredView)
+  };
+};
+const resetViewRegistry = () => {
+  for (const id of Object.keys(views)) {
+    delete views[id];
+  }
+  for (const uid of Object.keys(instances)) {
+    delete instances[Number(uid)];
+  }
+  for (const uid of Object.keys(renderedDoms)) {
+    delete renderedDoms[Number(uid)];
+  }
+};
+export {
+  createViewInstance,
+  dispatchViewEvent,
+  disposeViewInstance,
+  executeViewProvider,
+  getViewRegistrySnapshot,
+  registerView,
+  resetViewRegistry,
+  saveViewInstanceState
+};