@sussudio/platform/list/browser/listService.d.mts

Internal APIs for VS Code's service injection the base services.

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import { IListRenderer, IListVirtualDelegate } from '@sussudio/base/browser/ui/list/list.mjs';
import { IPagedListOptions, IPagedRenderer, PagedList } from '@sussudio/base/browser/ui/list/listPaging.mjs';
import {
	IListAccessibilityProvider,
	IListOptions,
	IListOptionsUpdate,
	List,
} from '@sussudio/base/browser/ui/list/listWidget.mjs';
import { ITableColumn, ITableRenderer, ITableVirtualDelegate } from '@sussudio/base/browser/ui/table/table.mjs';
import { ITableOptions, ITableOptionsUpdate, Table } from '@sussudio/base/browser/ui/table/tableWidget.mjs';
import { IAbstractTreeOptionsUpdate } from '@sussudio/base/browser/ui/tree/abstractTree.mjs';
import {
	AsyncDataTree,
	CompressibleAsyncDataTree,
	IAsyncDataTreeOptions,
	IAsyncDataTreeOptionsUpdate,
	ICompressibleAsyncDataTreeOptions,
	ICompressibleAsyncDataTreeOptionsUpdate,
	ITreeCompressionDelegate,
} from '@sussudio/base/browser/ui/tree/asyncDataTree.mjs';
import { DataTree, IDataTreeOptions } from '@sussudio/base/browser/ui/tree/dataTree.mjs';
import {
	CompressibleObjectTree,
	ICompressibleObjectTreeOptions,
	ICompressibleObjectTreeOptionsUpdate,
	ICompressibleTreeRenderer,
	IObjectTreeOptions,
	ObjectTree,
} from '@sussudio/base/browser/ui/tree/objectTree.mjs';
import { IAsyncDataSource, IDataSource, ITreeRenderer } from '@sussudio/base/browser/ui/tree/tree.mjs';
import { Event } from '@sussudio/base/common/event.mjs';
import { IDisposable } from '@sussudio/base/common/lifecycle.mjs';
import { IConfigurationService } from '../../configuration/common/configuration.mjs';
import { IContextKey, IContextKeyService, RawContextKey } from '../../contextkey/common/contextkey.mjs';
import { IEditorOptions } from '../../editor/common/editor.mjs';
import { IInstantiationService } from '../../instantiation/common/instantiation.mjs';
import { IColorMapping } from '../../theme/common/styler.mjs';
import { IThemeService } from '../../theme/common/themeService.mjs';
export type ListWidget =
	| List<any>
	| PagedList<any>
	| ObjectTree<any, any>
	| DataTree<any, any, any>
	| AsyncDataTree<any, any, any>
	| Table<any>;
export type WorkbenchListWidget =
	| WorkbenchList<any>
	| WorkbenchPagedList<any>
	| WorkbenchObjectTree<any, any>
	| WorkbenchCompressibleObjectTree<any, any>
	| WorkbenchDataTree<any, any, any>
	| WorkbenchAsyncDataTree<any, any, any>
	| WorkbenchCompressibleAsyncDataTree<any, any, any>
	| WorkbenchTable<any>;
export declare const IListService: import('../../instantiation/common/instantiation.mjs').ServiceIdentifier<IListService>;
export interface IListService {
	readonly _serviceBrand: undefined;
	/**
	 * Returns the currently focused list widget if any.
	 */
	readonly lastFocusedList: WorkbenchListWidget | undefined;
}
export declare class ListService implements IListService {
	private readonly _themeService;
	readonly _serviceBrand: undefined;
	private disposables;
	private lists;
	private _lastFocusedWidget;
	private _hasCreatedStyleController;
	get lastFocusedList(): WorkbenchListWidget | undefined;
	constructor(_themeService: IThemeService);
	private setLastFocusedList;
	register(widget: WorkbenchListWidget, extraContextKeys?: IContextKey<boolean>[]): IDisposable;
	dispose(): void;
}
export declare const RawWorkbenchListFocusContextKey: RawContextKey<boolean>;
export declare const WorkbenchListSupportsMultiSelectContextKey: RawContextKey<boolean>;
export declare const WorkbenchListFocusContextKey:
	| import('../../contextkey/common/contextkey.mjs').ContextKeyExpression
	| undefined;
