@lvce-editor/extension-host-worker 8.19.0 → 8.24.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/Diagnostic/Diagnostic.js

@@ -0,0 +1,10 @@
+import { executeDiagnosticProvider } from "../ExecuteDiagnosticProvider/ExecuteDiagnosticProvider.js";
+import { getDiagnosticProviderRegistrySnapshot } from "../GetDiagnosticProviderRegistrySnapshot/GetDiagnosticProviderRegistrySnapshot.js";
+import { registerDiagnosticProvider } from "../RegisterDiagnosticProvider/RegisterDiagnosticProvider.js";
+import { resetDiagnosticProviderRegistry } from "../ResetDiagnosticProviderRegistry/ResetDiagnosticProviderRegistry.js";
+export {
+  executeDiagnosticProvider,
+  getDiagnosticProviderRegistrySnapshot,
+  registerDiagnosticProvider,
+  resetDiagnosticProviderRegistry
+};

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

@@ -0,0 +1,66 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+import { createProviderRegistry } from "../ProviderRegistry/ProviderRegistry.js";
+const getType = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  return typeof value;
+};
+const validateDiagnosticResult = (diagnostics) => {
+  if (!Array.isArray(diagnostics)) {
+    throw new ExtensionApiError(`invalid diagnostic result: diagnostic must be of type array but is ${getType(diagnostics)}`);
+  }
+  for (const item of diagnostics) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new ExtensionApiError(`invalid diagnostic result: expected diagnostic item to be of type object but was of type ${getType(item)}`);
+    }
+  }
+  return diagnostics;
+};
+const registry = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      id: provider.id,
+      languageId: provider.languageId,
+      provideDiagnostics(textDocument, ...args) {
+        return provider.provideDiagnostics(textDocument, ...args);
+      }
+    };
+  },
+  providerName: "diagnostic provider",
+  requiredMethods: ["provideDiagnostics"],
+  requireLanguageId: true
+});
+const hasDiagnosticProvider = registry.hasProvider;
+const registerDiagnosticProvider = (provider) => {
+  const registeredProvider = registry.registerProvider(provider);
+  return {
+    dispose() {
+      registry.deleteProvider(registeredProvider.id);
+    }
+  };
+};
+const executeDiagnosticProvider = async (textDocument, ...args) => {
+  return registry.executeProviderByLanguageId(textDocument.languageId, "provideDiagnostics", [textDocument, ...args], validateDiagnosticResult);
+};
+const getDiagnosticProviders = registry.getProviders;
+const getDiagnosticProviderRegistrySnapshot = () => {
+  return {
+    providers: registry.getProviders()
+  };
+};
+const resetDiagnosticProviderRegistry = registry.reset;
+export {
+  executeDiagnosticProvider,
+  getDiagnosticProviderRegistrySnapshot,
+  getDiagnosticProviders,
+  hasDiagnosticProvider,
+  registerDiagnosticProvider,
+  resetDiagnosticProviderRegistry
+};

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/ExecuteDiagnosticProvider/ExecuteDiagnosticProvider.js

@@ -0,0 +1,4 @@
+import { executeDiagnosticProvider } from "../DiagnosticProviderRegistry/DiagnosticProviderRegistry.js";
+export {
+  executeDiagnosticProvider
+};

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

@@ -1,19 +1,27 @@
 import { executeCommand, getCommandRegistrySnapshot } from "../CommandRegistry/CommandRegistry.js";
 import { executeCompletionProvider, executeResolveCompletionItemProvider, getCompletionProviderRegistrySnapshot } from "../Completion/Completion.js";
+import { executeDiagnosticProvider, getDiagnosticProviderRegistrySnapshot } from "../Diagnostic/Diagnostic.js";
 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 { executeViewProvider, getViewRegistrySnapshot } from "../ViewRegistry/ViewRegistry.js";
 const commandMap = {
   "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
 };
 export {
   commandMap

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

@@ -0,0 +1,4 @@
+import { getDiagnosticProviderRegistrySnapshot } from "../DiagnosticProviderRegistry/DiagnosticProviderRegistry.js";
+export {
+  getDiagnosticProviderRegistrySnapshot
+};

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/RegisterDiagnosticProvider/RegisterDiagnosticProvider.js

@@ -0,0 +1,4 @@
+import { registerDiagnosticProvider } from "../DiagnosticProviderRegistry/DiagnosticProviderRegistry.js";
+export {
+  registerDiagnosticProvider
+};

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

@@ -0,0 +1,4 @@
+import { resetDiagnosticProviderRegistry } from "../DiagnosticProviderRegistry/DiagnosticProviderRegistry.js";
+export {
+  resetDiagnosticProviderRegistry
+};

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

@@ -0,0 +1,55 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const views = /* @__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) => {
+  return {
+    icon: view.icon,
+    id: view.id,
+    title: view.title
+  };
+};
+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 getViewRegistrySnapshot = () => {
+  return {
+    views: Object.values(views).map(toRegisteredView)
+  };
+};
+const resetViewRegistry = () => {
+  for (const id of Object.keys(views)) {
+    delete views[id];
+  }
+};
+export {
+  executeViewProvider,
+  getViewRegistrySnapshot,
+  registerView,
+  resetViewRegistry
+};