src/vs/workbench/common/editor.ts

1765 LOC · 1397 covered · 368 uncovered · 36 ranges · 2364 concepts · 1 introducers · 1341 tests
File neighbourhood

The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
  1
  >
  /*---------------------------------------------------------------------------------------------
  
editor.ts ×36

  2
  >
   *  Copyright (c) Microsoft Corporation. All rights reserved.
  
  3
  >
   *  Licensed under the MIT License. See License.txt in the project root for license information.
  
  4
  >
   *--------------------------------------------------------------------------------------------*/
  
  5
  >
  
  6
  >
  import { localize } from '../../nls.js';
  
  7
  >
  import { Event } from '../../base/common/event.js';
  
  8
  >
  import { DeepRequiredNonNullable, assertReturnsDefined } from '../../base/common/types.js';
  
  9
  >
  import { URI } from '../../base/common/uri.js';
  
  10
  >
  import { Disposable, IDisposable, toDisposable } from '../../base/common/lifecycle.js';
  
  11
  >
  import { ICodeEditorViewState, IDiffEditor, IDiffEditorViewState, IEditor, IEditorViewState } from '../../editor/common/editorCommon.js';
  
  12
  >
  import { IEditorOptions, IResourceEditorInput, ITextResourceEditorInput, IBaseTextResourceEditorInput, IBaseUntypedEditorInput, ITextEditorOptions } from '../../platform/editor/common/editor.js';
  
  13
  >
  import type { EditorInput } from './editor/editorInput.js';
  
  14
  >
  import { IInstantiationService, IConstructorSignature, ServicesAccessor, BrandedService } from '../../platform/instantiation/common/instantiation.js';
  
  15
  >
  import { IContextKeyService } from '../../platform/contextkey/common/contextkey.js';
  
  16
  >
  import { Registry } from '../../platform/registry/common/platform.js';
  
  17
  >
  import { IEncodingSupport, ILanguageSupport } from '../services/textfile/common/textfiles.js';
  
  18
  >
  import { IEditorGroup } from '../services/editor/common/editorGroupsService.js';
  
  19
  >
  import { ICompositeControl, IComposite } from './composite.js';
  
  20
  >
  import { FileType, IFileReadLimits, IFileService } from '../../platform/files/common/files.js';
  
  21
  >
  import { IPathData } from '../../platform/window/common/window.js';
  
  22
  >
  import { IExtUri } from '../../base/common/resources.js';
  
  23
  >
  import { Schemas } from '../../base/common/network.js';
  
  24
  >
  import { IEditorService } from '../services/editor/common/editorService.js';
  
  25
  >
  import { ILogService } from '../../platform/log/common/log.js';
  
  26
  >
  import { IErrorWithActions, createErrorWithActions, isErrorWithActions } from '../../base/common/errorMessage.js';
  
  27
  >
  import { IAction, toAction } from '../../base/common/actions.js';
  
  28
  >
  import Severity from '../../base/common/severity.js';
  
  29
  >
  import { IPreferencesService } from '../services/preferences/common/preferences.js';
  
  30
  >
  import { IReadonlyEditorGroupModel } from './editor/editorGroupModel.js';
  
  31
  >
  
  32
  >
  // Static values for editor contributions
  
  33
  >
  export const EditorExtensions = {
  
  34
  >
  	EditorPane: 'workbench.contributions.editors',
  
  35
  >
  	EditorFactory: 'workbench.contributions.editor.inputFactories'
  
  36
  >
  };
  
  37
  >
  
  38
  >
  // Static information regarding the text editor
  
  39
  >
  export const DEFAULT_EDITOR_ASSOCIATION = {
  
  40
  >
  	id: 'default',
  
  41
  >
  	displayName: localize('promptOpenWith.defaultEditor.displayName', "Text Editor"),
  
  42
  >
  	providerDisplayName: localize('builtinProviderDisplayName', "Built-in")
  
  43
  >
  };
  
  44
  >
  
  45
  >
  /**
  
  46
  >
   * Side by side editor id.
  
  47
  >
   */
  
  48
  >
  export const SIDE_BY_SIDE_EDITOR_ID = 'workbench.editor.sidebysideEditor';
  
  49
  >
  
  50
  >
  /**
  
  51
  >
   * Text diff editor id.
  
  52
  >
   */
  
  53
  >
  export const TEXT_DIFF_EDITOR_ID = 'workbench.editors.textDiffEditor';
  
  54
  >
  
  55
  >
  /**
  
  56
  >
   * Binary diff editor id.
  
  57
  >
   */
  
  58
  >
  export const BINARY_DIFF_EDITOR_ID = 'workbench.editors.binaryResourceDiffEditor';
  
  59
  >
  
  60
  >
  export interface IEditorDescriptor<T extends IEditorPane> {
  
  61
  >
  
  62
  >
  	/**
  
  63
  >
  	 * The unique type identifier of the editor. All instances
  
  64
  >
  	 * of the same `IEditorPane` should have the same type
  
  65
  >
  	 * identifier.
  
  66
  >
  	 */
  
  67
  >
  	readonly typeId: string;
  
  68
  >
  
  69
  >
  	/**
  
  70
  >
  	 * The display name of the editor.
  
  71
  >
  	 */
  
  72
  >
  	readonly name: string;
  
  73
  >
  
  74
  >
  	/**
  
  75
  >
  	 * Instantiates the editor pane using the provided services.
  
  76
  >
  	 */
  
  77
  >
  	instantiate(instantiationService: IInstantiationService, group: IEditorGroup): T;
  
  78
  >
  
  79
  >
  	/**
  
  80
  >
  	 * Whether the descriptor is for the provided editor pane.
  
  81
  >
  	 */
  
  82
  >
  	describes(editorPane: T): boolean;
  
  83
  >
  }
  
  84
  >
  
  85
  >
  /**
  
  86
  >
   * Declares that an editor hosts the full-width group header (rendered by the
  
  87
  >
   * editor group below the tab bar, using the group's configured header menus).
  
  88
  >
   */
  
  89
  >
  export interface IEditorHeaderActions {
  
  90
  >
  	/** Editor-scoped instantiation service so the header toolbars' `when` clauses see the editor's context. */
  
  91
  >
  	readonly instantiationService: IInstantiationService;
  
  92
  >
  }
  
  93
  >
  
  94
  >
  /**
  
  95
  >
   * The editor pane is the container for workbench editors.
  
  96
  >
   */
  
  97
  >
  export interface IEditorPane extends IComposite {
  
  98
  >
  
  99
  >
  	/**
  
  100
  >
  	 * An event to notify when the `IEditorControl` in this
  
  101
  >
  	 * editor pane changes.
  
  102
  >
  	 *
  
  103
  >
  	 * This can be used for editor panes that are a compound
  
  104
  >
  	 * of multiple editor controls to signal that the active
  
  105
  >
  	 * editor control has changed when the user clicks around.
  
  106
  >
  	 */
  
  107
  >
  	readonly onDidChangeControl: Event<void>;
  
  108
  >
  
  109
  >
  	/**
  
  110
  >
  	 * An optional event to notify when the selection inside the editor
  
  111
  >
  	 * pane changed in case the editor has a selection concept.
  
  112
  >
  	 *
  
  113
  >
  	 * For example, in a text editor pane, the selection changes whenever
  
  114
  >
  	 * the cursor is set to a new location.
  
  115
  >
  	 */
  
  116
  >
  	readonly onDidChangeSelection?: Event<IEditorPaneSelectionChangeEvent>;
  
  117
  >
  
  118
  >
  	/**
  
  119
  >
  	 * An optional event to notify when the editor inside the pane scrolled
  
  120
  >
  	 */
  
  121
  >
  	readonly onDidChangeScroll?: Event<void>;
  
  122
  >
  
  123
  >
  	/**
  
  124
  >
  	 * The assigned input of this editor.
  
  125
  >
  	 */
  
  126
  >
  	readonly input: EditorInput | undefined;
  
  127
  >
  
  128
  >
  	/**
  
  129
  >
  	 * The assigned options of the editor.
  
  130
  >
  	 */
  
  131
  >
  	readonly options: IEditorOptions | undefined;
  
  132
  >
  
  133
  >
  	/**
  
  134
  >
  	 * The assigned group this editor is showing in.
  
  135
  >
  	 */
  
  136
  >
  	readonly group: IEditorGroup;
  
  137
  >
  
  138
  >
  	/**
  
  139
  >
  	 * The minimum width of this editor.
  
  140
  >
  	 */
  
  141
  >
  	readonly minimumWidth: number;
  
  142
  >
  
  143
  >
  	/**
  
  144
  >
  	 * The maximum width of this editor.
  
  145
  >
  	 */
  
  146
  >
  	readonly maximumWidth: number;
  
  147
  >
  
  148
  >
  	/**
  
  149
  >
  	 * The minimum height of this editor.
  
  150
  >
  	 */
  
  151
  >
  	readonly minimumHeight: number;
  
  152
  >
  
  153
  >
  	/**
  
  154
  >
  	 * The maximum height of this editor.
  
  155
  >
  	 */
  
  156
  >
  	readonly maximumHeight: number;
  
  157
  >
  
  158
  >
  	/**
  
  159
  >
  	 * An event to notify whenever minimum/maximum width/height changes.
  
  160
  >
  	 */
  
  161
  >
  	readonly onDidChangeSizeConstraints: Event<{ width: number; height: number } | undefined>;
  
  162
  >
  
  163
  >
  	/**
  
  164
  >
  	 * The context key service for this editor. Should be overridden by
  
  165
  >
  	 * editors that have their own ScopedContextKeyService
  
  166
  >
  	 */
  
  167
  >
  	readonly scopedContextKeyService: IContextKeyService | undefined;
  
  168
  >
  
  169
  >
  	/**
  
  170
  >
  	 * Returns the underlying control of this editor. Callers need to cast
  
  171
  >
  	 * the control to a specific instance as needed, e.g. by using the
  
  172
  >
  	 * `isCodeEditor` helper method to access the text code editor.
  
  173
  >
  	 *
  
  174
  >
  	 * Use the `onDidChangeControl` event to track whenever the control
  
  175
  >
  	 * changes.
  
  176
  >
  	 */
  
  177
  >
  	getControl(): IEditorControl | undefined;
  
  178
  >
  
  179
  >
  	/**
  
  180
  >
  	 * Returns the current view state of the editor if any.
  
  181
  >
  	 *
  
  182
  >
  	 * This method is optional to override for the editor pane
  
  183
  >
  	 * and should only be overridden when the pane can deal with
  
  184
  >
  	 * `IEditorOptions.viewState` to be applied when opening.
  
  185
  >
  	 */
  
  186
  >
  	getViewState(): object | undefined;
  
  187
  >
  
  188
  >
  	/**
  
  189
  >
  	 * An optional method to declare that this editor hosts the full-width group
  
  190
  >
  	 * header (rendered by the editor group below the tab bar using the group's
  
  191
  >
  	 * configured header menus), providing the editor-scoped instantiation service
  
  192
  >
  	 * so the header actions' `when` clauses evaluate in the editor's context.
  
  193
  >
  	 * Return `undefined` for no header (the default).
  
  194
  >
  	 */
  
  195
  >
  	getHeaderActions?(): IEditorHeaderActions | undefined;
  
  196
  >
  
  197
  >
  	/**
  
  198
  >
  	 * An optional method to return the current selection in
  
  199
  >
  	 * the editor pane in case the editor pane has a selection
  
  200
  >
  	 * concept.
  
  201
  >
  	 *
  
  202
  >
  	 * Clients of this method will typically react to the
  
  203
  >
  	 * `onDidChangeSelection` event to receive the current
  
  204
  >
  	 * selection as needed.
  
  205
  >
  	 */
  
  206
  >
  	getSelection?(): IEditorPaneSelection | undefined;
  
  207
  >
  
  208
  >
  	/**
  
  209
  >
  	 * An optional method to return the current scroll position
  
  210
  >
  	 * of an editor inside the pane.
  
  211
  >
  	 *
  
  212
  >
  	 * Clients of this method will typically react to the
  
  213
  >
  	 * `onDidChangeScroll` event to receive the current
  
  214
  >
  	 * scroll position as needed.
  
  215
  >
  	 */
  
  216
  >
  	getScrollPosition?(): IEditorPaneScrollPosition;
  
  217
  >
  
  218
  >
  	/**
  
  219
  >
  	 * An optional method to set the current scroll position
  
  220
  >
  	 * of an editor inside the pane.
  
  221
  >
  	 */
  
  222
  >
  	setScrollPosition?(scrollPosition: IEditorPaneScrollPosition): void;
  
  223
  >
  
  224
  >
  	/**
  
  225
  >
  	 * Finds out if this editor is visible or not.
  
  226
  >
  	 */
  
  227
  >
  	isVisible(): boolean;
  
  228
  >
  }
  
  229
  >
  
  230
  >
  export interface IEditorPaneSelectionChangeEvent {
  
  231
  >
  
  232
  >
  	/**
  
  233
  >
  	 * More details for how the selection was made.
  
  234
  >
  	 */
  
  235
  >
  	reason: EditorPaneSelectionChangeReason;
  
  236
  >
  }
  
  237
  >
  
  238
  >
  export const enum EditorPaneSelectionChangeReason {
  
  239
  >
  
  240
  >
  	/**
  
  241
  >
  	 * The selection was changed as a result of a programmatic
  
  242
  >
  	 * method invocation.
  
  243
  >
  	 *
  
  244
  >
  	 * For a text editor pane, this for example can be a selection
  
  245
  >
  	 * being restored from previous view state automatically.
  
  246
  >
  	 */
  
  247
  >
  	PROGRAMMATIC = 1,
  
  248
  >
  
  249
  >
  	/**
  
  250
  >
  	 * The selection was changed by the user.
  
  251
  >
  	 *
  
  252
  >
  	 * This typically means the user changed the selection
  
  253
  >
  	 * with mouse or keyboard.
  
  254
  >
  	 */
  
  255
  >
  	USER,
  
  256
  >
  
  257
  >
  	/**
  
  258
  >
  	 * The selection was changed as a result of editing in
  
  259
  >
  	 * the editor pane.
  
  260
  >
  	 *
  
  261
  >
  	 * For a text editor pane, this for example can be typing
  
  262
  >
  	 * in the text of the editor pane.
  
  263
  >
  	 */
  
  264
  >
  	EDIT,
  
  265
  >
  
  266
  >
  	/**
  
  267
  >
  	 * The selection was changed as a result of a navigation
  
  268
  >
  	 * action.
  
  269
  >
  	 *
  
  270
  >
  	 * For a text editor pane, this for example can be a result
  
  271
  >
  	 * of selecting an entry from a text outline view.
  
  272
  >
  	 */
  
  273
  >
  	NAVIGATION,
  
  274
  >
  
  275
  >
  	/**
  
  276
  >
  	 * The selection was changed as a result of a jump action
  
  277
  >
  	 * from within the editor pane.
  
  278
  >
  	 *
  
  279
  >
  	 * For a text editor pane, this for example can be a result
  
  280
  >
  	 * of invoking "Go to definition" from a symbol.
  
  281
  >
  	 */
  
  282
  >
  	JUMP
  
  283
  >
  }
  
  284
  >
  
  285
  >
  export interface IEditorPaneSelection {
  
  286
  >
  
  287
  >
  	/**
  
  288
  >
  	 * Asks to compare this selection to another selection.
  
  289
  >
  	 */
  
  290
  >
  	compare(otherSelection: IEditorPaneSelection): EditorPaneSelectionCompareResult;
  
  291
  >
  
  292
  >
  	/**
  
  293
  >
  	 * Asks to massage the provided `options` in a way
  
  294
  >
  	 * that the selection can be restored when the editor
  
  295
  >
  	 * is opened again.
  
  296
  >
  	 *
  
  297
  >
  	 * For a text editor this means to apply the selected
  
  298
  >
  	 * line and column as text editor options.
  
  299
  >
  	 */
  
  300
  >
  	restore(options: IEditorOptions): IEditorOptions;
  
  301
  >
  
  302
  >
  	/**
  
  303
  >
  	 * Only used for logging to print more info about the selection.
  
  304
  >
  	 */
  
  305
  >
  	log?(): string;
  
  306
  >
  }
  
  307
  >
  
  308
  >
  export const enum EditorPaneSelectionCompareResult {
  
  309
  >
  
  310
  >
  	/**
  
  311
  >
  	 * The selections are identical.
  
  312
  >
  	 */
  
  313
  >
  	IDENTICAL = 1,
  
  314
  >
  
  315
  >
  	/**
  
  316
  >
  	 * The selections are similar.
  
  317
  >
  	 *
  
  318
  >
  	 * For a text editor this can mean that the one
  
  319
  >
  	 * selection is in close proximity to the other
  
  320
  >
  	 * selection.
  
  321
  >
  	 *
  
  322
  >
  	 * Upstream clients may decide in this case to
  
  323
  >
  	 * not treat the selection different from the
  
  324
  >
  	 * previous one because it is not distinct enough.
  
  325
  >
  	 */
  
  326
  >
  	SIMILAR = 2,
  
  327
  >
  
  328
  >
  	/**
  
  329
  >
  	 * The selections are entirely different.
  
  330
  >
  	 */
  
  331
  >
  	DIFFERENT = 3
  
  332
  >
  }
  
  333
  >
  
  334
  >
  export interface IEditorPaneWithSelection extends IEditorPane {
  
  335
  >
  
  336
  >
  	readonly onDidChangeSelection: Event<IEditorPaneSelectionChangeEvent>;
  
  337
  >
  
  338
  >
  	getSelection(): IEditorPaneSelection | undefined;
  
  339
  >
  }
  
  340
  >
  
  341
  >
  export function isEditorPaneWithSelection(editorPane: IEditorPane | undefined): editorPane is IEditorPaneWithSelection {
  
  342
  
  	const candidate = editorPane as IEditorPaneWithSelection | undefined;
  
  343
  
  344
  
  	return !!candidate && typeof candidate.getSelection === 'function' && !!candidate.onDidChangeSelection;
  
  345
  
  }
  
  346
  >
  
