@lvce-editor/test-worker 3.19.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) => {
@@ -430,10 +524,10 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
+const set$2 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$1 = id => {
+const get$2 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -449,7 +543,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$1(id, resolve);
+  set$2(id, resolve);
   return {
     id,
     promise
@@ -606,7 +700,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$1(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -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
 }) => {
@@ -849,19 +963,19 @@ const WebWorkerRpcClient = {
 const RendererWorker = 1;
 
 const rpcs = Object.create(null);
-const set = (id, rpc) => {
+const set$1 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get = id => {
+const get$1 = id => {
   return rpcs[id];
 };
 
 const invoke = (method, ...params) => {
-  const rpc = get(RendererWorker);
+  const rpc = get$1(RendererWorker);
   return rpc.invoke(method, ...params);
 };
 const invokeAndTransfer = (method, ...params) => {
-  const rpc = get(RendererWorker);
+  const rpc = get$1(RendererWorker);
   return rpc.invokeAndTransfer(method, ...params);
 };
 
@@ -959,7 +1073,20 @@ const importTest = async url => {
   }
 };
 
-// @ts-nocheck
+const webViews = Object.create(null);
+const set = (id, webView) => {
+  webViews[id] = webView;
+};
+const get = id => {
+  return webViews[id];
+};
+
+const getLocatorRpc = locator => {
+  if (locator.webViewId) {
+    return get(locator.webViewId);
+  }
+  return Rpc;
+};
 
 const Assert = {
   string(value, message) {
@@ -976,10 +1103,9 @@ const Assert = {
 const expect$1 = locator => {
   const {
     invoke
-  } = locator.webView || Rpc;
+  } = getLocatorRpc(locator);
   return {
     async checkSingleElementCondition(fnName, options) {
-      Assert.string(fnName);
       // TODO add rpcId property to locator instead
       return invoke('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
     },
@@ -1040,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
       });
@@ -1121,10 +1247,8 @@ const Locator = function (selector, {
   this._hasText = hasText;
 };
 const performAction = async (locator, action, options) => {
-  const {
-    invoke
-  } = locator.webView || Rpc;
-  return invoke('TestFrameWork.performAction', locator, action, options);
+  const rpc = getLocatorRpc(locator);
+  return rpc.invoke('TestFrameWork.performAction', locator, action, options);
 };
 Locator.prototype.click = async function ({
   button = 'left'
@@ -1308,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 => {
@@ -2234,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,
@@ -2261,33 +2375,23 @@ 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);
-    }
-  };
+  const rpc = await createPortIpc(webViewId);
+  set(webViewId, rpc);
   return {
     locator(selector, options) {
       const baseLocator = create(selector, options);
-      baseLocator.webView = webViewRpc;
+      baseLocator.webViewId = webViewId;
       return baseLocator;
-    },
-    expect: expect$1
+    }
   };
 };
 
@@ -2379,7 +2483,7 @@ const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set(RendererWorker, rpc);
+  set$1(RendererWorker, rpc);
 };
 
 const main = async () => {

package/package.json

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