@lvce-editor/test-worker 5.0.0 → 5.1.0

package/dist/testWorkerMain.js

@@ -521,7 +521,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
+const set$3 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -540,7 +540,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  set$3(id, resolve);
   return {
     id,
     promise
@@ -1034,33 +1034,17 @@ const WebWorkerRpcClient = {
   create: create$2
 };
 
-const formatDuration = duration => {
-  return duration.toFixed(2) + 'ms';
-};
-
-const printError = error => {
-  if (error && error.constructor.name === 'AssertionError') {
-    console.error(error.message);
-  } else {
-    console.error(error);
-  }
-};
-
-const printTestError = async error => {
-  // TODO ask error worker to add codeframe
-  printError(error);
-};
+const RendererWorker = 1;
+const TestWorker = 9001;
 
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create$1 = rpcId => {
   return {
     // @ts-ignore
@@ -1076,7 +1060,7 @@ const create$1 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
+      set$2(rpcId, rpc);
     },
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1084,29 +1068,33 @@ const create$1 = rpcId => {
     }
   };
 };
-const RendererWorker$1 = 1;
+
 const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$3,
-  set: set$3} = create$1(RendererWorker$1);
-const sendMessagePortToEditorWorker$1 = async (port, rpcId) => {
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$1} = create$1(RendererWorker);
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
 };
-const RendererWorker = {
-  __proto__: null,
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$3,
-  sendMessagePortToEditorWorker: sendMessagePortToEditorWorker$1,
-  set: set$3};
 