export declare const WorkbenchListHasSelectionOrFocus: RawContextKey<boolean>;
export declare const WorkbenchListDoubleSelection: RawContextKey<boolean>;
export declare const WorkbenchListMultiSelection: RawContextKey<boolean>;
export declare const WorkbenchListSelectionNavigation: RawContextKey<boolean>;
export declare const WorkbenchListSupportsFind: RawContextKey<boolean>;
export declare const WorkbenchTreeElementCanCollapse: RawContextKey<boolean>;
export declare const WorkbenchTreeElementHasParent: RawContextKey<boolean>;
export declare const WorkbenchTreeElementCanExpand: RawContextKey<boolean>;
export declare const WorkbenchTreeElementHasChild: RawContextKey<boolean>;
export declare const WorkbenchTreeFindOpen: RawContextKey<boolean>;
export interface IWorkbenchListOptionsUpdate extends IListOptionsUpdate {
	readonly overrideStyles?: IColorMapping;
}
export interface IWorkbenchListOptions<T>
	extends IWorkbenchListOptionsUpdate,
		IResourceNavigatorOptions,
		IListOptions<T> {
	readonly selectionNavigation?: boolean;
}
export declare class WorkbenchList<T> extends List<T> {
	readonly contextKeyService: IContextKeyService;
	private readonly themeService;
	private listSupportsMultiSelect;
	private listHasSelectionOrFocus;
	private listDoubleSelection;
	private listMultiSelection;
	private horizontalScrolling;
	private _styler;
	private _useAltAsMultipleSelectionModifier;
	private navigator;
	get onDidOpen(): Event<IOpenEvent<T | undefined>>;
	constructor(
		user: string,
		container: HTMLElement,
		delegate: IListVirtualDelegate<T>,
		renderers: IListRenderer<T, any>[],
		options: IWorkbenchListOptions<T>,
		contextKeyService: IContextKeyService,
		listService: IListService,
		themeService: IThemeService,
		configurationService: IConfigurationService,
		instantiationService: IInstantiationService,
	);
	updateOptions(options: IWorkbenchListOptionsUpdate): void;
	private updateStyles;
	get useAltAsMultipleSelectionModifier(): boolean;
	dispose(): void;
}
export interface IWorkbenchPagedListOptions<T>
	extends IWorkbenchListOptionsUpdate,
		IResourceNavigatorOptions,
		IPagedListOptions<T> {
	readonly selectionNavigation?: boolean;
}
export declare class WorkbenchPagedList<T> extends PagedList<T> {
	readonly contextKeyService: IContextKeyService;
	private readonly themeService;
	private readonly disposables;
	private listSupportsMultiSelect;
	private _useAltAsMultipleSelectionModifier;
	private horizontalScrolling;
	private _styler;
	private navigator;
	get onDidOpen(): Event<IOpenEvent<T | undefined>>;
	constructor(
		user: string,
		container: HTMLElement,
		delegate: IListVirtualDelegate<number>,
		renderers: IPagedRenderer<T, any>[],
		options: IWorkbenchPagedListOptions<T>,
		contextKeyService: IContextKeyService,
		listService: IListService,
		themeService: IThemeService,
		configurationService: IConfigurationService,
		instantiationService: IInstantiationService,
	);
	updateOptions(options: IWorkbenchListOptionsUpdate): void;
	private updateStyles;
	get useAltAsMultipleSelectionModifier(): boolean;
	dispose(): void;
}
export interface IWorkbenchTableOptionsUpdate extends ITableOptionsUpdate {
	readonly overrideStyles?: IColorMapping;
}
export interface IWorkbenchTableOptions<T>
	extends IWorkbenchTableOptionsUpdate,
		IResourceNavigatorOptions,
		ITableOptions<T> {
	readonly selectionNavigation?: boolean;
}
export declare class WorkbenchTable<TRow> extends Table<TRow> {
	readonly contextKeyService: IContextKeyService;
	private readonly themeService;
	private listSupportsMultiSelect;
	private listHasSelectionOrFocus;
	private listDoubleSelection;
	private listMultiSelection;
	private horizontalScrolling;
	private _styler;
	private _useAltAsMultipleSelectionModifier;
	private navigator;
	get onDidOpen(): Event<IOpenEvent<TRow | undefined>>;
	constructor(
		user: string,
		container: HTMLElement,
		delegate: ITableVirtualDelegate<TRow>,
		columns: ITableColumn<TRow, any>[],
		renderers: ITableRenderer<TRow, any>[],
		options: IWorkbenchTableOptions<TRow>,
		contextKeyService: IContextKeyService,
		listService: IListService,
		themeService: IThemeService,
		configurationService: IConfigurationService,
		instantiationService: IInstantiationService,
	);
	updateOptions(options: IWorkbenchTableOptionsUpdate): void;
	private updateStyles;
	get useAltAsMultipleSelectionModifier(): boolean;
	dispose(): void;
}
export interface IOpenResourceOptions {
	editorOptions: IEditorOptions;
	sideBySide: boolean;
	element: any;
	payload: any;
}
export interface IOpenEvent<T> {
	editorOptions: IEditorOptions;
	sideBySide: boolean;
	element: T;
	browserEvent?: UIEvent;
}
export interface IResourceNavigatorOptions {
	readonly configurationService?: IConfigurationService;
	readonly openOnSingleClick?: boolean;
}
export interface SelectionKeyboardEvent extends KeyboardEvent {
	preserveFocus?: boolean;
	pinned?: boolean;
	__forceEvent?: boolean;
}
export declare function getSelectionKeyboardEvent(
	typeArg?: string,
	preserveFocus?: boolean,
	pinned?: boolean,
): SelectionKeyboardEvent;
export interface IWorkbenchObjectTreeOptions<T, TFilterData>
	extends IObjectTreeOptions<T, TFilterData>,
		IResourceNavigatorOptions {
	readonly accessibilityProvider: IListAccessibilityProvider<T>;
	readonly overrideStyles?: IColorMapping;
	readonly selectionNavigation?: boolean;
}
export declare class WorkbenchObjectTree<T extends NonNullable<any>, TFilterData = void> extends ObjectTree<
	T,
	TFilterData