editor.ts ×36

  347
  >
  export interface IEditorPaneWithScrolling extends IEditorPane {
  
  348
  >
  
  349
  >
  	readonly onDidChangeScroll: Event<void>;
  
  350
  >
  
  351
  >
  	getScrollPosition(): IEditorPaneScrollPosition;
  
  352
  >
  
  353
  >
  	setScrollPosition(position: IEditorPaneScrollPosition): void;
  
  354
  >
  }
  
  355
  >
  
  356
  >
  export function isEditorPaneWithScrolling(editorPane: IEditorPane | undefined): editorPane is IEditorPaneWithScrolling {
  
  357
  
  	const candidate = editorPane as IEditorPaneWithScrolling | undefined;
  
  358
  
  359
  
  	return !!candidate && typeof candidate.getScrollPosition === 'function' && typeof candidate.setScrollPosition === 'function' && !!candidate.onDidChangeScroll;
  
  360
  
  }
  
  361
  >
  
editor.ts ×36

  362
  >
  /**
  
  363
  >
   * Scroll position of a pane
  
  364
  >
   */
  
  365
  >
  export interface IEditorPaneScrollPosition {
  
  366
  >
  	readonly scrollTop: number;
  
  367
  >
  	readonly scrollLeft?: number;
  
  368
  >
  }
  
  369
  >
  
  370
  >
  /**
  
  371
  >
   * Try to retrieve the view state for the editor pane that
  
  372
  >
   * has the provided editor input opened, if at all.
  
  373
  >
   *
  
  374
  >
   * This method will return `undefined` if the editor input
  
  375
  >
   * is not visible in any of the opened editor panes.
  
  376
  >
   */
  
  377
  >
  export function findViewStateForEditor(input: EditorInput, group: GroupIdentifier, editorService: IEditorService): object | undefined {
  
  378
  
  	for (const editorPane of editorService.visibleEditorPanes) {
  
  379
  
  		if (editorPane.group.id === group && input.matches(editorPane.input)) {
  
  380
  
  			return editorPane.getViewState();
  
  381
  
  		}
  
  382
  
  	}
  
  383
  
  384
  
  	return undefined;
  
  385
  
  }
  
  386
  >
  