-const {
-  set: set$1,
-  invoke: invoke$1,
-  invokeAndTransfer,
-  sendMessagePortToEditorWorker
-} = RendererWorker;
+const formatDuration = duration => {
+  return duration.toFixed(2) + 'ms';
+};
+
+const printError = error => {
+  if (error && error.constructor.name === 'AssertionError') {
+    console.error(error.message);
+  } else {
+    console.error(error);
+  }
+};
+
+const printTestError = async error => {
+  // TODO ask error worker to add codeframe
+  printError(error);
+};
 
 const stringifyError = error => {
   if (!error) {
@@ -1383,102 +1371,106 @@ const number = (value, message) => {
 };
 
 const expect$1 = locator => {
-  return {
-    negated: false,
-    async checkSingleElementCondition(fnName, options) {
-      // TODO add rpcId property to locator instead
-      const result = await locatorInvoke(locator, 'TestFrameWork.checkSingleElementCondition', locator, fnName, options);
-      if (result && result.error) {
-        const fn = getFunction(fnName);
-        const errorInfo = await fn(locator, options);
-        throw new AssertionError(errorInfo);
-      }
-    },
-    async checkMultiElementCondition(fnName, options) {
-      const result = await locatorInvoke(locator, 'TestFrameWork.checkMultiElementCondition', locator, fnName, options);
-      if (result && result.error) {
-        const fn = getFunction(fnName);
-        const errorInfo = await fn(locator, options);
-        throw new AssertionError(errorInfo);
-      }
-    },
-    async toBeVisible() {
-      if (this.negated) {
-        throw new Error('use toBeHidden instead of not.toBeVisible');
-      }
-      return this.checkSingleElementCondition('toBeVisible', {});
-    },
-    async toHaveText(text) {
-      string(text, 'text must be of type string');
-      return this.checkSingleElementCondition('toHaveText', {
-        text
-      });
-    },
-    async toContainText(text) {
-      string(text, 'text must be of type string');
-      return this.checkSingleElementCondition('toContainText', {
-        text
-      });
-    },
-    async toHaveValue(value) {
-      string(value, 'value must be of type string');
-      return this.checkSingleElementCondition('toHaveValue', {
-        value
-      });
-    },
-    async toBeFocused() {
-      return this.checkSingleElementCondition('toBeFocused');
-    },
-    async toHaveCSS(key, value) {
-      return this.checkSingleElementCondition('toHaveCss', {
-        key,
-        value
-      });
-    },
-    async toHaveAttribute(key, value) {
-      string(key, 'key must be of type string');
-      // Assert.string(value, 'value must be of type string')
-      return this.checkSingleElementCondition('toHaveAttribute', {
-        key,
-        value
-      });
-    },
-    async toHaveJSProperty(key, value) {
-      string(key, 'key must be of type string');
-      return this.checkSingleElementCondition('toHaveJSProperty', {
-        key,
-        value
-      });
-    },
-    async toHaveClass(className) {
-      string(className, 'className must be of type string');
-      return this.checkSingleElementCondition('toHaveClass', {
-        className
-      });
-    },
-    async toHaveId(id) {
-      string(id, 'id must be of type string');
-      return this.checkSingleElementCondition('toHaveId', {
-        id
-      });
-    },
-    async toHaveCount(count) {
-      number(count, 'count must be of type number');
-      return this.checkMultiElementCondition('toHaveCount', {
-        count
-      });
-    },
-    async toBeHidden() {
-      return this.checkMultiElementCondition('toBeHidden', {});
-    },
-    get not() {
-      this.negated = true;
-      return this;
+  return new Expect(locator);
+};
+class Expect {
+  negated = false;
+  constructor(locator, negated = false) {
+    this.locator = locator;
+    this.negated = negated;
+  }
+  async checkSingleElementCondition(fnName, options) {
+    // TODO add rpcId property to locator instead
+    const result = await locatorInvoke(this.locator, 'TestFrameWork.checkSingleElementCondition', this.locator, fnName, options);
+    if (result && result.error) {
+      const fn = getFunction(fnName);
+      const errorInfo = await fn(this.locator, options);
+      throw new AssertionError(errorInfo);
     }
-  };
-};
+  }
+  async checkMultiElementCondition(fnName, options) {
+    const result = await locatorInvoke(this.locator, 'TestFrameWork.checkMultiElementCondition', this.locator, fnName, options);
+    if (result && result.error) {
+      const fn = getFunction(fnName);
+      const errorInfo = await fn(this.locator, options);
+      throw new AssertionError(errorInfo);
+    }
+  }
+  async toBeVisible() {
+    if (this.negated) {
+      throw new Error('use toBeHidden instead of not.toBeVisible');
+    }
+    return this.checkSingleElementCondition('toBeVisible', {});
+  }
+  async toHaveText(text) {
+    string(text, 'text must be of type string');
+    return this.checkSingleElementCondition('toHaveText', {
+      text
+    });
+  }
+  async toContainText(text) {
+    string(text, 'text must be of type string');
+    return this.checkSingleElementCondition('toContainText', {
+      text
+    });
+  }
+  async toHaveValue(value) {
+    string(value, 'value must be of type string');
+    return this.checkSingleElementCondition('toHaveValue', {
+      value
+    });
+  }
+  async toBeFocused() {
+    return this.checkSingleElementCondition('toBeFocused');
+  }
+  async toHaveCSS(key, value) {
+    return this.checkSingleElementCondition('toHaveCss', {
+      key,
+      value
+    });
+  }
+  async toHaveAttribute(key, value) {
+    string(key, 'key must be of type string');
+    // Assert.string(value, 'value must be of type string')
+    return this.checkSingleElementCondition('toHaveAttribute', {
+      key,
+      value
+    });
+  }
+  async toHaveJSProperty(key, value) {
+    string(key, 'key must be of type string');
+    return this.checkSingleElementCondition('toHaveJSProperty', {
+      key,
+      value
+    });
+  }
+  async toHaveClass(className) {
+    string(className, 'className must be of type string');
+    return this.checkSingleElementCondition('toHaveClass', {
+      className
+    });
+  }
+  async toHaveId(id) {
+    string(id, 'id must be of type string');
+    return this.checkSingleElementCondition('toHaveId', {
+      id
+    });
+  }
+  async toHaveCount(count) {
+    number(count, 'count must be of type number');
+    return this.checkMultiElementCondition('toHaveCount', {
+      count
+    });
+  }
+  async toBeHidden() {
+    return this.checkMultiElementCondition('toBeHidden', {});
+  }
+  get not() {
+    return new Expect(this.locator, !this.negated);
+  }
+}
 
-const Expect = {
+const Expect$1 = {
   __proto__: null,
   expect: expect$1
 };
@@ -1608,7 +1600,7 @@ test.skip = async id => {
 };
 const {
   expect
-} = Expect;
+} = Expect$1;
 
 const TestFrameWork = {
   __proto__: null,
@@ -1872,8 +1864,7 @@ const areSelectionsEqual = (a, b) => {
 };
 
 const send = async port => {
-  const rpcId = 9001;
-  await sendMessagePortToEditorWorker(port, rpcId);
+  await sendMessagePortToEditorWorker(port, TestWorker);
 };
 const launchEditorWorkerRpc = async () => {
   const rpc = await TransferMessagePortRpcParent.create({
@@ -3357,6 +3348,7 @@ const waitForFirstEventEvent = async port => {
 };
 
 const createPortIpc = async webViewId => {
+  // TODO use transforpemssageportrpc
   const {
     port1,
     port2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-worker",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "Test Worker",
   "repository": {
     "type": "git",