Variable defaultConst

Type Declaration

• CancellationError: typeof CancellationError

• ColorThemeKind: { Dark: 2; HighContrast: 3; HighContrastLight: 4; Light: 1 }

  Theme-kind values plus a scriptable active-theme namespace.

• commands: {
      executeCommand: MockFn<
          [commandId: string, ...args: unknown[]],
          Promise<unknown>,
      >;
      registerCommand: MockFn<
          [commandId: string, callback: (...args: unknown[]) => unknown],
          { _callback: (...args: unknown[]) => unknown; dispose: MockFn<[], void> },
      >;
      registerTextEditorCommand: MockFn<
          [
              commandId: string,
              callback: (editor: unknown, edit: unknown, ...args: unknown[]) => unknown,
          ],
          {
              _callback: (
                  editor: unknown,
                  edit: unknown,
                  ...args: unknown[],
              ) => unknown;
              dispose: MockFn<[], void>;
          },
      >;
  }

  • executeCommand: MockFn<[commandId: string, ...args: unknown[]], Promise<unknown>>

    Dispatches to a registered handler, and rejects for an unknown id.

    setContext is the exception, and the only one. It is a VS Code built-in that no extension registers, so rejecting it would be the mock lying about the platform — and an extension mirroring a setting into a when clause is a common enough shape that every one of them would have to work around it. Other built-ins are left rejecting on purpose: they have effects a mock cannot stand in for, and silently resolving undefined would hide a test that never did what it claimed. The call is still recorded, so mock.calls is how a test asserts the key was published.

  • registerCommand: MockFn<
        [commandId: string, callback: (...args: unknown[]) => unknown],
        { _callback: (...args: unknown[]) => unknown; dispose: MockFn<[], void> },
    >

  • registerTextEditorCommand: MockFn<
        [
            commandId: string,
            callback: (editor: unknown, edit: unknown, ...args: unknown[]) => unknown,
        ],
        {
            _callback: (
                editor: unknown,
                edit: unknown,
                ...args: unknown[],
            ) => unknown;
            dispose: MockFn<[], void>;
        },
    >

• ConfigurationTarget: { Global: 1; Workspace: 2; WorkspaceFolder: 3 }

  Stable configuration target values; persistence is not emulated.

• DataTransfer: typeof DataTransfer

• DataTransferItem: typeof DataTransferItem

• Disposable: typeof Disposable

• env: {
      appHost: string;
      clipboard: {
          readText: MockFn<unknown[], unknown>;
          writeText: MockFn<unknown[], unknown>;
      };
      createTelemetryLogger: MockFn<
          [],
          {
              dispose: MockFn<unknown[], unknown>;
              isErrorsEnabled: boolean;
              isUsageEnabled: boolean;
              logError: MockFn<unknown[], unknown>;
              logUsage: MockFn<unknown[], unknown>;
              onDidChangeEnableStates: MockFn<
                  [],
                  { dispose: MockFn<unknown[], unknown> },
              >;
          },
      >;
      language: string;
      remoteName: string
      | undefined;
      uiKind: 1 | 2;
  }

• EventEmitter: typeof EventEmitter

• extensions: {
      all: Extension<unknown>[];
      getExtension: MockFn<[extensionId: string], Extension<unknown> | undefined>;
      onDidChange: MockFn<[], { dispose: MockFn<unknown[], unknown> }>;
  }

• l10n: {
      bundle: undefined;
      t: MockFn<[message: string, ..._args: unknown[]], string>;
      uri: undefined;
  }

• languages: {
      createDiagnosticCollection: MockFn<
          [name?: string],
          {
              clear: MockFn<unknown[], unknown>;
              delete: MockFn<unknown[], unknown>;
              dispose: MockFn<unknown[], unknown>;
              name: string;
              set: MockFn<unknown[], unknown>;
          },
      >;
      createLanguageStatusItem: MockFn<
          [],
          {
              accessibilityInformation: undefined;
              busy: boolean;
              command: undefined;
              detail: string | undefined;
              dispose: MockFn<unknown[], unknown>;
              id: string;
              name: string | undefined;
              selector: undefined;
              severity: 0;
              text: string;
          },
      >;
      registerCodeActionsProvider: MockFn<[], { dispose: unknown }>;
      registerCodeLensProvider: MockFn<[], { dispose: unknown }>;
      registerCompletionItemProvider: MockFn<[], { dispose: unknown }>;
      registerDefinitionProvider: MockFn<[], { dispose: unknown }>;
      registerDocumentFormattingEditProvider: MockFn<[], { dispose: unknown }>;
      registerHoverProvider: MockFn<[], { dispose: unknown }>;
  }