editor.ts ×36

  387
  >
  /**
  
  388
  >
   * Overrides `IEditorPane` where `input` and `group` are known to be set.
  
  389
  >
   */
  
  390
  >
  export interface IVisibleEditorPane extends IEditorPane {
  
  391
  >
  	readonly input: EditorInput;
  
  392
  >
  }
  
  393
  >
  
  394
  >
  /**
  
  395
  >
   * The text editor pane is the container for workbench text editors.
  
  396
  >
   */
  
  397
  >
  export interface ITextEditorPane extends IEditorPane {
  
  398
  >
  
  399
  >
  	/**
  
  400
  >
  	 * Returns the underlying text editor widget of this editor.
  
  401
  >
  	 */
  
  402
  >
  	getControl(): IEditor | undefined;
  
  403
  >
  }
  
  404
  >
  
  405
  >
  /**
  
  406
  >
   * The text editor pane is the container for workbench text diff editors.
  
  407
  >
   */
  
  408
  >
  export interface ITextDiffEditorPane extends IEditorPane {
  
  409
  >
  
  410
  >
  	/**
  
  411
  >
  	 * Returns the underlying text diff editor widget of this editor.
  
  412
  >
  	 */
  
  413
  >
  	getControl(): IDiffEditor | undefined;
  
  414
  >
  }
  
  415
  >
  
  416
  >
  /**
  
  417
  >
   * Marker interface for the control inside an editor pane. Callers
  
  418
  >
   * have to cast the control to work with it, e.g. via methods
  
  419
  >
   * such as `isCodeEditor(control)`.
  
  420
  >
   */
  
  421
  >
  export interface IEditorControl extends ICompositeControl { }
  
  422
  >
  
  423
  >
  export interface IFileEditorFactory {
  
  424
  >
  
  425
  >
  	/**
  
  426
  >
  	 * The type identifier of the file editor.
  
  427
  >
  	 */
  
  428
  >
  	typeId: string;
  
  429
  >
  
  430
  >
  	/**
  
  431
  >
  	 * Creates new editor capable of showing files.
  
  432
  >
  	 */
  
  433
  >
  	createFileEditor(resource: URI, preferredResource: URI | undefined, preferredName: string | undefined, preferredDescription: string | undefined, preferredEncoding: string | undefined, preferredLanguageId: string | undefined, preferredContents: string | undefined, instantiationService: IInstantiationService): IFileEditorInput;
  
  434
  >
  
  435
  >
  	/**
  
  436
  >
  	 * Check if the provided object is a file editor.
  
  437
  >
  	 */
  
  438
  >
  	isFileEditor(obj: unknown): obj is IFileEditorInput;
  
  439
  >
  }
  
  440
  >
  
  441
  >
  export interface IEditorFactoryRegistry {
  
  442
  >
  
  443
  >
  	/**
  
  444
  >
  	 * Registers the file editor factory to use for file editors.
  
  445
  >
  	 */
  
  446
  >
  	registerFileEditorFactory(factory: IFileEditorFactory): void;
  
  447
  >
  
  448
  >
  	/**
  
  449
  >
  	 * Returns the file editor factory to use for file editors.
  
  450
  >
  	 */
  
  451
  >
  	getFileEditorFactory(): IFileEditorFactory;
  
  452
  >
  
  453
  >
  	/**
  
  454
  >
  	 * Registers a editor serializer for the given editor to the registry.
  
  455
  >
  	 * An editor serializer is capable of serializing and deserializing editor
  
  456
  >
  	 * from string data.
  
  457
  >
  	 *
  
  458
  >
  	 * @param editorTypeId the type identifier of the editor
  
  459
  >
  	 * @param serializer the editor serializer for serialization/deserialization
  
  460
  >
  	 */
  
  461
  >
  	registerEditorSerializer<Services extends BrandedService[]>(editorTypeId: string, ctor: { new(...Services: Services): IEditorSerializer }): IDisposable;
  
  462
  >
  
  463
  >
  	/**
  
  464
  >
  	 * Returns the editor serializer for the given editor.
  
  465
  >
  	 */
  
  466
  >
  	getEditorSerializer(editor: EditorInput): IEditorSerializer | undefined;
  
  467
  >
  	getEditorSerializer(editorTypeId: string): IEditorSerializer | undefined;
  
  468
  >
  
  469
  >
  	/**
  
  470
  >
  	 * Starts the registry by providing the required services.
  
  471
  >
  	 */
  
  472
  >
  	start(accessor: ServicesAccessor): void;
  
  473
  >
  }
  
  474
  >
  
  475
  >
  export interface IEditorSerializer {
  
  476
  >
  
  477
  >
  	/**
  
  478
  >
  	 * Determines whether the given editor can be serialized by the serializer.
  
  479
  >
  	 */
  
  480
  >
  	canSerialize(editor: EditorInput): boolean;
  
  481
  >
  
  482
  >
  	/**
  
  483
  >
  	 * Returns a string representation of the provided editor that contains enough information
  
  484
  >
  	 * to deserialize back to the original editor from the deserialize() method.
  
  485
  >
  	 */
  
  486
  >
  	serialize(editor: EditorInput): string | undefined;
  
  487
  >
  
  488
  >
  	/**
  
  489
  >
  	 * Returns an editor from the provided serialized form of the editor. This form matches
  
  490
  >
  	 * the value returned from the serialize() method.
  
  491
  >
  	 */
  
  492
  >
  	deserialize(instantiationService: IInstantiationService, serializedEditor: string): EditorInput | undefined;
  
  493
  >
  }
  
  494
  >
  
  495
  >
  export interface IUntitledTextResourceEditorInput extends IBaseTextResourceEditorInput {
  
  496
  >
  
  497
  >
  	/**
  
  498
  >
  	 * Optional resource for the untitled editor. Depending on the value, the editor:
  
  499
  >
  	 * - should get a unique name if `undefined` (for example `Untitled-1`)
  
  500
  >
  	 * - should use the resource directly if the scheme is `untitled:`
  
  501
  >
  	 * - should change the scheme to `untitled:` otherwise and assume an associated path
  
  502
  >
  	 *
  
  503
  >
  	 * Untitled editors with associated path behave slightly different from other untitled
  
  504
  >
  	 * editors:
  
  505
  >
  	 * - they are dirty right when opening
  
  506
  >
  	 * - they will not ask for a file path when saving but use the associated path
  
  507
  >
  	 */
  
  508
  >
  	readonly resource: URI | undefined;
  
  509
  >
  }
  
  510
  >
  
  511
  >
  /**
  
  512
  >
   * A resource side by side editor input shows 2 editors side by side but
  
  513
  >
   * without highlighting any differences.
  
  514
  >
   *
  
  515
  >
   * Note: both sides will be resolved as editor individually. As such, it is
  
  516
  >
   * possible to show 2 different editors side by side.
  
  517
  >
   *
  
  518
  >
   * @see {@link IResourceDiffEditorInput} for a variant that compares 2 editors.
  
  519
  >
   */
  
  520
  >
  export interface IResourceSideBySideEditorInput extends IBaseUntypedEditorInput {
  
  521
  >
  
  522
  >
  	/**
  
  523
  >
  	 * The right hand side editor to open inside a side-by-side editor.
  
  524
  >
  	 */
  
  525
  >
  	readonly primary: Omit<IResourceEditorInput, 'options'> | Omit<ITextResourceEditorInput, 'options'> | Omit<IUntitledTextResourceEditorInput, 'options'>;
  
  526
  >
  
  527
  >
  	/**
  
  528
  >
  	 * The left hand side editor to open inside a side-by-side editor.
  
  529
  >
  	 */
  
  530
  >
  	readonly secondary: Omit<IResourceEditorInput, 'options'> | Omit<ITextResourceEditorInput, 'options'> | Omit<IUntitledTextResourceEditorInput, 'options'>;
  
  531
  >
  }
  
  532
  >
  
  533
  >
  /**
  
  534
  >
   * A resource diff editor input compares 2 editors side by side
  
  535
  >
   * highlighting the differences.
  
  536
  >
   *
  
  537
  >
   * Note: both sides must be resolvable to the same editor, or
  
  538
  >
   * a text based presentation will be used as fallback.
  
  539
  >
   */
  
  540
  >
  export interface IResourceDiffEditorInput extends IBaseUntypedEditorInput {
  
  541
  >
  
  542
  >
  	/**
  
  543
  >
  	 * The left hand side editor to open inside a diff editor.
  
  544
  >
  	 */
  
  545
  >
  	readonly original: Omit<IResourceEditorInput, 'options'> | Omit<ITextResourceEditorInput, 'options'> | Omit<IUntitledTextResourceEditorInput, 'options'>;
  
  546
  >
  
  547
  >
  	/**
  
  548
  >
  	 * The right hand side editor to open inside a diff editor.
  
  549
  >
  	 */
  
  550
  >
  	readonly modified: Omit<IResourceEditorInput, 'options'> | Omit<ITextResourceEditorInput, 'options'> | Omit<IUntitledTextResourceEditorInput, 'options'>;
  
  551
  >
  }
  
  552
  >
  
  553
  >
  export interface ITextResourceDiffEditorInput extends IBaseTextResourceEditorInput {
  
  554
  >
  
  555
  >
  	/**
  
  556
  >
  	 * The left hand side text editor to open inside a diff editor.
  
  557
  >
  	 */
  
  558
  >
  	readonly original: Omit<ITextResourceEditorInput, 'options'> | Omit<IUntitledTextResourceEditorInput, 'options'>;
  
  559
  >
  
  560
  >
  	/**
  
  561
  >
  	 * The right hand side text editor to open inside a diff editor.
  
  562
  >
  	 */
  
  563
  >
  	readonly modified: Omit<ITextResourceEditorInput, 'options'> | Omit<IUntitledTextResourceEditorInput, 'options'>;
  
  564
  >
  }
  
  565
  >
  
  566
  >
  /**
  
  567
  >
   * A resource list diff editor input compares multiple resources side by side
  
  568
  >
   * highlighting the differences.
  
  569
  >
   */
  
  570
  >
  export interface IResourceMultiDiffEditorInput extends IBaseUntypedEditorInput {
  
  571
  >
  	/**
  
  572
  >
  	 * A unique identifier of this multi diff editor input.
  
  573
  >
  	 * If a second multi diff editor with the same uri is opened, the existing one is revealed instead (even if the resources list is different!).
  
  574
  >
  	 */
  
  575
  >
  	readonly multiDiffSource?: URI;
  
  576
  >
  
  577
  >
  	/**
  
  578
  >
  	 * The list of resources to compare.
  
  579
  >
  	 * If not set, the resources are dynamically derived from the {@link multiDiffSource}.
  
  580
  >
  	 */
  
  581
  >
  	readonly resources?: IMultiDiffEditorResource[];
  
  582
  >
  
  583
  >
  	/**
  
  584
  >
  	 * Whether the editor should be serialized and stored for subsequent sessions.
  
  585
  >
  	 */
  
  586
  >
  	readonly isTransient?: boolean;
  
  587
  >
  }
  
  588
  >
  
  589
  >
  export interface IMultiDiffEditorResource extends IResourceDiffEditorInput {
  
  590
  >
  	readonly goToFileResource?: URI;
  
  591
  >
  }
  
  592
  >
  export type IResourceMergeEditorInputSide = (Omit<IResourceEditorInput, 'options'> | Omit<ITextResourceEditorInput, 'options'>) & { detail?: string };
  
  593
  >
  
  594
  >
  /**
  
  595
  >
   * A resource merge editor input compares multiple editors
  
  596
  >
   * highlighting the differences for merging.
  
  597
  >
   *
  
  598
  >
   * Note: all sides must be resolvable to the same editor, or
  
  599
  >
   * a text based presentation will be used as fallback.
  
  600
  >
   */
  
  601
  >
  export interface IResourceMergeEditorInput extends IBaseUntypedEditorInput {
  
  602
  >
  
  603
  >
  	/**
  
  604
  >
  	 * The one changed version of the file.
  
  605
  >
  	 */
  
  606
  >
  	readonly input1: IResourceMergeEditorInputSide;
  
  607
  >
  
  608
  >
  	/**
  
  609
  >
  	 * The second changed version of the file.
  
  610
  >
  	 */
  
  611
  >
  	readonly input2: IResourceMergeEditorInputSide;
  
  612
  >
  
  613
  >
  	/**
  
  614
  >
  	 * The base common ancestor of the file to merge.
  
  615
  >
  	 */
  
  616
  >
  	readonly base: Omit<IResourceEditorInput, 'options'> | Omit<ITextResourceEditorInput, 'options'>;
  
  617
  >
  
  618
  >
  	/**
  
  619
  >
  	 * The resulting output of the merge.
  
  620
  >
  	 */
  
  621
  >
  	readonly result: Omit<IResourceEditorInput, 'options'> | Omit<ITextResourceEditorInput, 'options'>;
  
  622
  >
  }
  
  623
  >
  
  624
  >
  export function isResourceEditorInput(editor: unknown): editor is IResourceEditorInput {
  
  625
  
  	if (isEditorInput(editor)) {
  
  626
  
  		return false; // make sure to not accidentally match on typed editor inputs
  
  627
  
  	}
  
  628
  
  629
  
  	const candidate = editor as IResourceEditorInput | undefined;
  
  630
  
  631
  
  	return URI.isUri(candidate?.resource);
  
  632
  
  }
  
  633
  >
  
editor.ts ×36

  634
  >
  export function isResourceDiffEditorInput(editor: unknown): editor is IResourceDiffEditorInput {
  
  635
  
  	if (isEditorInput(editor)) {
  
  636
  
  		return false; // make sure to not accidentally match on typed editor inputs
  
  637
  
  	}
  
  638
  
  639
  
  	const candidate = editor as IResourceDiffEditorInput | undefined;
  
  640
  
  641
  
  	return candidate?.original !== undefined && candidate.modified !== undefined;
  
  642
  
  }
  
  643
  >
  
editor.ts ×36

  644
  >
  export function isResourceMultiDiffEditorInput(editor: unknown): editor is IResourceMultiDiffEditorInput {
  
  645
  
  	if (isEditorInput(editor)) {
  
  646
  
  		return false; // make sure to not accidentally match on typed editor inputs
  
  647
  
  	}
  
  648
  
  649
  
  	const candidate = editor as IResourceMultiDiffEditorInput | undefined;
  
  650
  
  	if (!candidate) {
  
  651
  
  		return false;
  
  652
  
  	}
  
  653
  
  	if (candidate.resources && !Array.isArray(candidate.resources)) {
  
  654
  
  		return false;
  
  655
  
  	}
  
  656
  
  657
  
  	return !!candidate.resources || !!candidate.multiDiffSource;
  
  658
  
  }
  
  659
  >
  
editor.ts ×36

  660
  >
  export function isResourceSideBySideEditorInput(editor: unknown): editor is IResourceSideBySideEditorInput {
  
  661
  
  	if (isEditorInput(editor)) {
  
  662
  
  		return false; // make sure to not accidentally match on typed editor inputs
  
  663
  
  	}
  
  664
  
  665
  
  	if (isResourceDiffEditorInput(editor)) {
  
  666
  
  		return false; // make sure to not accidentally match on diff editors
  
  667
  
  	}
  
  668
  
  669
  
  	const candidate = editor as IResourceSideBySideEditorInput | undefined;
  
  670
  
  671
  
  	return candidate?.primary !== undefined && candidate.secondary !== undefined;
  
  672
  
  }
  
  673
  >
  
