@lvce-editor/test-worker 4.44.0 → 5.1.0

package/dist/api.d.ts

@@ -131,6 +131,10 @@ declare const selectIndices: (indices: readonly number[]) => Promise<void>;
 declare const toggleIndividualSelection: (index: number) => Promise<void>;
 declare const addWebExtension: (relativePath: string) => Promise<void>;
 declare const addNodeExtension: (relativePath: string) => Promise<void>;
+declare const handleClickCategory: (categoryId: string) => Promise<void>;
+declare const handleClickEnable: () => Promise<void>;
+declare const handleClickDisable: () => Promise<void>;
+declare const handleClickSetColorTheme: () => Promise<void>;
 declare const selectFeature: (name: string) => Promise<void>;
 declare const selectTab: (name: string) => Promise<void>;
 declare const selectDetails: () => Promise<void>;
@@ -346,7 +350,7 @@ declare namespace Extension {
 	export { addNodeExtension, addWebExtension };
 }
 declare namespace ExtensionDetail {
-	export { handleScroll, open, openCommands, openFeature, openJsonValidation, openRuntimeStatus, openSettings, openThemes, openWebViews, selectChangelog, selectDetails, selectFeature, selectFeatures, selectTab };
+	export { handleClickCategory, handleClickDisable, handleClickEnable, handleClickSetColorTheme, handleScroll, open, openCommands, openFeature, openJsonValidation, openRuntimeStatus, openSettings, openThemes, openWebViews, selectChangelog, selectDetails, selectFeature, selectFeatures, selectTab };
 }
 declare namespace FileSystem {
 	export { chmod, createExecutable, createExecutableFrom, getTmpDir, mkdir, readFile, remove, writeFile, writeJson };

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,101 +1371,106 @@ const number = (value, message) => {
 };
 
 const expect$1 = locator => {
-  return {
-    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
 };
@@ -1528,70 +1521,68 @@ const toButtonNumber = buttonType => {
 };
 
 const create = (selector, options = {}) => {
-  // @ts-ignore
   return new Locator(selector, options);
 };
-const Locator = function (selector, {
-  nth = -1,
-  hasText = ''
-} = {}) {
-  // @ts-ignore
-  this._selector = selector;
-  // @ts-ignore
-  this._nth = nth;
-  // @ts-ignore
-  this._hasText = hasText;
-};
 const performAction = async (locator, action, options) => {
   const invoke = getLocatorInvoke(locator);
   return invoke('TestFrameWork.performAction', locator, action, options);
 };
-Locator.prototype.click = async function ({
-  button = 'left'
-} = {}) {
-  const options = {
-    cancable: true,
-    bubbles: true,
-    button: toButtonNumber(button),
-    detail: 1
-  };
-  return performAction(this, 'click', options);
-};
-Locator.prototype.hover = async function () {
-  const options = {
-    cancable: true,
-    bubbles: true
-  };
-  return performAction(this, 'hover', options);
-};
-Locator.prototype.first = function () {
-  return create(this._selector, {
-    nth: 0
-  });
-};
-Locator.prototype.locator = function (subSelector) {
-  if (this._nth !== -1) {
-    return create(`${this._selector}:nth-of-type(${this._nth + 1}) ${subSelector}`);
+class Locator {
+  constructor(selector, {
+    nth = -1,
+    hasText = ''
+  } = {}) {
+    this._selector = selector;
+    this._nth = nth;
+    this._hasText = hasText;
+  }
+  async click({
+    button = 'left'
+  } = {}) {
+    const options = {
+      cancable: true,
+      bubbles: true,
+      button: toButtonNumber(button),
+      detail: 1
+    };
+    return performAction(this, 'click', options);
   }
-  return create(`${this._selector} ${subSelector}`);
-};
-Locator.prototype.nth = function (nth) {
-  return create(this._selector, {
-    nth
-  });
-};
-Locator.prototype.type = async function (text) {
-  const options = {
-    text
-  };
-  return performAction(this, 'type', options);
-};
-Locator.prototype.dispatchEvent = async function (type, init) {
-  return performAction(this, 'dispatchEvent', {
-    type,
-    init
-  });
-};
+  async hover() {
+    const options = {
+      cancable: true,
+      bubbles: true
+    };
+    return performAction(this, 'hover', options);
+  }
+  first() {
+    return create(this._selector, {
+      nth: 0
+    });
+  }
+  locator(subSelector) {
+    if (this._nth !== -1) {
+      return create(`${this._selector}:nth-of-type(${this._nth + 1}) ${subSelector}`);
+    }
+    return create(`${this._selector} ${subSelector}`);
+  }
+  nth(nth) {
+    return create(this._selector, {
+      nth
+    });
+  }
+  async type(text) {
+    const options = {
+      text
+    };
+    return performAction(this, 'type', options);
+  }
+  async dispatchEvent(type, init) {
+    return performAction(this, 'dispatchEvent', {
+      type,
+      init
+    });
+  }
+}
 
 const getTmpDir$1 = async () => {
   return 'memfs://';
@@ -1609,7 +1600,7 @@ test.skip = async id => {
 };
 const {
   expect
-} = Expect;
+} = Expect$1;
 
 const TestFrameWork = {
   __proto__: null,
@@ -1873,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({
@@ -2359,6 +2349,22 @@ const TestFrameWorkComponentExtension = {
   addWebExtension
 };
 
+const handleClickCategory = async categoryId => {
+  // @ts-ignore
+  await invoke$1('ExtensionDetail.handleClickCategory', categoryId);
+};
+const handleClickEnable = async () => {
+  // @ts-ignore
+  await invoke$1('ExtensionDetail.handleClickEnable');
+};
+const handleClickDisable = async () => {
+  // @ts-ignore
+  await invoke$1('ExtensionDetail.handleClickDisable');
+};
+const handleClickSetColorTheme = async () => {
+  // @ts-ignore
+  await invoke$1('ExtensionDetail.handleClickSetColorTheme');
+};
 const selectFeature = name => {
   return invoke$1('ExtensionDetail.selectFeature', name);
 };
@@ -2407,6 +2413,10 @@ const handleScroll$1 = async scrollTop => {
 
 const TestFrameWorkComponentExtensionDetail = {
   __proto__: null,
+  handleClickCategory,
+  handleClickDisable,
+  handleClickEnable,
+  handleClickSetColorTheme,
   handleScroll: handleScroll$1,
   open: open$4,
   openCommands,
@@ -3338,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": "4.44.0",
+  "version": "5.1.0",
   "description": "Test Worker",
   "repository": {
     "type": "git",