@lvce-editor/extension-host-worker 1.10.0 → 1.12.0

package/dist/extensionHostWorkerMain.js

@@ -30,13 +30,13 @@ const getJson = async url => {
   throw new DepecratedError(`vscode.getJson is deprecated, use createNodeRpc instead`);
 };
 
-let AssertionError$1 = class AssertionError extends Error {
+class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
-};
-const getType$3 = value => {
+}
+const getType$1 = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -59,39 +59,37 @@ const getType$3 = value => {
   }
 };
 const object = value => {
-  const type = getType$3(value);
+  const type = getType$1(value);
   if (type !== 'object') {
-    throw new AssertionError$1('expected value to be of type object');
+    throw new AssertionError('expected value to be of type object');
   }
 };
-const number$1 = value => {
-  const type = getType$3(value);
+const number = value => {
+  const type = getType$1(value);
   if (type !== 'number') {
-    throw new AssertionError$1('expected value to be of type number');
+    throw new AssertionError('expected value to be of type number');
   }
 };
 const array = value => {
-  const type = getType$3(value);
+  const type = getType$1(value);
   if (type !== 'array') {
-    throw new AssertionError$1('expected value to be of type array');
+    throw new AssertionError('expected value to be of type array');
   }
 };
 const string = value => {
-  const type = getType$3(value);
+  const type = getType$1(value);
   if (type !== 'string') {
-    throw new AssertionError$1('expected value to be of type string');
+    throw new AssertionError('expected value to be of type string');
   }
 };
 const fn = value => {
-  const type = getType$3(value);
+  const type = getType$1(value);
   if (type !== 'function') {
-    throw new AssertionError$1('expected value to be of type function');
+    throw new AssertionError('expected value to be of type function');
   }
 };
 
 const state$9 = {
-  /** @type{any[]} */
-  onDidOpenEditorListeners: [],
   /** @type{any[]} */
   onWillChangeEditorListeners: [],
   /** @type{any[]} */
@@ -287,7 +285,7 @@ const getSyntheticChanges = (textDocument, changes) => {
   return syntheticChanges;
 };
 const syncIncremental = (textDocumentId, changes) => {
-  number$1(textDocumentId);
+  number(textDocumentId);
   array(changes);
   const textDocument = getDocument(textDocumentId);
   if (!textDocument) {
@@ -332,10 +330,10 @@ class NoProviderFoundError extends Error {
 
 const normalizeLine$1 = line => {
   if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
+    return line.slice('Error: '.length);
   }
   if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
+    return line.slice('VError: '.length);
   }
   return line;
 };
@@ -386,7 +384,7 @@ let VError$1 = class VError extends Error {
   }
 };
 
-const getType$2 = value => {
+const getType = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -417,7 +415,7 @@ const validateResultObject = (result, resultShape) => {
   for (const [key, value] of Object.entries(resultShape.properties)) {
     // @ts-ignore
     const expectedType = value.type;
-    const actualType = getType$2(result[key]);
+    const actualType = getType(result[key]);
     if (expectedType !== actualType) {
       return `item.${key} must be of type ${expectedType}`;
     }
@@ -426,7 +424,7 @@ const validateResultObject = (result, resultShape) => {
 };
 const validateResultArray = (result, resultShape) => {
   for (const item of result) {
-    const actualType = getType$2(item);
+    const actualType = getType(item);
     const expectedType = resultShape.items.type;
     if (actualType !== expectedType) {
       return `expected result to be of type ${expectedType} but was of type ${actualType}`;
@@ -447,7 +445,7 @@ const getPreviewString = item => {
   return `"${item}"`;
 };
 const getPreview = item => {
-  const type = getType$2(item);
+  const type = getType(item);
   switch (type) {
     case 'object':
       return getPreviewObject();
@@ -460,7 +458,7 @@ const getPreview = item => {
   }
 };
 const validate = (item, schema) => {
-  const actualType = getType$2(item);
+  const actualType = getType(item);
   const expectedType = schema.type;
   if (actualType !== expectedType) {
     if (schema.allowUndefined && (item === undefined || item === null)) {
@@ -621,9 +619,7 @@ const String = 'string';
 
 const {
   registerBraceCompletionProvider,
-  executeBraceCompletionProvider,
-  reset: reset$9
-} = create$9({
+  executeBraceCompletionProvider} = create$9({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean
@@ -684,7 +680,7 @@ const getCommandDisplay = command => {
   }
   return '';
 };
-const registerCommand$1 = command => {
+const registerCommand = command => {
   try {
     if (!command) {
       if (command === null) {
@@ -766,95 +762,45 @@ const create$4$1 = (method, params) => {
     params
   };
 };
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType$1 = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const number = value => {
-  const type = getType$1(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const state$1$1 = {
+const state$6 = {
   callbacks: Object.create(null)
 };
 const set$4 = (id, fn) => {
-  state$1$1.callbacks[id] = fn;
+  state$6.callbacks[id] = fn;
 };
 const get$4 = id => {
-  return state$1$1.callbacks[id];
+  return state$6.callbacks[id];
 };
 const remove = id => {
-  delete state$1$1.callbacks[id];
-};
-const state$6 = {
-  id: 0
+  delete state$6.callbacks[id];
 };
+let id = 0;
 const create$3$1 = () => {
-  return ++state$6.id;
+  return ++id;
 };
 const warn = (...args) => {
   console.warn(...args);
 };
-const withResolvers$2 = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
 const registerPromise = () => {
   const id = create$3$1();
   const {
     resolve,
     promise
-  } = withResolvers$2();
+  } = Promise.withResolvers();
   set$4(id, resolve);
   return {
     id,
     promise
   };
 };
-const resolve = (id, args) => {
-  number(id);
+const resolve = (id, response) => {
   const fn = get$4(id);
   if (!fn) {
-    console.log(args);
+    console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
-  fn(args);
+  fn(response);
   remove(id);
 };
 const create$2$1 = (method, params) => {
@@ -1005,7 +951,7 @@ const unwrapJsonRpcResult = responseMessage => {
   throw new JsonRpcError('unexpected response message');
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getType = prettyError => {
+const getErrorType = prettyError => {
   if (prettyError && prettyError.type) {
     return prettyError.type;
   }
@@ -1028,7 +974,7 @@ const getErrorProperty = (error, prettyError) => {
     data: {
       stack: prettyError.stack,
       codeFrame: prettyError.codeFrame,
-      type: getType(prettyError),
+      type: getErrorType(prettyError),
       code: prettyError.code,
       name: prettyError.name
     }
@@ -1076,32 +1022,42 @@ const defaultRequiresSocket = () => {
   return false;
 };
 const defaultResolve = resolve;
-const handleJsonRpcMessage = async (...args) => {
-  let message;
-  let ipc;
-  let execute;
-  let preparePrettyError;
-  let logError;
-  let resolve;
-  let requiresSocket;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
   if (args.length === 1) {
-    const arg = args[0];
-    message = arg.message;
-    ipc = arg.ipc;
-    execute = arg.execute;
-    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
-    logError = arg.logError || defaultLogError;
-    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve = arg.resolve || defaultResolve;
-  } else {
-    ipc = args[0];
-    message = args[1];
-    execute = args[2];
-    resolve = args[3];
-    preparePrettyError = args[4];
-    logError = args[5];
-    requiresSocket = args[6];
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
   }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
   if ('id' in message) {
     if ('method' in message) {
       const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
@@ -1122,39 +1078,33 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const send$1 = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$1 = async (ipc, method, ...params) => {
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
   } = create$2$1(method, params);
-  ipc.send(message);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
   const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+  return unwrapJsonRpcResult(responseMessage);
 };
-const invokeAndTransfer$1 = async (ipc, method, ...params) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  ipc.sendAndTransfer(message);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+const send$1 = (transport, method, ...params) => {
+  const message = create$4$1(method, params);
+  transport.send(message);
+};
+const invoke$1 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
+};
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
 };
 
 const commands = Object.create(null);
-const registerCommand = (key, fn) => {
-  commands[key] = fn;
-};
 const register$1 = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
+  Object.assign(commands, commandMap);
 };
 const getCommand = key => {
   return commands[key];
@@ -1338,9 +1288,7 @@ const setPauseOnExceptions = async (protocol, value) => {
 
 const {
   registerDefinitionProvider,
-  executeDefinitionProvider,
-  reset: reset$8
-} = create$9({
+  executeDefinitionProvider} = create$9({
   name: 'Definition',
   resultShape: {
     allowUndefined: true,
@@ -1461,9 +1409,7 @@ const getPathSeparator = protocol => {
 
 const {
   registerFormattingProvider,
-  executeFormattingProvider,
-  reset: reset$7
-} = create$9({
+  executeFormattingProvider} = create$9({
   name: 'Formatting',
   executeKey: 'format',
   resultShape: {
@@ -1523,9 +1469,7 @@ const getPosition = (textDocument, offset) => {
 
 const {
   registerHoverProvider,
-  executeHoverProvider,
-  reset: reset$6
-} = create$9({
+  executeHoverProvider} = create$9({
   name: 'Hover',
   resultShape: {
     allowUndefined: true,
@@ -1536,9 +1480,7 @@ const {
 
 const {
   registerImplementationProvider,
-  executeImplementationProvider,
-  reset: reset$5
-} = create$9({
+  executeImplementationProvider} = create$9({
   name: 'Implementation',
   resultShape: {
     type: Array$1,
@@ -1650,9 +1592,7 @@ const showQuickPick = async ({
 const {
   registerReferenceProvider,
   executeReferenceProvider,
-  executefileReferenceProvider,
-  reset: reset$4
-} = create$9({
+  executefileReferenceProvider} = create$9({
   name: 'Reference',
   resultShape: {
     type: Array$1,
@@ -1677,9 +1617,7 @@ const {
 const {
   registerRenameProvider,
   executeRenameProvider,
-  executeprepareRenameProvider,
-  reset: reset$3
-} = create$9({
+  executeprepareRenameProvider} = create$9({
   name: 'Rename',
   resultShape: {
     type: Object$1,
@@ -1836,9 +1774,7 @@ const createRpc = ({
 
 const {
   registerSelectionProvider,
-  executeSelectionProvider,
-  reset: reset$2
-} = create$9({
+  executeSelectionProvider} = create$9({
   name: 'Selection',
   resultShape: {
     allowUndefined: true,
@@ -1944,9 +1880,7 @@ const getEnabledProviderIds = async (scheme, root) => {
 
 const {
   registerTabCompletionProvider,
-  executeTabCompletionProvider,
-  reset: reset$1
-} = create$9({
+  executeTabCompletionProvider} = create$9({
   name: 'TabCompletion',
   resultShape: {
     type: Object$1,
@@ -1974,7 +1908,7 @@ const executeTextSearchProvider = async (scheme, query) => {
   try {
     const textSearchProvider = state$2.textSearchProviders[scheme];
     if (!textSearchProvider) {
-      throw new Error(`no text search provider for ${scheme} found`);
+      throw new Error(`No text search provider for ${scheme} found`);
     }
     const results = await textSearchProvider.provideTextSearchResults(query);
     return results;
@@ -1985,9 +1919,7 @@ const executeTextSearchProvider = async (scheme, query) => {
 
 const {
   registerTypeDefinitionProvider,
-  executeTypeDefinitionProvider,
-  reset
-} = create$9({
+  executeTypeDefinitionProvider} = create$9({
   name: 'TypeDefinition',
   resultShape: {
     allowUndefined: true,
@@ -2269,7 +2201,7 @@ const api = {
   // Code Action
   registerCodeActionsProvider: registerCodeActionProvider,
   // Command
-  registerCommand: registerCommand$1,
+  registerCommand: registerCommand,
   executeCommand: executeCommand,
   // Completion
   registerCompletionProvider: registerCompletionProvider,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-host-worker",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "Webworker for the extension host functionality in Lvce Editor.",
   "main": "dist/extensionHostWorkerMain.js",
   "type": "module",