editor.ts ×36

  674
  >
  export function isUntitledResourceEditorInput(editor: unknown): editor is IUntitledTextResourceEditorInput {
  
  675
  
  	if (isEditorInput(editor)) {
  
  676
  
  		return false; // make sure to not accidentally match on typed editor inputs
  
  677
  
  	}
  
  678
  
  679
  
  	const candidate = editor as IUntitledTextResourceEditorInput | undefined;
  
  680
  
  	if (!candidate) {
  
  681
  
  		return false;
  
  682
  
  	}
  
  683
  
  684
  
  	return candidate.resource === undefined || candidate.resource.scheme === Schemas.untitled || candidate.forceUntitled === true;
  
  685
  
  }
  
  686
  >
  
editor.ts ×36

  687
  >
  export function isResourceMergeEditorInput(editor: unknown): editor is IResourceMergeEditorInput {
  
  688
  
  	if (isEditorInput(editor)) {
  
  689
  
  		return false; // make sure to not accidentally match on typed editor inputs
  
  690
  
  	}
  
  691
  
  692
  
  	const candidate = editor as IResourceMergeEditorInput | undefined;
  
  693
  
  694
  
  	return URI.isUri(candidate?.base?.resource) && URI.isUri(candidate?.input1?.resource) && URI.isUri(candidate?.input2?.resource) && URI.isUri(candidate?.result?.resource);
  
  695
  
  }
  
  696
  >
  
editor.ts ×36

  697
  >
  export const enum Verbosity {
  
  698
  >
  	SHORT,
  
  699
  >
  	MEDIUM,
  
  700
  >
  	LONG
  
  701
  >
  }
  
  702
  >
  
  703
  >
  export const enum SaveReason {
  
  704
  >
  
  705
  >
  	/**
  
  706
  >
  	 * Explicit user gesture.
  
  707
  >
  	 */
  
  708
  >
  	EXPLICIT = 1,
  
  709
  >
  
  710
  >
  	/**
  
  711
  >
  	 * Auto save after a timeout.
  
  712
  >
  	 */
  
  713
  >
  	AUTO = 2,
  
  714
  >
  
  715
  >
  	/**
  
  716
  >
  	 * Auto save after editor focus change.
  
  717
  >
  	 */
  
  718
  >
  	FOCUS_CHANGE = 3,
  
  719
  >
  
  720
  >
  	/**
  
  721
  >
  	 * Auto save after window change.
  
  722
  >
  	 */
  
  723
  >
  	WINDOW_CHANGE = 4
  
  724
  >
  }
  
  725
  >
  
  726
  >
  export type SaveSource = string;
  
  727
  >
  
  728
  >
  interface ISaveSourceDescriptor {
  
  729
  >
  	source: SaveSource;
  
  730
  >
  	label: string;
  
  731
  >
  }
  
  732
  >
  
  733
  >
  class SaveSourceFactory {
  
  734
  >
  
  735
  >
  	private readonly mapIdToSaveSource = new Map<SaveSource, ISaveSourceDescriptor>();
  
  736
  >
  
  737
  >
  	/**
  
  738
  >
  	 * Registers a `SaveSource` with an identifier and label
  
  739
  >
  	 * to the registry so that it can be used in save operations.
  
  740
  >
  	 */
  
  741
  >
  	registerSource(id: string, label: string): SaveSource {
  
  742
  
  		let sourceDescriptor = this.mapIdToSaveSource.get(id);
  
  743
  
  		if (!sourceDescriptor) {
  
  744
  
  			sourceDescriptor = { source: id, label };
  
  745
  
  			this.mapIdToSaveSource.set(id, sourceDescriptor);
  
  746
  
  		}
  
  747
  
  748
  
  		return sourceDescriptor.source;
  
  749
  
  	}
  
  750
  >
  
editor.ts ×36

  751
  >
  	getSourceLabel(source: SaveSource): string {
  
  752
  
  		return this.mapIdToSaveSource.get(source)?.label ?? source;
  
  753
  
  	}
  
  754
  >
  }
  
editor.ts ×36

  755
  >
  
  756
  >
  export const SaveSourceRegistry = new SaveSourceFactory();
  
  757
  >
  
  758
  >
  export interface ISaveOptions {
  
  759
  >
  
  760
  >
  	/**
  
  761
  >
  	 * An indicator how the save operation was triggered.
  
  762
  >
  	 */
  
  763
  >
  	reason?: SaveReason;
  
  764
  >
  
  765
  >
  	/**
  
  766
  >
  	 * An indicator about the source of the save operation.
  
  767
  >
  	 *
  
  768
  >
  	 * Must use `SaveSourceRegistry.registerSource()` to obtain.
  
  769
  >
  	 */
  
  770
  >
  	readonly source?: SaveSource;
  
  771
  >
  
  772
  >
  	/**
  
  773
  >
  	 * Forces to save the contents of the working copy
  
  774
  >
  	 * again even if the working copy is not dirty.
  
  775
  >
  	 */
  
  776
  >
  	readonly force?: boolean;
  
  777
  >
  
  778
  >
  	/**
  
  779
  >
  	 * Instructs the save operation to skip any save participants.
  
  780
  >
  	 */
  
  781
  >
  	readonly skipSaveParticipants?: boolean;
  
  782
  >
  
  783
  >
  	/**
  
  784
  >
  	 * A hint as to which file systems should be available for saving.
  
  785
  >
  	 */
  
  786
  >
  	readonly availableFileSystems?: string[];
  
  787
  >
  }
  
  788
  >
  
  789
  >
  export interface IRevertOptions {
  
  790
  >
  
  791
  >
  	/**
  
  792
  >
  	 * Forces to load the contents of the working copy
  
  793
  >
  	 * again even if the working copy is not dirty.
  
  794
  >
  	 */
  
  795
  >
  	readonly force?: boolean;
  
  796
  >
  
  797
  >
  	/**
  
  798
  >
  	 * A soft revert will clear dirty state of a working copy
  
  799
  >
  	 * but will not attempt to load it from its persisted state.
  
  800
  >
  	 *
  
  801
  >
  	 * This option may be used in scenarios where an editor is
  
  802
  >
  	 * closed and where we do not require to load the contents.
  
  803
  >
  	 */
  
  804
  >
  	readonly soft?: boolean;
  
  805
  >
  }
  
  806
  >
  
  807
  >
  export interface IMoveResult {
  
  808
  >
  	editor: EditorInput | IUntypedEditorInput;
  
  809
  >
  	options?: IEditorOptions;
  
  810
  >
  }
  
  811
  >
  
  812
  >
  export const enum EditorInputCapabilities {
  
  813
  >
  
  814
  >
  	/**
  
  815
  >
  	 * Signals no specific capability for the input.
  
  816
  >
  	 */
  
  817
  >
  	None = 0,
  
  818
  >
  
  819
  >
  	/**
  
  820
  >
  	 * Signals that the input is readonly.
  
  821
  >
  	 */
  
  822
  >
  	Readonly = 1 << 1,
  
  823
  >
  
  824
  >
  	/**
  
  825
  >
  	 * Signals that the input is untitled.
  
  826
  >
  	 */
  
  827
  >
  	Untitled = 1 << 2,
  
  828
  >
  
  829
  >
  	/**
  
  830
  >
  	 * Signals that the input can only be shown in one group
  
  831
  >
  	 * and not be split into multiple groups.
  
  832
  >
  	 */
  
  833
  >
  	Singleton = 1 << 3,
  
  834
  >
  
  835
  >
  	/**
  
  836
  >
  	 * Signals that the input requires workspace trust.
  
  837
  >
  	 */
  
  838
  >
  	RequiresTrust = 1 << 4,
  
  839
  >
  
  840
  >
  	/**
  
  841
  >
  	 * Signals that the editor can split into 2 in the same
  
  842
  >
  	 * editor group.
  
  843
  >
  	 */
  
  844
  >
  	CanSplitInGroup = 1 << 5,
  
  845
  >
  
  846
  >
  	/**
  
  847
  >
  	 * Signals that the editor wants its description to be
  
  848
  >
  	 * visible when presented to the user. By default, a UI
  
  849
  >
  	 * component may decide to hide the description portion
  
  850
  >
  	 * for brevity.
  
  851
  >
  	 */
  
  852
  >
  	ForceDescription = 1 << 6,
  
  853
  >
  
  854
  >
  	/**
  
  855
  >
  	 * Signals that the editor supports dropping into the
  
  856
  >
  	 * editor by holding shift.
  
  857
  >
  	 */
  
  858
  >
  	CanDropIntoEditor = 1 << 7,
  
  859
  >
  
  860
  >
  	/**
  
  861
  >
  	 * Signals that the editor is composed of multiple editors
  
  862
  >
  	 * within.
  
  863
  >
  	 */
  
  864
  >
  	MultipleEditors = 1 << 8,
  
  865
  >
  
  866
  >
  	/**
  
  867
  >
  	 * Signals that the editor cannot be in a dirty state
  
  868
  >
  	 * and may still have unsaved changes
  
  869
  >
  	 */
  
  870
  >
  	Scratchpad = 1 << 9,
  
  871
  >
  
  872
  >
  	/**
  
  873
  >
  	 * Signals that the editor should be revealed when being
  
  874
  >
  	 * opened if it is already opened in any editor group.
  
  875
  >
  	 */
  
  876
  >
  	ForceReveal = 1 << 10,
  
  877
  >
  
  878
  >
  	/**
  
  879
  >
  	 * Signals that the editor must be opened in a modal editor
  
  880
  >
  	 * part. This is honored unless the user has explicitly opted
  
  881
  >
  	 * out of modal editors via `workbench.editor.useModal: 'off'`.
  
  882
  >
  	 */
  
  883
  >
  	RequiresModal = 1 << 11,
  
  884
  >
  
  885
  >
  	/**
  
  886
  >
  	 * Signals that the editor is exempt from the opened editors
  
  887
  >
  	 * limit (`workbench.editor.limit`): it never counts towards the
  
  888
  >
  	 * limit and is never auto-closed to satisfy it.
  
  889
  >
  	 */
  
  890
  >
  	ExcludeFromEditorLimit = 1 << 12
  
  891
  >
  }
  
  892
  >
  
  893
  >
  export type IUntypedEditorInput = IResourceEditorInput | ITextResourceEditorInput | IUntitledTextResourceEditorInput | IResourceDiffEditorInput | IResourceMultiDiffEditorInput | IResourceSideBySideEditorInput | IResourceMergeEditorInput;
  
  894
  >
  
  895
  >
  export abstract class AbstractEditorInput extends Disposable {
  
  896
  >
  	// Marker class for implementing `isEditorInput`
  
  897
  >
  }
  
  898
  >
  
  899
  >
  export function isEditorInput(editor: unknown): editor is EditorInput {
  
  900
  
  	return editor instanceof AbstractEditorInput;
  
  901
  
  }
  
  902
  >
  
editor.ts ×36

  903
  >
  export interface EditorInputWithPreferredResource {
  
  904
  >
  
  905
  >
  	/**
  
  906
  >
  	 * An editor may provide an additional preferred resource alongside
  
  907
  >
  	 * the `resource` property. While the `resource` property serves as
  
  908
  >
  	 * unique identifier of the editor that should be used whenever we
  
  909
  >
  	 * compare to other editors, the `preferredResource` should be used
  
  910
  >
  	 * in places where e.g. the resource is shown to the user.
  
  911
  >
  	 *
  
  912
  >
  	 * For example: on Windows and macOS, the same URI with different
  
  913
  >
  	 * casing may point to the same file. The editor may chose to
  
  914
  >
  	 * "normalize" the URIs so that only one editor opens for different
  
  915
  >
  	 * URIs. But when displaying the editor label to the user, the
  
  916
  >
  	 * preferred URI should be used.
  
  917
  >
  	 *
  
  918
  >
  	 * Not all editors have a `preferredResource`. The `EditorResourceAccessor`
  
  919
  >
  	 * utility can be used to always get the right resource without having
  
  920
  >
  	 * to do instanceof checks.
  
  921
  >
  	 */
  
  922
  >
  	readonly preferredResource: URI;
  
  923
  >
  }
  
  924
  >
  
  925
  
  function isEditorInputWithPreferredResource(editor: unknown): editor is EditorInputWithPreferredResource {
  
  926
  
  	const candidate = editor as EditorInputWithPreferredResource | undefined;
  
  927
  
  928
  
  	return URI.isUri(candidate?.preferredResource);
  
  929
  
  }
  
  930
  >
  
