@lvce-editor/test-worker 15.9.0 → 16.0.0

package/dist/api.d.ts

@@ -148,6 +148,19 @@ export interface Diagnostic {
 	readonly type: "error" | "warning";
 }
 
+export interface FormattingTextDocument {
+	readonly documentId?: number;
+	readonly languageId: string;
+	readonly text?: string;
+	readonly uri?: string;
+}
+
+export interface FormattingEdit {
+	readonly endOffset: number;
+	readonly inserted: string;
+	readonly startOffset: number;
+}
+
 export interface FileSystemTmpDirOptions {
 	readonly scheme?: string;
 }
@@ -183,6 +196,10 @@ export interface LayoutExpectation extends LayoutExpectationObject {
 	readonly groups?: readonly LayoutExpectationObject[];
 }
 
+export interface SelectItemOptions {
+	readonly waitUntil?: SelectItemWaitUntil;
+}
+
 export interface SelectItem2Options {
 	readonly callbackCommand: string;
 	readonly label: string;
@@ -233,6 +250,8 @@ export type SavedState = {
 	readonly layout?: LayoutState;
 };
 
+export type SelectItemWaitUntil = "done" | "quickPick" | "none";
+
 export type SearchInputType = "SearchValue" | "ReplaceValue" | "IncludeValue" | "ExcludeValue";
 
 interface Workspace {
@@ -591,6 +610,7 @@ interface Explorer {
 interface Extension {
   readonly addNodeExtension: (relativePath: string) => Promise<void>;
   readonly addWebExtension: (relativePath: string) => Promise<void>;
+  readonly executeFormattingProvider: (textDocument: FormattingTextDocument, ...args: readonly unknown[]) => Promise<readonly FormattingEdit[]>;
 }
 
 interface ExtensionDetail {
@@ -675,15 +695,20 @@ interface Git {
   readonly add: (pathSpec: string) => Promise<void>;
   readonly addAll: () => Promise<void>;
   readonly addRemote: (name: string, remoteUrl: string) => Promise<void>;
+  readonly applyStash: () => Promise<void>;
   readonly branch: (name: string) => Promise<void>;
   readonly checkout: (ref: string) => Promise<void>;
   readonly cherryPick: (commitHash: string) => Promise<void>;
+  readonly cleanAll: () => Promise<void>;
   readonly clone: (repositoryUrl: string, cwd: string) => Promise<void>;
   readonly commit: (message: string) => Promise<void>;
+  readonly commitStaged: (message: string) => Promise<void>;
   readonly config: (values: Record<string, string>) => Promise<void>;
   readonly createTag: (name: string) => Promise<void>;
+  readonly createWorktree: (path: string, ref: string) => Promise<void>;
   readonly deleteBranch: (name: string) => Promise<void>;
   readonly deleteTag: (name: string) => Promise<void>;
+  readonly deleteWorktree: (path: string) => Promise<void>;
   readonly fetch: (remote: string) => Promise<void>;
   readonly fetchAll: () => Promise<void>;
   readonly fetchPrune: () => Promise<void>;
@@ -701,8 +726,11 @@ interface Git {
   readonly setUpstream: (remoteUrl: string) => Promise<void>;
   readonly shouldHaveCommit: (message: string) => Promise<void>;
   readonly shouldHaveInvocations: (invocations: readonly GitInvocation[]) => Promise<void>;
+  readonly stage: (pathSpec: string) => Promise<void>;
   readonly stash: (message?: string) => Promise<void>;
   readonly status: () => Promise<unknown>;
+  readonly undoLastCommit: () => Promise<void>;
+  readonly unstage: (pathSpec: string) => Promise<void>;
   readonly unstash: () => Promise<void>;
 }
 
@@ -854,7 +882,7 @@ interface QuickPick {
   readonly open: () => Promise<void>;
   readonly selectCurrentIndex: () => Promise<void>;
   readonly selectIndex: (index: number) => Promise<void>;
-  readonly selectItem: (label: string) => Promise<void>;
+  readonly selectItem: (label: string, { waitUntil }?: SelectItemOptions) => Promise<void>;
   readonly selectItem2: ({ callbackCommand, label }: SelectItem2Options) => Promise<void>;
   readonly setValue: (value: string) => Promise<void>;
 }

package/dist/testWorkerMain.js

@@ -1091,7 +1091,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$7 = (id, rpc) => {
+const set$8 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$2 = id => {
@@ -1124,7 +1124,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$7(rpcId, mockRpc);
+      set$8(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove$1(rpcId);
@@ -1133,7 +1133,7 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$7(rpcId, rpc);
+      set$8(rpcId, rpc);
     }
   };
 };
@@ -1147,16 +1147,22 @@ const Web = 1;
 const Remote = 3;
 
 const EditorWorker = 99;
+const ErrorWorker = 3308;
 const ExtensionHostWorker = 44;
 const ExtensionManagementWorker = 9006;
 const OpenerWorker = 4561;
 const RendererWorker = 1;
 const TestWorker = 9001;
 
+const {
+  invoke: invoke$4,
+  set: set$7
+} = create(EditorWorker);
+
 const {
   invoke: invoke$3,
   set: set$6
-} = create(EditorWorker);
+} = create(ErrorWorker);
 
 const {
   set: set$5
@@ -1185,6 +1191,10 @@ const sendMessagePortToOpenerWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
 };
+const sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
 const readFile$1 = async uri => {
   return invoke('FileSystem.readFile', uri);
 };
@@ -1200,10 +1210,21 @@ const getPreference = async key => {
   return await invoke('Preferences.get', key);
 };
 
-const send$3 = async port => {
+const send$4 = async port => {
   await sendMessagePortToEditorWorker(port, TestWorker);
 };
 const initializeEditorWorker = async () => {
+  const rpc = await create$3({
+    commandMap: {},
+    send: send$4
+  });
+  set$7(rpc);
+};
+
+const send$3 = async port => {
+  await sendMessagePortToErrorWorker(port, TestWorker);
+};
+const initializeErrorWorker = async () => {
   const rpc = await create$3({
     commandMap: {},
     send: send$3
@@ -2806,7 +2827,7 @@ const areSelectionsEqual = (a, b) => {
 };
 
 const getEditorKey = async () => {
-  const keys = await invoke$3('Editor.getKeys');
+  const keys = await invoke$4('Editor.getKeys');
   if (keys.length === 0) {
     throw new Error(`no editor found`);
   }
@@ -3072,11 +3093,11 @@ const growSelection = async () => {
 };
 const getSelections = async () => {
   const key = await getEditorKey();
-  return invoke$3('Editor.getSelections', key);
+  return invoke$4('Editor.getSelections', key);
 };
 const shouldHaveText = async expectedText => {
   const key = await getEditorKey();
-  const text = await invoke$3('Editor.getText', key);
+  const text = await invoke$4('Editor.getText', key);
   if (text !== expectedText) {
     throw new Error(`Expected editor to have text ${expectedText} but was ${text}`);
   }
@@ -3101,7 +3122,7 @@ const areTokensEqual = (actual, expected) => {
 };
 const shouldHaveTokens = async expectedTokens => {
   const key = await getEditorKey();
-  const text = await invoke$3('Editor.getTokens', key);
+  const text = await invoke$4('Editor.getTokens', key);
   if (!areTokensEqual(text, expectedTokens)) {
     const stringifiedActual = JSON.stringify(text);
     const stringifiedExpected = JSON.stringify(expectedTokens);
@@ -3110,20 +3131,20 @@ const shouldHaveTokens = async expectedTokens => {
 };
 const shouldHaveSelections = async expectedSelections => {
   const key = await getEditorKey();
-  const selections = await invoke$3('Editor.getSelections', key);
+  const selections = await invoke$4('Editor.getSelections', key);
   if (!areSelectionsEqual(selections, expectedSelections)) {
     throw new Error(`Expected editor to have selections ${expectedSelections} but was ${selections}`);
   }
 };
 const undo = async () => {
-  await invoke$3('Editor.undo');
+  await invoke$4('Editor.undo');
 };
 const redo = async () => {
-  await invoke$3('Editor.redo');
+  await invoke$4('Editor.redo');
 };
 const shouldHaveDiagnostics = async expectedDiagnostics => {
   const key = await getEditorKey();
-  const diagnostics = await invoke$3('Editor.getDiagnostics', key);
+  const diagnostics = await invoke$4('Editor.getDiagnostics', key);
   if (!areDiagnosticsEqual(diagnostics, expectedDiagnostics)) {
     const stringifiedActual = JSON.stringify(diagnostics);
     const stringifiedExpected = JSON.stringify(expectedDiagnostics);
@@ -3479,6 +3500,9 @@ const addWebExtension = async relativePath => {
   await invoke$2('Extensions.addWebExtension', absolutePath);
   await invoke('ExtensionMeta.addWebExtension', absolutePath);
 };
+const executeFormattingProvider = async (textDocument, ...args) => {
+  return invoke$2('Extensions.executeFormattingProvider', textDocument, ...args);
+};
 const addNodeExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
@@ -3487,7 +3511,8 @@ const addNodeExtension = async relativePath => {
 
 const Extension = {
   addNodeExtension,
-  addWebExtension
+  addWebExtension,
+  executeFormattingProvider
 };
 
 const handleClickCategory = async categoryId => {
@@ -3979,9 +4004,18 @@ const add = async pathSpec => {
 const addAll = async () => {
   await add('.');
 };
+const stage = async pathSpec => {
+  await executeExtensionCommand('git.stage', pathSpec);
+};
+const unstage = async pathSpec => {
+  await executeExtensionCommand('git.unstage', pathSpec);
+};
 const commit = async message => {
   await executeExtensionCommand('git.commit', message);
 };
+const commitStaged = async message => {
+  await executeExtensionCommand('git.commitStaged', message);
+};
 const push$1 = async (remoteOrOptions, branch) => {
   if (typeof remoteOrOptions === 'string') {
     await executeExtensionCommand('git.push', {
@@ -4013,6 +4047,9 @@ const stash = async message => {
 const unstash = async () => {
   await executeExtensionCommand('git.unstash');
 };
+const applyStash = async () => {
+  await executeExtensionCommand('git.applystash');
+};
 const checkout = async ref => {
   await executeExtensionCommand('git.checkout', ref);
 };
@@ -4040,6 +4077,18 @@ const createTag = async name => {
 const deleteTag = async name => {
   await executeExtensionCommand('git.deleteTag', name);
 };
+const undoLastCommit = async () => {
+  await executeExtensionCommand('git.undoLastCommit');
+};
+const cleanAll = async () => {
+  await executeExtensionCommand('git.cleanAll');
+};
+const createWorktree = async (path, ref) => {
+  await executeExtensionCommand('git.createWorktree', path, ref);
+};
+const deleteWorktree = async path => {
+  await executeExtensionCommand('git.deleteWorktree', path);
+};
 const status = async () => {
   return executeExtensionCommand('git.status');
 };
@@ -4090,15 +4139,20 @@ const Git = {
   add,
   addAll,
   addRemote,
+  applyStash,
   branch,
   checkout,
   cherryPick,
+  cleanAll,
   clone,
   commit,
+  commitStaged,
   config,
   createTag,
+  createWorktree,
   deleteBranch,
   deleteTag,
+  deleteWorktree,
   fetch: fetch$1,
   fetchAll,
   fetchPrune,
@@ -4116,8 +4170,11 @@ const Git = {
   setUpstream,
   shouldHaveCommit,
   shouldHaveInvocations,
+  stage,
   stash,
   status,
+  undoLastCommit,
+  unstage,
   unstash
 };
 
@@ -4577,8 +4634,21 @@ const focusIndex$2 = async index => {
 const focusPrevious$2 = async () => {
   await invoke('QuickPick.focusPrevious');
 };
-const selectItem = async label => {
-  await invoke('QuickPick.selectItem', label);
+const selectItem = async (label, {
+  waitUntil = 'done'
+} = {}) => {
+  if (waitUntil === 'done') {
+    await invoke('QuickPick.selectItem', label);
+    return;
+  }
+  const visiblePromise = waitUntil === 'quickPick' ? invoke('QuickPick.waitUntilVisible') : undefined;
+  const promise = Promise.resolve(invoke('QuickPick.selectItem', label));
+  if (waitUntil === 'none') {
+    void promise.catch(() => undefined);
+    return;
+  }
+  void promise.catch(() => undefined);
+  await visiblePromise;
 };
 const selectIndex$3 = async index => {
   await invoke('QuickPick.selectIndex', index);
@@ -5270,9 +5340,18 @@ const printError = error => {
   }
 };
 
+const prepareError = 'Errors.prepare';
+const formatPreparedError = preparedError => {
+  const codeFrame = preparedError.codeframe || preparedError.codeFrame;
+  return [preparedError.message, codeFrame, preparedError.stack].filter(Boolean).join('\n');
+};
 const printTestError = async error => {
-  // TODO ask error worker to add codeframe
-  printError(error);
+  try {
+    const preparedError = await invoke$3(prepareError, error);
+    console.error(formatPreparedError(preparedError));
+  } catch {
+    printError(error);
+  }
 };
 
 const now = () => {
@@ -5831,7 +5910,7 @@ const initializeRendererWorker = async () => {
 };
 
 const listen = async () => {
-  await Promise.all([initializeRendererWorker(), initializeEditorWorker(), initializeOpenerWorker(), initializeExtensionManagementWorker(), initializeExtensionHostWorker()]);
+  await Promise.all([initializeEditorWorker(), initializeErrorWorker(), initializeExtensionHostWorker(), initializeExtensionManagementWorker(), initializeOpenerWorker(), initializeRendererWorker()]);
 };
 
 const main = async () => {

package/package.json

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