@lvce-editor/test-worker 3.20.0 → 3.21.0

package/dist/testWorkerMain.js

@@ -420,6 +420,100 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    type,
+    event
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 const Two = '2.0';
 const create$4 = (method, params) => {
@@ -774,7 +868,7 @@ const register = commandMap => {
 const getCommand = key => {
   return commands[key];
 };
-const execute$3 = (command, ...args) => {
+const execute$2 = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
     throw new Error(`command not found ${command}`);
@@ -801,19 +895,19 @@ const createRpc = ipc => {
   };
   return rpc;
 };
-const requiresSocket$1 = () => {
+const requiresSocket = () => {
   return false;
 };
-const preparePrettyError$1 = error => {
+const preparePrettyError = error => {
   return error;
 };
-const logError$1 = () => {
+const logError = () => {
   // handled by renderer worker
 };
 const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
-  const actualExecute = event?.target?.execute || execute$3;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError$1, logError$1, actualRequiresSocket);
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute$2;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -831,6 +925,26 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
+const create$6 = async ({
+  commandMap,
+  messagePort,
+  isMessagePortOpen
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const MessagePortRpcParent = {
+  __proto__: null,
+  create: create$6
+};
 const create$1 = async ({
   commandMap
 }) => {
@@ -974,8 +1088,6 @@ const getLocatorRpc = locator => {
   return Rpc;
 };
 
-// @ts-nocheck
-
 const Assert = {
   string(value, message) {
     if (typeof value !== 'string') {
@@ -994,7 +1106,6 @@ const expect$1 = locator => {
   } = getLocatorRpc(locator);
   return {
     async checkSingleElementCondition(fnName, options) {
-      Assert.string(fnName);
       // TODO add rpcId property to locator instead
       return invoke('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
     },
@@ -1055,7 +1166,7 @@ const expect$1 = locator => {
       });
     },
     async toHaveCount(count) {
-      Assert.number(count, 'count must be of type string');
+      Assert.number(count, 'count must be of type number');
       return this.checkMultiElementCondition('toHaveCount', {
         count
       });
@@ -1321,13 +1432,13 @@ const TestFrameWorkComponentBaseUrl = {
   getBaseUrl
 };
 
-const execute$2 = async (id, ...args) => {
+const execute$1 = async (id, ...args) => {
   return invoke(id, ...args);
 };
 
 const TestFrameWorkComponentCommand = {
   __proto__: null,
-  execute: execute$2
+  execute: execute$1
 };
 
 const selectItem$1 = async text => {
@@ -2247,16 +2358,6 @@ const waitForFirstEventEvent = async port => {
   return firstEvent;
 };
 
-const preparePrettyError = error => {
-  return error;
-};
-const logError = () => {
-  // ignore
-};
-const execute$1 = () => {};
-const requiresSocket = () => {
-  return false;
-};
 const createPortIpc = async webViewId => {
   const {
     port1,
@@ -2274,27 +2375,17 @@ const createPortIpc = async webViewId => {
   if (firstEvent.data !== 'ready') {
     throw new Error('unexpected first message');
   }
-  const handleOtherMessage = async event => {
-    // @ts-ignore
-    await handleJsonRpcMessage(ipc, event.data, resolve, preparePrettyError, execute$1, logError, requiresSocket);
-  };
-  port1.onmessage = handleOtherMessage;
-  const ipc = {
-    send(message) {
-      port1.postMessage(message);
-    }
-  };
-  return ipc;
+  const rpc = await MessagePortRpcParent.create({
+    messagePort: port1,
+    commandMap: {},
+    isMessagePortOpen: true
+  });
+  return rpc;
 };
 
 const fromId = async webViewId => {
-  const ipc = await createPortIpc(webViewId);
-  const webViewRpc = {
-    invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
-    }
-  };
-  set(webViewId, webViewRpc);
+  const rpc = await createPortIpc(webViewId);
+  set(webViewId, rpc);
   return {
     locator(selector, options) {
       const baseLocator = create(selector, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-worker",
-  "version": "3.20.0",
+  "version": "3.21.0",
   "description": "",
   "license": "MIT",
   "author": "",