editor.ts ×36

  931
  >
  export interface ISideBySideEditorInput extends EditorInput {
  
  932
  >
  
  933
  >
  	/**
  
  934
  >
  	 * The primary editor input is shown on the right hand side.
  
  935
  >
  	 */
  
  936
  >
  	primary: EditorInput;
  
  937
  >
  
  938
  >
  	/**
  
  939
  >
  	 * The secondary editor input is shown on the left hand side.
  
  940
  >
  	 */
  
  941
  >
  	secondary: EditorInput;
  
  942
  >
  }
  
  943
  >
  
  944
  >
  export function isSideBySideEditorInput(editor: unknown): editor is ISideBySideEditorInput {
  
  945
  
  	const candidate = editor as ISideBySideEditorInput | undefined;
  
  946
  
  947
  
  	return isEditorInput(candidate?.primary) && isEditorInput(candidate?.secondary);
  
  948
  
  }
  
  949
  >
  
editor.ts ×36

  950
  >
  export interface IDiffEditorInput extends EditorInput {
  
  951
  >
  
  952
  >
  	/**
  
  953
  >
  	 * The modified (primary) editor input is shown on the right hand side.
  
  954
  >
  	 */
  
  955
  >
  	modified: EditorInput;
  
  956
  >
  
  957
  >
  	/**
  
  958
  >
  	 * The original (secondary) editor input is shown on the left hand side.
  
  959
  >
  	 */
  
  960
  >
  	original: EditorInput;
  
  961
  >
  }
  
  962
  >
  
  963
  >
  export function isDiffEditorInput(editor: unknown): editor is IDiffEditorInput {
  
  964
  
  	const candidate = editor as IDiffEditorInput | undefined;
  
  965
  
  966
  
  	return isEditorInput(candidate?.modified) && isEditorInput(candidate?.original);
  
  967
  
  }
  
  968
  >
  
editor.ts ×36

  969
  >
  export interface IUntypedFileEditorInput extends ITextResourceEditorInput {
  
  970
  >
  
  971
  >
  	/**
  
  972
  >
  	 * A marker to create a `IFileEditorInput` from this untyped input.
  
  973
  >
  	 */
  
  974
  >
  	forceFile: true;
  
  975
  >
  }
  
  976
  >
  
  977
  >
  /**
  
  978
  >
   * This is a tagging interface to declare an editor input being capable of dealing with files. It is only used in the editor registry
  
  979
  >
   * to register this kind of input to the platform.
  
  980
  >
   */
  
  981
  >
  export interface IFileEditorInput extends EditorInput, IEncodingSupport, ILanguageSupport, EditorInputWithPreferredResource {
  
  982
  >
  
  983
  >
  	/**
  
  984
  >
  	 * Gets the resource this file input is about. This will always be the
  
  985
  >
  	 * canonical form of the resource, so it may differ from the original
  
  986
  >
  	 * resource that was provided to create the input. Use `preferredResource`
  
  987
  >
  	 * for the form as it was created.
  
  988
  >
  	 */
  
  989
  >
  	readonly resource: URI;
  
  990
  >
  
  991
  >
  	/**
  
  992
  >
  	 * Sets the preferred resource to use for this file input.
  
  993
  >
  	 */
  
  994
  >
  	setPreferredResource(preferredResource: URI): void;
  
  995
  >
  
  996
  >
  	/**
  
  997
  >
  	 * Sets the preferred name to use for this file input.
  
  998
  >
  	 *
  
  999
  >
  	 * Note: for certain file schemes the input may decide to ignore this
  
  1000
  >
  	 * name and use our standard naming. Specifically for schemes we own,
  
  1001
  >
  	 * we do not let others override the name.
  
  1002
  >
  	 */
  
  1003
  >
  	setPreferredName(name: string): void;
  
  1004
  >
  
  1005
  >
  	/**
  
  1006
  >
  	 * Sets the preferred description to use for this file input.
  
  1007
  >
  	 *
  
  1008
  >
  	 * Note: for certain file schemes the input may decide to ignore this
  
  1009
  >
  	 * description and use our standard naming. Specifically for schemes we own,
  
  1010
  >
  	 * we do not let others override the description.
  
  1011
  >
  	 */
  
  1012
  >
  	setPreferredDescription(description: string): void;
  
  1013
  >
  
  1014
  >
  	/**
  
  1015
  >
  	 * Sets the preferred encoding to use for this file input.
  
  1016
  >
  	 */
  
  1017
  >
  	setPreferredEncoding(encoding: string): void;
  
  1018
  >
  
  1019
  >
  	/**
  
  1020
  >
  	 * Sets the preferred language id to use for this file input.
  
  1021
  >
  	 */
  
  1022
  >
  	setPreferredLanguageId(languageId: string): void;
  
  1023
  >
  
  1024
  >
  	/**
  
  1025
  >
  	 * Sets the preferred contents to use for this file input.
  
  1026
  >
  	 */
  
  1027
  >
  	setPreferredContents(contents: string): void;
  
  1028
  >
  
  1029
  >
  	/**
  
  1030
  >
  	 * Forces this file input to open as binary instead of text.
  
  1031
  >
  	 */
  
  1032
  >
  	setForceOpenAsBinary(): void;
  
  1033
  >
  
  1034
  >
  	/**
  
  1035
  >
  	 * Figure out if the file input has been resolved or not.
  
  1036
  >
  	 */
  
  1037
  >
  	isResolved(): boolean;
  
  1038
  >
  }
  
  1039
  >
  
  1040
  >
  export interface IFileLimitedEditorInputOptions extends IEditorOptions {
  
  1041
  >
  
  1042
  >
  	/**
  
  1043
  >
  	 * If provided, the size of the file will be checked against the limits
  
  1044
  >
  	 * and an error will be thrown if any limit is exceeded.
  
  1045
  >
  	 */
  
  1046
  >
  	readonly limits?: IFileReadLimits;
  
  1047
  >
  }
  
  1048
  >
  
  1049
  >
  export interface IFileEditorInputOptions extends ITextEditorOptions, IFileLimitedEditorInputOptions { }
  
  1050
  >
  
  1051
  >
  export function createTooLargeFileError(group: IEditorGroup, input: EditorInput, options: IEditorOptions | undefined, message: string, preferencesService: IPreferencesService): Error {
  
  1052
  
  	return createEditorOpenError(message, [
  
  1053
  
  		toAction({
  
  1054
  
  			id: 'workbench.action.openLargeFile', label: localize('openLargeFile', "Open Anyway"), run: () => {
  
  1055
  
  				const fileEditorOptions: IFileEditorInputOptions = {
  
  1056
  
  					...options,
  
  1057
  
  					limits: {
  
  1058
  
  						size: Number.MAX_VALUE
  
  1059
  
  					}
  
  1060
  
  				};
  
  1061
  
  1062
  
  				group.openEditor(input, fileEditorOptions);
  
  1063
  
  			}
  
  1064
  
  		}),
  
  1065
  
  		toAction({
  
  1066
  
  			id: 'workbench.action.configureEditorLargeFileConfirmation', label: localize('configureEditorLargeFileConfirmation', "Configure Limit"), run: () => {
  
  1067
  
  				return preferencesService.openUserSettings({ query: 'workbench.editorLargeFileConfirmation' });
  
  1068
  
  			}
  
  1069
  
  		}),
  
  1070
  
  	], {
  
  1071
  
  		forceMessage: true,
  
  1072
  
  		forceSeverity: Severity.Warning
  
  1073
  
  	});
  
  1074
  
  }
  
  1075
  >
  
editor.ts ×36

  1076
  >
  export interface EditorInputWithOptions {
  
  1077
  >
  	editor: EditorInput;
  
  1078
  >
  	options?: IEditorOptions;
  
  1079
  >
  }
  
  1080
  >
  
  1081
  >
  export interface EditorInputWithOptionsAndGroup extends EditorInputWithOptions {
  
  1082
  >
  	group: IEditorGroup;
  
  1083
  >
  }
  
  1084
  >
  
  1085
  >
  export function isEditorInputWithOptions(editor: unknown): editor is EditorInputWithOptions {
  
  1086
  
  	const candidate = editor as EditorInputWithOptions | undefined;
  
  1087
  
  1088
  
  	return isEditorInput(candidate?.editor);
  
  1089
  
  }
  
  1090
  >
  
editor.ts ×36

  1091
  >
  export function isEditorInputWithOptionsAndGroup(editor: unknown): editor is EditorInputWithOptionsAndGroup {
  
  1092
  
  	const candidate = editor as EditorInputWithOptionsAndGroup | undefined;
  
  1093
  
  1094
  
  	return isEditorInputWithOptions(editor) && candidate?.group !== undefined;
  
  1095
  
  }
  
  1096
  >
  
editor.ts ×36

  1097
  >
  /**
  
  1098
  >
   * Context passed into `EditorPane#setInput` to give additional
  
  1099
  >
   * context information around why the editor was opened.
  
  1100
  >
   */
  
  1101
  >
  export interface IEditorOpenContext {
  
  1102
  >
  
  1103
  >
  	/**
  
  1104
  >
  	 * An indicator if the editor input is new for the group the editor is in.
  
  1105
  >
  	 * An editor is new for a group if it was not part of the group before and
  
  1106
  >
  	 * otherwise was already opened in the group and just became the active editor.
  
  1107
  >
  	 *
  
  1108
  >
  	 * This hint can e.g. be used to decide whether to restore view state or not.
  
  1109
  >
  	 */
  
  1110
  >
  	newInGroup?: boolean;
  
  1111
  >
  }
  
  1112
  >
  
  1113
  >
  export interface IEditorIdentifier {
  
  1114
  >
  	groupId: GroupIdentifier;
  
  1115
  >
  	editor: EditorInput;
  
  1116
  >
  }
  
  1117
  >
  
  1118
  >
  export function isEditorIdentifier(identifier: unknown): identifier is IEditorIdentifier {
  
  1119
  
  	const candidate = identifier as IEditorIdentifier | undefined;
  
  1120
  
  1121
  
  	return typeof candidate?.groupId === 'number' && isEditorInput(candidate.editor);
  
  1122
  
  }
  
  1123
  >
  
editor.ts ×36

  1124
  >
  /**
  
  1125
  >
   * The editor commands context is used for editor commands (e.g. in the editor title)
  
  1126
  >
   * and we must ensure that the context is serializable because it potentially travels
  
  1127
  >
   * to the extension host!
  
  1128
  >
   */
  
  1129
  >
  export interface IEditorCommandsContext {
  
  1130
  >
  	groupId: GroupIdentifier;
  
  1131
  >
  	editorIndex?: number;
  
  1132
  >
  
  1133
  >
  	preserveFocus?: boolean;
  
  1134
  >
  }
  
  1135
  >
  
  1136
  >
  export function isEditorCommandsContext(context: unknown): context is IEditorCommandsContext {
  
  1137
  
  	const candidate = context as IEditorCommandsContext | undefined;
  
  1138
  
  1139
  
  	return typeof candidate?.groupId === 'number';
  
  1140
  
  }
  
  1141
  >
  
