1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
|
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { Emitter, Event } from 'vs/base/common/event';
import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
import * as nls from 'vs/nls';
export interface ITelemetryData {
readonly from?: string;
readonly target?: string;
[key: string]: unknown;
}
export type WorkbenchActionExecutedClassification = {
owner: 'bpasero';
id: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The identifier of the action that was run.' };
from: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The name of the component the action was run from.' };
};
export type WorkbenchActionExecutedEvent = {
id: string;
from: string;
};
export interface IAction extends IDisposable {
readonly id: string;
label: string;
tooltip: string;
class: string | undefined;
enabled: boolean;
checked?: boolean;
run(event?: unknown): unknown;
}
export interface IActionRunner extends IDisposable {
readonly onDidRun: Event<IRunEvent>;
readonly onBeforeRun: Event<IRunEvent>;
run(action: IAction, context?: unknown): unknown;
}
export interface IActionChangeEvent {
readonly label?: string;
readonly tooltip?: string;
readonly class?: string;
readonly enabled?: boolean;
readonly checked?: boolean;
}
export class Action extends Disposable implements IAction {
protected _onDidChange = this._register(new Emitter<IActionChangeEvent>());
readonly onDidChange = this._onDidChange.event;
protected readonly _id: string;
protected _label: string;
protected _tooltip: string | undefined;
protected _cssClass: string | undefined;
protected _enabled: boolean = true;
protected _checked?: boolean;
protected readonly _actionCallback?: (event?: unknown) => unknown;
constructor(id: string, label: string = '', cssClass: string = '', enabled: boolean = true, actionCallback?: (event?: unknown) => unknown) {
super();
this._id = id;
this._label = label;
this._cssClass = cssClass;
this._enabled = enabled;
this._actionCallback = actionCallback;
}
get id(): string {
return this._id;
}
get label(): string {
return this._label;
}
set label(value: string) {
this._setLabel(value);
}
private _setLabel(value: string): void {
if (this._label !== value) {
this._label = value;
this._onDidChange.fire({ label: value });
}
}
get tooltip(): string {
return this._tooltip || '';
}
set tooltip(value: string) {
this._setTooltip(value);
}
protected _setTooltip(value: string): void {
if (this._tooltip !== value) {
this._tooltip = value;
this._onDidChange.fire({ tooltip: value });
}
}
get class(): string | undefined {
return this._cssClass;
}
set class(value: string | undefined) {
this._setClass(value);
}
protected _setClass(value: string | undefined): void {
if (this._cssClass !== value) {
this._cssClass = value;
this._onDidChange.fire({ class: value });
}
}
get enabled(): boolean {
return this._enabled;
}
set enabled(value: boolean) {
this._setEnabled(value);
}
protected _setEnabled(value: boolean): void {
if (this._enabled !== value) {
this._enabled = value;
this._onDidChange.fire({ enabled: value });
}
}
get checked(): boolean | undefined {
return this._checked;
}
set checked(value: boolean | undefined) {
this._setChecked(value);
}
protected _setChecked(value: boolean | undefined): void {
if (this._checked !== value) {
this._checked = value;
this._onDidChange.fire({ checked: value });
}
}
async run(event?: unknown, data?: ITelemetryData): Promise<void> {
if (this._actionCallback) {
await this._actionCallback(event);
}
}
}
export interface IRunEvent {
readonly action: IAction;
readonly error?: Error;
}
export class ActionRunner extends Disposable implements IActionRunner {
private _onBeforeRun = this._register(new Emitter<IRunEvent>());
readonly onBeforeRun = this._onBeforeRun.event;
private _onDidRun = this._register(new Emitter<IRunEvent>());
readonly onDidRun = this._onDidRun.event;
async run(action: IAction, context?: unknown): Promise<void> {
if (!action.enabled) {
return;
}
this._onBeforeRun.fire({ action });
let error: Error | undefined = undefined;
try {
await this.runAction(action, context);
} catch (e) {
error = e;
}
this._onDidRun.fire({ action, error });
}
protected async runAction(action: IAction, context?: unknown): Promise<void> {
await action.run(context);
}
}
export class Separator extends Action {
/**
* Joins all non-empty lists of actions with separators.
*/
public static join(...actionLists: readonly IAction[][]) {
let out: IAction[] = [];
for (const list of actionLists) {
if (!list.length) {
// skip
} else if (out.length) {
out = [...out, new Separator(), ...list];
} else {
out = list;
}
}
return out;
}
static readonly ID = 'vs.actions.separator';
constructor(label?: string) {
super(Separator.ID, label, label ? 'separator text' : 'separator');
this.checked = false;
this.enabled = false;
}
}
export class SubmenuAction implements IAction {
readonly id: string;
readonly label: string;
readonly class: string | undefined;
readonly tooltip: string = '';
readonly enabled: boolean = true;
readonly checked: undefined = undefined;
private readonly _actions: readonly IAction[];
get actions(): readonly IAction[] { return this._actions; }
constructor(id: string, label: string, actions: readonly IAction[], cssClass?: string) {
this.id = id;
this.label = label;
this.class = cssClass;
this._actions = actions;
}
dispose(): void {
// there is NOTHING to dispose and the SubmenuAction should
// never have anything to dispose as it is a convenience type
// to bridge into the rendering world.
}
async run(): Promise<void> { }
}
export class EmptySubmenuAction extends Action {
static readonly ID = 'vs.actions.empty';
constructor() {
super(EmptySubmenuAction.ID, nls.localize('submenu.empty', '(empty)'), undefined, false);
}
}
export function toAction(props: { id: string; label: string; enabled?: boolean; checked?: boolean; run: Function }): IAction {
return {
id: props.id,
label: props.label,
class: undefined,
enabled: props.enabled ?? true,
checked: props.checked ?? false,
run: async () => props.run(),
tooltip: props.label,
dispose: () => { }
};
}
|