• LanguageStatusSeverity: { Error: 2; Information: 0; Warning: 1 }

  Stable language-status severities for adapter translation tests.

• LogLevel: { Debug: 2; Error: 5; Info: 3; Off: 0; Trace: 1; Warning: 4 }

  Numeric values needed by log-channel code; no filtering is performed.

• MarkdownString: typeof MarkdownString

• Position: typeof Position

• ProgressLocation: { Notification: 15; SourceControl: 1; Window: 10 }

  Stable ProgressLocation values used to assert adapter mapping.

• QuickInputButtonLocation: { Inline: 2; Input: 3; Title: 1 }

  Quick-input button locations; rendering is outside the mock's scope.

• QuickInputButtons: { Back: { iconPath: { id: "arrow-left" }; tooltip: "Back" } }

  Shared back-button identity used by quick-input navigation tests.

• QuickPickItemKind: { Default: 0; Separator: -1 }

  Quick-pick item kinds used in structural item fixtures.

• Range: typeof Range

• RelativePattern: typeof RelativePattern

• Selection: typeof Selection

• StatusBarAlignment: { Left: 1; Right: 2 }

  Stable status-bar alignment values used by item factories.

• TextEditorRevealType: { AtTop: 3; Default: 0; InCenter: 1; InCenterIfOutsideViewport: 2 }

  Reveal modes for call-shape assertions; there is no viewport to reveal.

• ThemeColor: typeof ThemeColor

• ThemeIcon: typeof ThemeIcon

• TreeItem: typeof TreeItem

• TreeItemCheckboxState: { Checked: 1; Unchecked: 0 }

  Stable checkbox values used by synthetic tree events.

• TreeItemCollapsibleState: { Collapsed: 1; Expanded: 2; None: 0 }

  Stable tree collapsibility values; no tree is rendered.

• UIKind: { Desktop: 1; Web: 2 }

  Host UI kind read by runtime preflight; no host is actually launched.

• Uri: {
      file: MockFn<
          [path: string],
          { fsPath: string; path: string; scheme: string; toString: () => string },
      >;
      joinPath: MockFn<
          [uri: { path: string; scheme?: string }, ...segments: string[]],
          { fsPath: string; path: string; scheme: string; toString: () => string },
      >;
      parse: MockFn<
          [value: string],
          { fsPath: string; path: string; scheme: string; toString: () => string },
      >;
  }

• version: string

  A plausible vscode.version baseline, pinned by the mock's tests. It is fixture data—not a claim about the editor running the test. Assign the exact version a scenario requires instead of branching on this default.

• ViewColumn: {
      Active: -1;
      Beside: -2;
      Eight: 8;
      Five: 5;
      Four: 4;
      Nine: 9;
      One: 1;
      Seven: 7;
      Six: 6;
      Three: 3;
      Two: 2;
  }

  Editor-column values accepted by panel/editor call-shape tests. Columns have no layout behavior in this mock.

• window: {
      activeColorTheme: ColorTheme;
      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;
              },
          >,
      >;
      showWarningMessage: MockFn<unknown[], unknown>;
      visibleTextEditors: TextEditor[];
      withProgress: MockFn<
          [
              _options: unknown,
              task: (progress: unknown, token: unknown) => Promise<unknown>,
          ],
          Promise<unknown>,
      >;
      _setColorTheme(kind: 1 | 2 | 3 | 4): void;
  }

  • 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