editor.ts ×36

  1142
  >
  /**
  
  1143
  >
   * More information around why an editor was closed in the model.
  
  1144
  >
   */
  
  1145
  >
  export enum EditorCloseContext {
  
  1146
  >
  
  1147
  >
  	/**
  
  1148
  >
  	 * No specific context for closing (e.g. explicit user gesture).
  
  1149
  >
  	 */
  
  1150
  >
  	UNKNOWN,
  
  1151
  >
  
  1152
  >
  	/**
  
  1153
  >
  	 * The editor closed because it was replaced with another editor.
  
  1154
  >
  	 * This can either happen via explicit replace call or when an
  
  1155
  >
  	 * editor is in preview mode and another editor opens.
  
  1156
  >
  	 */
  
  1157
  >
  	REPLACE,
  
  1158
  >
  
  1159
  >
  	/**
  
  1160
  >
  	 * The editor closed as a result of moving it to another group.
  
  1161
  >
  	 */
  
  1162
  >
  	MOVE,
  
  1163
  >
  
  1164
  >
  	/**
  
  1165
  >
  	 * The editor closed because another editor turned into preview
  
  1166
  >
  	 * and this used to be the preview editor before.
  
  1167
  >
  	 */
  
  1168
  >
  	UNPIN
  
  1169
  >
  }
  
  1170
  >
  
  1171
  >
  export interface IEditorCloseEvent extends IEditorIdentifier {
  
  1172
  >
  
  1173
  >
  	/**
  
  1174
  >
  	 * More information around why the editor was closed.
  
  1175
  >
  	 */
  
  1176
  >
  	readonly context: EditorCloseContext;
  
  1177
  >
  
  1178
  >
  	/**
  
  1179
  >
  	 * The index of the editor before closing.
  
  1180
  >
  	 */
  
  1181
  >
  	readonly index: number;
  
  1182
  >
  
  1183
  >
  	/**
  
  1184
  >
  	 * Whether the editor was sticky or not.
  
  1185
  >
  	 */
  
  1186
  >
  	readonly sticky: boolean;
  
  1187
  >
  }
  
  1188
  >
  
  1189
  >
  export interface IActiveEditorChangeEvent {
  
  1190
  >
  
  1191
  >
  	/**
  
  1192
  >
  	 * The new active editor or `undefined` if the group is empty.
  
  1193
  >
  	 */
  
  1194
  >
  	editor: EditorInput | undefined;
  
  1195
  >
  
  1196
  >
  	/**
  
  1197
  >
  	 * Indicates whether the editor change is the result of an explicit
  
  1198
  >
  	 * user action (`true`) or happened automatically as a side effect
  
  1199
  >
  	 * (e.g. the chat agent opening files it has edited).
  
  1200
  >
  	 *
  
  1201
  >
  	 * When omitted, callers should treat the change as explicit.
  
  1202
  >
  	 */
  
  1203
  >
  	isExplicit?: boolean;
  
  1204
  >
  }
  
  1205
  >
  
  1206
  >
  export interface IEditorWillMoveEvent extends IEditorIdentifier {
  
  1207
  >
  
  1208
  >
  	/**
  
  1209
  >
  	 * The target group of the move operation.
  
  1210
  >
  	 */
  
  1211
  >
  	readonly target: GroupIdentifier;
  
  1212
  >
  }
  
  1213
  >
  
  1214
  >
  export interface IEditorWillOpenEvent extends IEditorIdentifier { }
  
  1215
  >
  
  1216
  >
  export interface IWillInstantiateEditorPaneEvent {
  
  1217
  >
  
  1218
  >
  	/**
  
  1219
  >
  	 * @see {@link IEditorDescriptor.typeId}
  
  1220
  >
  	 */
  
  1221
  >
  	readonly typeId: string;
  
  1222
  >
  }
  
  1223
  >
  
  1224
  >
  export type GroupIdentifier = number;
  
  1225
  >
  
  1226
  >
  export const enum GroupModelChangeKind {
  
  1227
  >
  
  1228
  >
  	/* Group Changes */
  
  1229
  >
  	GROUP_ACTIVE,
  
  1230
  >
  	GROUP_INDEX,
  
  1231
  >
  	GROUP_LABEL,
  
  1232
  >
  	GROUP_LOCKED,
  
  1233
  >
  
  1234
  >
  	/* Editors Change */
  
  1235
  >
  	EDITORS_SELECTION,
  
  1236
  >
  
  1237
  >
  	/* Editor Changes */
  
  1238
  >
  	EDITOR_OPEN,
  
  1239
  >
  	EDITOR_CLOSE,
  
  1240
  >
  	EDITOR_MOVE,
  
  1241
  >
  	EDITOR_ACTIVE,
  
  1242
  >
  	EDITOR_LABEL,
  
  1243
  >
  	EDITOR_CAPABILITIES,
  
  1244
  >
  	EDITOR_PIN,
  
  1245
  >
  	EDITOR_TRANSIENT,
  
  1246
  >
  	EDITOR_STICKY,
  
  1247
  >
  	EDITOR_DIRTY,
  
  1248
  >
  	EDITOR_WILL_DISPOSE
  
  1249
  >
  }
  
  1250
  >
  
  1251
  >
  export interface IWorkbenchEditorConfiguration {
  
  1252
  >
  	workbench?: {
  
  1253
  >
  		editor?: IEditorPartConfiguration;
  
  1254
  >
  		iconTheme?: string;
  
  1255
  >
  	};
  
  1256
  >
  }
  
  1257
  >
  
  1258
  >
  interface IEditorPartLimitConfiguration {
  
  1259
  >
  	enabled?: boolean;
  
  1260
  >
  	excludeDirty?: boolean;
  
  1261
  >
  	value?: number;
  
  1262
  >
  	perEditorGroup?: boolean;
  
  1263
  >
  }
  
  1264
  >
  
  1265
  >
  export interface IEditorPartLimitOptions extends Required<IEditorPartLimitConfiguration> { }
  
  1266
  >
  
  1267
  >
  interface IEditorPartDecorationsConfiguration {
  
  1268
  >
  	badges?: boolean;
  
  1269
  >
  	colors?: boolean;
  
  1270
  >
  }
  
  1271
  >
  
  1272
  >
  export interface IEditorPartDecorationOptions extends Required<IEditorPartDecorationsConfiguration> { }
  
  1273
  >
  
  1274
  >
  interface IEditorPartConfiguration {
  
  1275
  >
  	showTabs?: 'multiple' | 'single' | 'none';
  
  1276
  >
  	wrapTabs?: boolean;
  
  1277
  >
  	scrollToSwitchTabs?: boolean;
  
  1278
  >
  	highlightModifiedTabs?: boolean;
  
  1279
  >
  	tabActionLocation?: 'left' | 'right';
  
  1280
  >
  	tabActionCloseVisibility?: boolean;
  
  1281
  >
  	tabActionUnpinVisibility?: boolean;
  
  1282
  >
  	showTabIndex?: boolean;
  
  1283
  >
  	alwaysShowEditorActions?: boolean;
  
  1284
  >
  	tabSizing?: 'fit' | 'shrink' | 'fixed';
  
  1285
  >
  	tabSizingFixedMinWidth?: number;
  
  1286
  >
  	tabSizingFixedMaxWidth?: number;
  
  1287
  >
  	pinnedTabSizing?: 'normal' | 'compact' | 'shrink';
  
  1288
  >
  	pinnedTabsOnSeparateRow?: boolean;
  
  1289
  >
  	tabHeight?: 'default' | 'compact';
  
  1290
  >
  	preventPinnedEditorClose?: PreventPinnedEditorClose;
  
  1291
  >
  	titleScrollbarSizing?: 'default' | 'large';
  
  1292
  >
  	titleScrollbarVisibility?: 'auto' | 'visible' | 'hidden';
  
  1293
  >
  	focusRecentEditorAfterClose?: boolean;
  
  1294
  >
  	showIcons?: boolean;
  
  1295
  >
  	enablePreview?: boolean;
  
  1296
  >
  	enablePreviewFromQuickOpen?: boolean;
  
  1297
  >
  	enablePreviewFromCodeNavigation?: boolean;
  
  1298
  >
  	closeOnFileDelete?: boolean;
  
  1299
  >
  	openPositioning?: 'left' | 'right' | 'first' | 'last';
  
  1300
  >
  	openSideBySideDirection?: 'right' | 'down';
  
  1301
  >
  	closeEmptyGroups?: boolean;
  
  1302
  >
  	autoLockGroups?: Set<string>;
  
  1303
  >
  	revealIfOpen?: boolean;
  
  1304
  >
  	swipeToNavigate?: boolean;
  
  1305
  >
  	mouseBackForwardToNavigate?: boolean;
  
  1306
  >
  	labelFormat?: 'default' | 'short' | 'medium' | 'long';
  
  1307
  >
  	restoreViewState?: boolean;
  
  1308
  >
  	splitInGroupLayout?: 'vertical' | 'horizontal';
  
  1309
  >
  	splitSizing?: 'auto' | 'split' | 'distribute';
  
  1310
  >
  	splitOnDragAndDrop?: boolean;
  
  1311
  >
  	allowDropIntoGroup?: boolean;
  
  1312
  >
  	dragToOpenWindow?: boolean;
  
  1313
  >
  	centeredLayoutFixedWidth?: boolean;
  
  1314
  >
  	doubleClickTabToToggleEditorGroupSizes?: 'maximize' | 'expand' | 'off';
  
  1315
  >
  	editorActionsLocation?: 'default' | 'titleBar' | 'hidden';
  
  1316
  >
  	limit?: IEditorPartLimitConfiguration;
  
  1317
  >
  	decorations?: IEditorPartDecorationsConfiguration;
  
  1318
  >
  }
  
  1319
  >
  
  1320
  >
  export interface IEditorPartOptions extends DeepRequiredNonNullable<IEditorPartConfiguration> {
  
  1321
  >
  	hasIcons: boolean;
  
  1322
  >
  }
  
  1323
  >
  
  1324
  >
  export interface IEditorPartOptionsChangeEvent {
  
  1325
  >
  	oldPartOptions: IEditorPartOptions;
  
  1326
  >
  	newPartOptions: IEditorPartOptions;
  
  1327
  >
  }
  
  1328
  >
  
  1329
  >
  export enum SideBySideEditor {
  
  1330
  >
  	PRIMARY = 1,
  
  1331
  >
  	SECONDARY = 2,
  
  1332
  >
  	BOTH = 3,
  
  1333
  >
  	ANY = 4
  
  1334
  >
  }
  
  1335
  >
  
  1336
  >
  export interface IFindEditorOptions {
  
  1337
  >
  
  1338
  >
  	/**
  
  1339
  >
  	 * Whether to consider any or both side by side editor as matching.
  
  1340
  >
  	 * By default, side by side editors will not be considered
  
  1341
  >
  	 * as matching, even if the editor is opened in one of the sides.
  
  1342
  >
  	 */
  
  1343
  >
  	supportSideBySide?: SideBySideEditor.PRIMARY | SideBySideEditor.SECONDARY | SideBySideEditor.ANY;
  
  1344
  >
  
  1345
  >
  	/**
  
  1346
  >
  	 * The order in which to consider editors for finding.
  
  1347
  >
  	 */
  
  1348
  >
  	order?: EditorsOrder;
  
  1349
  >
  }
  
  1350
  >
  
  1351
  >
  export interface IMatchEditorOptions {
  
  1352
  >
  
  1353
  >
  	/**
  
  1354
  >
  	 * Whether to consider a side by side editor as matching.
  
  1355
  >
  	 * By default, side by side editors will not be considered
  
  1356
  >
  	 * as matching, even if the editor is opened in one of the sides.
  
  1357
  >
  	 */
  
  1358
  >
  	supportSideBySide?: SideBySideEditor.ANY | SideBySideEditor.BOTH;
  
  1359
  >
  
  1360
  >
  	/**
  
  1361
  >
  	 * Only consider an editor to match when the
  
  1362
  >
  	 * `candidate === editor` but not when
  
  1363
  >
  	 * `candidate.matches(editor)`.
  
  1364
  >
  	 */
  
  1365
  >
  	strictEquals?: boolean;
  
  1366
  >
  }
  
  1367
  >
  
  1368
  >
  export interface IEditorResourceAccessorOptions {
  
  1369
  >
  
  1370
  >
  	/**
  
  1371
  >
  	 * Allows to access the `resource(s)` of side by side editors. If not
  
  1372
  >
  	 * specified, a `resource` for a side by side editor will always be
  
  1373
  >
  	 * `undefined`.
  
  1374
  >
  	 */
  
  1375
  >
  	supportSideBySide?: SideBySideEditor;
  
  1376
  >
  
  1377
  >
  	/**
  
  1378
  >
  	 * Allows to filter the scheme to consider. A resource scheme that does
  
  1379
  >
  	 * not match a filter will not be considered.
  
  1380
  >
  	 */
  
  1381
  >
  	filterByScheme?: string | string[];
  
  1382
  >
  }
  
  1383
  >
  
  1384
  >
  class EditorResourceAccessorImpl {
  
  1385
  >
  
  1386
  >
  	/**
  
  1387
  >
  	 * The original URI of an editor is the URI that was used originally to open
  
  1388
  >
  	 * the editor and should be used whenever the URI is presented to the user,
  
  1389
  >
  	 * e.g. as a label together with utility methods such as `ResourceLabel` or
  
  1390
  >
  	 * `ILabelService` that can turn this original URI into the best form for
  
  1391
  >
  	 * presenting.
  
  1392
  >
  	 *
  
  1393
  >
  	 * In contrast, the canonical URI (#getCanonicalUri) may be different and should
  
  1394
  >
  	 * be used whenever the URI is used to e.g. compare with other editors or when
  
  1395
  >
  	 * caching certain data based on the URI.
  
  1396
  >
  	 *
  
  1397
  >
  	 * For example: on Windows and macOS, the same file URI with different casing may
  
  1398
  >
  	 * point to the same file. The editor may chose to "normalize" the URI into a canonical
  
  1399
  >
  	 * form so that only one editor opens for same file URIs with different casing. As
  
  1400
  >
  	 * such, the original URI and the canonical URI can be different.
  
  1401
  >
  	 */
  
  1402
  >
  	getOriginalUri(editor: EditorInput | IUntypedEditorInput | undefined | null): URI | undefined;
  
  1403
  >
  	getOriginalUri(editor: EditorInput | IUntypedEditorInput | undefined | null, options: IEditorResourceAccessorOptions & { supportSideBySide?: SideBySideEditor.PRIMARY | SideBySideEditor.SECONDARY | SideBySideEditor.ANY }): URI | undefined;
  
  1404
  >
  	getOriginalUri(editor: EditorInput | IUntypedEditorInput | undefined | null, options: IEditorResourceAccessorOptions & { supportSideBySide: SideBySideEditor.BOTH }): URI | { primary?: URI; secondary?: URI } | undefined;
  
  1405
  >
  	getOriginalUri(editor: EditorInput | IUntypedEditorInput | undefined | null, options?: IEditorResourceAccessorOptions): URI | { primary?: URI; secondary?: URI } | undefined;
  
  1406
  >
  	getOriginalUri(editor: EditorInput | IUntypedEditorInput | undefined | null, options?: IEditorResourceAccessorOptions): URI | { primary?: URI; secondary?: URI } | undefined {
  
  1407
  
  		if (!editor) {
  
  1408
  
  			return undefined;
  
  1409
  
  		}
  
  1410
  
  1411
  
  		// Merge editors are handled with `merged` result editor
  
  1412
  
  		if (isResourceMergeEditorInput(editor)) {
  
  1413
  
  			return EditorResourceAccessor.getOriginalUri(editor.result, options);
  
  1414
  
  		}
  
  1415
  
  1416
  
  		// Optionally support side-by-side editors
  
  1417
  
  		if (options?.supportSideBySide) {
  
  1418
  
  			const { primary, secondary } = this.getSideEditors(editor);
  
  1419
  
  			if (primary && secondary) {
  
  1420
  
  				if (options?.supportSideBySide === SideBySideEditor.BOTH) {
  
  1421
  
  					return {
  
  1422
  
  						primary: this.getOriginalUri(primary, { filterByScheme: options.filterByScheme }),
  
  1423
  
  						secondary: this.getOriginalUri(secondary, { filterByScheme: options.filterByScheme })
  
  1424
  
  					};
  
  1425
  
  				} else if (options?.supportSideBySide === SideBySideEditor.ANY) {
  
  1426
  
  					return this.getOriginalUri(primary, { filterByScheme: options.filterByScheme }) ?? this.getOriginalUri(secondary, { filterByScheme: options.filterByScheme });
  
  1427
  
  				}
  
  1428
  
  1429
  
  				editor = options.supportSideBySide === SideBySideEditor.PRIMARY ? primary : secondary;
  
  1430
  
  			}
  
  1431
  
  		}
  
  1432
  
  1433
  
  		if (isResourceDiffEditorInput(editor) || isResourceMultiDiffEditorInput(editor) || isResourceSideBySideEditorInput(editor) || isResourceMergeEditorInput(editor)) {
  
  1434
  
  			return undefined;
  
  1435
  
  		}
  
  1436
  
  1437
  
  		// Original URI is the `preferredResource` of an editor if any
  
  1438
  
  		const originalResource = isEditorInputWithPreferredResource(editor) ? editor.preferredResource : editor.resource;
  
  1439
  
  		if (!originalResource || !options?.filterByScheme) {
  
  1440
  
  			return originalResource;
  
  1441
  
  		}
  
  1442
  
  1443
  
  		return this.filterUri(originalResource, options.filterByScheme);
  
  1444
  
  	}
  
  1445
  >
  
editor.ts ×36

  1446
  >
  	private getSideEditors(editor: EditorInput | IUntypedEditorInput): { primary: EditorInput | IUntypedEditorInput | undefined; secondary: EditorInput | IUntypedEditorInput | undefined } {
  
  1447
  
  		if (isSideBySideEditorInput(editor) || isResourceSideBySideEditorInput(editor)) {
  
  1448
  
  			return { primary: editor.primary, secondary: editor.secondary };
  
  1449
  
  		}
  
  1450
  
  1451
  
  		if (isDiffEditorInput(editor) || isResourceDiffEditorInput(editor)) {
  
  1452
  
  			return { primary: editor.modified, secondary: editor.original };
  
  1453
  
  		}
  
  1454
  
  1455
  
  		return { primary: undefined, secondary: undefined };
  
  1456
  
  	}
  
  1457
  >
  
editor.ts ×36

  1458
  >
  	/**
  
  1459
  >
  	 * The canonical URI of an editor is the true unique identifier of the editor
  
  1460
  >
  	 * and should be used whenever the URI is used e.g. to compare with other
  
  1461
  >
  	 * editors or when caching certain data based on the URI.
  
  1462
  >
  	 *
  
  1463
  >
  	 * In contrast, the original URI (#getOriginalUri) may be different and should
  
  1464
  >
  	 * be used whenever the URI is presented to the user, e.g. as a label.
  
  1465
  >
  	 *
  
  1466
  >
  	 * For example: on Windows and macOS, the same file URI with different casing may
  
  1467
  >
  	 * point to the same file. The editor may chose to "normalize" the URI into a canonical
  
  1468
  >
  	 * form so that only one editor opens for same file URIs with different casing. As
  
  1469
  >
  	 * such, the original URI and the canonical URI can be different.
  
  1470
  >
  	 */
  
  1471
  >
  	getCanonicalUri(editor: EditorInput | IUntypedEditorInput | undefined | null): URI | undefined;
  
  1472
  >
  	getCanonicalUri(editor: EditorInput | IUntypedEditorInput | undefined | null, options: IEditorResourceAccessorOptions & { supportSideBySide?: SideBySideEditor.PRIMARY | SideBySideEditor.SECONDARY | SideBySideEditor.ANY }): URI | undefined;
  
  1473
  >
  	getCanonicalUri(editor: EditorInput | IUntypedEditorInput | undefined | null, options: IEditorResourceAccessorOptions & { supportSideBySide: SideBySideEditor.BOTH }): URI | { primary?: URI; secondary?: URI } | undefined;
  
  1474
  >
  	getCanonicalUri(editor: EditorInput | IUntypedEditorInput | undefined | null, options?: IEditorResourceAccessorOptions): URI | { primary?: URI; secondary?: URI } | undefined;
  
  1475
  >
  	getCanonicalUri(editor: EditorInput | IUntypedEditorInput | undefined | null, options?: IEditorResourceAccessorOptions): URI | { primary?: URI; secondary?: URI } | undefined {
  
  1476
  
  		if (!editor) {
  
  1477
  
  			return undefined;
  
  1478
  
  		}
  
  1479
  
  1480
  
  		// Merge editors are handled with `merged` result editor
  
  1481
  
  		if (isResourceMergeEditorInput(editor)) {
  
  1482
  
  			return EditorResourceAccessor.getCanonicalUri(editor.result, options);
  
  1483
  
  		}
  
  1484
  
  1485
  
  		// Optionally support side-by-side editors
  
  1486
  
  		if (options?.supportSideBySide) {
  
  1487
  
  			const { primary, secondary } = this.getSideEditors(editor);
  
  1488
  
  			if (primary && secondary) {
  
  1489
  
  				if (options?.supportSideBySide === SideBySideEditor.BOTH) {
  
  1490
  
  					return {
  
  1491
  
  						primary: this.getCanonicalUri(primary, { filterByScheme: options.filterByScheme }),
  
  1492
  
  						secondary: this.getCanonicalUri(secondary, { filterByScheme: options.filterByScheme })
  
  1493
  
  					};
  
  1494
  
  				} else if (options?.supportSideBySide === SideBySideEditor.ANY) {
  
  1495
  
  					return this.getCanonicalUri(primary, { filterByScheme: options.filterByScheme }) ?? this.getCanonicalUri(secondary, { filterByScheme: options.filterByScheme });
  
  1496
  
  				}
  
  1497
  
  1498
  
  				editor = options.supportSideBySide === SideBySideEditor.PRIMARY ? primary : secondary;
  
  1499
  
  			}
  
  1500
  
  		}
  
  1501
  
  1502
  
  		if (isResourceDiffEditorInput(editor) || isResourceMultiDiffEditorInput(editor) || isResourceSideBySideEditorInput(editor) || isResourceMergeEditorInput(editor)) {
  
  1503
  
  			return undefined;
  
  1504
  
  		}
  
  1505
  
  1506
  
  		// Canonical URI is the `resource` of an editor
  
  1507
  
  		const canonicalResource = editor.resource;
  
  1508
  
  		if (!canonicalResource || !options?.filterByScheme) {
  
  1509
  
  			return canonicalResource;
  
  1510
  
  		}
  
  1511
  
  1512
  
  		return this.filterUri(canonicalResource, options.filterByScheme);
  
  1513
  
  	}
  
  1514
  >
  
editor.ts ×36

  1515
  >
  	private filterUri(resource: URI, filter: string | string[]): URI | undefined {
  
  1516
  
  1517
  
  		// Multiple scheme filter
  
  1518
  
  		if (Array.isArray(filter)) {
  
  1519
  
  			if (filter.some(scheme => resource.scheme === scheme)) {
  
  1520
  
  				return resource;
  
  1521
  
  			}
  
  1522
  
  		}
  
  1523
  
  1524
  
  		// Single scheme filter
  
  1525
  
  		else {
  
  1526
  
  			if (filter === resource.scheme) {
  
  1527
  
  				return resource;
  
  1528
  
  			}
  
  1529
  
  		}
  
  1530
  
  1531
  
  		return undefined;
  
  1532
  
  	}
  
  1533
  >
  }
  