> {
	private internals;
	get contextKeyService(): IContextKeyService;
	get useAltAsMultipleSelectionModifier(): boolean;
	get onDidOpen(): Event<IOpenEvent<T | undefined>>;
	constructor(
		user: string,
		container: HTMLElement,
		delegate: IListVirtualDelegate<T>,
		renderers: ITreeRenderer<T, TFilterData, any>[],
		options: IWorkbenchObjectTreeOptions<T, TFilterData>,
		instantiationService: IInstantiationService,
		contextKeyService: IContextKeyService,
		listService: IListService,
		themeService: IThemeService,
		configurationService: IConfigurationService,
	);
	updateOptions(options: IAbstractTreeOptionsUpdate): void;
}
export interface IWorkbenchCompressibleObjectTreeOptionsUpdate extends ICompressibleObjectTreeOptionsUpdate {
	readonly overrideStyles?: IColorMapping;
}
export interface IWorkbenchCompressibleObjectTreeOptions<T, TFilterData>
	extends IWorkbenchCompressibleObjectTreeOptionsUpdate,
		ICompressibleObjectTreeOptions<T, TFilterData>,
		IResourceNavigatorOptions {
	readonly accessibilityProvider: IListAccessibilityProvider<T>;
	readonly selectionNavigation?: boolean;
}
export declare class WorkbenchCompressibleObjectTree<
	T extends NonNullable<any>,
	TFilterData = void,
