@lvce-editor/extension-host-worker 8.16.0 → 8.18.0

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

@@ -0,0 +1,13 @@
+import { listen } from "../ExtensionApiWorkerListen/ExtensionApiWorkerListen.js";
+import * as Rpc from "../Rpc/Rpc.js";
+let rpcPromise;
+const activate = async () => {
+  if (!rpcPromise) {
+    rpcPromise = listen();
+  }
+  const rpc = await rpcPromise;
+  Rpc.set(rpc);
+};
+export {
+  activate
+};

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

@@ -0,0 +1,25 @@
+import { hasCompletionProvider } from "../CompletionProviderState/CompletionProviderState.js";
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const assertCompletionProvider = (provider) => {
+  if (!provider) {
+    throw new ExtensionApiError("completion provider is not defined");
+  }
+  if (!provider.id) {
+    throw new ExtensionApiError("completion provider is missing id");
+  }
+  if (!provider.languageId) {
+    throw new ExtensionApiError(`completion provider ${provider.id} is missing languageId`);
+  }
+  if (typeof provider.provideCompletions !== "function") {
+    throw new ExtensionApiError(`completion provider ${provider.id} is missing provideCompletions function`);
+  }
+  if (provider.resolveCompletionItem !== void 0 && typeof provider.resolveCompletionItem !== "function") {
+    throw new ExtensionApiError(`completion provider ${provider.id} has invalid resolveCompletionItem function`);
+  }
+  if (hasCompletionProvider(provider.id)) {
+    throw new ExtensionApiError(`completion provider ${provider.id} is already registered`);
+  }
+};
+export {
+  assertCompletionProvider
+};

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

@@ -0,0 +1,22 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+import { hasFormattingProvider } from "../FormattingProviderState/FormattingProviderState.js";
+const assertFormattingProvider = (provider) => {
+  if (!provider) {
+    throw new ExtensionApiError("formatting provider is not defined");
+  }
+  if (typeof provider.id !== "string" || provider.id.length === 0) {
+    throw new ExtensionApiError("formatting provider is missing id");
+  }
+  if (typeof provider.languageId !== "string" || provider.languageId.length === 0) {
+    throw new ExtensionApiError(`formatting provider ${provider.id} is missing languageId`);
+  }
+  if (typeof provider.format !== "function") {
+    throw new ExtensionApiError(`formatting provider ${provider.id} is missing format function`);
+  }
+  if (hasFormattingProvider(provider.id)) {
+    throw new ExtensionApiError(`formatting provider ${provider.id} is already registered`);
+  }
+};
+export {
+  assertFormattingProvider
+};

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

@@ -0,0 +1,19 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+import { hasStatusBarItemProvider } from "../StatusBarItemProviderState/StatusBarItemProviderState.js";
+const assertStatusBarItemProvider = (provider) => {
+  if (!provider) {
+    throw new ExtensionApiError("status bar item provider is not defined");
+  }
+  if (typeof provider.id !== "string" || provider.id.length === 0) {
+    throw new ExtensionApiError("status bar item provider is missing id");
+  }
+  if (typeof provider.getStatusBarItem !== "function") {
+    throw new ExtensionApiError(`status bar item provider ${provider.id} is missing getStatusBarItem function`);
+  }
+  if (hasStatusBarItemProvider(provider.id)) {
+    throw new ExtensionApiError(`status bar item provider ${provider.id} is already registered`);
+  }
+};
+export {
+  assertStatusBarItemProvider
+};

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

@@ -0,0 +1,14 @@
+import { commandMap as extensionApiCommandMap } from "../ExtensionApiCommandMap/ExtensionApiCommandMap.js";
+import { handleExtensionManagementMessagePort } from "../ExtensionApiWorkerHandleMessagePort/ExtensionApiWorkerHandleMessagePort.js";
+const commandMap = {
+  ...extensionApiCommandMap,
+  async initialize(type, port) {
+    if (type !== "message-port") {
+      throw new Error(`unsupported initialize type ${type}`);
+    }
+    await handleExtensionManagementMessagePort(port);
+  }
+};
+export {
+  commandMap
+};

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