editor.ts ×36

  1534
  >
  
  1535
  >
  export type PreventPinnedEditorClose = 'keyboardAndMouse' | 'keyboard' | 'mouse' | 'never' | undefined;
  
  1536
  >
  
  1537
  >
  export enum EditorCloseMethod {
  
  1538
  >
  	UNKNOWN,
  
  1539
  >
  	KEYBOARD,
  
  1540
  >
  	MOUSE
  
  1541
  >
  }
  
  1542
  >
  
  1543
  >
  export function preventEditorClose(group: IEditorGroup | IReadonlyEditorGroupModel, editor: EditorInput, method: EditorCloseMethod, configuration: IEditorPartConfiguration): boolean {
  
  1544
  
  	if (!group.isSticky(editor)) {
  
  1545
  
  		return false; // only interested in sticky editors
  
  1546
  
  	}
  
  1547
  
  1548
  
  	switch (configuration.preventPinnedEditorClose) {
  
  1549
  
  		case 'keyboardAndMouse': return method === EditorCloseMethod.MOUSE || method === EditorCloseMethod.KEYBOARD;
  
  1550
  
  		case 'mouse': return method === EditorCloseMethod.MOUSE;
  
  1551
  
  		case 'keyboard': return method === EditorCloseMethod.KEYBOARD;
  
  1552
  
  	}
  
  1553
  
  1554
  
  	return false;
  
  1555
  
  }
  
  1556
  >
  
