@lvce-editor/test-worker 10.11.0 → 10.13.0

package/dist/api.d.ts

@@ -50,6 +50,11 @@ export interface FileSystemTmpDirOptions {
 	readonly scheme?: string;
 }
 
+export interface SelectItem2Options {
+	readonly callbackCommand: string;
+	readonly label: string;
+}
+
 interface Workspace {
   readonly openTmpDir: () => Promise<string>;
   readonly setPath: (path: string) => Promise<void>;
@@ -429,6 +434,7 @@ interface QuickPick {
   readonly selectCurrentIndex: () => Promise<void>;
   readonly selectIndex: (index: number) => Promise<void>;
   readonly selectItem: (label: string) => Promise<void>;
+  readonly selectItem2: ({ callbackCommand, label }: SelectItem2Options) => Promise<void>;
   readonly setValue: (value: string) => Promise<void>;
 }
 

package/dist/testWorkerMain.js

@@ -231,8 +231,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -255,14 +255,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -281,8 +281,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -292,8 +292,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -354,8 +354,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -375,8 +375,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -433,8 +433,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -446,8 +446,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -457,8 +457,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
 };
 const Message$1 = 3;
 const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  messagePort
 }) => {
   if (!isMessagePort(messagePort)) {
     throw new IpcError('port must be of type MessagePort');
@@ -471,8 +471,8 @@ const create$5$1 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -512,55 +512,13 @@ const IpcParentWithMessagePort$1 = {
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
-const callbacks = Object.create(null);
-const set$3 = (id, fn) => {
-  callbacks[id] = fn;
-};
+const Two$1 = '2.0';
+const callbacks$1 = Object.create(null);
 const get$2 = id => {
-  return callbacks[id];
+  return callbacks$1[id];
 };
 const remove$1 = id => {
-  delete callbacks[id];
-};
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$3(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
+  delete callbacks$1[id];
 };
 class JsonRpcError extends Error {
   constructor(message) {
@@ -757,7 +715,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -768,20 +726,20 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$3 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$3(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -868,29 +826,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send$1 = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke$2 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -913,24 +848,87 @@ const execute$2 = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$p = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$o = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$n = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$n();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$o(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send$1(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$p(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -947,7 +945,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute$2;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve$1, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -965,16 +963,16 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$e = async ({
+const create$g = async ({
   commandMap,
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -983,17 +981,18 @@ const create$e = async ({
 };
 const MessagePortRpcParent = {
   __proto__: null,
-  create: create$e
+  create: create$g
 };
-const create$5 = async ({
+const create$7 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -1001,8 +1000,9 @@ const create$5 = async ({
   messagePort.start();
   return rpc;
 };
-const create$3 = async ({
+const create$5 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -1010,14 +1010,15 @@ const create$3 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$7({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
 const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3
+  create: create$5
 };
 const create$2 = async ({
   commandMap
@@ -1055,6 +1056,10 @@ const get$1 = id => {
 
 const create$1 = rpcId => {
   return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
       const rpc = get$1(rpcId);
@@ -1069,10 +1074,6 @@ const create$1 = rpcId => {
     },
     set(rpc) {
       set$2(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
     }
   };
 };
@@ -1080,7 +1081,8 @@ const create$1 = rpcId => {
 const {
   invoke: invoke$1,
   invokeAndTransfer,
-  set: set$1} = create$1(RendererWorker);
+  set: set$1
+} = create$1(RendererWorker);
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
@@ -1104,13 +1106,18 @@ const createLazyRpc = rpcId => {
     await rpcPromise;
   };
   return {
-    setFactory(value) {
-      factory = value;
-    },
     async invoke(method, ...params) {
       await ensureRpc();
       const rpc = get$1(rpcId);
       return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      await ensureRpc();
+      const rpc = get$1(rpcId);
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    setFactory(value) {
+      factory = value;
     }
   };
 };
@@ -3244,6 +3251,21 @@ const Problems = {
   viewAsTable
 };
 
+const callbacks = Object.create(null);
+const registerCallbackCommand = async commandId => {
+  const id = createId();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  callbacks[id] = resolve;
+  // @ts-ignore
+  await invoke$1(`Test.registerTestCommand`, commandId);
+  return {
+    promise
+  };
+};
+
 const QuickPick$1 = 'QuickPick';
 
 const open$1 = async () => {
@@ -3302,6 +3324,17 @@ const executeCommand = async label => {
   // @ts-ignore
   await invoke$1('QuickPick.selectItem', label);
 };
+const selectItem2 = async ({
+  callbackCommand,
+  label
+}) => {
+  const {
+    promise
+  } = await registerCallbackCommand(callbackCommand);
+  // @ts-ignore
+  invoke$1('QuickPick.selectItem', label);
+  await promise;
+};
 
 const QuickPick = {
   __proto__: null,
@@ -3317,6 +3350,7 @@ const QuickPick = {
   selectCurrentIndex,
   selectIndex: selectIndex$3,
   selectItem,
+  selectItem2,
   setValue: setValue$1
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-worker",
-  "version": "10.11.0",
+  "version": "10.13.0",
   "description": "Test Worker",
   "repository": {
     "type": "git",
@@ -11,7 +11,7 @@
   "type": "module",
   "main": "dist/testWorkerMain.js",
   "dependencies": {
-    "@lvce-editor/constants": "^1.41.0"
+    "@lvce-editor/constants": "^2.8.0"
   },
   "types": "dist/api.d.ts"
 }