@@ -0,0 +1,53 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const commands = /* @__PURE__ */ Object.create(null);
+const assertCommand = (command) => {
+  if (!command) {
+    throw new ExtensionApiError("command is not defined");
+  }
+  if (typeof command.id !== "string" || command.id.length === 0) {
+    throw new ExtensionApiError("command is missing id");
+  }
+  if (typeof command.execute !== "function") {
+    throw new ExtensionApiError(`command ${command.id} is missing execute function`);
+  }
+  if (command.id in commands) {
+    throw new ExtensionApiError(`command ${command.id} is already registered`);
+  }
+};
+const registerCommand = (command) => {
+  assertCommand(command);
+  commands[command.id] = {
+    execute(...args) {
+      return command.execute(...args);
+    },
+    id: command.id
+  };
+  return {
+    dispose() {
+      delete commands[command.id];
+    }
+  };
+};
+const getCommandRegistrySnapshot = () => {
+  return {
+    commands: Object.values(commands)
+  };
+};
+const executeCommand = async (id, ...args) => {
+  const command = commands[id];
+  if (!command) {
+    throw new ExtensionApiError(`command ${id} not found`);
+  }
+  return command.execute(...args);
+};
+const resetCommandRegistry = () => {
+  for (const id of Object.keys(commands)) {
+    delete commands[id];
+  }
+};
+export {
+  executeCommand,
+  getCommandRegistrySnapshot,
+  registerCommand,
+  resetCommandRegistry
+};

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

@@ -0,0 +1,11 @@
+import { executeCompletionProvider, executeResolveCompletionItemProvider } from "../ExecuteCompletionProvider/ExecuteCompletionProvider.js";
+import { getCompletionProviderRegistrySnapshot } from "../GetCompletionProviderRegistrySnapshot/GetCompletionProviderRegistrySnapshot.js";
+import { registerCompletionProvider } from "../RegisterCompletionProvider/RegisterCompletionProvider.js";
+import { resetCompletionProviderRegistry } from "../ResetCompletionProviderRegistry/ResetCompletionProviderRegistry.js";
+export {
+  executeCompletionProvider,
+  executeResolveCompletionItemProvider,
+  getCompletionProviderRegistrySnapshot,
+  registerCompletionProvider,
+  resetCompletionProviderRegistry
+};

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