editor.ts ×36

  1557
  >
  export const EditorResourceAccessor = new EditorResourceAccessorImpl();
  
  1558
  >
  
  1559
  >
  export const enum CloseDirection {
  
  1560
  >
  	LEFT,
  
  1561
  >
  	RIGHT
  
  1562
  >
  }
  
  1563
  >
  
  1564
  >
  export interface IEditorMemento<T> {
  
  1565
  >
  
  1566
  >
  	saveEditorState(group: IEditorGroup, resource: URI, state: T): void;
  
  1567
  >
  	saveEditorState(group: IEditorGroup, editor: EditorInput, state: T): void;
  
  1568
  >
  
  1569
  >
  	loadEditorState(group: IEditorGroup, resource: URI): T | undefined;
  
  1570
  >
  	loadEditorState(group: IEditorGroup, editor: EditorInput): T | undefined;
  
  1571
  >
  
  1572
  >
  	clearEditorState(resource: URI, group?: IEditorGroup): void;
  
  1573
  >
  	clearEditorState(editor: EditorInput, group?: IEditorGroup): void;
  
  1574
  >
  
  1575
  >
  	clearEditorStateOnDispose(resource: URI, editor: EditorInput): void;
  
  1576
  >
  
  1577
  >
  	moveEditorState(source: URI, target: URI, comparer: IExtUri): void;
  
  1578
  >
  }
  
  1579
  >
  
  1580
  >
  class EditorFactoryRegistry implements IEditorFactoryRegistry {
  
  1581
  >
  	private instantiationService: IInstantiationService | undefined;
  
  1582
  >
  
  1583
  >
  	private fileEditorFactory: IFileEditorFactory | undefined;
  
  1584
  >
  
  1585
  >
  	private readonly editorSerializerConstructors = new Map<string /* Type ID */, IConstructorSignature<IEditorSerializer>>();
  
  1586
  >
  	private readonly editorSerializerInstances = new Map<string /* Type ID */, IEditorSerializer>();
  
  1587
  >
  
  1588
  >
  	start(accessor: ServicesAccessor): void {
  
  1589
  
  		const instantiationService = this.instantiationService = accessor.get(IInstantiationService);
  
  1590
  
  1591
  
  		for (const [key, ctor] of this.editorSerializerConstructors) {
  
  1592
  
  			this.createEditorSerializer(key, ctor, instantiationService);
  
  1593
  
  		}
  
  1594
  
  1595
  
  		this.editorSerializerConstructors.clear();
  
  1596
  
  	}
  
  1597
  >
  
editor.ts ×36

  1598
  >
  	private createEditorSerializer(editorTypeId: string, ctor: IConstructorSignature<IEditorSerializer>, instantiationService: IInstantiationService): void {
  
  1599
  
  		const instance = instantiationService.createInstance(ctor);
  
  1600
  
  		this.editorSerializerInstances.set(editorTypeId, instance);
  
  1601
  
  	}
  
  1602
  >
  
editor.ts ×36

  1603
  >
  	registerFileEditorFactory(factory: IFileEditorFactory): void {
  
  1604
  
  		if (this.fileEditorFactory) {
  
  1605
  
  			throw new Error('Can only register one file editor factory.');
  
  1606
  
  		}
  
  1607
  
  1608
  
  		this.fileEditorFactory = factory;
  
  1609
  
  	}
  
  1610
  >
  
editor.ts ×36

  1611
  >
  	getFileEditorFactory(): IFileEditorFactory {
  
  1612
  
  		return assertReturnsDefined(this.fileEditorFactory);
  
  1613
  
  	}
  
  1614
  >
  
editor.ts ×36

  1615
  >
  	registerEditorSerializer(editorTypeId: string, ctor: IConstructorSignature<IEditorSerializer>): IDisposable {
  
  1616
  
  		if (this.editorSerializerConstructors.has(editorTypeId) || this.editorSerializerInstances.has(editorTypeId)) {
  
  1617
  
  			throw new Error(`A editor serializer with type ID '${editorTypeId}' was already registered.`);
  
  1618
  
  		}
  
  1619
  
  1620
  
  		if (!this.instantiationService) {
  
  1621
  
  			this.editorSerializerConstructors.set(editorTypeId, ctor);
  
  1622
  
  		} else {
  
  1623
  
  			this.createEditorSerializer(editorTypeId, ctor, this.instantiationService);
  
  1624
  
  		}
  
  1625
  
  1626
  
  		return toDisposable(() => {
  
  1627
  
  			this.editorSerializerConstructors.delete(editorTypeId);
  
  1628
  
  			this.editorSerializerInstances.delete(editorTypeId);
  
  1629
  
  		});
  
  1630
  
  	}
  
  1631
  >
  
editor.ts ×36

  1632
  >
  	getEditorSerializer(editor: EditorInput): IEditorSerializer | undefined;
  
  1633
  >
  	getEditorSerializer(editorTypeId: string): IEditorSerializer | undefined;
  
  1634
  >
  	getEditorSerializer(arg1: string | EditorInput): IEditorSerializer | undefined {
  
  1635
  
  		return this.editorSerializerInstances.get(typeof arg1 === 'string' ? arg1 : arg1.typeId);
  
  1636
  
  	}
  
  1637
  >
  }
  
editor.ts ×36

  1638
  >
  
  1639
  >
  Registry.add(EditorExtensions.EditorFactory, new EditorFactoryRegistry());
  
  1640
  >
  
  1641
  
  export async function pathsToEditors(paths: IPathData[] | undefined, fileService: IFileService, logService: ILogService): Promise<ReadonlyArray<IResourceEditorInput | IUntitledTextResourceEditorInput | undefined>> {
  
  1642
  
  	if (!paths?.length) {
  
  1643
  
  		return [];
  
  1644
  
  	}
  
  1645
  
  1646
  
  	return await Promise.all(paths.map(async path => {
  
  1647
  
  		const resource = URI.revive(path.fileUri);
  
  1648
  
  		if (!resource) {
  
  1649
  
  			logService.info('Cannot resolve the path because it is not valid.', path);
  
  1650
  
  			return undefined;
  
  1651
  
  		}
  
  1652
  
  1653
  
  		const canHandleResource = await fileService.canHandleResource(resource);
  
  1654
  
  		if (!canHandleResource) {
  
  1655
  
  			logService.info('Cannot resolve the path because it cannot be handled', path);
  
  1656
  
  			return undefined;
  
  1657
  
  		}
  
  1658
  
  1659
  
  		let exists = path.exists;
  
  1660
  
  		let type = path.type;
  
  1661
  
  		if (typeof exists !== 'boolean' || typeof type !== 'number') {
  
  1662
  
  			try {
  
  1663
  
  				type = (await fileService.stat(resource)).isDirectory ? FileType.Directory : FileType.Unknown;
  
  1664
  
  				exists = true;
  
  1665
  
  			} catch (error) {
  
  1666
  
  				logService.error(error);
  
  1667
  
  				exists = false;
  
  1668
  
  			}
  
  1669
  
  		}
  
  1670
  
  1671
  
  		if (!exists && path.openOnlyIfExists) {
  
  1672
  
  			logService.info('Cannot resolve the path because it does not exist', path);
  
  1673
  
  			return undefined;
  
  1674
  
  		}
  
  1675
  
  1676
  
  		if (type === FileType.Directory) {
  
  1677
  
  			logService.info('Cannot resolve the path because it is a directory', path);
  
  1678
  
  			return undefined;
  
  1679
  
  		}
  
  1680
  
  1681
  
  		const options: IEditorOptions = {
  
  1682
  
  			...path.options,
  
  1683
  
  			pinned: true
  
  1684
  
  		};
  
  1685
  
  1686
  
  		if (!exists) {
  
  1687
  
  			return { resource, options, forceUntitled: true };
  
  1688
  
  		}
  
  1689
  
  1690
  
  		return { resource, options };
  
  1691
  
  	}));
  
  1692
  
  }
  
  1693
  >
  
editor.ts ×36

  1694
  >
  export const enum EditorsOrder {
  
  1695
  >
  
  1696
  >
  	/**
  
  1697
  >
  	 * Editors sorted by most recent activity (most recent active first)
  
  1698
  >
  	 */
  
  1699
  >
  	MOST_RECENTLY_ACTIVE,
  
  1700
  >
  
  1701
  >
  	/**
  
  1702
  >
  	 * Editors sorted by sequential order
  
  1703
  >
  	 */
  
  1704
  >
  	SEQUENTIAL
  
  1705
  >
  }
  
  1706
  >
  
  1707
  >
  export function isTextEditorViewState(candidate: unknown): candidate is IEditorViewState {
  
  1708
  
  	const viewState = candidate as IEditorViewState | undefined;
  
  1709
  
  	if (!viewState) {
  
  1710
  
  		return false;
  
  1711
  
  	}
  
  1712
  
  1713
  
  	const diffEditorViewState = viewState as IDiffEditorViewState;
  
  1714
  
  	if (diffEditorViewState.modified) {
  
  1715
  
  		return isTextEditorViewState(diffEditorViewState.modified);
  
  1716
  
  	}
  
  1717
  
  1718
  
  	const codeEditorViewState = viewState as ICodeEditorViewState;
  
  1719
  
  1720
  
  	return !!(codeEditorViewState.contributionsState && codeEditorViewState.viewState && Array.isArray(codeEditorViewState.cursorState));
  
  1721
  
  }
  
  1722
  >
  
editor.ts ×36

  1723
  >
  export interface IEditorOpenErrorOptions {
  
  1724
  >
  
  1725
  >
  	/**
  
  1726
  >
  	 * If set to true, the message will be taken
  
  1727
  >
  	 * from the error message entirely and not be
  
  1728
  >
  	 * composed with more text.
  
  1729
  >
  	 */
  
  1730
  >
  	forceMessage?: boolean;
  
  1731
  >
  
  1732
  >
  	/**
  
  1733
  >
  	 * If set, will override the severity of the error.
  
  1734
  >
  	 */
  
  1735
  >
  	forceSeverity?: Severity;
  
  1736
  >
  
  1737
  >
  	/**
  
  1738
  >
  	 * If set to true, the error may be shown in a dialog
  
  1739
  >
  	 * to the user if the editor opening was triggered by
  
  1740
  >
  	 * user action. Otherwise and by default, the error will
  
  1741
  >
  	 * be shown as place holder in the editor area.
  
  1742
  >
  	 */
  
  1743
  >
  	allowDialog?: boolean;
  
  1744
  >
  }
  
  1745
  >
  
  1746
  >
  export interface IEditorOpenError extends IErrorWithActions, IEditorOpenErrorOptions { }
  
  1747
  >
  
  1748
  >
  export function isEditorOpenError(obj: unknown): obj is IEditorOpenError {
  
  1749
  
  	return isErrorWithActions(obj);
  
  1750
  
  }
  
  1751
  >
  
editor.ts ×36

  1752
  >
  export function createEditorOpenError(messageOrError: string | Error, actions: IAction[], options?: IEditorOpenErrorOptions): IEditorOpenError {
  
  1753
  
  	const error: IEditorOpenError = createErrorWithActions(messageOrError, actions);
  
  1754
  
  1755
  
  	error.forceMessage = options?.forceMessage;
  
  1756
  
  	error.forceSeverity = options?.forceSeverity;
  
  1757
  
  	error.allowDialog = options?.allowDialog;
  
  1758
  
  1759
  
  	return error;
  
  1760
  
  }
  
  1761
  >
  
editor.ts ×36

  1762
  >
  export interface IToolbarActions {
  
  1763
  >
  	readonly primary: IAction[];
  
  1764
  >
  	readonly secondary: IAction[];
  
  1765
  >
  }