Variable window

Type Declaration

• activeColorTheme: ColorTheme

  Dark by default. A plain mutable field, so a test can assign it directly — use _setColorTheme instead when listeners registered through onDidChangeActiveColorTheme also need to fire.

• activeTextEditor: TextEditor | undefined

• createInputBox: MockFn<
      [],
      {
          _accept: () => void;
          _hide: () => void;
          _setValue: (v: string) => void;
          _triggerButton: (button: unknown) => void;
          busy: boolean;
          buttons: unknown[];
          dispose: MockFn<[], void>;
          hide: MockFn<[], void>;
          ignoreFocusOut: boolean;
          onDidAccept: MockFn<[listener: () => void], { dispose: MockFn<[], void> }>;
          onDidChangeValue: MockFn<
              [listener: (value: string) => void],
              { dispose: MockFn<[], void> },
          >;
          onDidHide: MockFn<[listener: () => void], { dispose: MockFn<[], void> }>;
          onDidTriggerButton: MockFn<
              [listener: (button: unknown) => void],
              { dispose: MockFn<[], void> },
          >;
          password: boolean;
          placeholder: string;
          prompt: string;
          show: MockFn<[], void>;
          step: number | undefined;
          title: string;
          totalSteps: number | undefined;
          validationMessage: string | undefined;
          valueSelection: readonly [number, number] | undefined;
          get value(): string;
          set value(v: string): void;
      },
  >

• createOutputChannel: MockFn<
      [name: string, options?: { log: true }],
      {
          append: MockFn<unknown[], unknown>;
          appendLine: MockFn<unknown[], unknown>;
          clear: MockFn<unknown[], unknown>;
          dispose: MockFn<unknown[], unknown>;
          hide: MockFn<unknown[], unknown>;
          name: string;
          replace: MockFn<unknown[], unknown>;
          show: MockFn<unknown[], unknown>;
      },
  >

• createQuickPick: MockFn<
      [],
      {
          _accept: (selection?: { label: string }[]) => void;
          _hide: () => void;
          _setValue: (v: string) => void;
          _triggerButton: (button: unknown) => void;
          _triggerItemButton: (e: unknown) => void;
          activeItems: { label: string }[];
          busy: boolean;
          buttons: unknown[];
          canSelectMany: boolean;
          dispose: MockFn<[], void>;
          hide: MockFn<[], void>;
          ignoreFocusOut: boolean;
          matchOnDescription: boolean;
          matchOnDetail: boolean;
          onDidAccept: MockFn<[listener: () => void], { dispose: MockFn<[], void> }>;
          onDidChangeValue: MockFn<
              [listener: (value: string) => void],
              { dispose: MockFn<[], void> },
          >;
          onDidHide: MockFn<[listener: () => void], { dispose: MockFn<[], void> }>;
          onDidTriggerButton: MockFn<
              [listener: (button: unknown) => void],
              { dispose: MockFn<[], void> },
          >;
          onDidTriggerItemButton: MockFn<
              [listener: (e: unknown) => void],
              { dispose: MockFn<[], void> },
          >;
          placeholder: string;
          prompt: string | undefined;
          show: MockFn<[], void>;
          step: number | undefined;
          title: string;
          totalSteps: number | undefined;
          value: string;
          get items(): T[];
          set items(value: T[]): void;
          get selectedItems(): T[];
          set selectedItems(value: T[]): void;
      },
  >

• createStatusBarItem: MockFn<
      [
          _idOrAlignment?: string
          | number,
          _alignmentOrPriority?: number,
          _priority?: number,
      ],
      {
          accessibilityInformation: AccessibilityInformation | undefined;
          alignment: 1;
          backgroundColor: ThemeColor | undefined;
          color: string | ThemeColor | undefined;
          command: string | Command | undefined;
          dispose: MockFn<unknown[], unknown>;
          hide: MockFn<unknown[], unknown>;
          id: string;
          name: string | undefined;
          priority: number | undefined;
          show: MockFn<unknown[], unknown>;
          text: string;
          tooltip: string | MarkdownString | undefined;
      },
  >

• createTreeView: MockFn<
      [_viewId: string, _options: unknown],
      {
          _fireCheckboxState: (
              items: readonly (readonly [unknown, number])[],
          ) => void;
          _fireCollapseElement: (element: unknown) => void;
          _fireExpandElement: (element: unknown) => void;
          _fireSelectionChange: (selection: readonly unknown[]) => void;
          _fireVisibilityChange: (visible: boolean) => void;
          badge: { tooltip: string; value: number } | undefined;
          description: string | undefined;
          dispose: MockFn<unknown[], unknown>;
          message: string | undefined;
          onDidChangeCheckboxState: MockFn<
              [
                  listener: (
                      e: { items: readonly (readonly [unknown, number])[] },
                  ) => void,
              ],
              { dispose: MockFn<[], void> },
          >;
          onDidChangeSelection: MockFn<
              [listener: (e: { selection: readonly unknown[] }) => void],
              { dispose: MockFn<[], void> },
          >;
          onDidChangeVisibility: MockFn<
              [listener: (e: { visible: boolean }) => void],
              { dispose: MockFn<[], void> },
          >;
          onDidCollapseElement: MockFn<
              [listener: (e: { element: unknown }) => void],
              { dispose: MockFn<[], void> },
          >;
          onDidExpandElement: MockFn<
              [listener: (e: { element: unknown }) => void],
              { dispose: MockFn<[], void> },
          >;
          reveal: MockFn<unknown[], unknown>;
          selection: unknown[];
          title: string | undefined;
          visible: boolean;
      },
  >

