@kkdev92/vscode-ext-kit - v4.1.1
    Preparing search index...

    Function createVSCodeMock

    • Builds the documented partial replacement for the vscode module: the value classes and namespaces exported below, with their focused semantics.

      Pass the result straight to vi.mock's factory (or the Jest equivalent). Individual builders (createMockQuickPick, createMockFileSystemWatcher, ...) are also exported for tests that want a standalone fixture, e.g. to override a single window.createTreeView() call with a listener-capturing instance.

      Unsupported API members are absent on purpose. Add a focused builder plus contract tests when this package begins to depend on another member; do not add a catch-all proxy returning no-op functions, because that lets misspelled and unsupported APIs pass tests silently.

      Extension-authoring state that VS Code itself only lets the host set (window.activeTextEditor, window.visibleTextEditors, workspace.workspaceFolders) is exposed as plain, directly-assignable fields here — a test sets vscode.window.activeTextEditor = myEditor instead of recomposing the whole namespace.

      Parameters

      Returns {
          CancellationError: typeof CancellationError;
          ColorThemeKind: {
              Dark: 2;
              HighContrast: 3;
              HighContrastLight: 4;
              Light: 1;
          };
          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>;
                  },
              >;
          };
          ConfigurationTarget: { Global: 1; Workspace: 2; WorkspaceFolder: 3 };
          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 };
          LogLevel: { Debug: 2; Error: 5; Info: 3; Off: 0; Trace: 1; Warning: 4 };
          MarkdownString: typeof MarkdownString;
          Position: typeof Position;
          ProgressLocation: { Notification: 15; SourceControl: 1; Window: 10 };
          QuickInputButtonLocation: { Inline: 2; Input: 3; Title: 1 };
          QuickInputButtons: {
              Back: { iconPath: { id: "arrow-left" }; tooltip: "Back" };
          };
          QuickPickItemKind: { Default: 0; Separator: -1 };
          Range: typeof Range;
          RelativePattern: typeof RelativePattern;
          Selection: typeof Selection;
          StatusBarAlignment: { Left: 1; Right: 2 };
          TextEditorRevealType: {
              AtTop: 3;
              Default: 0;
              InCenter: 1;
              InCenterIfOutsideViewport: 2;
          };
          ThemeColor: typeof ThemeColor;
          ThemeIcon: typeof ThemeIcon;
          TreeItem: typeof TreeItem;
          TreeItemCheckboxState: { Checked: 1; Unchecked: 0 };
          TreeItemCollapsibleState: { Collapsed: 1; Expanded: 2; None: 0 };
          UIKind: { Desktop: 1; Web: 2 };
          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;
          ViewColumn: {
              Active: -1;
              Beside: -2;
              Eight: 8;
              Five: 5;
              Four: 4;
              Nine: 9;
              One: 1;
              Seven: 7;
              Six: 6;
              Three: 3;
              Two: 2;
          };
          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;
          };
          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;
          };
          WorkspaceEdit: typeof WorkspaceEdit;
      }

      • 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
      import { vi } from 'vitest';
      import { createVSCodeMock } from '@kkdev92/vscode-ext-kit/testing';

      vi.mock('vscode', () => createVSCodeMock(vi));

    Settings
    Member Visibility