> extends CompressibleObjectTree<T, TFilterData> {
	private internals;
	get contextKeyService(): IContextKeyService;
	get useAltAsMultipleSelectionModifier(): boolean;
	get onDidOpen(): Event<IOpenEvent<T | undefined>>;
	constructor(
		user: string,
		container: HTMLElement,
		delegate: IListVirtualDelegate<T>,
		renderers: ICompressibleTreeRenderer<T, TFilterData, any>[],
		options: IWorkbenchCompressibleObjectTreeOptions<T, TFilterData>,
		instantiationService: IInstantiationService,
		contextKeyService: IContextKeyService,
		listService: IListService,
		themeService: IThemeService,
		configurationService: IConfigurationService,
	);
	updateOptions(options?: IWorkbenchCompressibleObjectTreeOptionsUpdate): void;
}
export interface IWorkbenchDataTreeOptionsUpdate extends IAbstractTreeOptionsUpdate {
	readonly overrideStyles?: IColorMapping;
}
export interface IWorkbenchDataTreeOptions<T, TFilterData>
	extends IWorkbenchDataTreeOptionsUpdate,
		IDataTreeOptions<T, TFilterData>,
		IResourceNavigatorOptions {
	readonly accessibilityProvider: IListAccessibilityProvider<T>;
	readonly selectionNavigation?: boolean;
}
export declare class WorkbenchDataTree<TInput, T, TFilterData = void> extends DataTree<TInput, T, TFilterData> {
	private internals;
	get contextKeyService(): IContextKeyService;
	get useAltAsMultipleSelectionModifier(): boolean;
	get onDidOpen(): Event<IOpenEvent<T | undefined>>;
	constructor(
		user: string,
		container: HTMLElement,
		delegate: IListVirtualDelegate<T>,
		renderers: ITreeRenderer<T, TFilterData, any>[],
		dataSource: IDataSource<TInput, T>,
		options: IWorkbenchDataTreeOptions<T, TFilterData>,
		instantiationService: IInstantiationService,
		contextKeyService: IContextKeyService,
		listService: IListService,
		themeService: IThemeService,
		configurationService: IConfigurationService,
	);
	updateOptions(options?: IWorkbenchDataTreeOptionsUpdate): void;
}
export interface IWorkbenchAsyncDataTreeOptionsUpdate extends IAsyncDataTreeOptionsUpdate {
	readonly overrideStyles?: IColorMapping;
}
export interface IWorkbenchAsyncDataTreeOptions<T, TFilterData>
	extends IWorkbenchAsyncDataTreeOptionsUpdate,
		IAsyncDataTreeOptions<T, TFilterData>,
		IResourceNavigatorOptions {
	readonly accessibilityProvider: IListAccessibilityProvider<T>;
	readonly selectionNavigation?: boolean;
}
export declare class WorkbenchAsyncDataTree<TInput, T, TFilterData = void> extends AsyncDataTree<
	TInput,
	T,
	TFilterData
> {
	private internals;
	get contextKeyService(): IContextKeyService;
	get useAltAsMultipleSelectionModifier(): boolean;
	get onDidOpen(): Event<IOpenEvent<T | undefined>>;
	constructor(
		user: string,
		container: HTMLElement,
		delegate: IListVirtualDelegate<T>,
		renderers: ITreeRenderer<T, TFilterData, any>[],
		dataSource: IAsyncDataSource<TInput, T>,
		options: IWorkbenchAsyncDataTreeOptions<T, TFilterData>,
		instantiationService: IInstantiationService,
		contextKeyService: IContextKeyService,
		listService: IListService,
		themeService: IThemeService,
		configurationService: IConfigurationService,
	);
	updateOptions(options?: IWorkbenchAsyncDataTreeOptionsUpdate): void;
}
export interface IWorkbenchCompressibleAsyncDataTreeOptions<T, TFilterData>
	extends ICompressibleAsyncDataTreeOptions<T, TFilterData>,
		IResourceNavigatorOptions {
	readonly accessibilityProvider: IListAccessibilityProvider<T>;
	readonly overrideStyles?: IColorMapping;
	readonly selectionNavigation?: boolean;
}
export declare class WorkbenchCompressibleAsyncDataTree<
	TInput,
	T,
	TFilterData = void,
> extends CompressibleAsyncDataTree<TInput, T, TFilterData> {
	private internals;
	get contextKeyService(): IContextKeyService;
	get useAltAsMultipleSelectionModifier(): boolean;
	get onDidOpen(): Event<IOpenEvent<T | undefined>>;
	constructor(
		user: string,
		container: HTMLElement,
		virtualDelegate: IListVirtualDelegate<T>,
		compressionDelegate: ITreeCompressionDelegate<T>,
		renderers: ICompressibleTreeRenderer<T, TFilterData, any>[],
		dataSource: IAsyncDataSource<TInput, T>,
		options: IWorkbenchCompressibleAsyncDataTreeOptions<T, TFilterData>,
		instantiationService: IInstantiationService,
		contextKeyService: IContextKeyService,
		listService: IListService,
		themeService: IThemeService,
		configurationService: IConfigurationService,
	);
	updateOptions(options: ICompressibleAsyncDataTreeOptionsUpdate): void;
}