@lvce-editor/test-worker 16.8.0 → 17.0.1

package/dist/api.d.ts

@@ -168,8 +168,28 @@ export interface LayoutExpectation extends LayoutExpectationObject {
 	readonly groups?: readonly LayoutExpectationObject[];
 }
 
+export interface OpenInputOptions {
+	readonly editorInput: EditorInput;
+	readonly focu: boolean;
+	readonly preview?: boolean;
+}
+
+export interface LocatorClickOptions {
+	readonly button?: string;
+}
+
+export interface ILocatorExternal {
+	readonly click: (options?: LocatorClickOptions) => Promise<void>;
+	readonly dispatchEvent: (type: string, init: string) => Promise<void>;
+	readonly first: () => ILocatorExternal;
+	readonly hover: () => Promise<void>;
+	readonly locator: (subSelector: string) => ILocatorExternal;
+	readonly nth: (nth: number) => ILocatorExternal;
+	readonly type: (text: string) => Promise<void>;
+}
+
 export interface SelectItemOptions {
-	readonly waitUntil?: SelectItemWaitUntil;
+	readonly waitUntil?: "done" | "quickPick" | "none";
 }
 
 export interface SelectItem2Options {
@@ -203,6 +223,8 @@ export type DiffLayout = "horizontal" | "vertical";
 
 export type TokenRow = readonly string[];
 
+export type ExtensionStatus = "disabled" | "enabled" | "installing" | "not-installed" | "uninstalling";
+
 export type LayoutDirection = "horizontal" | "vertical" | number;
 
 export type LayoutExpectationValue = string | number | boolean | RegExp | null | readonly LayoutExpectationValue[] | LayoutExpectationObject;
@@ -226,7 +248,23 @@ export type SavedState = {
 	readonly layout?: LayoutState;
 };
 
-export type SelectItemWaitUntil = "done" | "quickPick" | "none";
+export type EditorInput = {
+	readonly type: "editor";
+	readonly uri: string;
+} | {
+	readonly type: "image";
+	readonly uri: string;
+} | {
+	readonly type: "video";
+	readonly uri: string;
+} | {
+	readonly type: "diff-editor";
+	readonly uriLeft: string;
+	readonly uriRight: string;
+} | {
+	readonly extensionId: string;
+	readonly type: "extension-detail-view";
+};
 
 export type SearchInputType = "SearchValue" | "ReplaceValue" | "IncludeValue" | "ExcludeValue";
 
@@ -616,6 +654,8 @@ interface Explorer {
 interface Extension {
   readonly addNodeExtension: (relativePath: string) => Promise<void>;
   readonly addWebExtension: (relativePath: string) => Promise<void>;
+  readonly disableWorkspace: (id: string) => Promise<void>;
+  readonly enableWorkspace: (id: string) => Promise<void>;
   readonly executeCompletionProvider: (textDocument: CompletionTextDocument, ...args: readonly unknown[]) => Promise<readonly CompletionItem[]>;
   readonly executeFormattingProvider: (textDocument: FormattingTextDocument, ...args: readonly unknown[]) => Promise<readonly FormattingEdit[]>;
 }
@@ -658,6 +698,7 @@ interface ExtensionSearch {
   readonly handleContextMenu: (button: number, x: number, y: number) => Promise<void>;
   readonly handleInput: (value: string) => Promise<void>;
   readonly open: () => Promise<void>;
+  readonly setExtensionStatus: (id: string, status: ExtensionStatus) => Promise<void>;
 }
 
 interface FileSystem {
@@ -733,7 +774,7 @@ interface Git {
   readonly setOrigin: (remoteUrl: string) => Promise<void>;
   readonly setUpstream: (remoteUrl: string) => Promise<void>;
   readonly shouldHaveCommit: (message: string) => Promise<void>;
-  readonly shouldHaveInvocations: (invocations: readonly GitInvocation[]) => Promise<void>;
+  readonly shouldHaveInvocations: (expectedInvocations: readonly GitInvocation[]) => Promise<void>;
   readonly stage: (pathSpec: string) => Promise<void>;
   readonly stash: (message?: string) => Promise<void>;
   readonly status: () => Promise<unknown>;
@@ -793,6 +834,7 @@ interface LanguageModels {
 }
 
 interface Layout {
+  readonly getSideBarPosition: () => Promise<number>;
   readonly handleWorkspaceRefresh: () => Promise<void>;
   readonly hideSecondarySideBar: () => Promise<void>;
   readonly hideSideBar: () => Promise<void>;
@@ -817,6 +859,7 @@ interface Main {
   readonly handleClickTogglePreview: () => Promise<void>;
   readonly handleModifiedStatusChange: (uri: string, newStatus: boolean) => Promise<void>;
   readonly handleTabContextMenu: (button: number, x: number, y: number) => Promise<void>;
+  readonly openInput: (options: OpenInputOptions) => Promise<void>;
   readonly openKeyBindings: () => Promise<void>;
   readonly openUri: (uri: string) => Promise<void>;
   readonly save: () => Promise<void>;
@@ -867,6 +910,46 @@ interface Preview {
   readonly waitForMutation: () => Promise<void>;
 }
 
+interface ProcessExplorer {
+  readonly clickRow: (index: number) => Promise<void>;
+  readonly collapseAll: () => Promise<void>;
+  readonly collapsedRow: () => ILocatorExternal;
+  readonly debugProcess: (index?: number) => Promise<void>;
+  readonly doubleClickRow: (index?: number) => Promise<void>;
+  readonly error: () => ILocatorExternal;
+  readonly expandAll: () => Promise<void>;
+  readonly expandedRow: () => ILocatorExternal;
+  readonly focusFirst: () => Promise<void>;
+  readonly focusLast: () => Promise<void>;
+  readonly focusNext: () => Promise<void>;
+  readonly focusPrevious: () => Promise<void>;
+  readonly focusedRow: () => ILocatorExternal;
+  readonly handleArrowLeft: () => Promise<void>;
+  readonly handleArrowRight: () => Promise<void>;
+  readonly headerCell: (index: number) => ILocatorExternal;
+  readonly killProcess: (index?: number) => Promise<void>;
+  readonly memoryCell: (index: number) => ILocatorExternal;
+  readonly memoryHeader: () => ILocatorExternal;
+  readonly nameCell: (index: number) => ILocatorExternal;
+  readonly nameHeader: () => ILocatorExternal;
+  readonly open: () => Promise<void>;
+  readonly openContextMenu: (index?: number) => Promise<void>;
+  readonly pidCell: (index: number) => ILocatorExternal;
+  readonly pidHeader: () => ILocatorExternal;
+  readonly refresh: () => Promise<void>;
+  readonly root: () => ILocatorExternal;
+  readonly row: (index: number) => ILocatorExternal;
+  readonly rows: () => ILocatorExternal;
+  readonly shouldBeHealthy: () => Promise<void>;
+  readonly shouldBeOpen: () => Promise<void>;
+  readonly shouldHaveCollapsedRow: () => Promise<void>;
+  readonly shouldHaveExpandedRow: () => Promise<void>;
+  readonly shouldHaveFocusedRow: () => Promise<void>;
+  readonly shouldHaveHeaders: () => Promise<void>;
+  readonly shouldHaveRow: (index?: number) => Promise<void>;
+  readonly table: () => ILocatorExternal;
+}
+
 interface Problems {
   readonly copyMessage: () => Promise<void>;
   readonly focusIndex: (index: number) => Promise<void>;
@@ -1071,6 +1154,7 @@ export interface TestApi {
   readonly Panel: Panel
   readonly Platform: Platform
   readonly Preview: Preview
+  readonly ProcessExplorer: ProcessExplorer
   readonly Problems: Problems
   readonly QuickPick: QuickPick
   readonly References: References
@@ -1090,4 +1174,7 @@ export interface TestApi {
 
 export interface Test {
   (api: TestApi): Promise<void>
-}
+}
+
+export type BrowserName = 'chromium' | 'firefox' | 'unknown' | 'webkit'
+export type Skip = boolean | number | readonly BrowserName[]

package/dist/testWorkerMain.js

@@ -145,7 +145,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -601,8 +600,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -613,55 +614,77 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    error.stack = error.stack + NewLine + currentStack;
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  restoredError.stack = parentStack + NewLine + currentStack;
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+    return;
+  }
+  if (error.data.stack) {
+    restoredError.stack = error.data.stack;
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  if (!error.data) {
+    return;
+  }
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -1265,17 +1288,53 @@ const initializeOpenerWorker = async () => {
   set$3(rpc);
 };
 
+// @ts-nocheck
+
 const state$3 = {
+  mockRpcs: Object.create(null),
+  /**
+   * @type {any[]}
+   */
+  pendingTests: []
+};
+const addTest = (name, fn) => {
+  state$3.pendingTests.push({
+    fn,
+    name
+  });
+};
+const setMockRpc = mockRpc => {
+  object(mockRpc);
+  string$1(mockRpc.name);
+  state$3.mockRpcs[mockRpc.name] = mockRpc;
+};
+const getMockRpc = name => {
+  return state$3.mockRpcs[name];
+};
+
+const executeMockRpcFunction = async (name, method, ...params) => {
+  const mockRpc = getMockRpc(name);
+  if (!mockRpc) {
+    throw new Error(`mock rpc not found: ${name}`);
+  }
+  const fn = mockRpc.commands?.[method];
+  if (typeof fn !== 'function') {
+    throw new TypeError(`mock rpc command not found: ${name}.${method}`);
+  }
+  return fn(...params);
+};
+
+const state$2 = {
   autoFixError: undefined
 };
 const get$1 = () => {
-  return state$3.autoFixError;
+  return state$2.autoFixError;
 };
 const set$1 = value => {
-  state$3.autoFixError = value;
+  state$2.autoFixError = value;
 };
 const clear$3 = () => {
-  state$3.autoFixError = undefined;
+  state$2.autoFixError = undefined;
 };
 
 class AssertionError extends Error {
@@ -1618,27 +1677,6 @@ const nameAnonymousFunction = (fn, name) => {
   });
 };
 
-// @ts-nocheck
-
-const state$2 = {
-  mockRpcs: Object.create(null),
-  /**
-   * @type {any[]}
-   */
-  pendingTests: []
-};
-const addTest = (name, fn) => {
-  state$2.pendingTests.push({
-    fn,
-    name
-  });
-};
-const setMockRpc = mockRpc => {
-  object(mockRpc);
-  string$1(mockRpc.name);
-  state$2.mockRpcs[mockRpc.name] = mockRpc;
-};
-
 class CssParsingError extends Error {
   constructor(message) {
     super(message);
@@ -1837,16 +1875,16 @@ const handleClickClose$1 = async () => {
 const handleClickCopy = async () => {
   return invoke('About.handleClickCopy');
 };
-const focusNext$9 = async () => {
+const focusNext$a = async () => {
   return invoke('About.focusNext');
 };
-const focusPrevious$8 = async () => {
+const focusPrevious$9 = async () => {
   return invoke('About.focusPrevious');
 };
 
 const About = {
-  focusNext: focusNext$9,
-  focusPrevious: focusPrevious$8,
+  focusNext: focusNext$a,
+  focusPrevious: focusPrevious$9,
   handleClickClose: handleClickClose$1,
   handleClickCopy,
   handleClickOk,
@@ -1865,19 +1903,19 @@ const toggleActivityBarItem = async id => {
 const setUserLoginState = async loginState => {
   await invoke('ActivityBar.setUserLoginState', loginState);
 };
-const focusFirst$7 = async () => {
+const focusFirst$8 = async () => {
   await invoke('ActivityBar.focusFirst');
 };
 const setAccountEnabled = async enabled => {
   await invoke('ActivityBar.setAccountEnabled', enabled);
 };
-const focusLast$6 = async () => {
+const focusLast$7 = async () => {
   await invoke('ActivityBar.focusLast');
 };
-const focusNext$8 = async () => {
+const focusNext$9 = async () => {
   await invoke('ActivityBar.focusNext');
 };
-const focusPrevious$7 = async () => {
+const focusPrevious$8 = async () => {
   await invoke('ActivityBar.focusPrevious');
 };
 const handleClick$4 = async index => {
@@ -1904,10 +1942,10 @@ const resize = async dimensions => {
 
 const ActivityBar = {
   focus: focus$2,
-  focusFirst: focusFirst$7,
-  focusLast: focusLast$6,
-  focusNext: focusNext$8,
-  focusPrevious: focusPrevious$7,
+  focusFirst: focusFirst$8,
+  focusLast: focusLast$7,
+  focusNext: focusNext$9,
+  focusPrevious: focusPrevious$8,
   handleClick: handleClick$4,
   handleClickSettings: handleClickSettings$1,
   handleContextMenu: handleContextMenu$5,
@@ -1924,8 +1962,13 @@ const execute$1 = async (id, ...args) => {
   return invoke(id, ...args);
 };
 const executeExtensionCommand = async (commandId, ...args) => {
-  // TODO maybe ask extension-management-worker instead
-  return invoke('ExtensionHost.executeCommand', commandId, ...args);
+  try {
+    return await invoke$2('Extensions.executeExtensionCommand', commandId, ...args);
+  } catch {
+    // legacy
+    // TODO maybe ask extension-management-worker instead
+    return invoke('ExtensionHost.executeCommand', commandId, ...args);
+  }
 };
 
 const Command = {
@@ -2282,7 +2325,7 @@ class ChatDebugShouldHavePayloadError extends Error {
   }
 }
 
-const open$a = async sessionId => {
+const open$b = async sessionId => {
   await invoke('Main.openUri', `chat-debug://${sessionId}`);
 };
 const open2 = async ({
@@ -2453,7 +2496,7 @@ const ChatDebug = {
   handleTimelinePointerDown,
   handleTimelinePointerMove,
   handleTimelinePointerUp,
-  open: open$a,
+  open: open$b,
   open2,
   openTab,
   openTabHeaders,
@@ -2679,6 +2722,9 @@ const serializeForError = value => {
 const openUri = async uri => {
   await invoke('Main.openUri', uri);
 };
+const openInput = async options => {
+  await invoke('Main.openInput', options);
+};
 const saveState = async uid => {
   return invoke('Main.saveState', uid);
 };
@@ -2740,19 +2786,19 @@ const save = async () => {
 const saveAll = async () => {
   await invoke('Main.saveAll');
 };
-const focusFirst$6 = async () => {
+const focusFirst$7 = async () => {
   await invoke('Main.focusFirst');
 };
-const focusNext$7 = async () => {
+const focusNext$8 = async () => {
   await invoke('Main.focusNext');
 };
-const focusPrevious$6 = async () => {
+const focusPrevious$7 = async () => {
   await invoke('Main.focusPrevious');
 };
 const handleClickCloseTab = async (rawGroupIndex, rawIndex) => {
   await invoke('Main.handleClickCloseTab', rawGroupIndex, rawIndex);
 };
-const focusLast$5 = async () => {
+const focusLast$6 = async () => {
   await invoke('Main.focusLast');
 };
 const handleTabContextMenu = async (button, x, y) => {
@@ -2773,15 +2819,16 @@ const Main = {
   closeTabsRight,
   copyPath: copyPath$2,
   copyRelativePath: copyRelativePath$1,
-  focusFirst: focusFirst$6,
-  focusLast: focusLast$5,
-  focusNext: focusNext$7,
-  focusPrevious: focusPrevious$6,
+  focusFirst: focusFirst$7,
+  focusLast: focusLast$6,
+  focusNext: focusNext$8,
+  focusPrevious: focusPrevious$7,
   handleClickAction,
   handleClickCloseTab,
   handleClickTogglePreview,
   handleModifiedStatusChange,
   handleTabContextMenu,
+  openInput,
   openKeyBindings,
   openUri,
   save,
@@ -2793,7 +2840,7 @@ const Main = {
   splitRight
 };
 
-const open$9 = async (leftUri, rightUri) => {
+const open$a = async (leftUri, rightUri) => {
   await openUri(`diff://${leftUri}<->${rightUri}`);
 };
 const shouldHaveContentLeft = async expectedContent => {
@@ -2871,7 +2918,7 @@ const DiffView = {
   handleScrollBarPointerUp,
   handleWheel: handleWheel$3,
   handleWorkspaceChange,
-  open: open$9,
+  open: open$a,
   setCursorPosition,
   setDiffMode,
   setFontFamily,
@@ -3196,7 +3243,7 @@ const copy$1 = async () => {
 const closeColorPicker = async () => {
   await invoke('Editor.closeColorPicker');
 };
-const openContextMenu$1 = async () => {
+const openContextMenu$2 = async () => {
   const button = 0;
   const x = 0;
   const y = 0;
@@ -3345,7 +3392,7 @@ const Editor = {
   openColorPicker,
   openCompletion,
   openCompletionDetails,
-  openContextMenu: openContextMenu$1,
+  openContextMenu: openContextMenu$2,
   openEditorContextMenu,
   openFind,
   openFindWidget,
@@ -3457,7 +3504,7 @@ const EditorSourceAction = {
   selectIndex: selectIndex$5
 };
 
-const openContextMenu = async index => {
+const openContextMenu$1 = async index => {
   await invoke('Explorer.handleContextMenuKeyboard', index);
 };
 const handleDragLeave = async () => {
@@ -3481,7 +3528,7 @@ const focus$1 = async () => {
 const setDeltaY = async deltaY => {
   await invoke('Explorer.setDeltaY', deltaY);
 };
-const focusNext$6 = async () => {
+const focusNext$7 = async () => {
   await invoke('Explorer.focusNext');
 };
 const selectUp = async () => {
@@ -3493,10 +3540,10 @@ const handleDragOverIndex = async index => {
 const selectDown = async () => {
   await invoke('Explorer.selectDown');
 };
-const collapseAll$2 = async () => {
+const collapseAll$3 = async () => {
   await invoke('Explorer.collapseAll');
 };
-const refresh$1 = async () => {
+const refresh$2 = async () => {
   await invoke('Explorer.refresh');
 };
 const focusIndex$5 = async index => {
@@ -3505,13 +3552,13 @@ const focusIndex$5 = async index => {
 const clickCurrent = async () => {
   await invoke('Explorer.handleClickCurrent');
 };
-const handleArrowLeft$1 = async () => {
+const handleArrowLeft$2 = async () => {
   await invoke('Explorer.handleArrowLeft');
 };
-const focusLast$4 = async () => {
+const focusLast$5 = async () => {
   await invoke('Explorer.focusLast');
 };
-const focusFirst$5 = async () => {
+const focusFirst$6 = async () => {
   await invoke('Explorer.focusFirst');
 };
 const removeDirent = async () => {
@@ -3559,7 +3606,7 @@ const acceptEdit = async () => {
 const updateEditingValue = async value => {
   await invoke('Explorer.updateEditingValue', value);
 };
-const expandAll = async () => {
+const expandAll$1 = async () => {
   await invoke('Explorer.expandAll');
 };
 const handleDragOver = async (x, y) => {
@@ -3585,17 +3632,17 @@ const Explorer = {
   acceptEdit,
   cancelEdit,
   clickCurrent,
-  collapseAll: collapseAll$2,
+  collapseAll: collapseAll$3,
   copyPath: copyPath$1,
   copyRelativePath,
-  expandAll,
+  expandAll: expandAll$1,
   expandRecursively,
   focus: focus$1,
-  focusFirst: focusFirst$5,
+  focusFirst: focusFirst$6,
   focusIndex: focusIndex$5,
-  focusLast: focusLast$4,
-  focusNext: focusNext$6,
-  handleArrowLeft: handleArrowLeft$1,
+  focusLast: focusLast$5,
+  focusNext: focusNext$7,
+  handleArrowLeft: handleArrowLeft$2,
   handleBlur,
   handleClick: handleClick$3,
   handleClickAt: handleClickAt$2,
@@ -3611,8 +3658,8 @@ const Explorer = {
   handlePaste,
   newFile,
   newFolder,
-  openContextMenu,
-  refresh: refresh$1,
+  openContextMenu: openContextMenu$1,
+  refresh: refresh$2,
   removeDirent,
   rename,
   renameDirent,
@@ -3637,6 +3684,12 @@ const executeFormattingProvider = async (textDocument, ...args) => {
 const executeCompletionProvider = async (textDocument, ...args) => {
   return invoke$2('Extensions.executeCompletionProvider', textDocument, ...args);
 };
+const enableWorkspace = async id => {
+  await invoke$2('Extensions.enableWorkspace', id);
+};
+const disableWorkspace = async id => {
+  await invoke$2('Extensions.disableWorkspace', id);
+};
 const addNodeExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
@@ -3646,6 +3699,8 @@ const addNodeExtension = async relativePath => {
 const Extension = {
   addNodeExtension,
   addWebExtension,
+  disableWorkspace,
+  enableWorkspace,
   executeCompletionProvider,
   executeFormattingProvider
 };
@@ -3689,7 +3744,7 @@ const focusNextTab = async () => {
 const focusPreviousTab = async () => {
   await invoke('ExtensionDetail.focusPreviousTab');
 };
-const open$8 = extensionId => {
+const open$9 = extensionId => {
   const uri = `extension-detail://${extensionId}`;
   return invoke('Main.openUri', uri);
 };
@@ -3744,7 +3799,7 @@ const ExtensionDetail = {
   handleScroll: handleScroll$1,
   handleTabFocus,
   hideSizeLink,
-  open: open$8,
+  open: open$9,
   openCommands,
   openFeature,
   openJsonValidation,
@@ -3759,7 +3814,7 @@ const ExtensionDetail = {
   selectTab: selectTab$1
 };
 
-const open$7 = async id => {
+const open$8 = async id => {
   await invoke('SideBar.openViewlet', id);
 };
 const hide = async () => {
@@ -3768,11 +3823,11 @@ const hide = async () => {
 
 const SideBar = {
   hide,
-  open: open$7
+  open: open$8
 };
 
-const open$6 = async () => {
-  await open$7('Extensions');
+const open$7 = async () => {
+  await open$8('Extensions');
 };
 const handleInput$5 = async value => {
   await invoke('Extensions.handleInput', value, Script$1);
@@ -3795,6 +3850,9 @@ const copyExtensionId = async () => {
 const clearSearchResults$1 = async () => {
   await invoke('Extensions.clearSearchResults');
 };
+const setExtensionStatus = async (id, status) => {
+  await invoke('Extensions.setExtensionStatus', id, status);
+};
 
 const ExtensionSearch = {
   clearSearchResults: clearSearchResults$1,
@@ -3804,7 +3862,8 @@ const ExtensionSearch = {
   handleClickFilter,
   handleContextMenu: handleContextMenu$4,
   handleInput: handleInput$5,
-  open: open$6
+  open: open$7,
+  setExtensionStatus
 };
 
 const Memfs = 'memfs';
@@ -4063,10 +4122,10 @@ const FileSystem = {
   writeJson
 };
 
-const focusNext$5 = async () => {
+const focusNext$6 = async () => {
   await invoke('FindWidget.focusNext');
 };
-const focusPrevious$5 = async () => {
+const focusPrevious$6 = async () => {
   await invoke('FindWidget.focusPrevious');
 };
 const close$1 = async () => {
@@ -4112,9 +4171,9 @@ const focusPreviousElement = async () => {
 const FindWidget = {
   close: close$1,
   focusElement,
-  focusNext: focusNext$5,
+  focusNext: focusNext$6,
   focusNextElement,
-  focusPrevious: focusPrevious$5,
+  focusPrevious: focusPrevious$6,
   focusPreviousElement,
   replace,
   replaceAll: replaceAll$1,
@@ -4183,7 +4242,7 @@ const unstash = async () => {
   await executeExtensionCommand('git.unstash');
 };
 const applyStash = async () => {
-  await executeExtensionCommand('git.applystash');
+  await executeExtensionCommand('git.applyStash');
 };
 const checkout = async ref => {
   await executeExtensionCommand('git.checkout', ref);
@@ -4266,8 +4325,23 @@ const shouldHaveCommit = async message => {
     throw new Error(`Expected commit message to be "${message}", but got "${commits[0].message}"`);
   }
 };
-const shouldHaveInvocations = async invocations => {
-  // TODO
+const shouldHaveInvocations = async expectedInvocations => {
+  const response = await executeExtensionCommand('git.getInvocations');
+  const actualInvocations = response && typeof response === 'object' && 'result' in response ? response.result : response;
+  if (!Array.isArray(actualInvocations)) {
+    throw new AssertionError(`expected git invocations to be an array but got ${JSON.stringify(actualInvocations)}`);
+  }
+  let actualIndex = 0;
+  for (const expectedInvocation of expectedInvocations) {
+    const expected = JSON.stringify(expectedInvocation);
+    while (actualIndex < actualInvocations.length && JSON.stringify(actualInvocations[actualIndex]) !== expected) {
+      actualIndex++;
+    }
+    if (actualIndex === actualInvocations.length) {
+      throw new AssertionError(`expected git invocation ${expected} in ${JSON.stringify(actualInvocations)}`);
+    }
+    actualIndex++;
+  }
 };
 
 const Git = {
@@ -4324,28 +4398,28 @@ const IconTheme = {
 const selectIndex$4 = async index => {
   return invoke('IframeInspector.selectIndex', index);
 };
-const focusNext$4 = async () => {
+const focusNext$5 = async () => {
   return invoke('IframeInspector.focusNext');
 };
-const focusPrevious$4 = async () => {
+const focusPrevious$5 = async () => {
   return invoke('IframeInspector.focusPrevious');
 };
-const focusFirst$4 = async () => {
+const focusFirst$5 = async () => {
   return invoke('IframeInspector.focusFirst');
 };
-const focusLast$3 = async () => {
+const focusLast$4 = async () => {
   return invoke('IframeInspector.focusLast');
 };
 
 const IframeInspector = {
-  focusFirst: focusFirst$4,
-  focusLast: focusLast$3,
-  focusNext: focusNext$4,
-  focusPrevious: focusPrevious$4,
+  focusFirst: focusFirst$5,
+  focusLast: focusLast$4,
+  focusNext: focusNext$5,
+  focusPrevious: focusPrevious$5,
   selectIndex: selectIndex$4
 };
 
-const open$5 = async () => {
+const open$6 = async () => {
   await invoke('Main.openUri', 'app://keybindings');
 };
 const handleInput$4 = value => {
@@ -4360,19 +4434,19 @@ const handleWheel$1 = (deltaMode, deltaY) => {
 const handleDoubleClick = (x, y) => {
   return invoke('KeyBindings.handleDoubleClick', x, y);
 };
-const focusNext$3 = () => {
+const focusNext$4 = () => {
   return invoke('KeyBindings.focusNext');
 };
-const focusPrevious$3 = () => {
+const focusPrevious$4 = () => {
   return invoke('KeyBindings.focusPrevious');
 };
-const focusFirst$3 = () => {
+const focusFirst$4 = () => {
   return invoke('KeyBindings.focusFirst');
 };
 const focusIndex$4 = index => {
   return invoke('KeyBindings.focusIndex', index);
 };
-const focusLast$2 = () => {
+const focusLast$3 = () => {
   return invoke('KeyBindings.focusLast');
 };
 const toggleRecordingKeys = () => {
@@ -4421,17 +4495,17 @@ const KeyBindingsEditor = {
   clearInput,
   copyCommandId,
   copyCommandTitle,
-  focusFirst: focusFirst$3,
+  focusFirst: focusFirst$4,
   focusIndex: focusIndex$4,
-  focusLast: focusLast$2,
-  focusNext: focusNext$3,
-  focusPrevious: focusPrevious$3,
+  focusLast: focusLast$3,
+  focusNext: focusNext$4,
+  focusPrevious: focusPrevious$4,
   handleClick: handleClick$1,
   handleContextMenu: handleContextMenu$3,
   handleDoubleClick,
   handleInput: handleInput$4,
   handleWheel: handleWheel$1,
-  open: open$5,
+  open: open$6,
   removeKeyBinding,
   resetKeyBinding,
   showSameKeyBindings,
@@ -4502,7 +4576,7 @@ const KeyBoard = {
   press
 };
 
-const open$4 = async () => {
+const open$5 = async () => {
   await invoke('Main.openUri', 'language-models:///1');
 };
 const handleFilterInput$2 = async value => {
@@ -4522,7 +4596,7 @@ const LanguageModels = {
   addModel,
   clearFilterInput,
   handleFilterInput: handleFilterInput$2,
-  open: open$4,
+  open: open$5,
   removeModel
 };
 
@@ -4532,6 +4606,9 @@ const showSideBar = async () => {
 const hideSideBar = async () => {
   await execute$1('Layout.hideSideBar');
 };
+const getSideBarPosition = async () => {
+  return execute$1('Layout.getSideBarPosition');
+};
 const showSecondarySideBar = async () => {
   await execute$1('Layout.showSecondarySideBar');
 };
@@ -4543,6 +4620,7 @@ const handleWorkspaceRefresh = async () => {
 };
 
 const Layout = {
+  getSideBarPosition,
   handleWorkspaceRefresh,
   hideSecondarySideBar,
   hideSideBar,
@@ -4575,11 +4653,11 @@ const Open = {
   shouldHaveUrl
 };
 
-const open$3 = async id => {
+const open$4 = async id => {
   await invoke('Layout.showPanel', id);
 };
 const openProblems = async () => {
-  await open$3('Problems');
+  await open$4('Problems');
   await invoke('Panel.selectIndex', 0);
 };
 const maximize = async () => {
@@ -4591,13 +4669,13 @@ const unmaximize = async () => {
 
 const Panel = {
   maximize,
-  open: open$3,
+  open: open$4,
   openProblems,
   unmaximize
 };
 
 const show$5 = async () => {
-  await open$3('Output');
+  await open$4('Output');
   await invoke('Panel.selectIndex', 1);
 };
 const handleFilterInput$1 = async text => {
@@ -4651,7 +4729,7 @@ const Platform = {
   isFirefox
 };
 
-const open$2 = async uri => {
+const open$3 = async uri => {
   await invoke('Layout.showPreview', uri);
 };
 const handleClick = async hdId => {
@@ -4693,12 +4771,178 @@ const Preview = {
   handleMouseDown,
   handleMouseMove,
   handleMouseUp,
-  open: open$2,
+  open: open$3,
   setUri,
   waitForClick,
   waitForMutation
 };
 
+const invokeOptionalIndex = async (command, index) => {
+  if (index === undefined) {
+    await invoke(command);
+    return;
+  }
+  await invoke(command, index);
+};
+const open$2 = async () => {
+  await invoke('Developer.openProcessExplorer');
+};
+const refresh$1 = async () => {
+  await invoke('ProcessExplorer.refresh');
+};
+const collapseAll$2 = async () => {
+  await invoke('ProcessExplorer.collapseAll');
+};
+const expandAll = async () => {
+  await invoke('ProcessExplorer.expandAll');
+};
+const focusFirst$3 = async () => {
+  await invoke('ProcessExplorer.focusFirst');
+};
+const focusLast$2 = async () => {
+  await invoke('ProcessExplorer.focusLast');
+};
+const focusNext$3 = async () => {
+  await invoke('ProcessExplorer.focusNext');
+};
+const focusPrevious$3 = async () => {
+  await invoke('ProcessExplorer.focusPrevious');
+};
+const handleArrowLeft$1 = async () => {
+  await invoke('ProcessExplorer.handleArrowLeft');
+};
+const handleArrowRight$1 = async () => {
+  await invoke('ProcessExplorer.handleArrowRight');
+};
+const clickRow = async index => {
+  await invoke('ProcessExplorer.handleClickAt', index);
+};
+const doubleClickRow = async index => {
+  await invokeOptionalIndex('ProcessExplorer.handleDoubleClick', index);
+};
+const openContextMenu = async index => {
+  await invokeOptionalIndex('ProcessExplorer.handleContextMenu', index);
+};
+const killProcess = async index => {
+  await invokeOptionalIndex('ProcessExplorer.killProcess', index);
+};
+const debugProcess = async index => {
+  await invokeOptionalIndex('ProcessExplorer.debugProcess', index);
+};
+const root = () => {
+  return createLocator('.ProcessExplorer');
+};
+const table = () => {
+  return createLocator('.ProcessExplorerTable');
+};
+const error = () => {
+  return createLocator('.ProcessExplorerError');
+};
+const headerCell = index => {
+  return root().locator('.ProcessExplorerHeaderCell').nth(index);
+};
+const nameHeader = () => {
+  return headerCell(0);
+};
+const pidHeader = () => {
+  return headerCell(1);
+};
+const memoryHeader = () => {
+  return headerCell(2);
+};
+const rows = () => {
+  return createLocator('.ProcessExplorerRow');
+};
+const row = index => {
+  return rows().nth(index);
+};
+const focusedRow = () => {
+  return createLocator('.ProcessExplorerRowFocused');
+};
+const expandedRow = () => {
+  return createLocator('.ProcessExplorerRow[aria-expanded="true"]').first();
+};
+const collapsedRow = () => {
+  return createLocator('.ProcessExplorerRow[aria-expanded="false"]').first();
+};
+const nameCell = index => {
+  return row(index).locator('.ProcessExplorerNameCell');
+};
+const pidCell = index => {
+  return row(index).locator('.ProcessExplorerCell').nth(1);
+};
+const memoryCell = index => {
+  return row(index).locator('.ProcessExplorerCell').nth(2);
+};
+const shouldBeOpen = async () => {
+  await expect$1(root()).toBeVisible();
+  await expect$1(table()).toBeVisible();
+};
+const shouldBeHealthy = async () => {
+  await expect$1(table()).toBeVisible();
+  await expect$1(error()).toBeHidden();
+};
+const shouldHaveHeaders = async () => {
+  await expect$1(nameHeader()).toHaveText('Name');
+  await expect$1(pidHeader()).toHaveText('PID');
+  await expect$1(memoryHeader()).toHaveText('Memory');
+};
+const shouldHaveRow = async (index = 0) => {
+  await expect$1(row(index)).toBeVisible();
+  await expect$1(nameCell(index)).toBeVisible();
+  await expect$1(pidCell(index)).toBeVisible();
+  await expect$1(memoryCell(index)).toBeVisible();
+};
+const shouldHaveFocusedRow = async () => {
+  await expect$1(focusedRow()).toBeVisible();
+};
+const shouldHaveCollapsedRow = async () => {
+  await expect$1(collapsedRow()).toBeVisible();
+};
+const shouldHaveExpandedRow = async () => {
+  await expect$1(expandedRow()).toBeVisible();
+};
+
+const ProcessExplorer = {
+  clickRow,
+  collapseAll: collapseAll$2,
+  collapsedRow,
+  debugProcess,
+  doubleClickRow,
+  error,
+  expandAll,
+  expandedRow,
+  focusFirst: focusFirst$3,
+  focusLast: focusLast$2,
+  focusNext: focusNext$3,
+  focusPrevious: focusPrevious$3,
+  focusedRow,
+  handleArrowLeft: handleArrowLeft$1,
+  handleArrowRight: handleArrowRight$1,
+  headerCell,
+  killProcess,
+  memoryCell,
+  memoryHeader,
+  nameCell,
+  nameHeader,
+  open: open$2,
+  openContextMenu,
+  pidCell,
+  pidHeader,
+  refresh: refresh$1,
+  root,
+  row,
+  rows,
+  shouldBeHealthy,
+  shouldBeOpen,
+  shouldHaveCollapsedRow,
+  shouldHaveExpandedRow,
+  shouldHaveFocusedRow,
+  shouldHaveHeaders,
+  shouldHaveRow,
+  table
+};
+
 const show$4 = async () => {
   await invoke('Panel.selectIndex', 0);
 };
@@ -4864,7 +5108,7 @@ const References = {
 };
 
 const show$3 = async () => {
-  await open$7('Run And Debug');
+  await open$8('Run And Debug');
 };
 const handleClickSectionBreakPoints = async () => {
   await invoke('Run And Debug.handleClickSectionBreakPoints');
@@ -4908,7 +5152,7 @@ const RunAndDebug = {
 };
 
 const show$2 = async () => {
-  await open$7('Search');
+  await open$8('Search');
 };
 const setValue = async value => {
   await invoke('Search.handleInput', value, Script);
@@ -5135,7 +5379,7 @@ const handleContextMenu$1 = async (button, x, y) => {
   await invoke('Source Control.handleContextMenu', button, x, y);
 };
 const show = async () => {
-  await open$7('Source Control');
+  await open$8('Source Control');
 };
 
 const SourceControl = {
@@ -5414,6 +5658,7 @@ const createApi = (platform, assetDir) => {
     Platform,
     Preview,
     Problems,
+    ProcessExplorer,
     QuickPick,
     References,
     RunAndDebug,
@@ -5576,6 +5821,40 @@ const importTest = async url => {
   }
 };
 
+const includes = (userAgent, value) => {
+  return userAgent.includes(value);
+};
+const getBrowserNameFromUserAgent = userAgent => {
+  const normalized = userAgent.toLowerCase();
+  if (includes(normalized, 'firefox')) {
+    return 'firefox';
+  }
+  if (includes(normalized, 'chrome') || includes(normalized, 'chromium') || includes(normalized, 'edg')) {
+    return 'chromium';
+  }
+  if (includes(normalized, 'safari') || includes(normalized, 'applewebkit')) {
+    return 'webkit';
+  }
+  return 'unknown';
+};
+const getBrowserName = () => {
+  if (typeof navigator === 'undefined') {
+    return 'unknown';
+  }
+  return getBrowserNameFromUserAgent(navigator.userAgent);
+};
+
+const shouldSkipTestWithBrowserName = (skip, browserName) => {
+  if (Array.isArray(skip)) {
+    return skip.includes(browserName);
+  }
+  return Boolean(skip);
+};
+const shouldSkipTest = skip => {
+  const browserName = getBrowserName();
+  return shouldSkipTestWithBrowserName(skip, browserName);
+};
+
 const state = {
   items: []
 };
@@ -5661,7 +5940,7 @@ const executeAllTest = async (item, globals) => {
     if (mockRpc) {
       setMockRpc(mockRpc);
     }
-    if (skip) {
+    if (shouldSkipTest(skip)) {
       return getSkippedResult(item.name);
     }
     if (!test) {
@@ -5744,7 +6023,7 @@ const execute = async (href, platform, assetDir) => {
       setMockRpc(mockRpc);
     }
     if (test) {
-      if (skip) {
+      if (shouldSkipTest(skip)) {
         await skipTest(name);
       } else {
         await executeTest(name, test, globals);
@@ -6206,6 +6485,7 @@ const commandMap = {
   'Test.execute': execute,
   'Test.executeAll': executeAll,
   'Test.executeMock': executeMock,
+  'Test.executeMockRpcFunction': executeMockRpcFunction,
   'Test.tryAutoFix': tryAutoFix
 };
 

package/package.json

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