@@ -0,0 +1,78 @@
+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);
+  }
+  return typeof value;
+};
+const validateCompletionResult = (completion) => {
+  if (!Array.isArray(completion)) {
+    throw new ExtensionApiError(`invalid completion result: completion must be of type array but is ${getType(completion)}`);
+  }
+  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)}`);
+    }
+  }
+  return completion;
+};
+const registry = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      id: provider.id,
+      languageId: provider.languageId,
+      provideCompletions(textDocument, offset, ...args) {
+        return provider.provideCompletions(textDocument, offset, ...args);
+      },
+      resolveCompletionItem: provider.resolveCompletionItem ? (textDocument, offset, name, completionItem, ...args) => provider.resolveCompletionItem?.(textDocument, offset, name, completionItem, ...args) : void 0
+    };
+  },
+  optionalMethods: ["resolveCompletionItem"],
+  providerName: "completion provider",
+  requiredMethods: ["provideCompletions"],
+  requireLanguageId: true
+});
+const hasCompletionProvider = registry.hasProvider;
+const registerCompletionProvider = (provider) => {
+  const registeredProvider = registry.registerProvider(provider);
+  return {
+    dispose() {
+      registry.deleteProvider(registeredProvider.id);
+    }
+  };
+};
+const executeCompletionProvider = async (textDocument, offset, ...args) => {
+  return registry.executeProviderByLanguageId(
+    textDocument.languageId,
+    "provideCompletions",
+    [textDocument, offset, ...args],
+    validateCompletionResult
+  );
+};
+const executeResolveCompletionItemProvider = async (textDocument, offset, name, completionItem, ...args) => {
+  const provider = registry.getProviderByLanguageId(textDocument.languageId);
+  if (!provider) {
+    throw new ExtensionApiError(`No completion provider found for ${textDocument.languageId}`);
+  }
+  return provider.resolveCompletionItem?.(textDocument, offset, name, completionItem, ...args);
+};
+const getCompletionProviders = registry.getProviders;
+const getCompletionProviderRegistrySnapshot = () => {
+  return {
+    providers: registry.getProviders()
+  };
+};
+const resetCompletionProviderRegistry = registry.reset;
+export {
+  executeCompletionProvider,
+  executeResolveCompletionItemProvider,
+  getCompletionProviderRegistrySnapshot,
+  getCompletionProviders,
+  hasCompletionProvider,
+  registerCompletionProvider,
+  resetCompletionProviderRegistry
+};

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

@@ -0,0 +1,10 @@
+import {
+  getCompletionProviders,
+  hasCompletionProvider,
+  resetCompletionProviderRegistry
+} from "../CompletionProviderRegistry/CompletionProviderRegistry.js";
+export {
+  resetCompletionProviderRegistry as clearCompletionProviders,
+  getCompletionProviders,
+  hasCompletionProvider
+};

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

@@ -0,0 +1,7 @@
+import * as Rpc from "../Rpc/Rpc.js";
+const executeCommand = async (id, ...args) => {
+  return Rpc.invoke("Extensions.executeCommand", id, ...args);
+};
+export {
+  executeCommand
+};

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

@@ -0,0 +1,5 @@
+import { executeCompletionProvider, executeResolveCompletionItemProvider } from "../CompletionProviderRegistry/CompletionProviderRegistry.js";
+export {
+  executeCompletionProvider,
+  executeResolveCompletionItemProvider
+};

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { executeCommand, getCommandRegistrySnapshot } from "../CommandRegistry/CommandRegistry.js";
+import { executeCompletionProvider, executeResolveCompletionItemProvider, getCompletionProviderRegistrySnapshot } from "../Completion/Completion.js";
+import { executeFormattingProvider, getFormattingProviderRegistrySnapshot } from "../Formatting/Formatting.js";
+import { getStatusBarItems } from "../GetStatusBarItems/GetStatusBarItems.js";
+import { executeHoverProvider, getHoverProviderRegistrySnapshot } from "../Hover/Hover.js";
+const commandMap = {
+  "ExtensionApi.executeCommand": executeCommand,
+  "ExtensionApi.executeCompletionProvider": executeCompletionProvider,
+  "ExtensionApi.executeFormattingProvider": executeFormattingProvider,
+  "ExtensionApi.executeHoverProvider": executeHoverProvider,
+  "ExtensionApi.executeResolveCompletionItemProvider": executeResolveCompletionItemProvider,
+  "ExtensionApi.getCommandRegistrySnapshot": getCommandRegistrySnapshot,
+  "ExtensionApi.getCompletionProviderRegistrySnapshot": getCompletionProviderRegistrySnapshot,
+  "ExtensionApi.getFormattingProviderRegistrySnapshot": getFormattingProviderRegistrySnapshot,
+  "ExtensionApi.getHoverProviderRegistrySnapshot": getHoverProviderRegistrySnapshot,
+  "ExtensionApi.getStatusBarItems": getStatusBarItems
+};
+export {
+  commandMap
+};

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

@@ -0,0 +1,9 @@
+class ExtensionApiError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExtensionApiError";
+  }
+}
+export {
+  ExtensionApiError
+};

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

@@ -0,0 +1,15 @@
+import { commandMap as extensionApiCommandMap } from "../ExtensionApiCommandMap/ExtensionApiCommandMap.js";
+import { handleExtensionManagementMessagePort } from "../ExtensionApiWorkerHandleMessagePort/ExtensionApiWorkerHandleMessagePort.js";
+const commandMap = {
+  ...extensionApiCommandMap,
+  "HandleMessagePort.handleExtensionManagementMessagePort": handleExtensionManagementMessagePort,
+  async initialize(type, port) {
+    if (type !== "message-port") {
+      throw new Error(`unsupported initialize type ${type}`);
+    }
+    await handleExtensionManagementMessagePort(port);
+  }
+};
+export {
+  commandMap
+};

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

@@ -0,0 +1,21 @@
+import { PlainMessagePortRpc } from "@lvce-editor/rpc";
+import * as ExtensionApiCommandMap from "../ExtensionApiCommandMap/ExtensionApiCommandMap.js";
+const commandMap = {
+  ...ExtensionApiCommandMap.commandMap,
+  async initialize(type, port) {
+    if (type !== "message-port") {
+      throw new Error(`unsupported initialize type ${type}`);
+    }
+    await handleExtensionManagementMessagePort(port);
+  }
+};
+const handleExtensionManagementMessagePort = async (port) => {
+  await PlainMessagePortRpc.create({
+    commandMap,
+    isMessagePortOpen: true,
+    messagePort: port
+  });
+};
+export {
+  handleExtensionManagementMessagePort
+};

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

@@ -0,0 +1,11 @@
+import { WebWorkerRpcClient } from "@lvce-editor/rpc";
+import * as ExtensionApiWorkerCommandMap from "../ExtensionApiWorkerCommandMap/ExtensionApiWorkerCommandMap.js";
+const listen = async () => {
+  const rpc = WebWorkerRpcClient.create({
+    commandMap: ExtensionApiWorkerCommandMap.commandMap
+  });
+  return rpc;
+};
+export {
+  listen
+};

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

@@ -0,0 +1,10 @@
+import { executeFormattingProvider } from "../ExecuteFormattingProvider/ExecuteFormattingProvider.js";
+import { getFormattingProviderRegistrySnapshot } from "../GetFormattingProviderRegistrySnapshot/GetFormattingProviderRegistrySnapshot.js";
+import { registerFormattingProvider } from "../RegisterFormattingProvider/RegisterFormattingProvider.js";
+import { resetFormattingProviderRegistry } from "../ResetFormattingProviderRegistry/ResetFormattingProviderRegistry.js";
+export {
+  executeFormattingProvider,
+  getFormattingProviderRegistrySnapshot,
+  registerFormattingProvider,
+  resetFormattingProviderRegistry
+};

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

@@ -0,0 +1,42 @@
+import { createProviderRegistry } from "../ProviderRegistry/ProviderRegistry.js";
+const registry = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      format(textDocument, ...args) {
+        return provider.format(textDocument, ...args);
+      },
+      id: provider.id,
+      languageId: provider.languageId
+    };
+  },
+  providerName: "formatting provider",
+  requiredMethods: ["format"],
+  requireLanguageId: true
+});
+const hasFormattingProvider = registry.hasProvider;
+const registerFormattingProvider = (provider) => {
+  const registeredProvider = registry.registerProvider(provider);
+  return {
+    dispose() {
+      registry.deleteProvider(registeredProvider.id);
+    }
+  };
+};
+const executeFormattingProvider = async (textDocument, ...args) => {
+  return registry.executeProviderByLanguageId(textDocument.languageId, "format", [textDocument, ...args]);
+};
+const getFormattingProviders = registry.getProviders;
+const getFormattingProviderRegistrySnapshot = () => {
+  return {
+    providers: registry.getProviders()
+  };
+};
+const resetFormattingProviderRegistry = registry.reset;
+export {
+  executeFormattingProvider,
+  getFormattingProviderRegistrySnapshot,
+  getFormattingProviders,
+  hasFormattingProvider,
+  registerFormattingProvider,
+  resetFormattingProviderRegistry
+};

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

@@ -0,0 +1,10 @@
+import {
+  getFormattingProviders,
+  hasFormattingProvider,
+  resetFormattingProviderRegistry
+} from "../FormattingProviderRegistry/FormattingProviderRegistry.js";
+export {
+  resetFormattingProviderRegistry as clearFormattingProviders,
+  getFormattingProviders,
+  hasFormattingProvider
+};

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+import { commandMap as extensionApiCommandMap } from "../CommandMap/CommandMap.js";
+const handleExtensionManagementMessagePort = async ({
+  commandMap,
+  createMessagePortRpcClient,
+  port
+}) => {
+  await createMessagePortRpcClient({
+    commandMap: {
+      ...extensionApiCommandMap,
+      ...commandMap
+    },
+    messagePort: port
+  });
+};
+export {
+  handleExtensionManagementMessagePort
+};

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

@@ -0,0 +1,10 @@
+import { executeHoverProvider } from "../ExecuteHoverProvider/ExecuteHoverProvider.js";
+import { getHoverProviderRegistrySnapshot } from "../GetHoverProviderRegistrySnapshot/GetHoverProviderRegistrySnapshot.js";
+import { registerHoverProvider } from "../RegisterHoverProvider/RegisterHoverProvider.js";
+import { resetHoverProviderRegistry } from "../ResetHoverProviderRegistry/ResetHoverProviderRegistry.js";
+export {
+  executeHoverProvider,
+  getHoverProviderRegistrySnapshot,
+  registerHoverProvider,
+  resetHoverProviderRegistry
+};

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

@@ -0,0 +1,64 @@
+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 validateHoverResult = (hover) => {
+  if (hover === void 0) {
+    return void 0;
+  }
+  if (!hover || typeof hover !== "object" || Array.isArray(hover)) {
+    throw new ExtensionApiError(`invalid hover result: hover must be of type object or undefined but is ${getType(hover)}`);
+  }
+  return hover;
+};
+const registry = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      id: provider.id,
+      languageId: provider.languageId,
+      provideHover(textDocument, offset, ...args) {
+        return provider.provideHover(textDocument, offset, ...args);
+      }
+    };
+  },
+  providerName: "hover provider",
+  requiredMethods: ["provideHover"],
+  requireLanguageId: true
+});
+const hasHoverProvider = registry.hasProvider;
+const registerHoverProvider = (provider) => {
+  const registeredProvider = registry.registerProvider(provider);
+  return {
+    dispose() {
+      registry.deleteProvider(registeredProvider.id);
+    }
+  };
+};
+const executeHoverProvider = async (textDocument, offset, ...args) => {
+  return registry.executeProviderByLanguageId(textDocument.languageId, "provideHover", [textDocument, offset, ...args], validateHoverResult);
+};
+const getHoverProviders = registry.getProviders;
+const getHoverProviderRegistrySnapshot = () => {
+  return {
+    providers: registry.getProviders()
+  };
+};
+const resetHoverProviderRegistry = registry.reset;
+export {
+  executeHoverProvider,
+  getHoverProviderRegistrySnapshot,
+  getHoverProviders,
+  hasHoverProvider,
+  registerHoverProvider,
+  resetHoverProviderRegistry
+};

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

@@ -0,0 +1,7 @@
+import * as Rpc from "../Rpc/Rpc.js";
+const notifyStatusBarChange = async (id) => {
+  await Rpc.invoke("StatusBar.handleChange", id);
+};
+export {
+  notifyStatusBarChange
+};