• createWebviewPanel: MockFn<
      [viewType: string, title: string, _column?: unknown, _options?: unknown],
      {
          _fireDispose: () => void;
          _fireViewStateChange: (visible: boolean) => void;
          active: boolean;
          dispose: MockFn<unknown[], unknown>;
          onDidChangeViewState: MockFn<
              [listener: (e: { webviewPanel: { visible: boolean } }) => void],
              { dispose: MockFn<[], void> },
          >;
          onDidDispose: MockFn<
              [listener: () => void],
              { dispose: MockFn<[], void> },
          >;
          options: {};
          reveal: MockFn<unknown[], unknown>;
          title: string;
          viewColumn: number;
          viewType: string;
          visible: boolean;
          webview: {
              _fireMessage: (message: unknown) => void;
              asWebviewUri: MockFn<
                  [uri: { toString: () => string }],
                  { fsPath: string; scheme: string; toString: () => string },
              >;
              cspSource: string;
              html: string;
              onDidReceiveMessage: MockFn<
                  [listener: (message: unknown) => void],
                  { dispose: MockFn<[], void> },
              >;
              options: {};
              postMessage: MockFn<unknown[], unknown>;
          };
      },
  >

• onDidChangeActiveColorTheme: MockFn<[listener: (theme: ColorTheme) => void], Disposable>

• onDidChangeActiveTextEditor: MockFn<[], { dispose: MockFn<unknown[], unknown> }>

• onDidChangeTextEditorSelection: MockFn<[], { dispose: MockFn<unknown[], unknown> }>

• registerWebviewPanelSerializer: MockFn<[], { dispose: MockFn<unknown[], unknown> }>

• registerWebviewViewProvider: MockFn<[], { dispose: MockFn<unknown[], unknown> }>

• showErrorMessage: MockFn<unknown[], unknown>

• showInformationMessage: MockFn<unknown[], unknown>

• showInputBox: MockFn<unknown[], unknown>

• showOpenDialog: MockFn<unknown[], unknown>

• showQuickPick: MockFn<unknown[], unknown>

• showSaveDialog: MockFn<unknown[], unknown>

• showTextDocument: MockFn<
      [document?: unknown],
      Promise<
          {
              document: {
                  _content: string;
                  _lines: string[];
                  eol: number;
                  fileName: string;
                  getText: MockFn<[range?: Range], string>;
                  getWordRangeAtPosition: MockFn<
                      [position: Position, regex?: RegExp],
                      Range | undefined,
                  >;
                  isClosed: boolean;
                  isDirty: boolean;
                  isUntitled: boolean;
                  languageId: string;
                  lineAt: MockFn<[lineOrPosition: number | Position], MockTextLine>;
                  lineCount: number;
                  offsetAt: MockFn<[position: Position], number>;
                  positionAt: MockFn<[offset: number], Position>;
                  save: MockFn<unknown[], unknown>;
                  uri: {
                      fsPath: string;
                      path: string;
                      scheme: string;
                      toString: () => string;
                  };
                  validatePosition: MockFn<[position: Position], Position>;
                  validateRange: MockFn<[range: Range], Range>;
                  version: number;
              };
              edit: MockFn<
                  [
                      callback: (
                          editBuilder: {
                              delete: (range: Range) => void;
                              insert: (position: Position, text: string) => void;
                              replace: (range: Range, text: string) => void;
                          },
                      ) => void,
                      _options?: { undoStopAfter: boolean; undoStopBefore: boolean },
                  ],
                  Promise<boolean>,
              >;
              hide: MockFn<unknown[], unknown>;
              insertSnippet: MockFn<unknown[], unknown>;
              options: { insertSpaces: boolean; tabSize: number };
              revealRange: MockFn<unknown[], unknown>;
              setDecorations: MockFn<unknown[], unknown>;
              show: MockFn<unknown[], unknown>;
              viewColumn: number;
              get selection(): Selection;
              set selection(value: Selection): void;
              get selections(): Selection[];
              set selections(value: Selection[]): void;
          },
      >,
  >

  Returns a fresh createMockTextEditor fixture. When document looks like a mock TextDocument (has getText), it's threaded through so result.document is the same object the caller passed in, matching the real API's identity guarantee.

• showWarningMessage: MockFn<unknown[], unknown>

• visibleTextEditors: TextEditor[]

• withProgress: MockFn<
      [
          _options: unknown,
          task: (progress: unknown, token: unknown) => Promise<unknown>,
      ],
      Promise<unknown>,
  >

• _setColorTheme: function

  • _setColorTheme(kind: 1 | 2 | 3 | 4): void

    Test hook: switches the active theme and notifies onDidChangeActiveColorTheme listeners, as VS Code does when the user picks a different theme.

    Parameters

    • kind: 1 | 2 | 3 | 4

    Returns void