• workspace: {
      applyEdit: MockFn<unknown[], unknown>;
      asRelativePath: MockFn<
          [pathOrUri: string | Uri, _includeWorkspaceFolder?: boolean],
          string,
      >;
      createFileSystemWatcher: MockFn<
          [_pattern: unknown],
          {
              _fireChange: (uri: unknown) => void;
              _fireCreate: (uri: unknown) => void;
              _fireDelete: (uri: unknown) => void;
              dispose: MockFn<unknown[], unknown>;
              ignoreChangeEvents: boolean;
              ignoreCreateEvents: boolean;
              ignoreDeleteEvents: boolean;
              onDidChange: MockFn<
                  [listener: (uri: unknown) => void],
                  { dispose: MockFn<[], void> },
              >;
              onDidCreate: MockFn<
                  [listener: (uri: unknown) => void],
                  { dispose: MockFn<[], void> },
              >;
              onDidDelete: MockFn<
                  [listener: (uri: unknown) => void],
                  { dispose: MockFn<[], void> },
              >;
          },
      >;
      fs: { readFile: MockFn<unknown[], unknown> };
      getConfiguration: MockFn<
          [_section?: string],
          {
              get: MockFn<[_key: string, defaultValue?: unknown], unknown>;
              has: MockFn<[], boolean>;
              inspect: MockFn<unknown[], unknown>;
              update: MockFn<unknown[], unknown>;
          },
      >;
      getWorkspaceFolder: MockFn<[_uri: Uri], WorkspaceFolder | undefined>;
      isTrusted: boolean;
      onDidChangeConfiguration: MockFn<
          [],
          { dispose: MockFn<unknown[], unknown> },
      >;
      onDidChangeTextDocument: MockFn<
          [],
          { dispose: MockFn<unknown[], unknown> },
      >;
      onDidGrantWorkspaceTrust: MockFn<
          [_listener: () => void],
          { dispose: MockFn<unknown[], unknown> },
      >;
      onDidSaveTextDocument: MockFn<[], { dispose: MockFn<unknown[], unknown> }>;
      openTextDocument: MockFn<
          [uriOrOptions?: unknown],
          Promise<
              {
                  _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;
              },
          >,
      >;
      workspaceFolders: WorkspaceFolder[]
      | undefined;
  }

  • applyEdit: MockFn<unknown[], unknown>

    Used by applyWorkspaceEdits/applyEditsGrouped (src/workspace/editor.ts).

  • asRelativePath: MockFn<[pathOrUri: string | Uri, _includeWorkspaceFolder?: boolean], string>

    Simplified: returns pathOrUri itself for a string, or .fsPath for a Uri.

  • createFileSystemWatcher: MockFn<
        [_pattern: unknown],
        {
            _fireChange: (uri: unknown) => void;
            _fireCreate: (uri: unknown) => void;
            _fireDelete: (uri: unknown) => void;
            dispose: MockFn<unknown[], unknown>;
            ignoreChangeEvents: boolean;
            ignoreCreateEvents: boolean;
            ignoreDeleteEvents: boolean;
            onDidChange: MockFn<
                [listener: (uri: unknown) => void],
                { dispose: MockFn<[], void> },
            >;
            onDidCreate: MockFn<
                [listener: (uri: unknown) => void],
                { dispose: MockFn<[], void> },
            >;
            onDidDelete: MockFn<
                [listener: (uri: unknown) => void],
                { dispose: MockFn<[], void> },
            >;
        },
    >

  • fs: { readFile: MockFn<unknown[], unknown> }

  • getConfiguration: MockFn<
        [_section?: string],
        {
            get: MockFn<[_key: string, defaultValue?: unknown], unknown>;
            has: MockFn<[], boolean>;
            inspect: MockFn<unknown[], unknown>;
            update: MockFn<unknown[], unknown>;
        },
    >

  • getWorkspaceFolder: MockFn<[_uri: Uri], WorkspaceFolder | undefined>

  • isTrusted: boolean

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

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

  • onDidGrantWorkspaceTrust: MockFn<[_listener: () => void], { dispose: MockFn<unknown[], unknown> }>

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

  • openTextDocument: MockFn<
        [uriOrOptions?: unknown],
        Promise<
            {
                _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;
            },
        >,
    >

    Honors { language, content } options; otherwise an empty plaintext document.

  • workspaceFolders: WorkspaceFolder[] | undefined

• WorkspaceEdit: typeof WorkspaceEdit