askQuestionsTool.test|title=AskQuestionsTool - prepareToolInvocation validation allows single option with freeform input|occurrence=1

src/vs/workbench/contrib/chat/common/chatService/chatService.ts 1847 covered LOC · 27 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- chatService.ts

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 { IAction } from '../../../../../base/common/actions.js';

7 > import { DeferredPromise } from '../../../../../base/common/async.js';

8 > import { CancellationToken } from '../../../../../base/common/cancellation.js';

9 > import { IStringDictionary } from '../../../../../base/common/collections.js';

10 > import { Event } from '../../../../../base/common/event.js';

11 > import { IMarkdownString } from '../../../../../base/common/htmlContent.js';

12 > import { DisposableStore, IReference } from '../../../../../base/common/lifecycle.js';

13 > import { autorun, autorunSelfDisposable, IObservable, IReader } from '../../../../../base/common/observable.js';

14 > import { ThemeIcon } from '../../../../../base/common/themables.js';

15 > import { hasKey } from '../../../../../base/common/types.js';

16 > import { URI, UriComponents } from '../../../../../base/common/uri.js';

17 > import { IRange, Range } from '../../../../../editor/common/core/range.js';

18 > import { ISelection } from '../../../../../editor/common/core/selection.js';

19 > import { Command, Location, TextEdit } from '../../../../../editor/common/languages.js';

20 > import { FileType } from '../../../../../platform/files/common/files.js';

21 > import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';

22 > import { IAutostartResult } from '../../../mcp/common/mcpTypes.js';

23 > import { ICellEditOperation } from '../../../notebook/common/notebookCommon.js';

24 > import { IWorkspaceSymbol } from '../../../search/common/search.js';

25 > import { IChatRequestVariableEntry } from '../attachments/chatVariableEntries.js';

26 > import { IChatRequestVariableValue } from '../attachments/chatVariables.js';

27 > import { ReadonlyChatSessionOptionsMap } from '../chatSessionsService.js';

28 > import { ChatAgentLocation, ChatModeKind } from '../constants.js';

29 > import { IChatEditingSession } from '../editing/chatEditingService.js';

30 > import { IChatModel, IChatRequestModeInfo, IChatRequestModel, IChatRequestVariableData, IChatResponseModel, IExportableChatData, ISerializableChatData } from '../model/chatModel.js';

31 > import type { IChatModelReferenceDebugSnapshot } from '../model/chatModelStore.js';

32 > import { IChatAgentCommand, IChatAgentData, IChatAgentResult, UserSelectedTools } from '../participants/chatAgents.js';

33 > import { HookTypeValue } from '../promptSyntax/hookTypes.js';

34 > import { IParsedChatRequest } from '../requestParser/chatParserTypes.js';

35 > import { IChatParserContext } from '../requestParser/chatRequestParser.js';

36 > import { IPreparedToolInvocation, IToolConfirmationMessages, IToolResult, IToolResultInputOutputDetails, ToolDataSource } from '../tools/languageModelToolsService.js';

37 > import { ConfirmationOptionKind, type McpOAuthClient } from '../../../../../platform/agentHost/common/state/protocol/state.js';

38 >

39 > export interface IChatRequest {

40 > message: string;

41 > variables: Record<string, IChatRequestVariableValue[]>;

42 > }

43 >

44 > export enum ChatErrorLevel {

45 > Info = 0,

46 > Warning = 1,

47 > Error = 2

48 > }

49 >

50 > export interface IChatResponseErrorDetailsConfirmationButton {

51 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

52 > data: any;

53 > label: string;

54 > isSecondary?: boolean;

55 > }

56 >

57 > export interface IChatResponseErrorDetails {

58 > message: string;

59 > responseIsIncomplete?: boolean;

60 > responseIsFiltered?: boolean;

61 > responseIsRedacted?: boolean;

62 > isQuotaExceeded?: boolean;

63 > isRateLimited?: boolean;

64 > /**

65 > * If true, the error is an expected operational condition (e.g. user-actionable

66 > * configuration, network connectivity, missing dependency) and should not be

67 > * logged as a `chatAgentError` telemetry event.

68 > */

69 > isExpectedError?: boolean;

70 > level?: ChatErrorLevel;

71 > confirmationButtons?: IChatResponseErrorDetailsConfirmationButton[];

72 > code?: string;

73 > }

74 >

75 > export interface IChatResponseProgressFileTreeData {

76 > label: string;

77 > uri: URI;

78 > type?: FileType;

79 > children?: IChatResponseProgressFileTreeData[];

80 > }

81 >

82 > export type IDocumentContext = {

83 > uri: URI;

84 > version: number;

85 > ranges: IRange[];

86 > };

87 >

88 > export function isIDocumentContext(obj: unknown): obj is IDocumentContext {

89 return (

90 !!obj &&

95 );

96 }

97 > chatService.ts

98 > export interface IChatUsedContext {

99 > documents: IDocumentContext[];

100 > kind: 'usedContext';

101 > }

102 >

103 > export function isIUsedContext(obj: unknown): obj is IChatUsedContext {

104 return (

105 !!obj &&

110 );

111 }

112 > chatService.ts

113 > export interface IChatContentVariableReference {

114 > variableName: string;

115 > value?: URI | Location;

116 > }

117 >

118 > export function isChatContentVariableReference(obj: unknown): obj is IChatContentVariableReference {

119 return !!obj &&

120 typeof obj === 'object' &&

121 typeof (obj as IChatContentVariableReference).variableName === 'string';

122 }

123 > chatService.ts

124 > export enum ChatResponseReferencePartStatusKind {

125 > Complete = 1,

126 > Partial = 2,

127 > Omitted = 3

128 > }

129 >

130 > export enum ChatResponseClearToPreviousToolInvocationReason {

131 > NoReason = 0,

132 > FilteredContentRetry = 1,

133 > CopyrightContentRetry = 2,

134 > }

135 >

136 > export interface IChatContentReference {

137 > reference: URI | Location | IChatContentVariableReference | string;

138 > iconPath?: ThemeIcon | { light: URI; dark?: URI };

139 > options?: {

140 > status?: { description: string; kind: ChatResponseReferencePartStatusKind };

141 > diffMeta?: { added: number; removed: number };

142 > originalUri?: URI;

143 > /** Overrides the reference URI when opening the modified side of a diff. */

144 > modifiedUri?: URI;

145 > isDeletion?: boolean;

146 > };

147 > kind: 'reference';

148 > }

149 >

150 > export interface IChatCodeCitation {

151 > value: URI;

152 > license: string;

153 > snippet: string;

154 > kind: 'codeCitation';

155 > }

156 >

157 > export interface IChatUsagePromptTokenDetail {

158 > category: string;

159 > label: string;

160 > percentageOfPrompt: number;

161 > }

162 >

163 > export interface IChatUsage {

164 > promptTokens: number;

165 > completionTokens: number;

166 > outputBuffer?: number;

167 > promptTokenDetails?: readonly IChatUsagePromptTokenDetail[];

168 > copilotCredits?: number;

169 > /**

170 > * The language-model ID that actually served the request. Set when a

171 > * meta-model (e.g. "auto") routes to a concrete model so consumers

172 > * can look up the real model's metadata (context window size, etc.).

173 > */

174 > actualModelId?: string;

175 > kind: 'usage';

176 > }

177 >

178 > /**

179 > * Formats a copilot credit value for display.

180 > */

181 > export function formatCopilotCredits(credits: number): string {

182 return parseFloat(credits.toFixed(1)).toString();

183 }

184 > chatService.ts

185 > export interface IChatContentInlineReference {

186 > resolveId?: string;

187 > inlineReference: URI | Location | IWorkspaceSymbol;

188 > name?: string;

189 > kind: 'inlineReference';

190 > }

191 >

192 > export interface IChatMarkdownContent {

193 > kind: 'markdownContent';

194 > content: IMarkdownString;

195 > inlineReferences?: Record<string, IChatContentInlineReference>;

196 > }

197 >

198 > export interface IChatTreeData {

199 > treeData: IChatResponseProgressFileTreeData;

200 > kind: 'treeData';

201 > }

202 > export interface IMultiDiffResource {

203 > originalUri?: URI;

204 > modifiedUri?: URI;

205 > goToFileUri?: URI;

206 > added?: number;

207 > removed?: number;

208 > }

209 >

210 > export interface IChatMultiDiffInnerData {

211 > title: string;

212 > resources: IMultiDiffResource[];

213 > }

214 >

215 > export interface IChatMultiDiffData {

216 > multiDiffData: IChatMultiDiffInnerData | IObservable<IChatMultiDiffInnerData>;

217 > kind: 'multiDiffData';

218 > collapsed?: boolean;

219 > readOnly?: boolean;

220 > toJSON(): IChatMultiDiffDataSerialized;

221 > }

222 >

223 > export interface IChatMultiDiffDataSerialized {

224 > multiDiffData: IChatMultiDiffInnerData;

225 > kind: 'multiDiffData';

226 > collapsed?: boolean;

227 > readOnly?: boolean;

228 > }

229 >

230 > export class ChatMultiDiffData implements IChatMultiDiffData {

231 > public readonly kind = 'multiDiffData';

232 > public readonly collapsed?: boolean | undefined;

233 > public readonly readOnly?: boolean | undefined;

234 > public readonly multiDiffData: IChatMultiDiffData['multiDiffData'];

235 >

236 > constructor(opts: {

237 multiDiffData: IChatMultiDiffInnerData | IObservable<IChatMultiDiffInnerData>;

238 collapsed?: boolean;

243 this.multiDiffData = opts.multiDiffData;

244 }

245 > chatService.ts

246 > toJSON(): IChatMultiDiffDataSerialized {

247 return {

248 kind: this.kind,

252 };

253 }

254 > } chatService.ts

255 >

256 > export interface IChatProgressMessage {

257 > content: IMarkdownString;

258 > kind: 'progressMessage';

259 > shimmer?: boolean;

260 > }

261 >

262 > export interface IChatSystemNotificationPart {

263 > content: IMarkdownString;

264 > kind: 'systemNotification';

265 > }

266 >

267 > export interface IChatTask extends IChatTaskDto {

268 > deferred: DeferredPromise<string | void>;

269 > progress: (IChatWarningMessage | IChatContentReference)[];

270 > readonly onDidAddProgress: Event<IChatWarningMessage | IChatContentReference>;

271 > add(progress: IChatWarningMessage | IChatContentReference): void;

272 >

273 > complete: (result: string | void) => void;

274 > task: () => Promise<string | void>;

275 > isSettled: () => boolean;

276 > toJSON(): IChatTaskSerialized;

277 > }

278 >

279 > export interface IChatUndoStop {

280 > kind: 'undoStop';

281 > id: string;

282 > }

283 >

284 > export interface IChatExternalEditsDto {

285 > kind: 'externalEdits';

286 > undoStopId: string;

287 > start: boolean; /** true=start, false=stop */

288 > resources: UriComponents[];

289 > /**

290 > * When present, these URIs are read instead of the `resources` URIs

291 > * (by-index) when capturing file snapshots. Used by the agent host

292 > * to provide before/after content from the remote filesystem

293 > * or from stored snapshots.

294 > */

295 > contentFor?: UriComponents[];

296 > }

297 >

298 > export interface IChatTaskDto {

299 > content: IMarkdownString;

300 > kind: 'progressTask';

301 > }

302 >

303 > export interface IChatTaskSerialized {

304 > content: IMarkdownString;

305 > progress: (IChatWarningMessage | IChatContentReference)[];

306 > kind: 'progressTaskSerialized';

307 > }

308 >

309 > export interface IChatTaskResult {

310 > content: IMarkdownString | void;

311 > kind: 'progressTaskResult';

312 > }

313 >

314 > export interface IChatWarningMessage {

315 > content: IMarkdownString;

316 > kind: 'warning';

317 > }

318 >

319 > export interface IChatInfoMessage {

320 > content: IMarkdownString;

321 > kind: 'info';

322 > }

323 >

324 > export interface IChatAgentVulnerabilityDetails {

325 > title: string;

326 > description: string;

327 > }

328 >

329 > export interface IChatResponseCodeblockUriPart {

330 > kind: 'codeblockUri';

331 > uri: URI;

332 > isEdit?: boolean;

333 > undoStopId?: string;

334 > subAgentInvocationId?: string;

335 > }

336 >

337 > export interface IChatAgentMarkdownContentWithVulnerability {

338 > content: IMarkdownString;

339 > vulnerabilities: IChatAgentVulnerabilityDetails[];

340 > kind: 'markdownVuln';

341 > }

342 >

343 > export interface IChatCommandButton {

344 > command: Command;

345 > kind: 'command';

346 > additionalCommands?: Command[]; // rendered as secondary buttons

347 > }

348 >

349 > export interface IChatMoveMessage {

350 > uri: URI;

351 > range: IRange;

352 > kind: 'move';

353 > }

354 >

355 > export interface IChatTextEdit {

356 > uri: URI;

357 > edits: TextEdit[];

358 > kind: 'textEdit';

359 > done?: boolean;

360 > isExternalEdit?: boolean;

361 > }

362 >

363 > export interface IChatClearToPreviousToolInvocation {

364 > kind: 'clearToPreviousToolInvocation';

365 > reason: ChatResponseClearToPreviousToolInvocationReason;

366 > }

367 >

368 > export interface IChatNotebookEdit {

369 > uri: URI;

370 > edits: ICellEditOperation[];

371 > kind: 'notebookEdit';

372 > done?: boolean;

373 > isExternalEdit?: boolean;

374 > }

375 >

376 > export interface IChatWorkspaceFileEdit {

377 > oldResource?: URI;

378 > newResource?: URI;

379 > }

380 >

381 > export interface IChatWorkspaceEdit {

382 > kind: 'workspaceEdit';

383 > edits: IChatWorkspaceFileEdit[];

384 > }

385 >

386 > /**

387 > * The kind of file operation an {@link IChatExternalEdit} represents.

388 > */

389 > export type ChatExternalEditKind = 'create' | 'delete' | 'rename' | 'edit';

390 >

391 > /**

392 > * A summary of a file edit that has been performed externally (i.e. by an

393 > * agent or tool outside of chat's own editing pipeline). Carries everything

394 > * needed to render a static "edit pill" without round-tripping through

395 > * {@link IChatEditingSession} for diff computation: the producer already

396 > * knows the URIs and diff stats up-front.

397 > */

398 > export interface IChatExternalEdit {

399 > kind: 'externalEdit';

400 > /** The resulting file URI (after-URI for create/edit/rename, before-URI for delete). */

401 > uri: URI;

402 > /** The kind of file operation. */

403 > editKind: ChatExternalEditKind;

404 > /** For renames, the file URI before the operation. */

405 > originalUri?: URI;

406 > /** URI from which the "before" content can be read (for diff viewing). Absent for creates. */

407 > beforeContentUri?: URI;

408 > /** URI from which the "after" content can be read (for diff viewing). Absent for deletes. */

409 > afterContentUri?: URI;

410 > /** Pre-computed diff display metadata. */

411 > diff?: { added: number; removed: number };

412 > /** Optional undo-stop id (typically the tool call id) for grouping. */

413 > undoStopId?: string;

414 > }

415 >

416 > export interface IChatConfirmation {

417 > title: string;

418 > message: string | IMarkdownString;

419 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

420 > data: any;

421 > buttons?: string[];

422 > isUsed?: boolean;

423 > kind: 'confirmation';

424 > }

425 >

426 > /**

427 > * Validation rules for a question in a question carousel.

428 > */

429 > export interface IChatQuestionValidation {

430 > minLength?: number;

431 > maxLength?: number;

432 > format?: 'email' | 'uri' | 'date' | 'date-time';

433 > minimum?: number;

434 > maximum?: number;

435 > isInteger?: boolean;

436 > }

437 >

438 > /**

439 > * Represents an individual question in a question carousel.

440 > */

441 > export interface IChatQuestion {

442 > id: string;

443 > type: 'text' | 'singleSelect' | 'multiSelect';

444 > title: string;

445 > message?: string | IMarkdownString;

446 > description?: string;

447 > options?: { id: string; label: string; value: string }[];

448 > defaultValue?: string | string[];

449 > allowFreeformInput?: boolean;

450 > required?: boolean;

451 > validation?: IChatQuestionValidation;

452 > detailedMessage?: string | IMarkdownString;

453 > }

454 >

455 > /** Answer shape for a single-select question. */

456 > export interface IChatSingleSelectAnswer {

457 > selectedValue?: string;

458 > freeformValue?: string;

459 > }

460 >

461 > /** Answer shape for a multi-select question. */

462 > export interface IChatMultiSelectAnswer {

463 > selectedValues: string[];

464 > freeformValue?: string;

465 > }

466 >

467 > /** Union of all possible answer values in a question carousel. */

468 > export type IChatQuestionAnswerValue = string | IChatSingleSelectAnswer | IChatMultiSelectAnswer;

469 >

470 > /** Record mapping question IDs to their typed answer values. */

471 > export type IChatQuestionAnswers = Record<string, IChatQuestionAnswerValue>;

472 >

473 > /**

474 > * A carousel for presenting multiple questions inline in the chat response.

475 > * Users can navigate between questions and submit their answers.

476 > */

477 > export interface IChatQuestionCarousel {

478 > questions: IChatQuestion[];

479 > allowSkip: boolean;

480 > /** Unique identifier for resolving the carousel answers back to the extension */

481 > resolveId?: string;

482 > /** Storage for collected answers when user submits */

483 > data?: IChatQuestionAnswers;

484 > /** Whether the carousel has been submitted/skipped */

485 > isUsed?: boolean;

486 > /** True when accepted/answered outside the carousel UI (e.g. via voice) without structured answers. */

487 > answeredExternally?: boolean;

488 > /** Top-level message shown above the questions (e.g. from MCP elicitation message) */

489 > message?: string | IMarkdownString;

490 > /** Source attribution (e.g. MCP server) */

491 > source?: ToolDataSource;

492 > /** Terminal ID when the carousel was triggered by a terminal needing input */

493 > terminalId?: string;

494 > kind: 'questionCarousel';

495 > }

496 >

497 > export const enum ElicitationState {

498 > Pending = 'pending',

499 > Accepted = 'accepted',

500 > Rejected = 'rejected',

501 > }

502 >

503 > export interface IChatElicitationRequest {

504 > kind: 'elicitation2'; // '2' because initially serialized data used the same kind

505 > title: string | IMarkdownString;

506 > message: string | IMarkdownString;

507 > acceptButtonLabel: string;

508 > rejectButtonLabel: string | undefined;

509 > subtitle?: string | IMarkdownString;

510 > source?: ToolDataSource;

511 > state: IObservable<ElicitationState>;

512 > acceptedResult?: Record<string, unknown>;

513 > moreActions?: IAction[];

514 > riskAssessment?: { toolId: string; parameters: unknown };

515 > accept(value: IAction | true): Promise<void>;

516 > reject?: () => Promise<void>;

517 > isHidden?: IObservable<boolean>;

518 > hide?(): void;

519 > toJSON(): IChatElicitationRequestSerialized;

520 > }

521 >

522 > export interface IChatElicitationRequestSerialized {

523 > kind: 'elicitationSerialized';

524 > title: string | IMarkdownString;

525 > message: string | IMarkdownString;

526 > subtitle: string | IMarkdownString | undefined;

527 > source: ToolDataSource | undefined;

528 > state: ElicitationState.Accepted | ElicitationState.Rejected;

529 > isHidden: boolean;

530 > acceptedResult?: Record<string, unknown>;

531 > }

532 >

533 > export interface IChatThinkingPart {

534 > kind: 'thinking';

535 > value?: string | string[];

536 > id?: string;

537 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

538 > metadata?: { readonly [key: string]: any };

539 > generatedTitle?: string;

540 > /** Elapsed reasoning time in milliseconds, persisted so the duration survives reload. */

541 > reasoningDurationMs?: number;

542 > }

543 >

544 > /**

545 > * A progress part representing an auto-mode model routing resolution.

546 > * Shown as a collapsible widget in the chat stream: collapsed displays

547 > * "Routed to <model>", expanded shows routing details and confidence.

548 > */

549 > export interface IChatAutoModeResolutionPart {

550 > kind: 'autoModeResolution';

551 > /** The model ID that was selected by the router */

552 > resolvedModel: string;

553 > /** The user-facing display name of the resolved model */

554 > resolvedModelName: string;

555 > /** The router's classification label */

556 > predictedLabel: 'needs_reasoning' | 'no_reasoning' | 'fallback';

557 > /** Confidence score (0-1) from the router */

558 > confidence: number;

559 > }

560 >

561 > /**

562 > * A progress part representing the execution result of a hook.

563 > * Aligned with the hook output JSON structure: { stopReason, systemMessage, hookSpecificOutput }.

564 > * If {@link stopReason} is set, the hook blocked/denied the operation.

565 > */

566 > export interface IChatHookPart {

567 > kind: 'hook';

568 > /** The type of hook that was executed */

569 > hookType: HookTypeValue;

570 > /** If set, the hook blocked processing. This message is shown to the user. */

571 > stopReason?: string;

572 > /** Warning/system message from the hook, shown to the user */

573 > systemMessage?: string;

574 > /** Display name of the tool that was affected by the hook */

575 > toolDisplayName?: string;

576 > metadata?: { readonly [key: string]: unknown };

577 > /** If set, this hook was executed within a subagent invocation and should be grouped with it. */

578 > subAgentInvocationId?: string;

579 > }

580 >

581 > export interface IChatTerminalToolInvocationData {

582 > kind: 'terminal';

583 > commandLine: {

584 > original: string;

585 > userEdited?: string;

586 > toolEdited?: string;

587 > // command to show in the chat UI (potentially different from what is actually run in the terminal)

588 > forDisplay?: string;

589 > // isSandboxWrapped boolean to run in the terminal (potentially different from original command)

590 > isSandboxWrapped?: boolean;

591 > };

592 > /**

593 > * LM-generated intention describing why the command is being run, shown

594 > * above the command in the terminal tool card. Set by the Agent Host; the

595 > * built-in terminal tool leaves this unset.

596 > */

597 > intention?: string;

598 > /** The working directory URI for the terminal */

599 > cwd?: UriComponents;

600 > /**

601 > * Pre-computed confirmation display data (localization must happen at source).

602 > * Contains the command line to show in confirmation (potentially without cd prefix)

603 > * and the formatted cwd label if a cd prefix was extracted.

604 > */

605 > confirmation?: {

606 > /** The command line to display in the confirmation editor */

607 > commandLine: string;

608 > /** The formatted cwd label to show in title (if cd was extracted) */

609 > cwdLabel?: string;

610 > /** The cd prefix to prepend back when user edits */

611 > cdPrefix?: string;

612 > };

613 > /**

614 > * Overrides to apply to the presentation of the tool call only, but not actually change the

615 > * command that gets run. For example, python -c "print('hello')" can be presented as just

616 > * the Python code with Python syntax highlighting.

617 > */

618 > presentationOverrides?: {

619 > /** The command line to display in the UI */

620 > commandLine: string;

621 > /** The language for syntax highlighting */

622 > language?: string;

623 > };

624 > /** Message for model recommending the use of an alternative tool */

625 > alternativeRecommendation?: string;

626 > language: string;

627 > terminalToolSessionId?: string;

628 > /** False for output-only data that must not create a workbench terminal instance. */

629 > isPty?: boolean;

630 > /** The predefined command ID that will be used for this terminal command */

631 > terminalCommandId?: string;

632 > /** Whether the terminal command was started as a background execution */

633 > isBackground?: boolean;

634 > /** Whether the command was explicitly approved to run outside the sandbox */

635 > requestUnsandboxedExecution?: boolean;

636 > /** The model-provided reason for requesting sandbox bypass */

637 > requestUnsandboxedExecutionReason?: string;

638 > /** Whether the terminal command was approved to run sandboxed with unrestricted network access */

639 > requestAllowNetwork?: boolean;

640 > /** The model-provided reason for requesting unrestricted network access within the sandbox */

641 > requestAllowNetworkReason?: string;

642 > /** Serialized URI for the command that was executed in the terminal */

643 > terminalCommandUri?: UriComponents;

644 > /** Serialized output of the executed command */

645 > terminalCommandOutput?: {

646 > text: string;

647 > truncated?: boolean;

648 > lineCount?: number;

649 > };

650 > /** Stored theme colors at execution time to style detached output */

651 > terminalTheme?: {

652 > background?: string;

653 > foreground?: string;

654 > };

655 > /** Stored command state to restore decorations after reload */

656 > terminalCommandState?: {

657 > exitCode?: number;

658 > timestamp?: number;

659 > duration?: number;

660 > };

661 > /** Whether the user chose to continue in background for this tool invocation */

662 > didContinueInBackground?: boolean;

663 > autoApproveInfo?: IMarkdownString;

664 > /** Names of missing sandbox dependencies that the user may choose to install */

665 > missingSandboxDependencies?: string[];

666 > /** Approved repair actions that may make an installed but unusable sandbox dependency work. */

667 > sandboxRemediations?: string[];

668 > /** User-visible reason a sandbox prerequisite cannot be repaired automatically. */

669 > sandboxPrerequisiteFailure?: string;

670 > }

671 >

672 > /**

673 > * @deprecated This is the old API shape, we should support this for a while before removing it so

674 > * we don't break existing chats

675 > */

676 > export interface ILegacyChatTerminalToolInvocationData {

677 > kind: 'terminal';

678 > command: string;

679 > language: string;

680 > }

681 >

682 > export function isLegacyChatTerminalToolInvocationData(data: unknown): data is ILegacyChatTerminalToolInvocationData {

683 return !!data && typeof data === 'object' && 'command' in data && 'language' in data;

684 }

685 > chatService.ts

686 > /**

687 > * Routing information for an MCP App's webview sub-RPCs. The kind

688 > * determines where `tools/call`, `resources/read`,

689 > * `sampling/createMessage`, etc. are sent:

690 > *

691 > * - `local`: resolves the MCP server via {@link IMcpService} from a

692 > * `serverDefinitionId` + `collectionId`. Used for locally-configured

693 > * MCP servers whose state lives in the workbench.

694 > * - `agentHost`: routes through {@link IAgentHostService.handleMcpRequest}

695 > * on an AHP `mcp://` side channel. Used for MCP servers owned by an

696 > * agent host (e.g. Copilot CLI).

697 > */

698 > export type ChatMcpAppData =

699 > | {

700 > kind: 'local';

701 > /** URI of the UI resource for rendering (e.g., "ui://weather-server/dashboard") */

702 > resourceUri: string;

703 > /** Reference to the server definition for reconnection */

704 > serverDefinitionId: string;

705 > /** Reference to the collection containing the server */

706 > collectionId: string;

707 > }

708 > | {

709 > kind: 'agentHost';

710 > /** URI of the UI resource for rendering (e.g., "ui://weather-server/dashboard") */

711 > resourceUri: string;

712 > /** AHP `mcp://` channel URI for the originating server. */

713 > channel: string;

714 > /**

715 > * Stable identifier for the originating server, used as the

716 > * additional key when computing the webview origin. Typically the

717 > * AHP customization id. For top-level (bare) MCP servers this id

718 > * is currently session-scoped, so see {@link ChatMcpAppModel} for

719 > * how it avoids growing persistent application storage on every

720 > * new session.

721 > */

722 > serverId: string;

723 > };

724 >

725 > export interface IChatToolInputInvocationData {

726 > kind: 'input';

727 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

728 > rawInput: any;

729 > /** Optional MCP App UI metadata for rendering during and after tool execution */

730 > mcpAppData?: ChatMcpAppData;

731 > }

732 >

733 > export const enum ToolConfirmKind {

734 > Denied,

735 > ConfirmationNotNeeded,

736 > Setting,

737 > LmServicePerTool,

738 > UserAction,

739 > Skipped

740 > }

741 >

742 > export type ConfirmedReason =

743 > | { type: ToolConfirmKind.Denied }

744 > | { type: ToolConfirmKind.ConfirmationNotNeeded; reason?: string | IMarkdownString }

745 > | { type: ToolConfirmKind.Setting; id: string }

746 > | { type: ToolConfirmKind.LmServicePerTool; scope: 'session' | 'workspace' | 'profile' }

747 > | { type: ToolConfirmKind.UserAction; selectedButton?: string; selectedButtonKind?: ConfirmationOptionKind }

748 > | { type: ToolConfirmKind.Skipped };

749 >

750 > /**

751 > * Active-only controls for a tool call executing on another connected client.

752 > */

753 > export interface IChatToolInvocationOtherClientData {

754 > readonly cancel: () => void;

755 > }

756 >

757 > export interface IChatToolInvocation {

758 > readonly presentation: IPreparedToolInvocation['presentation'];

759 > readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData | IChatSessionCreatedData | IChatAutomationConfigurationData | IChatAutomationConfiguredData;

760 > /** Active-only metadata that is omitted when the invocation is serialized. */

761 > readonly otherClientToolCall?: IChatToolInvocationOtherClientData;

762 > /**

763 > * Observable that tracks the `kind` of `toolSpecificData`. Used by the

764 > * tool invocation part to re-render when the kind changes (e.g. from

765 > * `'input'` to `'terminal'` when terminal content arrives).

766 > */

767 > readonly toolSpecificDataKind: IObservable<string | undefined>;

768 > readonly originMessage: string | IMarkdownString | undefined;

769 > readonly invocationMessage: string | IMarkdownString;

770 > readonly pastTenseMessage: string | IMarkdownString | undefined;

771 > readonly source: ToolDataSource;

772 > readonly toolId: string;

773 > readonly toolCallId: string;

774 > readonly subAgentInvocationId?: string;

775 > readonly icon?: ThemeIcon;

776 > readonly state: IObservable<IChatToolInvocation.State>;

777 > generatedTitle?: string;

778 > isAttachedToThinking: boolean;

779 >

780 > kind: 'toolInvocation';

781 >

782 > toJSON(): IChatToolInvocationSerialized;

783 > }

784 >

785 > export namespace IChatToolInvocation {

786 > export const enum StateKind {

787 > /** Tool call is streaming partial input from the LM */

788 > Streaming,

789 > WaitingForConfirmation,

790 > Executing,

791 > WaitingForPostApproval,

792 > Completed,

793 > Cancelled,

794 > WaitingForAuthentication,

795 > }

796 >

797 > interface IChatToolInvocationStateBase {

798 > type: StateKind;

799 > }

800 >

801 > export interface IChatToolInvocationStreamingState extends IChatToolInvocationStateBase {

802 > type: StateKind.Streaming;

803 > /** Observable partial input from the LM stream */

804 > readonly partialInput: IObservable<unknown>;

805 > /** Custom invocation message from handleToolStream */

806 > readonly streamingMessage: IObservable<string | IMarkdownString | undefined>;

807 > }

808 >

809 > /** Properties available after streaming is complete */

810 > interface IChatToolInvocationPostStreamState {

811 > readonly parameters: unknown;

812 > readonly confirmationMessages?: IToolConfirmationMessages;

813 > }

814 >

815 > interface IChatToolInvocationWaitingForConfirmationState extends IChatToolInvocationStateBase, IChatToolInvocationPostStreamState {

816 > type: StateKind.WaitingForConfirmation;

817 > confirm(reason: ConfirmedReason): void;

818 > }

819 >

820 > interface IChatToolInvocationPostConfirmState extends IChatToolInvocationPostStreamState {

821 > confirmed: ConfirmedReason;

822 > }

823 >

824 > interface IChatToolInvocationExecutingState extends IChatToolInvocationStateBase, IChatToolInvocationPostConfirmState {

825 > type: StateKind.Executing;

826 > progress: IObservable<{ message?: string | IMarkdownString; progress: number | undefined }>;

827 > }

828 >

829 > export interface IChatToolInvocationWaitingForAuthenticationState extends IChatToolInvocationStateBase, IChatToolInvocationPostConfirmState {

830 > type: StateKind.WaitingForAuthentication;

831 > readonly server: IChatMcpAuthenticationRequiredServer;

832 > cancel(): void;

833 > }

834 >

835 > interface IChatToolInvocationPostExecuteState extends IChatToolInvocationPostConfirmState {

836 > resultDetails: IToolResult['toolResultDetails'];

837 > }

838 >

839 > interface IChatToolWaitingForPostApprovalState extends IChatToolInvocationStateBase, IChatToolInvocationPostExecuteState {

840 > type: StateKind.WaitingForPostApproval;

841 > confirm(reason: ConfirmedReason): void;

842 > contentForModel: IToolResult['content'];

843 > }

844 >

845 > interface IChatToolInvocationCompleteState extends IChatToolInvocationStateBase, IChatToolInvocationPostExecuteState {

846 > type: StateKind.Completed;

847 > postConfirmed: ConfirmedReason | undefined;

848 > contentForModel: IToolResult['content'];

849 > }

850 >

851 > interface IChatToolInvocationCancelledState extends IChatToolInvocationStateBase, IChatToolInvocationPostStreamState {

852 > type: StateKind.Cancelled;

853 > reason: ToolConfirmKind.Denied | ToolConfirmKind.Skipped;

854 > /** Optional message explaining why the tool was cancelled (e.g., from hook denial) */

855 > reasonMessage?: string | IMarkdownString;

856 > }

857 >

858 > export type State =

859 > | IChatToolInvocationStreamingState

860 > | IChatToolInvocationWaitingForConfirmationState

861 > | IChatToolInvocationExecutingState

862 > | IChatToolInvocationWaitingForAuthenticationState

863 > | IChatToolWaitingForPostApprovalState

864 > | IChatToolInvocationCompleteState

865 > | IChatToolInvocationCancelledState;

866 >

867 > export function executionConfirmedOrDenied(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): ConfirmedReason | undefined {

868 if (invocation.kind === 'toolInvocationSerialized') {

869 if (invocation.isConfirmed === undefined || typeof invocation.isConfirmed === 'boolean') {

883 return state.confirmed;

884 }

885 > chatService.ts

886 > export function awaitConfirmation(invocation: IChatToolInvocation, token?: CancellationToken): Promise<ConfirmedReason> {

887 const reason = executionConfirmedOrDenied(invocation);

888 if (reason) {

909 });

910 }

911 > chatService.ts

912 > function postApprovalConfirmedOrDenied(invocation: IChatToolInvocation, reader?: IReader): ConfirmedReason | undefined {

913 const state = invocation.state.read(reader);

914 if (state.type === StateKind.Completed) {

921 return undefined;

922 }

923 > chatService.ts

924 > export function confirmWith(invocation: IChatToolInvocation | undefined, reason: ConfirmedReason) {

925 const state = invocation?.state.get();

926 if (state?.type === StateKind.WaitingForConfirmation || state?.type === StateKind.WaitingForPostApproval) {

930 return false;

931 }

932 > chatService.ts

933 > export function awaitPostConfirmation(invocation: IChatToolInvocation, token?: CancellationToken): Promise<ConfirmedReason> {

934 const reason = postApprovalConfirmedOrDenied(invocation);

935 if (reason) {

956 });

957 }

958 > chatService.ts

959 > export function resultDetails(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader) {

960 if (invocation.kind === 'toolInvocationSerialized') {

961 return invocation.resultDetails;

969 return undefined;

970 }

971 > chatService.ts

972 > export function isComplete(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean {

973 if (invocation.kind === 'toolInvocationSerialized') {

974 return true; // always cancelled or complete

978 return state.type === StateKind.Completed || state.type === StateKind.Cancelled;

979 }

980 > chatService.ts

981 > export function isEffectivelyHidden(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean {

982 if (invocation.presentation === 'hidden') {

983 return true;

988 return false;

989 }

990 > chatService.ts

991 > export function isStreaming(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean {

992 if (invocation.kind === 'toolInvocationSerialized') {

993 return false;

997 return state.type === StateKind.Streaming;

998 }

999 > chatService.ts

1000 > /**

1001 > * Get parameters from invocation. Returns undefined during streaming state.

1002 > */

1003 > export function getParameters(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): unknown | undefined {

1004 if (invocation.kind === 'toolInvocationSerialized') {

1005 return undefined; // serialized invocations don't store parameters

1013 return state.parameters;

1014 }

1015 > chatService.ts

1016 > /**

1017 > * Get confirmation messages from invocation. Returns undefined during streaming state.

1018 > */

1019 > export function getConfirmationMessages(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): IToolConfirmationMessages | undefined {

1020 if (invocation.kind === 'toolInvocationSerialized') {

1021 return undefined; // serialized invocations don't store confirmation messages

1029 return state.confirmationMessages;

1030 }

1031 > } chatService.ts

1032 >

1033 >

1034 > export interface IToolResultOutputDetailsSerialized {

1035 > output: {

1036 > type: 'data';

1037 > mimeType: string;

1038 > base64Data: string;

1039 > };

1040 > }

1041 >

1042 > /**

1043 > * This is a IChatToolInvocation that has been serialized, like after window reload, so it is no longer an active tool invocation.

1044 > */

1045 > export interface IChatToolInvocationSerialized {

1046 > presentation: IPreparedToolInvocation['presentation'];

1047 > toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData | IChatSessionCreatedData | IChatAutomationConfiguredData;

1048 > invocationMessage: string | IMarkdownString;

1049 > originMessage: string | IMarkdownString | undefined;

1050 > pastTenseMessage: string | IMarkdownString | undefined;

1051 > resultDetails?: Array<URI | Location> | IToolResultInputOutputDetails | IToolResultOutputDetailsSerialized;

1052 > /** boolean used by pre-1.104 versions */

1053 > isConfirmed: ConfirmedReason | boolean | undefined;

1054 > isComplete: boolean;

1055 > toolCallId: string;

1056 > toolId: string;

1057 > readonly icon?: undefined;

1058 > source: ToolDataSource | undefined; // undefined on pre-1.104 versions

1059 > readonly subAgentInvocationId?: string;

1060 > generatedTitle?: string;

1061 > isAttachedToThinking?: boolean;

1062 > kind: 'toolInvocationSerialized';

1063 > }

1064 >

1065 > export interface IChatExtensionsContent {

1066 > extensions: string[];

1067 > kind: 'extensions';

1068 > }

1069 >

1070 > export interface IChatPullRequestContent {

1071 > /**

1072 > * @deprecated use `command` instead

1073 > */

1074 > uri?: URI;

1075 > command: Command;

1076 > title: string;

1077 > description: string;

1078 > author: string;

1079 > linkTag: string;

1080 > kind: 'pullRequest';

1081 > }

1082 >

1083 > export interface IChatSubagentToolInvocationData {

1084 > kind: 'subagent';

1085 > isActive?: boolean;

1086 > description?: string;

1087 > agentName?: string;

1088 > prompt?: string;

1089 > result?: string;

1090 > modelName?: string;

1091 > credits?: number;

1092 > /** Millisecond timestamp when the subagent's first turn started. */

1093 > startedAt?: number;

1094 > /** Final elapsed duration in milliseconds. Set when the subagent stops. */

1095 > duration?: number;

1096 > /**

1097 > * Resource (URI string) of the subagent's own chat, when the subagent runs as

1098 > * a distinct chat (e.g. an agent host worker chat). Used to offer an "Open

1099 > * chat" link that reveals the subagent's read-only chat. Undefined when the

1100 > * subagent has no separately-openable chat. A string (not a `URI`) so it stays

1101 > * serializable across the extension host protocol.

1102 > */

1103 > chatResource?: string;

1104 > }

1105 >

1106 > /**

1107 > * Progress type for external tool invocation updates from extensions.

1108 > * When isComplete is false, creates or updates a tool invocation.

1109 > * When isComplete is true, completes an existing tool invocation.

1110 > */

1111 > export interface IChatExternalToolInvocationUpdate {

1112 > kind: 'externalToolInvocationUpdate';

1113 > toolCallId: string;

1114 > toolName: string;

1115 > isComplete: boolean;

1116 > errorMessage?: string;

1117 > invocationMessage?: string | IMarkdownString;

1118 > pastTenseMessage?: string | IMarkdownString;

1119 > toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatModifiedFilesConfirmationData;

1120 > subagentInvocationId?: string;

1121 > resultDetails?: IToolResultInputOutputDetails;

1122 > }

1123 >

1124 > export interface IChatTodoListContent {

1125 > kind: 'todoList';

1126 > todoList: Array<{

1127 > id: string;

1128 > title: string;

1129 > status: 'not-started' | 'in-progress' | 'completed';

1130 > }>;

1131 > }

1132 >

1133 > export interface IChatSimpleToolInvocationData {

1134 > kind: 'simpleToolInvocation';

1135 > input: string;

1136 > output: string;

1137 > }

1138 >

1139 > export interface IChatSearchToolInvocationData {

1140 > readonly kind: 'search';

1141 > }

1142 >

1143 > export interface IChatToolResourcesInvocationData {

1144 > readonly kind: 'resources';

1145 > readonly values: Array<URI | Location>;

1146 > }

1147 >

1148 > /**

1149 > * Tool-specific data for a completed `create_session` / `create_chat`

1150 > * agent-host tool call. Carries a clickable link so the renderer can show a

1151 > * deterministic confirmation + "open" button instead of relying on the model

1152 > * to echo a markdown link.

1153 > */

1154 > export interface IChatSessionCreatedData {

1155 > readonly kind: 'sessionCreated';

1156 > /** The `agent-host-session://` link that opens the created/owning session. */

1157 > readonly openLink: string;

1158 > /** Label for the button (e.g. the session title / prompt). */

1159 > readonly label: string;

1160 > /** Whether this is a `create_chat` result (vs `create_session`); selects the pill icon. */

1161 > readonly isChat?: boolean;

1162 > }

1163 >

1164 > /**

1165 > * Tool-specific data for a completed automation create or update. The stable

1166 > * automation ID lets the renderer open the Automations editor at the affected

1167 > * entry without relying on model-authored prose.

1168 > */

1169 > export interface IChatAutomationConfiguredData {

1170 > readonly kind: 'automationConfigured';

1171 > readonly automationId: string;

1172 > readonly automationName: string;

1173 > readonly operation: 'created' | 'updated';

1174 > }

1175 >

1176 > /**

1177 > * Transient preparation data used to guard an automation update across the

1178 > * confirmation boundary. It is omitted from serialized chat invocations.

1179 > */

1180 > export interface IChatAutomationConfigurationData {

1181 > readonly kind: 'automationConfiguration';

1182 > readonly expectedAutomationId: string;

1183 > readonly expectedEditableState: string;

1184 > }

1185 >

1186 > export interface IChatModifiedFilesConfirmationData {

1187 > readonly kind: 'modifiedFilesConfirmation';

1188 > readonly options: readonly string[];

1189 > readonly modifiedFiles: readonly {

1190 > readonly uri: UriComponents;

1191 > /** The pending file operation represented by this entry. */

1192 > readonly editKind?: ChatExternalEditKind;

1193 > readonly originalUri?: UriComponents;

1194 > /**

1195 > * Optional URI to read the modified (after) content from for the diff

1196 > * view. When absent, {@link uri} is used as the modified side.

1197 > */

1198 > readonly modifiedContentUri?: UriComponents;

1199 > /**

1200 > * Optional URI to read the original (before) content from for the diff

1201 > * view. When absent, {@link originalUri} is used as the original side.

1202 > */

1203 > readonly originalContentUri?: UriComponents;

1204 > readonly insertions?: number;

1205 > readonly deletions?: number;

1206 > readonly title?: string;

1207 > readonly description?: string;

1208 > }[];

1209 > }

1210 >

1211 > /**

1212 > * Confirmation data for the agent host `viewUnreviewedComments` tool. The

1213 > * comments themselves are not carried here: the renderer fetches them (and

1214 > * performs reveal/delete/accept actions) through commands registered by the

1215 > * agent feedback feature, so this workbench/chat layer stays decoupled from the

1216 > * `vs/sessions` feedback model. The renderer resolves the owning session from

1217 > * its render context. Only the confirmation button labels are needed up front.

1218 > */

1219 > export interface IChatAgentFeedbackReviewConfirmationData {

1220 > readonly kind: 'agentFeedbackReviewConfirmation';

1221 > /** Confirmation button labels (first is the primary/approve action). */

1222 > readonly options: readonly string[];

1223 > }

1224 >

1225 > /**

1226 > * A single unreviewed comment shown in the {@link IChatAgentFeedbackReviewConfirmationData}

1227 > * confirmation. Produced by {@link AgentFeedbackReviewCommandId.GetComments}.

1228 > */

1229 > export interface IChatAgentFeedbackReviewComment {

1230 > readonly id: string;

1231 > /** Localized origin label, e.g. "PR Review" or "Agent Review"; absent for user-authored comments. */

1232 > readonly kindLabel?: string;

1233 > /** The comment body. */

1234 > readonly text: string;

1235 > /** The file the comment is anchored to. */

1236 > readonly fileUri: UriComponents;

1237 > }

1238 >

1239 > /**

1240 > * Command ids the agent feedback review confirmation renderer (workbench/chat)

1241 > * uses to fetch unreviewed comments and apply the user's selection. They are

1242 > * implemented by the agent feedback feature in `vs/sessions`, keeping the chat

1243 > * layer decoupled from the feedback model. Most take the owning session resource

1244 > * (`UriComponents`) as their first argument; {@link AgentFeedbackReviewCommandId.RevealAt}

1245 > * instead resolves the session from the file resource so a rendered tool call

1246 > * can link to a comment without knowing the session URI.

1247 > */

1248 > export const enum AgentFeedbackReviewCommandId {

1249 > /** `(sessionResource)` -> `IChatAgentFeedbackReviewComment[]` (the `created` reviewable comments). */

1250 > GetComments = '_agentFeedbackReview.getComments',

1251 > /** `(sessionResource, commentId)` -> opens the file and reveals the comment. */

1252 > Reveal = '_agentFeedbackReview.reveal',

1253 > /** `(resourceUri, range)` -> resolves the owning session and reveals the comment at that file range. */

1254 > RevealAt = '_agentFeedbackReview.revealAt',

1255 > /** `(sessionResource, commentId)` -> deletes the comment entirely. */

1256 > Delete = '_agentFeedbackReview.delete',

1257 > /** `(sessionResource, commentIds)` -> accepts (reveals) the given comments. */

1258 > Accept = '_agentFeedbackReview.accept',

1259 > }

1260 >

1261 > export interface IChatMcpServersStarting {

1262 > readonly kind: 'mcpServersStarting';

1263 > readonly state?: IObservable<IAutostartResult>; // not hydrated when serialized

1264 > didStartServerIds?: string[];

1265 > toJSON(): IChatMcpServersStartingSerialized;

1266 > }

1267 >

1268 > export interface IChatMcpServersStartingSerialized {

1269 > readonly kind: 'mcpServersStarting';

1270 > readonly state?: undefined;

1271 > didStartServerIds?: string[];

1272 > }

1273 >

1274 > export interface IChatMcpAuthenticationRequired {

1275 > readonly kind: 'mcpAuthenticationRequired';

1276 > readonly sessionResource: UriComponents;

1277 > readonly servers: IObservable<readonly IChatMcpAuthenticationRequiredServer[]>;

1278 > isUsed: boolean;

1279 > }

1280 >

1281 > export interface IChatMcpAuthenticationRequiredServer {

1282 > readonly id: string;

1283 > readonly name: string;

1284 > readonly resource: string;

1285 > readonly oauthClient?: McpOAuthClient;

1286 > readonly authorizationServers?: readonly string[];

1287 > readonly supportedScopes?: readonly string[];

1288 > readonly requiredScopes?: readonly string[];

1289 > readonly reason?: string;

1290 > }

1291 >

1292 > /**

1293 > * Surfaced by agent-host sessions when one or more MCP servers are still in the

1294 > * {@link McpServerStatus.Starting starting} state a noticeable time after a

1295 > * turn began without any content arriving from the host. The part lists the

1296 > * servers still starting and updates dynamically via {@link servers}: it hides

1297 > * itself (by emptying the observable) once every server has started, content

1298 > * starts being received, or the turn ends — whichever happens first.

1299 > *

1300 > * Unlike {@link IChatMcpServersStarting} (used by the in-process MCP autostart

1301 > * flow), this is a lightweight progress hint with no interactive affordance

1302 > * (there is no "Skip" button).

1303 > */

1304 > export interface IChatMcpServersStartingSlow {

1305 > readonly kind: 'mcpServersStartingSlow';

1306 > readonly sessionResource: UriComponents;

1307 > readonly servers: IObservable<readonly IChatMcpStartingServer[]>;

1308 > }

1309 >

1310 > export interface IChatMcpStartingServer {

1311 > readonly id: string;

1312 > readonly name: string;

1313 > }

1314 >

1315 > export interface IChatDisabledClaudeHooksPart {

1316 > readonly kind: 'disabledClaudeHooks';

1317 > }

1318 >

1319 > /** A single approval option shown in the plan review dropdown button. */

1320 > export interface IChatPlanApprovalAction {

1321 > /**

1322 > * Stable identifier for matching the chosen action programmatically.

1323 > * Unlike `label` this is not localized, so callers should compare

1324 > * against `IChatPlanReviewResult.actionId` rather than `action`.

1325 > * Optional for backwards-compatibility; omit for one-off actions

1326 > * where the localized label is the only intended identifier.

1327 > */

1328 > id?: string;

1329 > label: string;

1330 > description?: string;

1331 > default?: boolean;

1332 > /** When set to 'autopilot', a confirmation dialog is shown before proceeding. */

1333 > permissionLevel?: 'autopilot';

1334 > }

1335 >

1336 > /** The result of reviewing a plan. */

1337 > export interface IChatPlanReviewResult {

1338 > /** The chosen action's localized `label`. */

1339 > action?: string;

1340 > /** The chosen action's stable `id`, if it had one. Prefer this over

1341 > * `action` for programmatic comparisons. */

1342 > actionId?: string;

1343 > rejected: boolean;

1344 > /** Combined feedback string sent to the agent (overall comment + inline

1345 > * comments, joined and formatted as markdown). */

1346 > feedback?: string;

1347 > /** Display-only: the overall textarea comment, kept separate from

1348 > * `feedbackInlineMarkdown` so the chat transcript can render the two

1349 > * parts differently. Falls back to `feedback` when unset. */

1350 > feedbackOverall?: string;

1351 > /** Display-only: pre-formatted markdown listing the inline comments

1352 > * (heading + bullets). See `feedbackOverall`. */

1353 > feedbackInlineMarkdown?: string;

1354 > }

1355 >

1356 > /**

1357 > * A plan review widget. Presents a title, markdown plan content, an optional

1358 > * link to edit the backing plan file, a dropdown of approval actions, a reject

1359 > * button and an optional feedback textarea.

1360 > */

1361 > export interface IChatPlanReview {

1362 > kind: 'planReview';

1363 > /** Title to display in the widget header. */

1364 > title: string;

1365 > /** Markdown content rendered in the body (plan summary or contents). */

1366 > content: string;

1367 > /** Selectable approval actions. Displayed as a dropdown primary button. */

1368 > actions: IChatPlanApprovalAction[];

1369 > /** Whether to show the additional feedback textarea. */

1370 > canProvideFeedback: boolean;

1371 > /** Optional URI to the underlying plan file. An Edit button opens it. */

1372 > planUri?: UriComponents;

1373 > /** Unique identifier for resolving the review back to the extension. */

1374 > resolveId?: string;

1375 > /** Stored result once the user has responded. */

1376 > data?: IChatPlanReviewResult;

1377 > /** Whether the widget has been responded to. */

1378 > isUsed?: boolean;

1379 > /** Source attribution. */

1380 > source?: ToolDataSource;

1381 > }

1382 >

1383 > export class ChatMcpServersStarting implements IChatMcpServersStarting {

1384 > public readonly kind = 'mcpServersStarting';

1385 >

1386 > public didStartServerIds?: string[] = [];

1387 >

1388 > public get isEmpty() {

1389 > const s = this.state.get();

1390 > return !s.working && s.serversRequiringInteraction.length === 0;

1391 > }

1392 >

1393 > constructor(public readonly state: IObservable<IAutostartResult>) { }

1394 >

1395 > wait() {

1396 return new Promise<IAutostartResult>(resolve => {

1397 autorunSelfDisposable(reader => {

1404 });

1405 }

1406 > chatService.ts

1407 > toJSON(): IChatMcpServersStartingSerialized {

1408 return { kind: 'mcpServersStarting', didStartServerIds: this.didStartServerIds };

1409 }

1410 > } chatService.ts

1411 >

1412 > export type IChatProgress =

1413 > | IChatMarkdownContent

1414 > | IChatAgentMarkdownContentWithVulnerability

1415 > | IChatUsage

1416 > | IChatTreeData

1417 > | IChatMultiDiffData

1418 > | IChatMultiDiffDataSerialized

1419 > | IChatUsedContext

1420 > | IChatContentReference

1421 > | IChatContentInlineReference

1422 > | IChatCodeCitation

1423 > | IChatProgressMessage

1424 > | IChatSystemNotificationPart

1425 > | IChatTask

1426 > | IChatTaskResult

1427 > | IChatCommandButton

1428 > | IChatWarningMessage

1429 > | IChatInfoMessage

1430 > | IChatTextEdit

1431 > | IChatNotebookEdit

1432 > | IChatWorkspaceEdit

1433 > | IChatExternalEdit

1434 > | IChatMoveMessage

1435 > | IChatResponseCodeblockUriPart

1436 > | IChatConfirmation

1437 > | IChatQuestionCarousel

1438 > | IChatPlanReview

1439 > | IChatClearToPreviousToolInvocation

1440 > | IChatToolInvocation

1441 > | IChatToolInvocationSerialized

1442 > | IChatExtensionsContent

1443 > | IChatPullRequestContent

1444 > | IChatUndoStop

1445 > | IChatThinkingPart

1446 > | IChatTaskSerialized

1447 > | IChatElicitationRequest

1448 > | IChatElicitationRequestSerialized

1449 > | IChatMcpServersStarting

1450 > | IChatMcpServersStartingSerialized

1451 > | IChatMcpAuthenticationRequired

1452 > | IChatMcpServersStartingSlow

1453 > | IChatHookPart

1454 > | IChatExternalToolInvocationUpdate

1455 > | IChatDisabledClaudeHooksPart

1456 > | IChatAutoModeResolutionPart;

1457 >

1458 > export interface IChatFollowup {

1459 > kind: 'reply';

1460 > message: string;

1461 > agentId: string;

1462 > subCommand?: string;

1463 > title?: string;

1464 > tooltip?: string;

1465 > }

1466 >

1467 > export function isChatFollowup(obj: unknown): obj is IChatFollowup {

1468 return (

1469 !!obj &&

1473 );

1474 }

1475 > chatService.ts

1476 > export enum ChatAgentVoteDirection {

1477 > Down = 0,

1478 > Up = 1

1479 > }

1480 >

1481 > export interface IChatVoteAction {

1482 > kind: 'vote';

1483 > direction: ChatAgentVoteDirection;

1484 > }

1485 >

1486 > export enum ChatCopyKind {

1487 > // Keyboard shortcut or context menu

1488 > Action = 1,

1489 > Toolbar = 2

1490 > }

1491 >

1492 > export interface IChatCopyAction {

1493 > kind: 'copy';

1494 > codeBlockIndex: number;

1495 > copyKind: ChatCopyKind;

1496 > copiedCharacters: number;

1497 > totalCharacters: number;

1498 > copiedText: string;

1499 > totalLines: number;

1500 > copiedLines: number;

1501 > modelId: string;

1502 > languageId?: string;

1503 > }

1504 >

1505 > export interface IChatInsertAction {

1506 > kind: 'insert';

1507 > codeBlockIndex: number;

1508 > totalCharacters: number;

1509 > totalLines: number;

1510 > languageId?: string;

1511 > modelId: string;

1512 > newFile?: boolean;

1513 > }

1514 >

1515 > export interface IChatApplyAction {

1516 > kind: 'apply';

1517 > codeBlockIndex: number;

1518 > totalCharacters: number;

1519 > totalLines: number;

1520 > languageId?: string;

1521 > modelId: string;

1522 > newFile?: boolean;

1523 > codeMapper?: string;

1524 > editsProposed: boolean;

1525 > }

1526 >

1527 >

1528 > export interface IChatTerminalAction {

1529 > kind: 'runInTerminal';

1530 > codeBlockIndex: number;

1531 > languageId?: string;

1532 > }

1533 >

1534 > export interface IChatCommandAction {

1535 > kind: 'command';

1536 > commandButton: IChatCommandButton;

1537 > }

1538 >

1539 > export interface IChatFollowupAction {

1540 > kind: 'followUp';

1541 > followup: IChatFollowup;

1542 > }

1543 >

1544 > export interface IChatBugReportAction {

1545 > kind: 'bug';

1546 > }

1547 >

1548 > export interface IChatInlineChatCodeAction {

1549 > kind: 'inlineChat';

1550 > action: 'accepted' | 'discarded';

1551 > }

1552 >

1553 >

1554 > export interface IChatEditingSessionAction {

1555 > kind: 'chatEditingSessionAction';

1556 > uri: URI;

1557 > hasRemainingEdits: boolean;

1558 > outcome: 'accepted' | 'rejected' | 'userModified';

1559 > }

1560 >

1561 > export interface IChatEditingHunkAction {

1562 > kind: 'chatEditingHunkAction';

1563 > uri: URI;

1564 > lineCount: number;

1565 > linesAdded: number;

1566 > linesRemoved: number;

1567 > outcome: 'accepted' | 'rejected';

1568 > hasRemainingEdits: boolean;

1569 > modeId?: string;

1570 > modelId?: string;

1571 > languageId?: string;

1572 > }

1573 >

1574 > export type ChatUserAction = IChatVoteAction | IChatCopyAction | IChatInsertAction | IChatApplyAction | IChatTerminalAction | IChatCommandAction | IChatFollowupAction | IChatBugReportAction | IChatInlineChatCodeAction | IChatEditingSessionAction | IChatEditingHunkAction;

1575 >

1576 > export interface IChatUserActionEvent {

1577 > action: ChatUserAction;

1578 > agentId: string | undefined;

1579 > command: string | undefined;

1580 > sessionResource: URI;

1581 > requestId: string;

1582 > result: IChatAgentResult | undefined;

1583 > modelId?: string | undefined;

1584 > modeId?: string | undefined;

1585 > }

1586 >

1587 > export interface IChatDynamicRequest {

1588 > /**

1589 > * The message that will be displayed in the UI

1590 > */

1591 > message: string;

1592 >

1593 > /**

1594 > * Any extra metadata/context that will go to the provider.

1595 > */

1596 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

1597 > metadata?: any;

1598 > }

1599 >

1600 > export interface IChatCompleteResponse {

1601 > message: string | ReadonlyArray<IChatProgress>;

1602 > result?: IChatAgentResult;

1603 > followups?: IChatFollowup[];

1604 > }

1605 >

1606 > export interface IChatSessionStats {

1607 > readonly fileCount: number;

1608 > readonly added: number;

1609 > readonly removed: number;

1610 > }

1611 >

1612 > export type IChatSessionTiming = {

1613 > /**

1614 > * Timestamp when the session was created in milliseconds elapsed since January 1, 1970 00:00:00 UTC.

1615 > */

1616 > readonly created: number;

1617 >

1618 > /**

1619 > * Timestamp when the most recent request started in milliseconds elapsed since January 1, 1970 00:00:00 UTC.

1620 > *

1621 > * Should be undefined if no requests have been made yet.

1622 > */

1623 > readonly lastRequestStarted: number | undefined;

1624 >

1625 > /**

1626 > * Timestamp when the most recent request completed in milliseconds elapsed since January 1, 1970 00:00:00 UTC.

1627 > *

1628 > * Should be undefined if the most recent request is still in progress or if no requests have been made yet.

1629 > */

1630 > readonly lastRequestEnded: number | undefined;

1631 > };

1632 >

1633 > interface ILegacyChatSessionTiming {

1634 > readonly startTime: number;

1635 > readonly endTime?: number;

1636 > }

1637 >

1638 > export function convertLegacyChatSessionTiming(timing: IChatSessionTiming | ILegacyChatSessionTiming): IChatSessionTiming {

1639 if (hasKey(timing, { created: true })) {

1640 return timing;

1646 };

1647 }

1648 > chatService.ts

1649 > export const enum ResponseModelState {

1650 > Pending,

1651 > Complete,

1652 > Cancelled,

1653 > Failed,

1654 > NeedsInput,

1655 > }

1656 >

1657 > export interface IChatDetail {

1658 > sessionResource: URI;

1659 > title: string;

1660 > lastMessageDate: number;

1661 > // Also support old timing format for backwards compatibility with persisted data

1662 > timing: IChatSessionTiming | ILegacyChatSessionTiming;

1663 > isActive: boolean;

1664 > stats?: IChatSessionStats;

1665 > lastResponseState: ResponseModelState;

1666 > /**

1667 > * The working directory URI associated with this session.

1668 > * Only populated in the sessions/agents window context.

1669 > */

1670 > workingDirectory?: URI;

1671 > }

1672 >

1673 > export interface IChatProviderInfo {

1674 > id: string;

1675 > }

1676 >

1677 > export interface IChatSendRequestResponseState {

1678 > responseCreatedPromise: Promise<IChatResponseModel>;

1679 > responseCompletePromise: Promise<void>;

1680 > }

1681 >

1682 > export interface IChatSendRequestData extends IChatSendRequestResponseState {

1683 > agent: IChatAgentData;

1684 > slashCommand?: IChatAgentCommand;

1685 > }

1686 >

1687 > /**

1688 > * Result of a sendRequest call - a discriminated union of possible outcomes.

1689 > */

1690 > export type ChatSendResult =

1691 > | ChatSendResultRejected

1692 > | ChatSendResultSent

1693 > | ChatSendResultQueued;

1694 >

1695 > export interface ChatSendResultRejected {

1696 > readonly kind: 'rejected';

1697 > readonly reason: string;

1698 > /** Set when the session was replaced before the request was rejected (e.g. untitled -> read-only contributed session). */

1699 > readonly newSessionResource?: URI;

1700 > }

1701 >

1702 > export interface ChatSendResultSent {

1703 > readonly kind: 'sent';

1704 > readonly data: IChatSendRequestData;

1705 > /** Set when the session was replaced by a new one (e.g. untitled -> real contributed session). */

1706 > readonly newSessionResource?: URI;

1707 > }

1708 >

1709 > export interface ChatSendResultQueued {

1710 > readonly kind: 'queued';

1711 > /**

1712 > * Promise that resolves when the queued message is actually processed.

1713 > * Will resolve to a 'sent' or 'rejected' result.

1714 > */

1715 > readonly deferred: Promise<ChatSendResult>;

1716 > }

1717 >

1718 > export namespace ChatSendResult {

1719 > export function isSent(result: ChatSendResult): result is ChatSendResultSent {

1720 return result.kind === 'sent';

1721 }

1722 > chatService.ts

1723 > export function isRejected(result: ChatSendResult): result is ChatSendResultRejected {

1724 return result.kind === 'rejected';

1725 }

1726 > chatService.ts

1727 > export function isQueued(result: ChatSendResult): result is ChatSendResultQueued {

1728 return result.kind === 'queued';

1729 }

1730 > chatService.ts

1731 > /** Assertion function for tests - asserts that the result is a sent result */

1732 > export function assertSent(result: ChatSendResult): asserts result is ChatSendResultSent {

1733 if (result.kind !== 'sent') {

1734 throw new Error(`Expected ChatSendResult to be 'sent', but was '${result.kind}'`);

1735 }

1736 }

1737 > } chatService.ts

1738 >

1739 > export interface IChatEditorLocationData {

1740 > type: ChatAgentLocation.EditorInline;

1741 > id: string;

1742 > document: URI;

1743 > selection: ISelection;

1744 > wholeRange: IRange;

1745 > }

1746 >

1747 > export interface IChatNotebookLocationData {

1748 > type: ChatAgentLocation.Notebook;

1749 > sessionInputUri: URI;

1750 > }

1751 >

1752 > export interface IChatTerminalLocationData {

1753 > type: ChatAgentLocation.Terminal;

1754 > // TBD

1755 > }

1756 >

1757 > export type IChatLocationData = IChatEditorLocationData | IChatNotebookLocationData | IChatTerminalLocationData;

1758 >

1759 > /**

1760 > * The kind of queue request.

1761 > */

1762 > export const enum ChatRequestQueueKind {

1763 > /** Request is queued to be sent after current request completes */

1764 > Queued = 'queued',

1765 > /** Request is queued and signals the active request to yield */

1766 > Steering = 'steering'

1767 > }

1768 >

1769 > /**

1770 > * A queued or steering message that was authored outside of this client, e.g.

1771 > * by another window connected to the same server-managed session.

1772 > */

1773 > export interface IRemotePendingRequest {

1774 > /** Stable id of the message, as known by the server. */

1775 > readonly id: string;

1776 > readonly kind: ChatRequestQueueKind;

1777 > /** The raw message text. */

1778 > readonly message: string;

1779 > readonly variableData?: IChatRequestVariableData;

1780 > readonly timestamp?: number;

1781 > }

1782 >

1783 > export interface IChatSendRequestOptions {

1784 > modeInfo?: IChatRequestModeInfo;

1785 > userSelectedModelId?: string;

1786 > /**

1787 > * The configuration (e.g. context size, thinking effort) for the selected

1788 > * model as scoped to the requesting editor. When set, it takes precedence

1789 > * over the global per-model configuration so the value sent matches what the

1790 > * editor displays. See issue #320393.

1791 > */

1792 > userSelectedModelConfiguration?: IStringDictionary<unknown>;

1793 > userSelectedTools?: IObservable<UserSelectedTools>;

1794 > location?: ChatAgentLocation;

1795 > locationData?: IChatLocationData;

1796 > parserContext?: IChatParserContext;

1797 > attempt?: number;

1798 > noCommandDetection?: boolean;

1799 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

1800 > acceptedConfirmationData?: any[];

1801 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

1802 > rejectedConfirmationData?: any[];

1803 > attachedContext?: IChatRequestVariableEntry[];

1804 > resolvedVariables?: IChatRequestVariableEntry[];

1805 > agentHostSessionConfig?: Record<string, unknown>;

1806 >

1807 > /** The target agent ID can be specified with this property instead of using @ in 'message' */

1808 > agentId?: string;

1809 > /** agentId, but will not add a @ name to the request */

1810 > agentIdSilent?: string;

1811 > slashCommand?: string;

1812 >

1813 > /**

1814 > * The label of the confirmation action that was selected.

1815 > */

1816 > confirmation?: string;

1817 >

1818 > /**

1819 > * When set, queues this message to be sent after the current request completes.

1820 > * If Steering, also sets yieldRequested on any active request to signal it should wrap up.

1821 > */

1822 > queue?: ChatRequestQueueKind;

1823 >

1824 > /**

1825 > * When true, the queued request will not be processed immediately even if no request is active.

1826 > * The request stays in the queue until `processPendingRequests` is called explicitly.

1827 > */

1828 > pauseQueue?: boolean;

1829 >

1830 > /**

1831 > * When true, the request is rendered as a compact tool-progress-style line

1832 > * instead of a full user message bubble. Used for system-initiated notifications

1833 > * such as terminal command completion.

1834 > */

1835 > isSystemInitiated?: boolean;

1836 >

1837 > /**

1838 > * Display label for system-initiated requests. When set, the request row renders

1839 > * this label as a compact progress-style message instead of the full request text.

1840 > */

1841 > systemInitiatedLabel?: string;

1842 >

1843 > /**

1844 > * Structured terminal execution ID for system-initiated terminal notifications.

1845 > * This avoids parsing IDs from request text when tools need to correlate

1846 > * terminal prompts with follow-up actions.

1847 > */

1848 > terminalExecutionId?: string;

1849 >

1850 > /**

1851 > * When set, the chat service will collect automatic instructions

1852 > * (for example `.instructions.md` files and skills) asynchronously after showing

1853 > * the request in the UI, rather than blocking the UI on collection.

1854 > */

1855 > instructionContext?: {

1856 > modeKind: ChatModeKind;

1857 > enabledTools?: UserSelectedTools;

1858 > enabledSubAgents?: readonly string[];

1859 > };

1860 > }

1861 >

1862 > export type IChatModelReference = IReference<IChatModel>;

1863 >

1864 > export const IChatService = createDecorator<IChatService>('IChatService');

1865 >

1866 > export interface IChatService {

1867 > _serviceBrand: undefined;

1868 > transferredSessionResource: URI | undefined;

1869 >

1870 > readonly onDidSubmitRequest: Event<{ readonly chatSessionResource: URI; readonly message?: IParsedChatRequest }>;

1871 >

1872 > readonly onDidCreateModel: Event<IChatModel>;

1873 >

1874 > /**

1875 > * An observable containing all live chat models.

1876 > */

1877 > readonly chatModels: IObservable<Iterable<IChatModel>>;

1878 >

1879 > readonly editingSessions: readonly IChatEditingSession[];

1880 >

1881 > isEnabled(location: ChatAgentLocation): boolean;

1882 >

1883 > hasSessions(): boolean;

1884 >

1885 > /**

1886 > * Starts a new chat session at the given location.

1887 > *

1888 > * @returns A reference to the session's model.

1889 > */

1890 > startNewLocalSession(location: ChatAgentLocation, options?: IChatSessionStartOptions): IChatModelReference;

1891 >

1892 > /**

1893 > * Get an active session without holding a reference to it.

1894 > *

1895 > * @returns The session's model, or undefined if no active session exists.

1896 > */

1897 > getSession(sessionResource: URI): IChatModel | undefined;

1898 >

1899 > /**

1900 > * Acquire a reference to an active session.

1901 > *

1902 > * @returns A reference to the session's model or undefined if there is no active session for the given resource.

1903 > */

1904 > acquireExistingSession(sessionResource: URI, debugOwner?: string): IChatModelReference | undefined;

1905 >

1906 > /**

1907 > * Tries to acquire an existing a chat session for the resource. If no session exists, tries to load one for the given

1908 > * session resource and location. This may load the session from an external provider.

1909 > *

1910 > * @returns A reference to the session's model, or undefined if the session could not be loaded

1911 > */

1912 > acquireOrLoadSession(sessionResource: URI, location: ChatAgentLocation, token: CancellationToken, debugOwner?: string): Promise<IChatModelReference | undefined>;

1913 >

1914 > /**

1915 > * Loads a session from exported chat data

1916 > */

1917 > loadSessionFromData(data: IExportableChatData | ISerializableChatData, debugOwner?: string): IChatModelReference;

1918 >

1919 > getChatModelReferenceDebugInfo(): IChatModelReferenceDebugSnapshot;

1920 >

1921 > /**

1922 > * Sends a chat request for the given session.

1923 > * @returns A result indicating whether the request was sent, queued, or rejected.

1924 > */

1925 > sendRequest(sessionResource: URI, message: string, options?: IChatSendRequestOptions): Promise<ChatSendResult>;

1926 >

1927 > getSessionTitle(sessionResource: URI): string | undefined;

1928 > setSessionTitle(sessionResource: URI, title: string): void;

1929 >

1930 > appendProgress(request: IChatRequestModel, progress: IChatProgress): void;

1931 > resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;

1932 > adoptRequest(sessionResource: URI, request: IChatRequestModel): Promise<void>;

1933 > removeRequest(sessionResource: URI, requestId: string): Promise<void>;

1934 > cancelCurrentRequestForSession(sessionResource: URI, source?: string): Promise<void>;

1935 > /**

1936 > * Migrates all in-flight and queued pending requests from one session to another.

1937 > * Cancels the in-flight request on the original session, removes queued requests,

1938 > * and re-sends them all on the target session preserving their original send options.

1939 > */

1940 > migrateRequests(originalResource: URI, targetResource: URI): void;

1941 > /**

1942 > * Sets yieldRequested on the active request for the given session.

1943 > */

1944 > setYieldRequested(sessionResource: URI): void;

1945 > /**

1946 > * Removes a pending request from the session's queue.

1947 > */

1948 > removePendingRequest(sessionResource: URI, requestId: string): void;

1949 > /**

1950 > * Sets the pending requests for a session, allowing for deletions/reordering.

1951 > * Adding new requests should go through sendRequest with the queue option.

1952 > */

1953 > setPendingRequests(sessionResource: URI, requests: readonly { requestId: string; kind: ChatRequestQueueKind }[]): void;

1954 > /**

1955 > * Atomically reconciles the pending queue with messages authored by another client.

1956 > * Preserves remote ids and existing matching requests, and no-ops when already equal.

1957 > */

1958 > syncPendingRequestsFromRemote(sessionResource: URI, requests: readonly IRemotePendingRequest[]): void;

1959 > /**

1960 > * Ensures pending requests for the session are processing. If restoring from

1961 > * storage or after an error, pending requests may be present without an

1962 > * active chat message 'loop' happening. THis triggers the loop to happen

1963 > * as needed. Idempotent, safe to call at any time.

1964 > */

1965 > processPendingRequests(sessionResource: URI): void;

1966 > /**

1967 > * Cancels the in-flight request and immediately sends a single pending

1968 > * (queued or steering) request. Local sessions move it to the front and

1969 > * dequeue it; server-managed (agent host) sessions re-send it as a normal

1970 > * turn, since the server does not drain its queue on cancellation.

1971 > */

1972 > sendPendingRequestImmediately(sessionResource: URI, requestId: string): Promise<void>;

1973 > addCompleteRequest(sessionResource: URI, message: IParsedChatRequest | string, variableData: IChatRequestVariableData | undefined, attempt: number | undefined, response: IChatCompleteResponse): void;

1974 > setChatSessionTitle(sessionResource: URI, title: string): void;

1975 > getLocalSessionHistory(): Promise<IChatDetail[]>;

1976 > clearAllHistoryEntries(): Promise<void>;

1977 > removeHistoryEntry(sessionResource: URI): Promise<void>;

1978 > getChatStorageFolder(): URI;

1979 > logChatIndex(): void;

1980 > getLiveSessionItems(): Promise<IChatDetail[]>;

1981 > getHistorySessionItems(): Promise<IChatDetail[]>;

1982 > getMetadataForSession(sessionResource: URI): Promise<IChatDetail | undefined>;

1983 >

1984 > readonly onDidPerformUserAction: Event<IChatUserActionEvent>;

1985 > notifyUserAction(event: IChatUserActionEvent): void;

1986 >

1987 > readonly onDidReceiveQuestionCarouselAnswer: Event<{ requestId: string; resolveId: string; answers: IChatQuestionAnswers | undefined }>;

1988 > notifyQuestionCarouselAnswer(requestId: string, resolveId: string, answers: IChatQuestionAnswers | undefined): void;

1989 >

1990 > readonly onDidDisposeSession: Event<{ readonly sessionResources: readonly URI[]; readonly reason: 'cleared' }>;

1991 >

1992 > transferChatSession(transferredSessionResource: URI, toWorkspace: URI): Promise<void>;

1993 >

1994 > activateDefaultAgent(location: ChatAgentLocation): Promise<void>;

1995 >

1996 > readonly requestInProgressObs: IObservable<boolean>;

1997 >

1998 > /**

1999 > * For tests only!

2000 > */

2001 > setSaveModelsEnabled(enabled: boolean): void;

2002 >

2003 > /**

2004 > * For tests only!

2005 > */

2006 > waitForModelDisposals(): Promise<void>;

2007 > }

2008 >

2009 > export interface IChatSessionContext {

2010 > readonly initialSessionOptions?: ReadonlyChatSessionOptionsMap;

2011 > }

2012 >

2013 > export const KEYWORD_ACTIVIATION_SETTING_ID = 'accessibility.voice.keywordActivation';

2014 >

2015 > export interface IChatSessionStartOptions {

2016 > canUseTools?: boolean;

2017 > disableBackgroundKeepAlive?: boolean;

2018 > debugOwner?: string;

2019 > }

2020 >

2021 > export const ChatStopCancellationNoopEventName = 'chat.stopCancellationNoop';

2022 >

2023 > export type ChatStopCancellationNoopEvent = {

2024 > source: string;

2025 > reason: 'noWidget' | 'noViewModel' | 'noPendingRequest' | 'requestAlreadyCanceled' | 'requestIdUnavailable';

2026 > requestInProgress: 'true' | 'false' | 'unknown';

2027 > pendingRequests: number;

2028 > sessionScheme?: string;

2029 > lastRequestId?: string;

2030 > chatSessionId?: string;

2031 > };

2032 >

2033 > export type ChatStopCancellationNoopClassification = {

2034 > source: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The layer where stop cancellation no-op occurred.' };

2035 > reason: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The no-op reason when stop cancellation did not dispatch fully.' };

2036 > requestInProgress: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether request-in-progress was true, false, or unknown at no-op time.' };

2037 > pendingRequests: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The number of queued pending requests at no-op time when known.'; isMeasurement: true };

2038 > sessionScheme?: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The URI scheme of the session resource (e.g. vscodeLocalChatSession vs remote).' };

2039 > lastRequestId?: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The ID of the last request in the session, for correlating with tool invocations.' };

2040 > chatSessionId?: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The chat session ID.' };

2041 > owner: 'roblourens';

2042 > comment: 'Tracks possible no-op stop cancellation paths.';

2043 > };

2044 >

2045 > export const ChatPendingRequestChangeEventName = 'chat.pendingRequestChange';

2046 >

2047 > export type ChatPendingRequestChangeEvent = {

2048 > action: 'add' | 'remove' | 'notCancelable';

2049 > source: string;

2050 > requestId?: string;

2051 > chatSessionId?: string;

2052 > };

2053 >

2054 > export type ChatPendingRequestChangeClassification = {

2055 > action: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether a pending request was added or removed.' };

2056 > source: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The method that triggered the pending request change.' };

2057 > requestId?: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The request ID associated with the pending request change.' };

2058 > chatSessionId?: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The chat session ID.' };

2059 > owner: 'roblourens';

2060 > comment: 'Tracks pending request lifecycle changes in the chat service.';

2061 > };

src/vs/workbench/common/editor.ts 1397 covered LOC · 36 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- editor.ts

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

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

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)) {

384 return undefined;

385 }

386 > editor.ts

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

631 return URI.isUri(candidate?.resource);

632 }

633 > editor.ts

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

641 return candidate?.original !== undefined && candidate.modified !== undefined;

642 }

643 > editor.ts

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

657 return !!candidate.resources || !!candidate.multiDiffSource;

658 }

659 > editor.ts

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

671 return candidate?.primary !== undefined && candidate.secondary !== undefined;

672 }

673 > editor.ts

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

684 return candidate.resource === undefined || candidate.resource.scheme === Schemas.untitled || candidate.forceUntitled === true;

685 }

686 > editor.ts

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

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

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) {

748 return sourceDescriptor.source;

749 }

750 > editor.ts

751 > getSourceLabel(source: SaveSource): string {

752 return this.mapIdToSaveSource.get(source)?.label ?? source;

753 }

754 > } editor.ts

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

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;

928 return URI.isUri(candidate?.preferredResource);

929 }

930 > editor.ts

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

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

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({

1073 });

1074 }

1075 > editor.ts

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

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

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

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

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;

1443 return this.filterUri(originalResource, options.filterByScheme);

1444 }

1445 > editor.ts

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 };

1455 return { primary: undefined, secondary: undefined };

1456 }

1457 > editor.ts

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;

1512 return this.filterUri(canonicalResource, options.filterByScheme);

1513 }

1514 > editor.ts

1515 > private filterUri(resource: URI, filter: string | string[]): URI | undefined {

1516

1517 // Multiple scheme filter

1531 return undefined;

1532 }

1533 > } editor.ts

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

1554 return false;

1555 }

1556 > editor.ts

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

1595 this.editorSerializerConstructors.clear();

1596 }

1597 > editor.ts

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

1603 > registerFileEditorFactory(factory: IFileEditorFactory): void {

1604 if (this.fileEditorFactory) {

1605 throw new Error('Can only register one file editor factory.');

1608 this.fileEditorFactory = factory;

1609 }

1610 > editor.ts

1611 > getFileEditorFactory(): IFileEditorFactory {

1612 return assertReturnsDefined(this.fileEditorFactory);

1613 }

1614 > editor.ts

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.`);

1629 });

1630 }

1631 > editor.ts

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

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) {

1691 }));

1692 }

1693 > editor.ts

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) {

1720 return !!(codeEditorViewState.contributionsState && codeEditorViewState.viewState && Array.isArray(codeEditorViewState.cursorState));

1721 }

1722 > editor.ts

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

1752 > export function createEditorOpenError(messageOrError: string | Error, actions: IAction[], options?: IEditorOpenErrorOptions): IEditorOpenError {

1753 const error: IEditorOpenError = createErrorWithActions(messageOrError, actions);

1754

1759 return error;

1760 }

1761 > editor.ts

1762 > export interface IToolbarActions {

1763 > readonly primary: IAction[];

1764 > readonly secondary: IAction[];

1765 > }

src/vs/platform/files/common/files.ts 1360 covered LOC · 44 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- files.ts

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 { VSBuffer, VSBufferReadable, VSBufferReadableStream } from '../../../base/common/buffer.js';

7 > import { CancellationToken } from '../../../base/common/cancellation.js';

8 > import { Event } from '../../../base/common/event.js';

9 > import { IExpression, IRelativePattern } from '../../../base/common/glob.js';

10 > import { IDisposable } from '../../../base/common/lifecycle.js';

11 > import { TernarySearchTree } from '../../../base/common/ternarySearchTree.js';

12 > import { sep } from '../../../base/common/path.js';

13 > import { ReadableStreamEvents } from '../../../base/common/stream.js';

14 > import { startsWithIgnoreCase } from '../../../base/common/strings.js';

15 > import { isNumber } from '../../../base/common/types.js';

16 > import { URI } from '../../../base/common/uri.js';

17 > import { localize } from '../../../nls.js';

18 > import { createDecorator } from '../../instantiation/common/instantiation.js';

19 > import { isWeb } from '../../../base/common/platform.js';

20 > import { Schemas } from '../../../base/common/network.js';

21 > import { IMarkdownString } from '../../../base/common/htmlContent.js';

22 > import { Lazy } from '../../../base/common/lazy.js';

23 >

24 > //#region file service & providers

25 >

26 > export const IFileService = createDecorator<IFileService>('fileService');

27 >

28 > export interface IFileService {

29 >

30 > readonly _serviceBrand: undefined;

31 >

32 > /**

33 > * An event that is fired when a file system provider is added or removed

34 > */

35 > readonly onDidChangeFileSystemProviderRegistrations: Event<IFileSystemProviderRegistrationEvent>;

36 >

37 > /**

38 > * An event that is fired when a registered file system provider changes its capabilities.

39 > */

40 > readonly onDidChangeFileSystemProviderCapabilities: Event<IFileSystemProviderCapabilitiesChangeEvent>;

41 >

42 > /**

43 > * An event that is fired when a file system provider is about to be activated. Listeners

44 > * can join this event with a long running promise to help in the activation process.

45 > */

46 > readonly onWillActivateFileSystemProvider: Event<IFileSystemProviderActivationEvent>;

47 >

48 > /**

49 > * Registers a file system provider for a certain scheme.

50 > */

51 > registerProvider(scheme: string, provider: IFileSystemProvider): IDisposable;

52 >

53 > /**

54 > * Returns a file system provider for a certain scheme.

55 > */

56 > getProvider(scheme: string): IFileSystemProvider | undefined;

57 >

58 > /**

59 > * Tries to activate a provider with the given scheme.

60 > */

61 > activateProvider(scheme: string): Promise<void>;

62 >

63 > /**

64 > * Checks if this file service can handle the given resource by

65 > * first activating any extension that wants to be activated

66 > * on the provided resource scheme to include extensions that

67 > * contribute file system providers for the given resource.

68 > */

69 > canHandleResource(resource: URI): Promise<boolean>;

70 >

71 > /**

72 > * Checks if the file service has a registered provider for the

73 > * provided resource.

74 > *

75 > * Note: this does NOT account for contributed providers from

76 > * extensions that have not been activated yet. To include those,

77 > * consider to call `await fileService.canHandleResource(resource)`.

78 > */

79 > hasProvider(resource: URI): boolean;

80 >

81 > /**

82 > * Checks if the provider for the provided resource has the provided file system capability.

83 > */

84 > hasCapability(resource: URI, capability: FileSystemProviderCapabilities): boolean;

85 >

86 > /**

87 > * List the schemes and capabilities for registered file system providers

88 > */

89 > listCapabilities(): Iterable<{ scheme: string; capabilities: FileSystemProviderCapabilities }>;

90 >

91 > /**

92 > * Allows to listen for file changes. The event will fire for every file within the opened workspace

93 > * (if any) as well as all files that have been watched explicitly using the #watch() API.

94 > */

95 > readonly onDidFilesChange: Event<FileChangesEvent>;

96 >

97 > /**

98 > * An event that is fired upon successful completion of a certain file operation.

99 > */

100 > readonly onDidRunOperation: Event<FileOperationEvent>;

101 >

102 > /**

103 > * Resolve the properties of a file/folder identified by the resource. For a folder, children

104 > * information is resolved as well depending on the provided options. Use `stat()` method if

105 > * you do not need children information.

106 > *

107 > * If the optional parameter "resolveTo" is specified in options, the stat service is asked

108 > * to provide a stat object that should contain the full graph of folders up to all of the

109 > * target resources.

110 > *

111 > * If the optional parameter "resolveSingleChildDescendants" is specified in options,

112 > * the stat service is asked to automatically resolve child folders that only

113 > * contain a single element.

114 > *

115 > * If the optional parameter "resolveMetadata" is specified in options,

116 > * the stat will contain metadata information such as size, mtime and etag.

117 > */

118 > resolve(resource: URI, options: IResolveMetadataFileOptions): Promise<IFileStatWithMetadata>;

119 > resolve(resource: URI, options?: IResolveFileOptions): Promise<IFileStat>;

120 >

121 > /**

122 > * Same as `resolve()` but supports resolving multiple resources in parallel.

123 > *

124 > * If one of the resolve targets fails to resolve returns a fake `IFileStat` instead of

125 > * making the whole call fail.

126 > */

127 > resolveAll(toResolve: { resource: URI; options: IResolveMetadataFileOptions }[]): Promise<IFileStatResult[]>;

128 > resolveAll(toResolve: { resource: URI; options?: IResolveFileOptions }[]): Promise<IFileStatResult[]>;

129 >

130 > /**

131 > * Same as `resolve()` but without resolving the children of a folder if the

132 > * resource is pointing to a folder.

133 > */

134 > stat(resource: URI): Promise<IFileStatWithPartialMetadata>;

135 >

136 > /**

137 > * Attempts to resolve the real path of the provided resource. The real path can be

138 > * different from the resource path for example when it is a symlink.

139 > *

140 > * Will return `undefined` if the real path cannot be resolved.

141 > */

142 > realpath(resource: URI): Promise<URI | undefined>;

143 >

144 > /**

145 > * Finds out if a file/folder identified by the resource exists.

146 > */

147 > exists(resource: URI): Promise<boolean>;

148 >

149 > /**

150 > * Read the contents of the provided resource unbuffered.

151 > */

152 > readFile(resource: URI, options?: IReadFileOptions, token?: CancellationToken): Promise<IFileContent>;

153 >

154 > /**

155 > * Read the contents of the provided resource buffered as stream.

156 > */

157 > readFileStream(resource: URI, options?: IReadFileStreamOptions, token?: CancellationToken): Promise<IFileStreamContent>;

158 >

159 > /**

160 > * Updates the content replacing its previous value.

161 > * If `options.append` is true, appends content to the end of the file instead.

162 > *

163 > * Emits a `FileOperation.WRITE` file operation event when successful.

164 > */

165 > writeFile(resource: URI, bufferOrReadableOrStream: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: IWriteFileOptions): Promise<IFileStatWithMetadata>;

166 >

167 > /**

168 > * Moves the file/folder to a new path identified by the resource.

169 > *

170 > * The optional parameter overwrite can be set to replace an existing file at the location.

171 > *

172 > * Emits a `FileOperation.MOVE` file operation event when successful.

173 > */

174 > move(source: URI, target: URI, overwrite?: boolean): Promise<IFileStatWithMetadata>;

175 >

176 > /**

177 > * Find out if a move operation is possible given the arguments. No changes on disk will

178 > * be performed. Returns an Error if the operation cannot be done.

179 > */

180 > canMove(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;

181 >

182 > /**

183 > * Copies the file/folder to a path identified by the resource. A folder is copied

184 > * recursively.

185 > *

186 > * Emits a `FileOperation.COPY` file operation event when successful.

187 > */

188 > copy(source: URI, target: URI, overwrite?: boolean): Promise<IFileStatWithMetadata>;

189 >

190 > /**

191 > * Find out if a copy operation is possible given the arguments. No changes on disk will

192 > * be performed. Returns an Error if the operation cannot be done.

193 > */

194 > canCopy(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;

195 >

196 > /**

197 > * Clones a file to a path identified by the resource. Folders are not supported.

198 > *

199 > * If the target path exists, it will be overwritten.

200 > */

201 > cloneFile(source: URI, target: URI): Promise<void>;

202 >

203 > /**

204 > * Creates a new file with the given path and optional contents. The returned promise

205 > * will have the stat model object as a result.

206 > *

207 > * The optional parameter content can be used as value to fill into the new file.

208 > *

209 > * Emits a `FileOperation.CREATE` file operation event when successful.

210 > */

211 > createFile(resource: URI, bufferOrReadableOrStream?: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: ICreateFileOptions): Promise<IFileStatWithMetadata>;

212 >

213 > /**

214 > * Find out if a file create operation is possible given the arguments. No changes on disk will

215 > * be performed. Returns an Error if the operation cannot be done.

216 > */

217 > canCreateFile(resource: URI, options?: ICreateFileOptions): Promise<Error | true>;

218 >

219 > /**

220 > * Creates a new folder with the given path. The returned promise

221 > * will have the stat model object as a result.

222 > *

223 > * Emits a `FileOperation.CREATE` file operation event when successful.

224 > */

225 > createFolder(resource: URI): Promise<IFileStatWithMetadata>;

226 >

227 > /**

228 > * Deletes the provided file. The optional useTrash parameter allows to

229 > * move the file to trash. The optional recursive parameter allows to delete

230 > * non-empty folders recursively.

231 > *

232 > * Emits a `FileOperation.DELETE` file operation event when successful.

233 > */

234 > del(resource: URI, options?: Partial<IFileDeleteOptions>): Promise<void>;

235 >

236 > /**

237 > * Find out if a delete operation is possible given the arguments. No changes on disk will

238 > * be performed. Returns an Error if the operation cannot be done.

239 > */

240 > canDelete(resource: URI, options?: Partial<IFileDeleteOptions>): Promise<Error | true>;

241 >

242 > /**

243 > * An event that signals an error when watching for file changes.

244 > */

245 > readonly onDidWatchError: Event<Error>;

246 >

247 > /**

248 > * Allows to start a watcher that reports file/folder change events on the provided resource.

249 > *

250 > * The watcher runs correlated and thus, file events will be reported on the returned

251 > * `IFileSystemWatcher` and not on the generic `IFileService.onDidFilesChange` event.

252 > *

253 > * Note: only non-recursive file watching supports event correlation for now.

254 > */

255 > createWatcher(resource: URI, options: IWatchOptionsWithoutCorrelation & { recursive: false }): IFileSystemWatcher;

256 >

257 > /**

258 > * Allows to start a watcher that reports file/folder change events on the provided resource.

259 > *

260 > * The watcher runs uncorrelated and thus will report all events from `IFileService.onDidFilesChange`.

261 > * This means, most listeners in the application will receive your events. It is encouraged to

262 > * use correlated watchers (via `IWatchOptionsWithCorrelation`) to limit events to your listener.

263 > */

264 > watch(resource: URI, options?: IWatchOptionsWithoutCorrelation): IDisposable;

265 >

266 > /**

267 > * Frees up any resources occupied by this service.

268 > */

269 > dispose(): void;

270 > }

271 >

272 > export interface IFileOverwriteOptions {

273 >

274 > /**

275 > * Set to `true` to overwrite a file if it exists. Will

276 > * throw an error otherwise if the file does exist.

277 > */

278 > readonly overwrite: boolean;

279 > }

280 >

281 > export interface IFileUnlockOptions {

282 >

283 > /**

284 > * Set to `true` to try to remove any write locks the file might

285 > * have. A file that is write locked will throw an error for any

286 > * attempt to write to unless `unlock: true` is provided.

287 > */

288 > readonly unlock: boolean;

289 > }

290 >

291 > export interface IFileAtomicReadOptions {

292 >

293 > /**

294 > * The optional `atomic` flag can be used to make sure

295 > * the `readFile` method is not running in parallel with

296 > * any `write` operations in the same process.

297 > *

298 > * Typically you should not need to use this flag but if

299 > * for example you are quickly reading a file right after

300 > * a file event occurred and the file changes a lot, there

301 > * is a chance that a read returns an empty or partial file

302 > * because a pending write has not finished yet.

303 > *

304 > * Note: this does not prevent the file from being written

305 > * to from a different process. If you need such atomic

306 > * operations, you better use a real database as storage.

307 > */

308 > readonly atomic: boolean;

309 > }

310 >

311 > export interface IFileAtomicOptions {

312 >

313 > /**

314 > * The postfix is used to create a temporary file based

315 > * on the original resource. The resulting temporary

316 > * file will be in the same folder as the resource and

317 > * have `postfix` appended to the resource name.

318 > *

319 > * Example: given a file resource `file:///some/path/foo.txt`

320 > * and a postfix `.vsctmp`, the temporary file will be

321 > * created as `file:///some/path/foo.txt.vsctmp`.

322 > */

323 > readonly postfix: string;

324 > }

325 >

326 > export interface IFileAtomicWriteOptions {

327 >

328 > /**

329 > * The optional `atomic` flag can be used to make sure

330 > * the `writeFile` method updates the target file atomically

331 > * by first writing to a temporary file in the same folder

332 > * and then renaming it over the target.

333 > */

334 > readonly atomic: IFileAtomicOptions | false;

335 > }

336 >

337 > export interface IFileAtomicDeleteOptions {

338 >

339 > /**

340 > * The optional `atomic` flag can be used to make sure

341 > * the `delete` method deletes the target atomically by

342 > * first renaming it to a temporary resource in the same

343 > * folder and then deleting it.

344 > */

345 > readonly atomic: IFileAtomicOptions | false;

346 > }

347 >

348 > export interface IFileReadLimits {

349 >

350 > /**

351 > * If the file exceeds the given size, an error of kind

352 > * `FILE_TOO_LARGE` will be thrown.

353 > */

354 > size?: number;

355 > }

356 >

357 > export interface IFileReadStreamOptions {

358 >

359 > /**

360 > * Is an integer specifying where to begin reading from in the file. If position is undefined,

361 > * data will be read from the current file position.

362 > */

363 > readonly position?: number;

364 >

365 > /**

366 > * Is an integer specifying how many bytes to read from the file. By default, all bytes

367 > * will be read.

368 > */

369 > readonly length?: number;

370 >

371 > /**

372 > * If provided, the size of the file will be checked against the limits

373 > * and an error will be thrown if any limit is exceeded.

374 > */

375 > readonly limits?: IFileReadLimits;

376 > }

377 >

378 > export interface IFileWriteOptions extends IFileOverwriteOptions, IFileUnlockOptions, IFileAtomicWriteOptions {

379 >

380 > /**

381 > * Set to `true` to create a file when it does not exist. Will

382 > * throw an error otherwise if the file does not exist.

383 > */

384 > readonly create: boolean;

385 >

386 > /**

387 > * Set to `true` to append content to the end of the file. Implies `create: true`,

388 > * and set only when the corresponding `FileAppend` capability is defined.

389 > */

390 > readonly append?: boolean;

391 > }

392 >

393 > export type IFileOpenOptions = IFileOpenForReadOptions | IFileOpenForWriteOptions;

394 >

395 > export function isFileOpenForWriteOptions(options: IFileOpenOptions): options is IFileOpenForWriteOptions {

396 return options.create === true;

397 }

398 > files.ts

399 > export interface IFileOpenForReadOptions {

400 >

401 > /**

402 > * A hint that the file should be opened for reading only.

403 > */

404 > readonly create: false;

405 > }

406 >

407 > export interface IFileOpenForWriteOptions extends IFileUnlockOptions {

408 >

409 > /**

410 > * A hint that the file should be opened for reading and writing.

411 > */

412 > readonly create: true;

413 >

414 > /**

415 > * Open the file in append mode. This will write data to the

416 > * end of the file.

417 > */

418 > readonly append?: boolean;

419 > }

420 >

421 > export interface IFileDeleteOptions {

422 >

423 > /**

424 > * Set to `true` to recursively delete any children of the file. This

425 > * only applies to folders and can lead to an error unless provided

426 > * if the folder is not empty.

427 > */

428 > readonly recursive: boolean;

429 >

430 > /**

431 > * Set to `true` to attempt to move the file to trash

432 > * instead of deleting it permanently from disk.

433 > *

434 > * This option maybe not be supported on all providers.

435 > */

436 > readonly useTrash: boolean;

437 >

438 > /**

439 > * The optional `atomic` flag can be used to make sure

440 > * the `delete` method deletes the target atomically by

441 > * first renaming it to a temporary resource in the same

442 > * folder and then deleting it.

443 > *

444 > * This option maybe not be supported on all providers.

445 > */

446 > readonly atomic: IFileAtomicOptions | false;

447 > }

448 >

449 > export enum FileType {

450 >

451 > /**

452 > * File is unknown (neither file, directory nor symbolic link).

453 > */

454 > Unknown = 0,

455 >

456 > /**

457 > * File is a normal file.

458 > */

459 > File = 1,

460 >

461 > /**

462 > * File is a directory.

463 > */

464 > Directory = 2,

465 >

466 > /**

467 > * File is a symbolic link.

468 > *

469 > * Note: even when the file is a symbolic link, you can test for

470 > * `FileType.File` and `FileType.Directory` to know the type of

471 > * the target the link points to.

472 > */

473 > SymbolicLink = 64

474 > }

475 >

476 > export enum FilePermission {

477 >

478 > /**

479 > * File is readonly. Components like editors should not

480 > * offer to edit the contents.

481 > */

482 > Readonly = 1,

483 >

484 > /**

485 > * File is locked. Components like editors should offer

486 > * to edit the contents and ask the user upon saving to

487 > * remove the lock.

488 > */

489 > Locked = 2,

490 >

491 > /**

492 > * File is executable. Relevant for Unix-like systems where

493 > * the executable bit determines if a file can be run.

494 > */

495 > Executable = 4

496 > }

497 >

498 > export interface IStat {

499 >

500 > /**

501 > * The file type.

502 > */

503 > readonly type: FileType;

504 >

505 > /**

506 > * The last modification date represented as millis from unix epoch.

507 > */

508 > readonly mtime: number;

509 >

510 > /**

511 > * The creation date represented as millis from unix epoch.

512 > */

513 > readonly ctime: number;

514 >

515 > /**

516 > * The size of the file in bytes.

517 > */

518 > readonly size: number;

519 >

520 > /**

521 > * The file permissions.

522 > */

523 > readonly permissions?: FilePermission;

524 > }

525 >

526 > export interface IWatchOptionsWithoutCorrelation {

527 >

528 > /**

529 > * Set to `true` to watch for changes recursively in a folder

530 > * and all of its children.

531 > */

532 > recursive: boolean;

533 >

534 > /**

535 > * A set of glob patterns or paths to exclude from watching.

536 > * Paths can be relative or absolute and when relative are

537 > * resolved against the watched folder. Glob patterns are

538 > * always matched relative to the watched folder.

539 > */

540 > excludes: string[];

541 >

542 > /**

543 > * An optional set of glob patterns or paths to include for

544 > * watching. If not provided, all paths are considered for

545 > * events.

546 > * Paths can be relative or absolute and when relative are

547 > * resolved against the watched folder. Glob patterns are

548 > * always matched relative to the watched folder.

549 > */

550 > includes?: Array<string | IRelativePattern>;

551 >

552 > /**

553 > * If provided, allows to filter the events that the watcher should consider

554 > * for emitting. If not provided, all events are emitted.

555 > *

556 > * For example, to emit added and updated events, set to:

557 > * `FileChangeFilter.ADDED | FileChangeFilter.UPDATED`.

558 > */

559 > filter?: FileChangeFilter;

560 > }

561 >

562 > export interface IWatchOptions extends IWatchOptionsWithoutCorrelation {

563 >

564 > /**

565 > * If provided, file change events from the watcher that

566 > * are a result of this watch request will carry the same

567 > * id.

568 > */

569 > readonly correlationId?: number;

570 > }

571 >

572 > export const enum FileChangeFilter {

573 > UPDATED = 1 << 1,

574 > ADDED = 1 << 2,

575 > DELETED = 1 << 3

576 > }

577 >

578 > export interface IWatchOptionsWithCorrelation extends IWatchOptions {

579 > readonly correlationId: number;

580 > }

581 >

582 > export interface IFileSystemWatcher extends IDisposable {

583 >

584 > /**

585 > * An event which fires on file/folder change only for changes

586 > * that correlate to the watch request with matching correlation

587 > * identifier.

588 > */

589 > readonly onDidChange: Event<FileChangesEvent>;

590 > }

591 >

592 > export function isFileSystemWatcher(thing: unknown): thing is IFileSystemWatcher {

593 const candidate = thing as IFileSystemWatcher | undefined;

594

595 return !!candidate && typeof candidate.onDidChange === 'function';

596 }

597 > files.ts

598 > export const enum FileSystemProviderCapabilities {

599 >

600 > /**

601 > * No capabilities.

602 > */

603 > None = 0,

604 >

605 > /**

606 > * Provider supports unbuffered read/write.

607 > */

608 > FileReadWrite = 1 << 1,

609 >

610 > /**

611 > * Provider supports open/read/write/close low level file operations.

612 > */

613 > FileOpenReadWriteClose = 1 << 2,

614 >

615 > /**

616 > * Provider supports stream based reading.

617 > */

618 > FileReadStream = 1 << 4,

619 >

620 > /**

621 > * Provider supports copy operation.

622 > */

623 > FileFolderCopy = 1 << 3,

624 >

625 > /**

626 > * Provider is path case sensitive.

627 > */

628 > PathCaseSensitive = 1 << 10,

629 >

630 > /**

631 > * All files of the provider are readonly.

632 > */

633 > Readonly = 1 << 11,

634 >

635 > /**

636 > * Provider supports to delete via trash.

637 > */

638 > Trash = 1 << 12,

639 >

640 > /**

641 > * Provider support to unlock files for writing.

642 > */

643 > FileWriteUnlock = 1 << 13,

644 >

645 > /**

646 > * Provider support to read files atomically. This implies the

647 > * provider provides the `FileReadWrite` capability too.

648 > */

649 > FileAtomicRead = 1 << 14,

650 >

651 > /**

652 > * Provider support to write files atomically. This implies the

653 > * provider provides the `FileReadWrite` capability too.

654 > */

655 > FileAtomicWrite = 1 << 15,

656 >

657 > /**

658 > * Provider support to delete atomically.

659 > */

660 > FileAtomicDelete = 1 << 16,

661 >

662 > /**

663 > * Provider support to clone files atomically.

664 > */

665 > FileClone = 1 << 17,

666 >

667 > /**

668 > * Provider support to resolve real paths.

669 > */

670 > FileRealpath = 1 << 18,

671 >

672 > /**

673 > * Provider support to append to files.

674 > */

675 > FileAppend = 1 << 19

676 > }

677 >

678 > export interface IFileSystemProvider {

679 >

680 > readonly capabilities: FileSystemProviderCapabilities;

681 > readonly onDidChangeCapabilities: Event<void>;

682 >

683 > readonly onDidChangeFile: Event<readonly IFileChange[]>;

684 > readonly onDidWatchError?: Event<string>;

685 > watch(resource: URI, opts: IWatchOptions): IDisposable;

686 >

687 > stat(resource: URI): Promise<IStat>;

688 > mkdir(resource: URI): Promise<void>;

689 > readdir(resource: URI): Promise<[string, FileType][]>;

690 > delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;

691 >

692 > rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;

693 > copy?(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;

694 >

695 > readFile?(resource: URI): Promise<Uint8Array>;

696 > writeFile?(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;

697 >

698 > readFileStream?(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;

699 >

700 > open?(resource: URI, opts: IFileOpenOptions): Promise<number>;

701 > close?(fd: number): Promise<void>;

702 > read?(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;

703 > write?(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;

704 >

705 > cloneFile?(from: URI, to: URI): Promise<void>;

706 > }

707 >

708 > export interface IFileSystemProviderWithFileReadWriteCapability extends IFileSystemProvider {

709 > readFile(resource: URI): Promise<Uint8Array>;

710 > writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;

711 > }

712 >

713 > export function hasReadWriteCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileReadWriteCapability {

714 return !!(provider.capabilities & FileSystemProviderCapabilities.FileReadWrite);

715 }

716 > files.ts

717 > export function hasFileAppendCapability(provider: IFileSystemProvider): boolean {

718 return !!(provider.capabilities & FileSystemProviderCapabilities.FileAppend);

719 }

720 > files.ts

721 > export interface IFileSystemProviderWithFileFolderCopyCapability extends IFileSystemProvider {

722 > copy(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;

723 > }

724 >

725 > export function hasFileFolderCopyCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileFolderCopyCapability {

726 return !!(provider.capabilities & FileSystemProviderCapabilities.FileFolderCopy);

727 }

728 > files.ts

729 > export interface IFileSystemProviderWithFileCloneCapability extends IFileSystemProvider {

730 > cloneFile(from: URI, to: URI): Promise<void>;

731 > }

732 >

733 > export function hasFileCloneCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileCloneCapability {

734 return !!(provider.capabilities & FileSystemProviderCapabilities.FileClone);

735 }

736 > files.ts

737 > export interface IFileSystemProviderWithFileRealpathCapability extends IFileSystemProvider {

738 > realpath(resource: URI): Promise<string>;

739 > }

740 >

741 > export function hasFileRealpathCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileRealpathCapability {

742 return !!(provider.capabilities & FileSystemProviderCapabilities.FileRealpath);

743 }

744 > files.ts

745 > export interface IFileSystemProviderWithOpenReadWriteCloseCapability extends IFileSystemProvider {

746 > open(resource: URI, opts: IFileOpenOptions): Promise<number>;

747 > close(fd: number): Promise<void>;

748 > read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;

749 > write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;

750 > }

751 >

752 > export function hasOpenReadWriteCloseCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithOpenReadWriteCloseCapability {

753 return !!(provider.capabilities & FileSystemProviderCapabilities.FileOpenReadWriteClose);

754 }

755 > files.ts

756 > export interface IFileSystemProviderWithFileReadStreamCapability extends IFileSystemProvider {

757 > readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;

758 > }

759 >

760 > export function hasFileReadStreamCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileReadStreamCapability {

761 return !!(provider.capabilities & FileSystemProviderCapabilities.FileReadStream);

762 }

763 > files.ts

764 > export interface IFileSystemProviderWithFileAtomicReadCapability extends IFileSystemProvider {

765 > readFile(resource: URI, opts?: IFileAtomicReadOptions): Promise<Uint8Array>;

766 > enforceAtomicReadFile?(resource: URI): boolean;

767 > }

768 >

769 > export function hasFileAtomicReadCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileAtomicReadCapability {

770 if (!hasReadWriteCapability(provider)) {

771 return false; // we require the `FileReadWrite` capability too

774 return !!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicRead);

775 }

776 > files.ts

777 > export interface IFileSystemProviderWithFileAtomicWriteCapability extends IFileSystemProvider {

778 > writeFile(resource: URI, contents: Uint8Array, opts?: IFileAtomicWriteOptions): Promise<void>;

779 > enforceAtomicWriteFile?(resource: URI): IFileAtomicOptions | false;

780 > }

781 >

782 > export function hasFileAtomicWriteCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileAtomicWriteCapability {

783 if (!hasReadWriteCapability(provider)) {

784 return false; // we require the `FileReadWrite` capability too

787 return !!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicWrite);

788 }

789 > files.ts

790 > export interface IFileSystemProviderWithFileAtomicDeleteCapability extends IFileSystemProvider {

791 > delete(resource: URI, opts: IFileAtomicDeleteOptions): Promise<void>;

792 > enforceAtomicDelete?(resource: URI): IFileAtomicOptions | false;

793 > }

794 >

795 > export function hasFileAtomicDeleteCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileAtomicDeleteCapability {

796 return !!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicDelete);

797 }

798 > files.ts

799 > export interface IFileSystemProviderWithReadonlyCapability extends IFileSystemProvider {

800 >

801 > readonly capabilities: FileSystemProviderCapabilities.Readonly & FileSystemProviderCapabilities;

802 >

803 > /**

804 > * An optional message to show in the UI to explain why the file system is readonly.

805 > */

806 > readonly readOnlyMessage?: IMarkdownString;

807 > }

808 >

809 > export function hasReadonlyCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithReadonlyCapability {

810 return !!(provider.capabilities & FileSystemProviderCapabilities.Readonly);

811 }

812 > files.ts

813 > export enum FileSystemProviderErrorCode {

814 > FileExists = 'EntryExists',

815 > FileNotFound = 'EntryNotFound',

816 > FileNotADirectory = 'EntryNotADirectory',

817 > FileIsADirectory = 'EntryIsADirectory',

818 > FileExceedsStorageQuota = 'EntryExceedsStorageQuota',

819 > FileTooLarge = 'EntryTooLarge',

820 > FileWriteLocked = 'EntryWriteLocked',

821 > NoPermissions = 'NoPermissions',

822 > Unavailable = 'Unavailable',

823 > Unknown = 'Unknown'

824 > }

825 >

826 > export interface IFileSystemProviderError extends Error {

827 > readonly name: string;

828 > readonly code: FileSystemProviderErrorCode;

829 > }

830 >

831 > export class FileSystemProviderError extends Error implements IFileSystemProviderError {

832 >

833 > static create(error: Error | string, code: FileSystemProviderErrorCode): FileSystemProviderError {

834 > const providerError = new FileSystemProviderError(error.toString(), code);

835 > markAsFileSystemProviderError(providerError, code);

836 >

837 > return providerError;

838 > }

839 >

840 > private constructor(message: string, readonly code: FileSystemProviderErrorCode) {

841 super(message);

842 }

843 > } files.ts

844 >

845 > export function createFileSystemProviderError(error: Error | string, code: FileSystemProviderErrorCode): FileSystemProviderError {

846 return FileSystemProviderError.create(error, code);

847 }

848 > files.ts

849 > export function ensureFileSystemProviderError(error?: Error): Error {

850 if (!error) {

851 return createFileSystemProviderError(localize('unknownError', "Unknown Error"), FileSystemProviderErrorCode.Unknown); // https://github.com/microsoft/vscode/issues/72798

854 return error;

855 }

856 > files.ts

857 > export function markAsFileSystemProviderError(error: Error, code: FileSystemProviderErrorCode): Error {

858 error.name = code ? `${code} (FileSystemError)` : `FileSystemError`;

859

860 return error;

861 }

862 > files.ts

863 > export function toFileSystemProviderErrorCode(error: Error | undefined | null): FileSystemProviderErrorCode {

864

865 // Guard against abuse

893 return FileSystemProviderErrorCode.Unknown;

894 }

895 > files.ts

896 > export function toFileOperationResult(error: Error): FileOperationResult {

897

898 // FileSystemProviderError comes with the result already

921 }

922 }

923 > files.ts

924 > export interface IFileSystemProviderRegistrationEvent {

925 > readonly added: boolean;

926 > readonly scheme: string;

927 > readonly provider?: IFileSystemProvider;

928 > }

929 >

930 > export interface IFileSystemProviderCapabilitiesChangeEvent {

931 > readonly provider: IFileSystemProvider;

932 > readonly scheme: string;

933 > }

934 >

935 > export interface IFileSystemProviderActivationEvent {

936 > readonly scheme: string;

937 > join(promise: Promise<void>): void;

938 > }

939 >

940 > export const enum FileOperation {

941 > CREATE,

942 > DELETE,

943 > MOVE,

944 > COPY,

945 > WRITE

946 > }

947 >

948 > export interface IFileOperationEvent {

949 >

950 > readonly resource: URI;

951 > readonly operation: FileOperation;

952 >

953 > isOperation(operation: FileOperation.DELETE | FileOperation.WRITE): boolean;

954 > isOperation(operation: FileOperation.CREATE | FileOperation.MOVE | FileOperation.COPY): this is IFileOperationEventWithMetadata;

955 > }

956 >

957 > export interface IFileOperationEventWithMetadata extends IFileOperationEvent {

958 > readonly target: IFileStatWithMetadata;

959 > }

960 >

961 > export class FileOperationEvent implements IFileOperationEvent {

962 >

963 > constructor(resource: URI, operation: FileOperation.DELETE | FileOperation.WRITE);

964 > constructor(resource: URI, operation: FileOperation.CREATE | FileOperation.MOVE | FileOperation.COPY, target: IFileStatWithMetadata);

965 > constructor(readonly resource: URI, readonly operation: FileOperation, readonly target?: IFileStatWithMetadata) { }

966 >

967 > isOperation(operation: FileOperation.DELETE | FileOperation.WRITE): boolean;

968 > isOperation(operation: FileOperation.CREATE | FileOperation.MOVE | FileOperation.COPY): this is IFileOperationEventWithMetadata;

969 > isOperation(operation: FileOperation): boolean {

970 return this.operation === operation;

971 }

972 > } files.ts

973 >

974 > /**

975 > * Possible changes that can occur to a file.

976 > */

977 > export const enum FileChangeType {

978 > UPDATED,

979 > ADDED,

980 > DELETED

981 > }

982 >

983 > /**

984 > * Identifies a single change in a file.

985 > */

986 > export interface IFileChange {

987 >

988 > /**

989 > * The type of change that occurred to the file.

990 > */

991 > type: FileChangeType;

992 >

993 > /**

994 > * The unified resource identifier of the file that changed.

995 > */

996 > readonly resource: URI;

997 >

998 > /**

999 > * If provided when starting the file watcher, the correlation

1000 > * identifier will match the original file watching request as

1001 > * a way to identify the original component that is interested

1002 > * in the change.

1003 > */

1004 > readonly cId?: number;

1005 > }

1006 >

1007 > export class FileChangesEvent {

1008 >

1009 > private static readonly MIXED_CORRELATION = null;

1010 >

1011 > private readonly correlationId: number | undefined | typeof FileChangesEvent.MIXED_CORRELATION = undefined;

1012 >

1013 > constructor(changes: readonly IFileChange[], private readonly ignorePathCasing: boolean) {

1014 for (const change of changes) {

1015

1043 }

1044 }

1045 > files.ts

1046 > private readonly added = new Lazy(() => {

1047 > const added = TernarySearchTree.forUris<boolean>(() => this.ignorePathCasing); files.ts

1048 > added.fill(this.rawAdded.map(resource => [resource, true]));

1049 >

1050 > return added;

1051 > }); files.ts

1052 >

1053 > private readonly updated = new Lazy(() => {

1054 > const updated = TernarySearchTree.forUris<boolean>(() => this.ignorePathCasing); files.ts

1055 > updated.fill(this.rawUpdated.map(resource => [resource, true]));

1056 >

1057 > return updated;

1058 > }); files.ts

1059 >

1060 > private readonly deleted = new Lazy(() => {

1061 > const deleted = TernarySearchTree.forUris<boolean>(() => this.ignorePathCasing); files.ts

1062 > deleted.fill(this.rawDeleted.map(resource => [resource, true]));

1063 >

1064 > return deleted;

1065 > }); files.ts

1066 >

1067 > /**

1068 > * Find out if the file change events match the provided resource.

1069 > *

1070 > * Note: when passing `FileChangeType.DELETED`, we consider a match

1071 > * also when the parent of the resource got deleted.

1072 > */

1073 > contains(resource: URI, ...types: FileChangeType[]): boolean {

1074 return this.doContains(resource, { includeChildren: false }, ...types);

1075 }

1076 > files.ts

1077 > /**

1078 > * Find out if the file change events either match the provided

1079 > * resource, or contain a child of this resource.

1080 > */

1081 > affects(resource: URI, ...types: FileChangeType[]): boolean {

1082 return this.doContains(resource, { includeChildren: true }, ...types);

1083 }

1084 > files.ts

1085 > private doContains(resource: URI, options: { includeChildren: boolean }, ...types: FileChangeType[]): boolean {

1086 if (!resource) {

1087 return false;

1125 return false;

1126 }

1127 > files.ts

1128 > /**

1129 > * Returns if this event contains added files.

1130 > */

1131 > gotAdded(): boolean {

1132 return this.rawAdded.length > 0;

1133 }

1134 > files.ts

1135 > /**

1136 > * Returns if this event contains deleted files.

1137 > */

1138 > gotDeleted(): boolean {

1139 return this.rawDeleted.length > 0;

1140 }

1141 > files.ts

1142 > /**

1143 > * Returns if this event contains updated files.

1144 > */

1145 > gotUpdated(): boolean {

1146 return this.rawUpdated.length > 0;

1147 }

1148 > files.ts

1149 > /**

1150 > * Returns if this event contains changes that correlate to the

1151 > * provided `correlationId`.

1152 > *

1153 > * File change event correlation is an advanced watch feature that

1154 > * allows to identify from which watch request the events originate

1155 > * from. This correlation allows to route events specifically

1156 > * only to the requestor and not emit them to all listeners.

1157 > */

1158 > correlates(correlationId: number): boolean {

1159 return this.correlationId === correlationId;

1160 }

1161 > files.ts

1162 > /**

1163 > * Figure out if the event contains changes that correlate to one

1164 > * correlation identifier.

1165 > *

1166 > * File change event correlation is an advanced watch feature that

1167 > * allows to identify from which watch request the events originate

1168 > * from. This correlation allows to route events specifically

1169 > * only to the requestor and not emit them to all listeners.

1170 > */

1171 > hasCorrelation(): boolean {

1172 return typeof this.correlationId === 'number';

1173 }

1174 > files.ts

1175 > /**

1176 > * @deprecated use the `contains` or `affects` method to efficiently find

1177 > * out if the event relates to a given resource. these methods ensure:

1178 > * - that there is no expensive lookup needed (by using a `TernarySearchTree`)

1179 > * - correctly handles `FileChangeType.DELETED` events

1180 > */

1181 > readonly rawAdded: URI[] = [];

1182 >

1183 > /**

1184 > * @deprecated use the `contains` or `affects` method to efficiently find

1185 > * out if the event relates to a given resource. these methods ensure:

1186 > * - that there is no expensive lookup needed (by using a `TernarySearchTree`)

1187 > * - correctly handles `FileChangeType.DELETED` events

1188 > */

1189 > readonly rawUpdated: URI[] = [];

1190 >

1191 > /**

1192 > * @deprecated use the `contains` or `affects` method to efficiently find

1193 > * out if the event relates to a given resource. these methods ensure:

1194 > * - that there is no expensive lookup needed (by using a `TernarySearchTree`)

1195 > * - correctly handles `FileChangeType.DELETED` events

1196 > */

1197 > readonly rawDeleted: URI[] = [];

1198 > }

1199 >

1200 > export function isParent(path: string, candidate: string, ignoreCase?: boolean): boolean {

1201 if (!path || !candidate || path === candidate) {

1202 return false;

1217 return path.indexOf(candidate) === 0;

1218 }

1219 > files.ts

1220 > export interface IBaseFileStat {

1221 >

1222 > /**

1223 > * The unified resource identifier of this file or folder.

1224 > */

1225 > readonly resource: URI;

1226 >

1227 > /**

1228 > * The name which is the last segment

1229 > * of the {{path}}.

1230 > */

1231 > readonly name: string;

1232 >

1233 > /**

1234 > * The size of the file.

1235 > *

1236 > * The value may or may not be resolved as

1237 > * it is optional.

1238 > */

1239 > readonly size?: number;

1240 >

1241 > /**

1242 > * The last modification date represented as millis from unix epoch.

1243 > *

1244 > * The value may or may not be resolved as

1245 > * it is optional.

1246 > */

1247 > readonly mtime?: number;

1248 >

1249 > /**

1250 > * The creation date represented as millis from unix epoch.

1251 > *

1252 > * The value may or may not be resolved as

1253 > * it is optional.

1254 > */

1255 > readonly ctime?: number;

1256 >

1257 > /**

1258 > * A unique identifier that represents the

1259 > * current state of the file or directory.

1260 > *

1261 > * The value may or may not be resolved as

1262 > * it is optional.

1263 > */

1264 > readonly etag?: string;

1265 >

1266 > /**

1267 > * File is readonly. Components like editors should not

1268 > * offer to edit the contents.

1269 > */

1270 > readonly readonly?: boolean;

1271 >

1272 > /**

1273 > * File is locked. Components like editors should offer

1274 > * to edit the contents and ask the user upon saving to

1275 > * remove the lock.

1276 > */

1277 > readonly locked?: boolean;

1278 >

1279 > /**

1280 > * File is executable. Relevant for Unix-like systems where

1281 > * the executable bit determines if a file can be run.

1282 > */

1283 > readonly executable?: boolean;

1284 > }

1285 >

1286 > export interface IBaseFileStatWithMetadata extends Required<IBaseFileStat> { }

1287 >

1288 > /**

1289 > * A file resource with meta information and resolved children if any.

1290 > */

1291 > export interface IFileStat extends IBaseFileStat {

1292 >

1293 > /**

1294 > * The resource is a file.

1295 > */

1296 > readonly isFile: boolean;

1297 >

1298 > /**

1299 > * The resource is a directory.

1300 > */

1301 > readonly isDirectory: boolean;

1302 >

1303 > /**

1304 > * The resource is a symbolic link. Note: even when the

1305 > * file is a symbolic link, you can test for `FileType.File`

1306 > * and `FileType.Directory` to know the type of the target

1307 > * the link points to.

1308 > */

1309 > readonly isSymbolicLink: boolean;

1310 >

1311 > /**

1312 > * The children of the file stat or undefined if none.

1313 > */

1314 > children: IFileStat[] | undefined;

1315 > }

1316 >

1317 > export interface IFileStatWithMetadata extends IFileStat, IBaseFileStatWithMetadata {

1318 > readonly mtime: number;

1319 > readonly ctime: number;

1320 > readonly etag: string;

1321 > readonly size: number;

1322 > readonly readonly: boolean;

1323 > readonly locked: boolean;

1324 > readonly executable: boolean;

1325 > readonly children: IFileStatWithMetadata[] | undefined;

1326 > }

1327 >

1328 > export interface IFileStatResult {

1329 > readonly stat?: IFileStat;

1330 > readonly success: boolean;

1331 > }

1332 >

1333 > export interface IFileStatResultWithMetadata extends IFileStatResult {

1334 > readonly stat?: IFileStatWithMetadata;

1335 > }

1336 >

1337 > export interface IFileStatWithPartialMetadata extends Omit<IFileStatWithMetadata, 'children'> { }

1338 >

1339 > export interface IFileContent extends IBaseFileStatWithMetadata {

1340 >

1341 > /**

1342 > * The content of a file as buffer.

1343 > */

1344 > readonly value: VSBuffer;

1345 > }

1346 >

1347 > export interface IFileStreamContent extends IBaseFileStatWithMetadata {

1348 >

1349 > /**

1350 > * The content of a file as stream.

1351 > */

1352 > readonly value: VSBufferReadableStream;

1353 > }

1354 >

1355 > export interface IBaseReadFileOptions extends IFileReadStreamOptions {

1356 >

1357 > /**

1358 > * The optional etag parameter allows to return early from resolving the resource if

1359 > * the contents on disk match the etag. This prevents accumulated reading of resources

1360 > * that have been read already with the same etag.

1361 > * It is the task of the caller to makes sure to handle this error case from the promise.

1362 > */

1363 > readonly etag?: string;

1364 > }

1365 >

1366 > export interface IReadFileStreamOptions extends IBaseReadFileOptions { }

1367 >

1368 > export interface IReadFileOptions extends IBaseReadFileOptions {

1369 >

1370 > /**

1371 > * The optional `atomic` flag can be used to make sure

1372 > * the `readFile` method is not running in parallel with

1373 > * any `write` operations in the same process.

1374 > *

1375 > * Typically you should not need to use this flag but if

1376 > * for example you are quickly reading a file right after

1377 > * a file event occurred and the file changes a lot, there

1378 > * is a chance that a read returns an empty or partial file

1379 > * because a pending write has not finished yet.

1380 > *

1381 > * Note: this does not prevent the file from being written

1382 > * to from a different process. If you need such atomic

1383 > * operations, you better use a real database as storage.

1384 > */

1385 > readonly atomic?: boolean;

1386 > }

1387 >

1388 > export interface IWriteFileOptions {

1389 >

1390 > /**

1391 > * The last known modification time of the file. This can be used to prevent dirty writes.

1392 > */

1393 > readonly mtime?: number;

1394 >

1395 > /**

1396 > * The etag of the file. This can be used to prevent dirty writes.

1397 > */

1398 > readonly etag?: string;

1399 >

1400 > /**

1401 > * Whether to attempt to unlock a file before writing.

1402 > */

1403 > readonly unlock?: boolean;

1404 >

1405 > /**

1406 > * The optional `atomic` flag can be used to make sure

1407 > * the `writeFile` method updates the target file atomically

1408 > * by first writing to a temporary file in the same folder

1409 > * and then renaming it over the target.

1410 > */

1411 > readonly atomic?: IFileAtomicOptions | false;

1412 >

1413 > /**

1414 > * If set to true, will append to the end of the file instead of

1415 > * replacing its contents. Will create the file if it doesn't exist.

1416 > */

1417 > readonly append?: boolean;

1418 > }

1419 >

1420 > export interface IResolveFileOptions {

1421 >

1422 > /**

1423 > * Automatically continue resolving children of a directory until the provided resources

1424 > * are found.

1425 > */

1426 > readonly resolveTo?: readonly URI[];

1427 >

1428 > /**

1429 > * Automatically continue resolving children of a directory if the number of children is 1.

1430 > */

1431 > readonly resolveSingleChildDescendants?: boolean;

1432 >

1433 > /**

1434 > * Will resolve mtime, ctime, size and etag of files if enabled. This can have a negative impact

1435 > * on performance and thus should only be used when these values are required.

1436 > */

1437 > readonly resolveMetadata?: boolean;

1438 > }

1439 >

1440 > export interface IResolveMetadataFileOptions extends IResolveFileOptions {

1441 > readonly resolveMetadata: true;

1442 > }

1443 >

1444 > export interface ICreateFileOptions {

1445 >

1446 > /**

1447 > * Overwrite the file to create if it already exists on disk. Otherwise

1448 > * an error will be thrown (FILE_MODIFIED_SINCE).

1449 > */

1450 > readonly overwrite?: boolean;

1451 > }

1452 >

1453 > export class FileOperationError extends Error {

1454 > constructor(

1455 message: string,

1456 readonly fileOperationResult: FileOperationResult,

1459 super(message);

1460 }

1461 > } files.ts

1462 >

1463 > export class TooLargeFileOperationError extends FileOperationError {

1464 > constructor(

1465 message: string,

1466 override readonly fileOperationResult: FileOperationResult.FILE_TOO_LARGE,

1470 super(message, fileOperationResult, options);

1471 }

1472 > } files.ts

1473 >

1474 > export class NotModifiedSinceFileOperationError extends FileOperationError {

1475 >

1476 > constructor(

1477 message: string,

1478 readonly stat: IFileStatWithMetadata,

1481 super(message, FileOperationResult.FILE_NOT_MODIFIED_SINCE, options);

1482 }

1483 > } files.ts

1484 >

1485 > export const enum FileOperationResult {

1486 > FILE_IS_DIRECTORY,

1487 > FILE_NOT_FOUND,

1488 > FILE_NOT_MODIFIED_SINCE,

1489 > FILE_MODIFIED_SINCE,

1490 > FILE_MOVE_CONFLICT,

1491 > FILE_WRITE_LOCKED,

1492 > FILE_PERMISSION_DENIED,

1493 > FILE_TOO_LARGE,

1494 > FILE_INVALID_PATH,

1495 > FILE_NOT_DIRECTORY,

1496 > FILE_OTHER_ERROR

1497 > }

1498 >

1499 > //#endregion

1500 >

1501 > //#region Settings

1502 >

1503 > export const AutoSaveConfiguration = {

1504 > OFF: 'off',

1505 > AFTER_DELAY: 'afterDelay',

1506 > ON_FOCUS_CHANGE: 'onFocusChange',

1507 > ON_WINDOW_CHANGE: 'onWindowChange'

1508 > };

1509 >

1510 > export const HotExitConfiguration = {

1511 > OFF: 'off',

1512 > ON_EXIT: 'onExit',

1513 > ON_EXIT_AND_WINDOW_CLOSE: 'onExitAndWindowClose'

1514 > };

1515 >

1516 > export const FILES_ASSOCIATIONS_CONFIG = 'files.associations';

1517 > export const FILES_EXCLUDE_CONFIG = 'files.exclude';

1518 > export const FILES_READONLY_INCLUDE_CONFIG = 'files.readonlyInclude';

1519 > export const FILES_READONLY_EXCLUDE_CONFIG = 'files.readonlyExclude';

1520 > export const FILES_READONLY_FROM_PERMISSIONS_CONFIG = 'files.readonlyFromPermissions';

1521 >

1522 > export interface IGlobPatterns {

1523 > [filepattern: string]: boolean;

1524 > }

1525 >

1526 > export interface IFilesConfiguration {

1527 > files?: IFilesConfigurationNode;

1528 > }

1529 >

1530 > export interface IFilesConfigurationNode {

1531 > associations: { [filepattern: string]: string };

1532 > exclude: IExpression;

1533 > watcherExclude: IGlobPatterns;

1534 > watcherInclude: string[];

1535 > encoding: string;

1536 > autoGuessEncoding: boolean;

1537 > candidateGuessEncodings: string[];

1538 > defaultLanguage: string;

1539 > trimTrailingWhitespace: boolean;

1540 > autoSave: string;

1541 > autoSaveDelay: number;

1542 > autoSaveWorkspaceFilesOnly: boolean;

1543 > autoSaveWhenNoErrors: boolean;

1544 > eol: string;

1545 > enableTrash: boolean;

1546 > hotExit: string;

1547 > saveConflictResolution: 'askUser' | 'overwriteFileOnDisk';

1548 > readonlyInclude: IGlobPatterns;

1549 > readonlyExclude: IGlobPatterns;

1550 > readonlyFromPermissions: boolean;

1551 > }

1552 >

1553 > //#endregion

1554 >

1555 > //#region Utilities

1556 >

1557 > export enum FileKind {

1558 > FILE,

1559 > FOLDER,

1560 > ROOT_FOLDER

1561 > }

1562 >

1563 > /**

1564 > * A hint to disable etag checking for reading/writing.

1565 > */

1566 > export const ETAG_DISABLED = '';

1567 >

1568 > export function etag(stat: { mtime: number; size: number }): string;

1569 > export function etag(stat: { mtime: number | undefined; size: number | undefined }): string | undefined;

1570 > export function etag(stat: { mtime: number | undefined; size: number | undefined }): string | undefined {

1571 if (typeof stat.size !== 'number' || typeof stat.mtime !== 'number') {

1572 return undefined;

1575 return stat.mtime.toString(29) + stat.size.toString(31);

1576 }

1577 > files.ts

1578 export async function whenProviderRegistered(file: URI, fileService: IFileService): Promise<void> {

1579 if (fileService.hasProvider(URI.from({ scheme: file.scheme }))) {

1590 });

1591 }

1592 > files.ts

1593 > /**

1594 > * Helper to format a raw byte size into a human readable label.

1595 > */

1596 > export class ByteSize {

1597 >

1598 > static readonly KB = 1024;

1599 > static readonly MB = ByteSize.KB * ByteSize.KB;

1600 > static readonly GB = ByteSize.MB * ByteSize.KB;

1601 > static readonly TB = ByteSize.GB * ByteSize.KB;

1602 >

1603 > static formatSize(size: number): string {

1604 if (!isNumber(size)) {

1605 size = 0;

1624 return localize('sizeTB', "{0}TB", (size / ByteSize.TB).toFixed(2));

1625 }

1626 > } files.ts

1627 >

1628 > // File limits

1629 >

1630 > export function getLargeFileConfirmationLimit(remoteAuthority?: string): number;

1631 > export function getLargeFileConfirmationLimit(uri?: URI): number;

1632 > export function getLargeFileConfirmationLimit(arg?: string | URI): number {

1633 const isRemote = typeof arg === 'string' || arg?.scheme === Schemas.vscodeRemote;

1634 const isLocal = typeof arg !== 'string' && arg?.scheme === Schemas.file;

1655 return 1024 * ByteSize.MB;

1656 }

1657 > files.ts

1658 > //#endregion

src/vs/base/common/async.ts 1238 covered LOC · 202 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- async.ts

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 { CancellationToken, CancellationTokenSource } from './cancellation.js';

7 > import { BugIndicatingError, CancellationError, isCancellationError } from './errors.js';

8 > import { Emitter, Event } from './event.js';

9 > import { Disposable, DisposableMap, DisposableStore, IDisposable, isDisposable, MutableDisposable, toDisposable } from './lifecycle.js';

10 > import { extUri as defaultExtUri, IExtUri } from './resources.js';

11 > import { URI } from './uri.js';

12 > import { setTimeout0 } from './platform.js';

13 > import { MicrotaskDelay } from './symbols.js';

14 > import { Lazy } from './lazy.js';

15 >

16 > export function isThenable<T>(obj: unknown): obj is Promise<T> {

17 return !!obj && typeof (obj as unknown as Promise<T>).then === 'function';

18 }

19 > async.ts

20 > export interface CancelablePromise<T> extends Promise<T> {

21 > cancel(): void;

22 > }

23 >

24 > /**

25 > * Returns a promise that can be cancelled using the provided cancellation token.

26 > *

27 > * @remarks When cancellation is requested, the promise will be rejected with a {@link CancellationError}.

28 > * If the promise resolves to a disposable object, it will be automatically disposed when cancellation

29 > * is requested.

30 > *

31 > * @param callback A function that accepts a cancellation token and returns a promise

32 > * @returns A promise that can be cancelled

33 > */

34 > export function createCancelablePromise<T>(callback: (token: CancellationToken) => Promise<T>): CancelablePromise<T> {

35 const source = new CancellationTokenSource();

36

80 };

81 }

82 > async.ts

83 > /**

84 > * Returns a promise that resolves with `undefined` as soon as the passed token is cancelled.

85 > * @see {@link raceCancellationError}

86 > */

87 > export function raceCancellation<T>(promise: Promise<T>, token: CancellationToken): Promise<T | undefined>;

88 >

89 > /**

90 > * Returns a promise that resolves with `defaultValue` as soon as the passed token is cancelled.

91 > * @see {@link raceCancellationError}

92 > */

93 > export function raceCancellation<T>(promise: Promise<T>, token: CancellationToken, defaultValue: T): Promise<T>;

94 >

95 > export function raceCancellation<T>(promise: Promise<T>, token: CancellationToken, defaultValue?: T): Promise<T | undefined> {

96 return new Promise((resolve, reject) => {

97 const ref = token.onCancellationRequested(() => {

102 });

103 }

104 > async.ts

105 > /**

106 > * Returns a promise that rejects with an {@CancellationError} as soon as the passed token is cancelled.

107 > * @see {@link raceCancellation}

108 > */

109 > export function raceCancellationError<T>(promise: Promise<T>, token: CancellationToken): Promise<T> {

110 return new Promise((resolve, reject) => {

111 const ref = token.onCancellationRequested(() => {

116 });

117 }

118 > async.ts

119 > export function rejectIfNotCanceled(err: unknown): undefined {

120 if (isCancellationError(err)) {

121 return undefined;

123 return Promise.reject(err) as never;

124 }

125 > async.ts

126 > /**

127 > * Wraps a cancellable promise such that it is no cancellable. Can be used to

128 > * avoid issues with shared promises that would normally be returned as

129 > * cancellable to consumers.

130 > */

131 > export function notCancellablePromise<T>(promise: CancelablePromise<T>): Promise<T> {

132 return new Promise<T>((resolve, reject) => {

133 promise.then(resolve, reject);

134 });

135 }

136 > async.ts

137 > /**

138 > * Returns as soon as one of the promises resolves or rejects and cancels remaining promises

139 > */

140 > export function raceCancellablePromises<T>(cancellablePromises: (CancelablePromise<T> | Promise<T>)[]): CancelablePromise<T> {

141 let resolvedPromiseIndex = -1;

142 const promises = cancellablePromises.map((promise, index) => promise.then(result => { resolvedPromiseIndex = index; return result; }));

154 return promise;

155 }

156 > async.ts

157 > export function raceTimeout<T>(promise: Promise<T>, timeout: number, onTimeout?: () => void): Promise<T | undefined> {

158 let promiseResolve: ((value: T | undefined) => void) | undefined = undefined;

159

168 ]);

169 }

170 > async.ts

171 > export function asPromise<T>(callback: () => T | Thenable<T>): Promise<T> {

172 return new Promise<T>((resolve, reject) => {

173 const item = callback();

179 });

180 }

181 > async.ts

182 > /**

183 > * Creates and returns a new promise, plus its `resolve` and `reject` callbacks.

184 > *

185 > * Replace with standardized [`Promise.withResolvers`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers) once it is supported

186 > */

187 > export function promiseWithResolvers<T>(): { promise: Promise<T>; resolve: (value: T | PromiseLike<T>) => void; reject: (err?: any) => void } {

188 let resolve: (value: T | PromiseLike<T>) => void;

189 let reject: (reason?: any) => void;

194 return { promise, resolve: resolve!, reject: reject! };

195 }

196 > async.ts

197 > export interface ITask<T> {

198 > (): T;

199 > }

200 >

201 > export interface ICancellableTask<T> {

202 > (token: CancellationToken): T;

203 > }

204 >

205 > /**

206 > * A helper to prevent accumulation of sequential async tasks.

207 > *

208 > * Imagine a mail man with the sole task of delivering letters. As soon as

209 > * a letter submitted for delivery, he drives to the destination, delivers it

210 > * and returns to his base. Imagine that during the trip, N more letters were submitted.

211 > * When the mail man returns, he picks those N letters and delivers them all in a

212 > * single trip. Even though N+1 submissions occurred, only 2 deliveries were made.

213 > *

214 > * The throttler implements this via the queue() method, by providing it a task

215 > * factory. Following the example:

216 > *

217 > * const throttler = new Throttler();

218 > * const letters = [];

219 > *

220 > * function deliver() {

221 > * const lettersToDeliver = letters;

222 > * letters = [];

223 > * return makeTheTrip(lettersToDeliver);

224 > * }

225 > *

226 > * function onLetterReceived(l) {

227 > * letters.push(l);

228 > * throttler.queue(deliver);

229 > * }

230 > */

231 > export class Throttler implements IDisposable {

232 >

233 > private activePromise: Promise<any> | null;

234 > private queuedPromise: Promise<any> | null;

235 > private queuedPromiseFactory: ICancellableTask<Promise<any>> | null;

236 > private cancellationTokenSource: CancellationTokenSource;

237 >

238 > constructor() {

239 this.activePromise = null;

240 this.queuedPromise = null;

243 this.cancellationTokenSource = new CancellationTokenSource();

244 }

245 > async.ts

246 > queue<T>(promiseFactory: ICancellableTask<Promise<T>>): Promise<T> {

247 if (this.cancellationTokenSource.token.isCancellationRequested) {

248 return Promise.reject(new Error('Throttler is disposed'));

288 });

289 }

290 > async.ts

291 > dispose(): void {

292 this.cancellationTokenSource.cancel();

293 }

294 > } async.ts

295 >

296 > export class Sequencer {

297

298 private current: Promise<unknown> = Promise.resolve(null);

299 > async.ts

300 > queue<T>(promiseTask: ITask<Promise<T>>): Promise<T> {

301 return this.current = this.current.then(() => promiseTask(), () => promiseTask());

302 }

303 > } async.ts

304 >

305 > /**

306 > * A {@link Throttler} per key. Calls for the same key coalesce (only the most

307 > * recently queued task runs after the active one settles); calls for different

308 > * keys are independent. Idle keys are cleaned up automatically.

309 > */

310 > export class ThrottlerByKey<TKey> implements IDisposable {

311

312 private readonly throttlers = new Map<TKey, { throttler: Throttler; count: number }>();

313 > async.ts

314 > queue<T>(key: TKey, task: ITask<Promise<T>>): Promise<T> {

315 let entry = this.throttlers.get(key);

316 if (!entry) {

327 });

328 }

329 > async.ts

330 > dispose(): void {

331 for (const { throttler } of this.throttlers.values()) {

332 throttler.dispose();

334 this.throttlers.clear();

335 }

336 > } async.ts

337 >

338 > export class SequencerByKey<TKey> {

339

340 private promiseMap = new Map<TKey, Promise<unknown>>();

341 > async.ts

342 > queue<T>(key: TKey, promiseTask: ITask<Promise<T>>): Promise<T> {

343 const runningPromise = this.promiseMap.get(key) ?? Promise.resolve();

344 const newPromise = runningPromise

353 return newPromise;

354 }

355 > async.ts

356 > peek(key: TKey): Promise<unknown> | undefined {

357 return this.promiseMap.get(key) || undefined;

358 }

359 > async.ts

360 > keys(): IterableIterator<TKey> {

361 return this.promiseMap.keys();

362 }

363 > } async.ts

364 >

365 > interface IScheduledLater extends IDisposable {

366 > isTriggered(): boolean;

367 > }

368 >

369 > const timeoutDeferred = (timeout: number, fn: () => void): IScheduledLater => {

370 let scheduled = true;

371 const handle = setTimeout(() => {

381 };

382 };

383 > async.ts

384 > const microtaskDeferred = (fn: () => void): IScheduledLater => {

385 let scheduled = true;

386 queueMicrotask(() => {

396 };

397 };

398 > async.ts

399 > /**

400 > * A helper to delay (debounce) execution of a task that is being requested often.

401 > *

402 > * Following the throttler, now imagine the mail man wants to optimize the number of

403 > * trips proactively. The trip itself can be long, so he decides not to make the trip

404 > * as soon as a letter is submitted. Instead he waits a while, in case more

405 > * letters are submitted. After said waiting period, if no letters were submitted, he

406 > * decides to make the trip. Imagine that N more letters were submitted after the first

407 > * one, all within a short period of time between each other. Even though N+1

408 > * submissions occurred, only 1 delivery was made.

409 > *

410 > * The delayer offers this behavior via the trigger() method, into which both the task

411 > * to be executed and the waiting period (delay) must be passed in as arguments. Following

412 > * the example:

413 > *

414 > * const delayer = new Delayer(WAITING_PERIOD);

415 > * const letters = [];

416 > *

417 > * function letterReceived(l) {

418 > * letters.push(l);

419 > * delayer.trigger(() => { return makeTheTrip(); });

420 > * }

421 > */

422 > export class Delayer<T> implements IDisposable {

423 >

424 > private deferred: IScheduledLater | null;

425 > private completionPromise: Promise<any> | null;

426 > private doResolve: ((value?: any | Promise<any>) => void) | null;

427 > private doReject: ((err: unknown) => void) | null;

428 > private task: ITask<T | Promise<T>> | null;

429 >

430 > constructor(public defaultDelay: number | typeof MicrotaskDelay) {

431 this.deferred = null;

432 this.completionPromise = null;

435 this.task = null;

436 }

437 > async.ts

438 > trigger(task: ITask<T | Promise<T>>, delay = this.defaultDelay): Promise<T> {

439 this.task = task;

440 this.cancelTimeout();

465 return this.completionPromise;

466 }

467 > async.ts

468 > isTriggered(): boolean {

469 return !!this.deferred?.isTriggered();

470 }

471 > async.ts

472 > cancel(): void {

473 this.cancelTimeout();

474

478 }

479 }

480 > async.ts

481 > private cancelTimeout(): void {

482 this.deferred?.dispose();

483 this.deferred = null;

484 }

485 > async.ts

486 > dispose(): void {

487 this.cancel();

488 }

489 > } async.ts

490 >

491 > /**

492 > * A helper to delay execution of a task that is being requested often, while

493 > * preventing accumulation of consecutive executions, while the task runs.

494 > *

495 > * The mail man is clever and waits for a certain amount of time, before going

496 > * out to deliver letters. While the mail man is going out, more letters arrive

497 > * and can only be delivered once he is back. Once he is back the mail man will

498 > * do one more trip to deliver the letters that have accumulated while he was out.

499 > */

500 > export class ThrottledDelayer<T> {

501 >

502 > private delayer: Delayer<Promise<T>>;

503 > private throttler: Throttler;

504 >

505 > constructor(defaultDelay: number) {

506 this.delayer = new Delayer(defaultDelay);

507 this.throttler = new Throttler();

508 }

509 > async.ts

510 > trigger(promiseFactory: ICancellableTask<Promise<T>>, delay?: number): Promise<T> {

511 return this.delayer.trigger(() => this.throttler.queue(promiseFactory), delay) as unknown as Promise<T>;

512 }

513 > async.ts

514 > isTriggered(): boolean {

515 return this.delayer.isTriggered();

516 }

517 > async.ts

518 > cancel(): void {

519 this.delayer.cancel();

520 }

521 > async.ts

522 > dispose(): void {

523 this.delayer.dispose();

524 this.throttler.dispose();

525 }

526 > } async.ts

527 >

528 > /**

529 > * A barrier that is initially closed and then becomes opened permanently.

530 > */

531 > export class Barrier {

532 > private _isOpen: boolean;

533 > private _promise: Promise<boolean>;

534 > private _completePromise!: (v: boolean) => void;

535 >

536 > constructor() {

537 this._isOpen = false;

538 this._promise = new Promise<boolean>((c, e) => {

540 });

541 }

542 > async.ts

543 > isOpen(): boolean {

544 return this._isOpen;

545 }

546 > async.ts

547 > open(): void {

548 this._isOpen = true;

549 this._completePromise(true);

550 }

551 > async.ts

552 > wait(): Promise<boolean> {

553 return this._promise;

554 }

555 > } async.ts

556 >

557 > /**

558 > * A barrier that is initially closed and then becomes opened permanently after a certain period of

559 > * time or when open is called explicitly

560 > */

561 > export class AutoOpenBarrier extends Barrier {

562 >

563 > private readonly _timeout: Timeout;

564 >

565 > constructor(autoOpenTimeMs: number) {

566 super();

567 this._timeout = setTimeout(() => this.open(), autoOpenTimeMs);

568 }

569 > async.ts

570 > override open(): void {

571 clearTimeout(this._timeout);

572 super.open();

573 }

574 > } async.ts

575 >

576 > export function timeout(millis: number): CancelablePromise<void>;

577 > export function timeout(millis: number, token: CancellationToken): Promise<void>;

578 > export function timeout(millis: number, token?: CancellationToken): CancelablePromise<void> | Promise<void> {

579 if (!token) {

580 return createCancelablePromise(token => timeout(millis, token));

593 });

594 }

595 > async.ts

596 > /**

597 > * Creates a timeout that can be disposed using its returned value.

598 > * @param handler The timeout handler.

599 > * @param timeout An optional timeout in milliseconds.

600 > * @param store An optional {@link DisposableStore} that will have the timeout disposable managed automatically.

601 > *

602 > * @example

603 > * const store = new DisposableStore;

604 > * // Call the timeout after 1000ms at which point it will be automatically

605 > * // evicted from the store.

606 > * const timeoutDisposable = disposableTimeout(() => {}, 1000, store);

607 > *

608 > * if (foo) {

609 > * // Cancel the timeout and evict it from store.

610 > * timeoutDisposable.dispose();

611 > * }

612 > */

613 > export function disposableTimeout(handler: () => void, timeout = 0, store?: DisposableStore): IDisposable {

614 const timer = setTimeout(() => {

615 handler();

625 return disposable;

626 }

627 > async.ts

628 > /**

629 > * The largest delay (in milliseconds) a single `setTimeout` can represent.

630 > * Larger values overflow its internal 32-bit signed integer and fire (almost)

631 > * immediately instead of waiting.

632 > */

633 > export const MAX_TIMEOUT_DELAY = 2 ** 31 - 1; // ~24.8 days

634 >

635 > /**

636 > * Like {@link disposableTimeout}, but supports delays larger than

637 > * {@link MAX_TIMEOUT_DELAY} (~24.8 days), which a single `setTimeout` cannot

638 > * represent. The wait is split into chunks and re-armed until the target time is

639 > * reached, so the handler fires at approximately `Date.now() + timeout`.

640 > *

641 > * Note: like `setTimeout`, firing is best-effort and may drift across system

642 > * sleep or wall-clock changes; do not rely on it for precise scheduling.

643 > *

644 > * @param handler The timeout handler.

645 > * @param timeout The timeout in milliseconds. May exceed {@link MAX_TIMEOUT_DELAY}.

646 > * @param store An optional {@link DisposableStore} that will have the timeout disposable managed automatically.

647 > */

648 > export function disposableLongTimeout(handler: () => void, timeout: number, store?: DisposableStore): IDisposable {

649 const target = Date.now() + timeout;

650 let timer: Timeout;

671 return disposable;

672 }

673 > async.ts

674 > /**

675 > * Runs the provided list of promise factories in sequential order. The returned

676 > * promise will complete to an array of results from each promise.

677 > */

678 >

679 > export function sequence<T>(promiseFactories: ITask<Promise<T>>[]): Promise<T[]> {

680 const results: T[] = [];

681 let index = 0;

701 return Promise.resolve(null).then(thenHandler);

702 }

703 > async.ts

704 > export function first<T>(promiseFactories: ITask<Promise<T>>[], shouldStop: (t: T) => boolean = t => !!t, defaultValue: T | null = null): Promise<T | null> {

705 let index = 0;

706 const len = promiseFactories.length;

725 return loop();

726 }

727 > async.ts

728 > /**

729 > * Returns the result of the first promise that matches the "shouldStop",

730 > * running all promises in parallel. Supports cancelable promises.

731 > */

732 > export function firstParallel<T>(promiseList: Promise<T>[], shouldStop?: (t: T) => boolean, defaultValue?: T | null): Promise<T | null>;

733 > export function firstParallel<T, R extends T>(promiseList: Promise<T>[], shouldStop: (t: T) => t is R, defaultValue?: R | null): Promise<R | null>;

734 > export function firstParallel<T>(promiseList: Promise<T>[], shouldStop: (t: T) => boolean = t => !!t, defaultValue: T | null = null) {

735 if (promiseList.length === 0) {

736 return Promise.resolve(defaultValue);

764 });

765 }

766 > async.ts

767 > interface ILimitedTaskFactory<T> {

768 > factory: ITask<Promise<T>>;

769 > c: (value: T | Promise<T>) => void;

770 > e: (error?: unknown) => void;

771 > }

772 >

773 > export interface ILimiter<T> {

774 >

775 > readonly size: number;

776 >

777 > queue(factory: ITask<Promise<T>>): Promise<T>;

778 >

779 > clear(): void;

780 > }

781 >

782 > /**

783 > * A helper to queue N promises and run them all with a max degree of parallelism. The helper

784 > * ensures that at any time no more than M promises are running at the same time.

785 > */

786 > export class Limiter<T> implements ILimiter<T> {

787 >

788 > private _size = 0;

789 > private _isDisposed = false;

790 > private runningPromises: number;

791 > private readonly maxDegreeOfParalellism: number;

792 > private readonly outstandingPromises: ILimitedTaskFactory<T>[];

793 > private readonly _onDrained: Emitter<void>;

794 >

795 > constructor(maxDegreeOfParalellism: number) {

796 this.maxDegreeOfParalellism = maxDegreeOfParalellism;

797 this.outstandingPromises = [];

799 this._onDrained = new Emitter<void>();

800 }

801 > async.ts

802 > /**

803 > *

804 > * @returns A promise that resolved when all work is done (onDrained) or when

805 > * there is nothing to do

806 > */

807 > whenIdle(): Promise<void> {

808 return this.size > 0

809 ? Event.toPromise(this.onDrained)

810 : Promise.resolve();

811 }

812 > async.ts

813 > get onDrained(): Event<void> {

814 return this._onDrained.event;

815 }

816 > async.ts

817 > get size(): number {

818 return this._size;

819 }

820 > async.ts

821 > queue(factory: ITask<Promise<T>>): Promise<T> {

822 if (this._isDisposed) {

823 throw new Error('Object has been disposed');

830 });

831 }

832 > async.ts

833 > private consume(): void {

834 while (this.outstandingPromises.length && this.runningPromises < this.maxDegreeOfParalellism) {

835 const iLimitedTask = this.outstandingPromises.shift()!;

841 }

842 }

843 > async.ts

844 > private consumed(): void {

845 if (this._isDisposed) {

846 return;

855 }

856 }

857 > async.ts

858 > clear(): void {

859 if (this._isDisposed) {

860 throw new Error('Object has been disposed');

863 this._size = this.runningPromises;

864 }

865 > async.ts

866 > dispose(): void {

867 this._isDisposed = true;

868 this.outstandingPromises.length = 0; // stop further processing

870 this._onDrained.dispose();

871 }

872 > } async.ts

873 >

874 > /**

875 > * A queue is handles one promise at a time and guarantees that at any time only one promise is executing.

876 > */

877 > export class Queue<T> extends Limiter<T> {

878 >

879 > constructor() {

880 super(1);

881 }

882 > } async.ts

883 >

884 > /**

885 > * Same as `Queue`, ensures that only 1 task is executed at the same time. The difference to `Queue` is that

886 > * there is only 1 task about to be scheduled next. As such, calling `queue` while a task is executing will

887 > * replace the currently queued task until it executes.

888 > *

889 > * As such, the returned promise may not be from the factory that is passed in but from the next factory that

890 > * is running after having called `queue`.

891 > */

892 > export class LimitedQueue {

893

894 private readonly sequentializer = new TaskSequentializer();

895

896 private tasks = 0;

897 > async.ts

898 > queue(factory: ITask<Promise<void>>): Promise<void> {

899 if (!this.sequentializer.isRunning()) {

900 return this.sequentializer.run(this.tasks++, factory());

905 });

906 }

907 > } async.ts

908 >

909 > /**

910 > * A helper to organize queues per resource. The ResourceQueue makes sure to manage queues per resource

911 > * by disposing them once the queue is empty.

912 > */

913 > export class ResourceQueue implements IDisposable {

914

915 private readonly queues = new Map<string, Queue<void>>();

919 private drainListeners: DisposableMap<number> | undefined = undefined;

920 private drainListenerCount = 0;

921 > async.ts

922 > async whenDrained(): Promise<void> {

923 if (this.isDrained()) {

924 return;

930 return promise.p;

931 }

932 > async.ts

933 > private isDrained(): boolean {

934 for (const [, queue] of this.queues) {

935 if (queue.size > 0) {

940 return true;

941 }

942 > async.ts

943 > queueSize(resource: URI, extUri: IExtUri = defaultExtUri): number {

944 const key = extUri.getComparisonKey(resource);

945

946 return this.queues.get(key)?.size ?? 0;

947 }

948 > async.ts

949 > queueFor(resource: URI, factory: ITask<Promise<void>>, extUri: IExtUri = defaultExtUri): Promise<void> {

950 const key = extUri.getComparisonKey(resource);

951

977 return queue.queue(factory);

978 }

979 > async.ts

980 > private onDidQueueDrain(): void {

981 if (!this.isDrained()) {

982 return; // not done yet

985 this.releaseDrainers();

986 }

987 > async.ts

988 > private releaseDrainers(): void {

989 for (const drainer of this.drainers) {

990 drainer.complete();

993 this.drainers.clear();

994 }

995 > async.ts

996 > dispose(): void {

997 for (const [, queue] of this.queues) {

998 queue.dispose();

1011 this.drainListeners?.dispose();

1012 }

1013 > } async.ts

1014 >

1015 > export type Task<T = void> = () => (Promise<T> | T);

1016 >

1017 > /**

1018 > * Wrap a type in an optional promise. This can be useful to avoid the runtime

1019 > * overhead of creating a promise.

1020 > */

1021 > export type MaybePromise<T> = Promise<T> | T;

1022 >

1023 > /**

1024 > * Processes tasks in the order they were scheduled.

1025 > */

1026 > export class TaskQueue {

1027 private _runningTask: Task<any> | undefined = undefined;

1028 private _pendingTasks: { task: Task<any>; deferred: DeferredPromise<any>; setUndefinedWhenCleared: boolean }[] = [];

1029 > async.ts

1030 > /**

1031 > * Waits for the current and pending tasks to finish, then runs and awaits the given task.

1032 > * If the task is skipped because of clearPending, the promise is rejected with a CancellationError.

1033 > */

1034 > public schedule<T>(task: Task<T>): Promise<T> {

1035 const deferred = new DeferredPromise<T>();

1036 this._pendingTasks.push({ task, deferred, setUndefinedWhenCleared: false });

1038 return deferred.p;

1039 }

1040 > async.ts

1041 > /**

1042 > * Waits for the current and pending tasks to finish, then runs and awaits the given task.

1043 > * If the task is skipped because of clearPending, the promise is resolved with undefined.

1044 > */

1045 > public scheduleSkipIfCleared<T>(task: Task<T>): Promise<T | undefined> {

1046 const deferred = new DeferredPromise<T>();

1047 this._pendingTasks.push({ task, deferred, setUndefinedWhenCleared: true });

1049 return deferred.p;

1050 }

1051 > async.ts

1052 > private _runIfNotRunning(): void {

1053 if (this._runningTask === undefined) {

1054 this._processQueue();

1055 }

1056 }

1057 > async.ts

1058 > private async _processQueue(): Promise<void> {

1059 if (this._pendingTasks.length === 0) {

1060 return;

1082 }

1083 }

1084 > async.ts

1085 > /**

1086 > * Clears all pending tasks. Does not cancel the currently running task.

1087 > */

1088 > public clearPending(): void {

1089 const tasks = this._pendingTasks;

1090 this._pendingTasks = [];

1097 }

1098 }

1099 > } async.ts

1100 >

1101 > export class TimeoutTimer implements IDisposable {

1102 > private _token: Timeout | undefined;

1103 > private _isDisposed = false;

1104 >

1105 > constructor();

1106 > constructor(runner: () => void, timeout: number);

1107 > constructor(runner?: () => void, timeout?: number) {

1108 this._token = undefined;

1109

1112 }

1113 }

1114 > async.ts

1115 > dispose(): void {

1116 this.cancel();

1117 this._isDisposed = true;

1118 }

1119 > async.ts

1120 > cancel(): void {

1121 if (this._token !== undefined) {

1122 clearTimeout(this._token);

1124 }

1125 }

1126 > async.ts

1127 > cancelAndSet(runner: () => void, timeout: number): void {

1128 if (this._isDisposed) {

1129 throw new BugIndicatingError(`Calling 'cancelAndSet' on a disposed TimeoutTimer`);

1136 }, timeout);

1137 }

1138 > async.ts

1139 > setIfNotSet(runner: () => void, timeout: number): void {

1140 if (this._isDisposed) {

1141 throw new BugIndicatingError(`Calling 'setIfNotSet' on a disposed TimeoutTimer`);

1151 }, timeout);

1152 }

1153 > } async.ts

1154 >

1155 > export class IntervalTimer implements IDisposable {

1156

1157 private disposable: IDisposable | undefined = undefined;

1158 private isDisposed = false;

1159 > async.ts

1160 > cancel(): void {

1161 this.disposable?.dispose();

1162 this.disposable = undefined;

1163 }

1164 > async.ts

1165 > cancelAndSet(runner: () => void, interval: number, context = globalThis): void {

1166 if (this.isDisposed) {

1167 throw new BugIndicatingError(`Calling 'cancelAndSet' on a disposed IntervalTimer`);

1178 });

1179 }

1180 > async.ts

1181 > dispose(): void {

1182 this.cancel();

1183 this.isDisposed = true;

1184 }

1185 > } async.ts

1186 >

1187 > export class RunOnceScheduler<Runner extends (...args: any[]) => any = () => any> implements IDisposable {

1188 >

1189 > protected runner: Runner | null;

1190 >

1191 > private timeoutToken: Timeout | undefined;

1192 > private timeout: number;

1193 > private timeoutHandler: () => void;

1194 >

1195 > constructor(runner: Runner, delay: number) {

1196 this.timeoutToken = undefined;

1197 this.runner = runner;

1199 this.timeoutHandler = this.onTimeout.bind(this);

1200 }

1201 > async.ts

1202 > /**

1203 > * Dispose RunOnceScheduler

1204 > */

1205 > dispose(): void {

1206 this.cancel();

1207 this.runner = null;

1208 }

1209 > async.ts

1210 > /**

1211 > * Cancel current scheduled runner (if any).

1212 > */

1213 > cancel(): void {

1214 if (this.isScheduled()) {

1215 clearTimeout(this.timeoutToken);

1217 }

1218 }

1219 > async.ts

1220 > /**

1221 > * Cancel previous runner (if any) & schedule a new runner.

1222 > */

1223 > schedule(delay = this.timeout): void {

1224 this.cancel();

1225 this.timeoutToken = setTimeout(this.timeoutHandler, delay);

1226 }

1227 > async.ts

1228 > get delay(): number {

1229 return this.timeout;

1230 }

1231 > async.ts

1232 > set delay(value: number) {

1233 this.timeout = value;

1234 }

1235 > async.ts

1236 > /**

1237 > * Returns true if scheduled.

1238 > */

1239 > isScheduled(): boolean {

1240 return this.timeoutToken !== undefined;

1241 }

1242 > async.ts

1243 > flush(): void {

1244 if (this.isScheduled()) {

1245 this.cancel();

1247 }

1248 }

1249 > async.ts

1250 > private onTimeout() {

1251 this.timeoutToken = undefined;

1252 if (this.runner) {

1254 }

1255 }

1256 > async.ts

1257 > protected doRun(): void {

1258 this.runner?.();

1259 }

1260 > } async.ts

1261 >

1262 > /**

1263 > * Same as `RunOnceScheduler`, but doesn't count the time spent in sleep mode.

1264 > * > **NOTE**: Only offers 1s resolution.

1265 > *

1266 > * When calling `setTimeout` with 3hrs, and putting the computer immediately to sleep

1267 > * for 8hrs, `setTimeout` will fire **as soon as the computer wakes from sleep**. But

1268 > * this scheduler will execute 3hrs **after waking the computer from sleep**.

1269 > */

1270 > export class ProcessTimeRunOnceScheduler {

1271 >

1272 > private runner: (() => void) | null;

1273 > private timeout: number;

1274 >

1275 > private counter: number;

1276 > private intervalToken: Timeout | undefined;

1277 > private intervalHandler: () => void;

1278 >

1279 > constructor(runner: () => void, delay: number) {

1280 if (delay % 1000 !== 0) {

1281 console.warn(`ProcessTimeRunOnceScheduler resolution is 1s, ${delay}ms is not a multiple of 1000ms.`);

1287 this.intervalHandler = this.onInterval.bind(this);

1288 }

1289 > async.ts

1290 > dispose(): void {

1291 this.cancel();

1292 this.runner = null;

1293 }

1294 > async.ts

1295 > cancel(): void {

1296 if (this.isScheduled()) {

1297 clearInterval(this.intervalToken);

1299 }

1300 }

1301 > async.ts

1302 > /**

1303 > * Cancel previous runner (if any) & schedule a new runner.

1304 > */

1305 > schedule(delay = this.timeout): void {

1306 if (delay % 1000 !== 0) {

1307 console.warn(`ProcessTimeRunOnceScheduler resolution is 1s, ${delay}ms is not a multiple of 1000ms.`);

1311 this.intervalToken = setInterval(this.intervalHandler, 1000);

1312 }

1313 > async.ts

1314 > /**

1315 > * Returns true if scheduled.

1316 > */

1317 > isScheduled(): boolean {

1318 return this.intervalToken !== undefined;

1319 }

1320 > async.ts

1321 > private onInterval() {

1322 this.counter--;

1323 if (this.counter > 0) {

1331 this.runner?.();

1332 }

1333 > } async.ts

1334 >

1335 > export class RunOnceWorker<T> extends RunOnceScheduler<(units: T[]) => void> {

1336 >

1337 > private units: T[] = [];

1338 >

1339 > constructor(runner: (units: T[]) => void, timeout: number) {

1340 super(runner, timeout);

1341 }

1342 > async.ts

1343 > work(unit: T): void {

1344 this.units.push(unit);

1345

1348 }

1349 }

1350 > async.ts

1351 > protected override doRun(): void {

1352 const units = this.units;

1353 this.units = [];

1355 this.runner?.(units);

1356 }

1357 > async.ts

1358 > override dispose(): void {

1359 this.units = [];

1360

1361 super.dispose();

1362 }

1363 > } async.ts

1364 >

1365 > export interface IThrottledWorkerOptions {

1366 >

1367 > /**

1368 > * maximum of units the worker will pass onto handler at once

1369 > */

1370 > maxWorkChunkSize: number;

1371 >

1372 > /**

1373 > * maximum of units the worker will keep in memory for processing

1374 > */

1375 > maxBufferedWork: number | undefined;

1376 >

1377 > /**

1378 > * delay before processing the next round of chunks when chunk size exceeds limits

1379 > */

1380 > throttleDelay: number;

1381 >

1382 > /**

1383 > * When enabled will guarantee that two distinct calls to `work()` are not executed

1384 > * without throttle delay between them.

1385 > * Otherwise if the worker isn't currently throttling it will execute work immediately.

1386 > */

1387 > waitThrottleDelayBetweenWorkUnits?: boolean;

1388 > }

1389 >

1390 > /**

1391 > * The `ThrottledWorker` will accept units of work `T`

1392 > * to handle. The contract is:

1393 > * * there is a maximum of units the worker can handle at once (via `maxWorkChunkSize`)

1394 > * * there is a maximum of units the worker will keep in memory for processing (via `maxBufferedWork`)

1395 > * * after having handled `maxWorkChunkSize` units, the worker needs to rest (via `throttleDelay`)

1396 > */

1397 > export class ThrottledWorker<T> extends Disposable {

1398 >

1399 > private readonly pendingWork: T[] = [];

1400 >

1401 > private readonly throttler = this._register(new MutableDisposable<RunOnceScheduler>());

1402 > private disposed = false;

1403 > private lastExecutionTime = 0;

1404 >

1405 > constructor(

1406 private options: IThrottledWorkerOptions,

1407 private readonly handler: (units: T[]) => void

1409 super();

1410 }

1411 > async.ts

1412 > /**

1413 > * The number of work units that are pending to be processed.

1414 > */

1415 > get pending(): number { return this.pendingWork.length; }

1416 >

1417 > /**

1418 > * Add units to be worked on. Use `pending` to figure out

1419 > * how many units are not yet processed after this method

1420 > * was called.

1421 > *

1422 > * @returns whether the work was accepted or not. If the

1423 > * worker is disposed, it will not accept any more work.

1424 > * If the number of pending units would become larger

1425 > * than `maxPendingWork`, more work will also not be accepted.

1426 > */

1427 > work(units: readonly T[]): boolean {

1428 if (this.disposed) {

1429 return false; // work not accepted: disposed

1469 return true; // work accepted

1470 }

1471 > async.ts

1472 > private doWork(): void {

1473 this.lastExecutionTime = Date.now();

1474

1481 }

1482 }

1483 > async.ts

1484 > private scheduleThrottler(delay = this.options.throttleDelay): void {

1485 this.throttler.value = new RunOnceScheduler(() => {

1486 this.throttler.clear();

1490 this.throttler.value.schedule();

1491 }

1492 > async.ts

1493 > override dispose(): void {

1494 super.dispose();

1495

1497 this.disposed = true;

1498 }

1499 > } async.ts

1500 >

1501 > //#region -- run on idle tricks ------------

1502 >

1503 > export interface IdleDeadline {

1504 > readonly didTimeout: boolean;

1505 > timeRemaining(): number;

1506 > }

1507 >

1508 > type IdleApi = Pick<typeof globalThis, 'requestIdleCallback' | 'cancelIdleCallback'>;

1509 >

1510 >

1511 > /**

1512 > * Execute the callback the next time the browser is idle, returning an

1513 > * {@link IDisposable} that will cancel the callback when disposed. This wraps

1514 > * [requestIdleCallback] so it will fallback to [setTimeout] if the environment

1515 > * doesn't support it.

1516 > *

1517 > * @param callback The callback to run when idle, this includes an

1518 > * [IdleDeadline] that provides the time alloted for the idle callback by the

1519 > * browser. Not respecting this deadline will result in a degraded user

1520 > * experience.

1521 > * @param timeout A timeout at which point to queue no longer wait for an idle

1522 > * callback but queue it on the regular event loop (like setTimeout). Typically

1523 > * this should not be used.

1524 > *

1525 > * [IdleDeadline]: https://developer.mozilla.org/en-US/docs/Web/API/IdleDeadline

1526 > * [requestIdleCallback]: https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback

1527 > * [setTimeout]: https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout

1528 > *

1529 > * **Note** that there is `dom.ts#runWhenWindowIdle` which is better suited when running inside a browser

1530 > * context

1531 > */

1532 > export let runWhenGlobalIdle: (callback: (idle: IdleDeadline) => void, timeout?: number) => IDisposable;

1533 >

1534 > export let _runWhenIdle: (targetWindow: IdleApi, callback: (idle: IdleDeadline) => void, timeout?: number) => IDisposable;

1535 >

1536 > (function () {

1537 > const safeGlobal: any = globalThis;

1538 > if (typeof safeGlobal.requestIdleCallback !== 'function' || typeof safeGlobal.cancelIdleCallback !== 'function') {

1539 > _runWhenIdle = (_targetWindow, runner, timeout?) => {

1540 setTimeout0(() => {

1541 if (disposed) {

1561 };

1562 };

1563 > } else { async.ts

1564 _runWhenIdle = (targetWindow: typeof safeGlobal, runner, timeout?) => {

1565 const handle: number = targetWindow.requestIdleCallback(runner, typeof timeout === 'number' ? { timeout } : undefined);

1576 };

1577 }

1578 > runWhenGlobalIdle = (runner, timeout) => _runWhenIdle(globalThis, runner, timeout); async.ts

1579 > })();

1580 >

1581 > export function installFakeRunWhenIdle(fakeImpl: typeof _runWhenIdle): IDisposable {

1582 const origRunWhenIdle = _runWhenIdle;

1583 const origRunWhenGlobalIdle = runWhenGlobalIdle;

1589 });

1590 }

1591 > async.ts

1592 > export abstract class AbstractIdleValue<T> {

1593 >

1594 > private readonly _executor: () => void;

1595 > private readonly _handle: IDisposable;

1596 >

1597 > private _didRun: boolean = false;

1598 > private _value?: T;

1599 > private _error: unknown;

1600 >

1601 > constructor(targetWindow: IdleApi, executor: () => T) {

1602 this._executor = () => {

1603 try {

1611 this._handle = _runWhenIdle(targetWindow, () => this._executor());

1612 }

1613 > async.ts

1614 > dispose(): void {

1615 this._handle.dispose();

1616 }

1617 > async.ts

1618 > get value(): T {

1619 if (!this._didRun) {

1620 this._handle.dispose();

1626 return this._value!;

1627 }

1628 > async.ts

1629 > get isInitialized(): boolean {

1630 return this._didRun;

1631 }

1632 > } async.ts

1633 >

1634 > /**

1635 > * An `IdleValue` that always uses the current window (which might be throttled or inactive)

1636 > *

1637 > * **Note** that there is `dom.ts#WindowIdleValue` which is better suited when running inside a browser

1638 > * context

1639 > */

1640 > export class GlobalIdleValue<T> extends AbstractIdleValue<T> {

1641 >

1642 > constructor(executor: () => T) {

1643 super(globalThis, executor);

1644 }

1645 > } async.ts

1646 >

1647 > //#endregion

1648 >

1649 export async function retry<T>(task: ITask<Promise<T>>, delay: number, retries: number): Promise<T> {

1650 let lastError: Error | undefined;

1662 throw lastError;

1663 }

1664 > async.ts

1665 > //#region Task Sequentializer

1666 >

1667 > interface IRunningTask {

1668 > readonly taskId: number;

1669 > readonly cancel: () => void;

1670 > readonly promise: Promise<void>;

1671 > }

1672 >

1673 > interface IQueuedTask {

1674 > readonly promise: Promise<void>;

1675 > readonly promiseResolve: () => void;

1676 > readonly promiseReject: (error: Error) => void;

1677 > run: ITask<Promise<void>>;

1678 > }

1679 >

1680 > export interface ITaskSequentializerWithRunningTask {

1681 > readonly running: Promise<void>;

1682 > }

1683 >

1684 > export interface ITaskSequentializerWithQueuedTask {

1685 > readonly queued: IQueuedTask;

1686 > }

1687 >

1688 > /**

1689 > * @deprecated use `LimitedQueue` instead for an easier to use API

1690 > */

1691 > export class TaskSequentializer {

1692 >

1693 > private _running?: IRunningTask;

1694 > private _queued?: IQueuedTask;

1695 >

1696 > isRunning(taskId?: number): this is ITaskSequentializerWithRunningTask {

1697 if (typeof taskId === 'number') {

1698 return this._running?.taskId === taskId;

1701 return !!this._running;

1702 }

1703 > async.ts

1704 > get running(): Promise<void> | undefined {

1705 return this._running?.promise;

1706 }

1707 > async.ts

1708 > cancelRunning(): void {

1709 this._running?.cancel();

1710 }

1711 > async.ts

1712 > run(taskId: number, promise: Promise<void>, onCancel?: () => void,): Promise<void> {

1713 this._running = { taskId, cancel: () => onCancel?.(), promise };

1714

1717 return promise;

1718 }

1719 > async.ts

1720 > private doneRunning(taskId: number): void {

1721 if (this._running && taskId === this._running.taskId) {

1722

1728 }

1729 }

1730 > async.ts

1731 > private runQueued(): void {

1732 if (this._queued) {

1733 const queued = this._queued;

1738 }

1739 }

1740 > async.ts

1741 > /**

1742 > * Note: the promise to schedule as next run MUST itself call `run`.

1743 > * Otherwise, this sequentializer will report `false` for `isRunning`

1744 > * even when this task is running. Missing this detail means that

1745 > * suddenly multiple tasks will run in parallel.

1746 > */

1747 > queue(run: ITask<Promise<void>>): Promise<void> {

1748

1749 // this is our first queued task, so we create associated promise with it

1767 return this._queued.promise;

1768 }

1769 > async.ts

1770 > hasQueued(): this is ITaskSequentializerWithQueuedTask {

1771 return !!this._queued;

1772 }

1773 > async.ts

1774 > async join(): Promise<void> {

1775 return this._queued?.promise ?? this._running?.promise;

1776 }

1777 > } async.ts

1778 >

1779 > //#endregion

1780 >

1781 > //#region

1782 >

1783 > /**

1784 > * The `IntervalCounter` allows to count the number

1785 > * of calls to `increment()` over a duration of

1786 > * `interval`. This utility can be used to conditionally

1787 > * throttle a frequent task when a certain threshold

1788 > * is reached.

1789 > */

1790 > export class IntervalCounter {

1791 >

1792 > private lastIncrementTime = 0;

1793 >

1794 > private value = 0;

1795 >

1796 > constructor(private readonly interval: number, private readonly nowFn = () => Date.now()) { }

1797 >

1798 > increment(): number {

1799 const now = this.nowFn();

1800

1810 return this.value;

1811 }

1812 > } async.ts

1813 >

1814 > //#endregion

1815 >

1816 > //#region

1817 >

1818 > export type ValueCallback<T = unknown> = (value: T | Promise<T>) => void;

1819 >

1820 > const enum DeferredOutcome {

1821 > Resolved,

1822 > Rejected

1823 > }

1824 >

1825 > /**

1826 > * Creates a promise whose resolution or rejection can be controlled imperatively.

1827 > */

1828 > export class DeferredPromise<T> {

1829 >

1830 > public static fromPromise<T>(promise: Promise<T>): DeferredPromise<T> {

1831 const deferred = new DeferredPromise<T>();

1832 deferred.settleWith(promise);

1833 return deferred;

1834 }

1835 > async.ts

1836 > private completeCallback!: ValueCallback<T>;

1837 > private errorCallback!: (err: unknown) => void;

1838 > private outcome?: { outcome: DeferredOutcome.Rejected; value: unknown } | { outcome: DeferredOutcome.Resolved; value: T };

1839 >

1840 > public get isRejected() {

1841 return this.outcome?.outcome === DeferredOutcome.Rejected;

1842 }

1843 > async.ts

1844 > public get isResolved() {

1845 return this.outcome?.outcome === DeferredOutcome.Resolved;

1846 }

1847 > async.ts

1848 > public get isSettled() {

1849 return !!this.outcome;

1850 }

1851 > async.ts

1852 > public get value() {

1853 return this.outcome?.outcome === DeferredOutcome.Resolved ? this.outcome?.value : undefined;

1854 }

1855 > async.ts

1856 > public readonly p: Promise<T>;

1857 >

1858 > constructor() {

1859 this.p = new Promise<T>((c, e) => {

1860 this.completeCallback = c;

1862 });

1863 }

1864 > async.ts

1865 > public complete(value: T) {

1866 if (this.isSettled) {

1867 return Promise.resolve();

1874 });

1875 }

1876 > async.ts

1877 > public error(err: unknown) {

1878 if (this.isSettled) {

1879 return Promise.resolve();

1886 });

1887 }

1888 > async.ts

1889 > public settleWith(promise: Promise<T>): Promise<void> {

1890 return promise.then(

1891 value => this.complete(value),

1893 );

1894 }

1895 > async.ts

1896 > public cancel() {

1897 return this.error(new CancellationError());

1898 }

1899 > } async.ts

1900 >

1901 > //#endregion

1902 >

1903 > //#region Promises

1904 >

1905 > export namespace Promises {

1906 >

1907 > /**

1908 > * A drop-in replacement for `Promise.all` with the only difference

1909 > * that the method awaits every promise to either fulfill or reject.

1910 > *

1911 > * Similar to `Promise.all`, only the first error will be returned

1912 > * if any.

1913 > */

1914 > export async function settled<T>(promises: Promise<T>[]): Promise<T[]> {

1915 let firstError: Error | undefined = undefined;

1916

1929 return result as unknown as T[]; // cast is needed and protected by the `throw` above

1930 }

1931 > async.ts

1932 > /**

1933 > * A helper to create a new `Promise<T>` with a body that is a promise

1934 > * itself. By default, an error that raises from the async body will

1935 > * end up as a unhandled rejection, so this utility properly awaits the

1936 > * body and rejects the promise as a normal promise does without async

1937 > * body.

1938 > *

1939 > * This method should only be used in rare cases where otherwise `async`

1940 > * cannot be used (e.g. when callbacks are involved that require this).

1941 > */

1942 > export function withAsyncBody<T, E = Error>(bodyFn: (resolve: (value: T) => unknown, reject: (error: E) => unknown) => Promise<unknown>): Promise<T> {

1943 // eslint-disable-next-line no-async-promise-executor

1944 return new Promise<T>(async (resolve, reject) => {

1950 });

1951 }

1952 > } async.ts

1953 >

1954 > export class StatefulPromise<T> {

1955 > private _value: T | undefined = undefined;

1956 > get value(): T | undefined { return this._value; }

1957 >

1958 > private _error: unknown = undefined;

1959 > get error(): unknown { return this._error; }

1960 >

1961 > private _isResolved = false;

1962 > get isResolved() { return this._isResolved; }

1963 >

1964 > public readonly promise: Promise<T>;

1965 >

1966 > constructor(promise: Promise<T>) {

1967 this.promise = promise.then(

1968 value => {

1978 );

1979 }

1980 > async.ts

1981 > /**

1982 > * Returns the resolved value.

1983 > * Throws if the promise is not resolved yet.

1984 > */

1985 > public requireValue(): T {

1986 if (!this._isResolved) {

1987 throw new BugIndicatingError('Promise is not resolved yet');

1992 return this._value!;

1993 }

1994 > } async.ts

1995 >

1996 > export class LazyStatefulPromise<T> {

1997 > private readonly _promise = new Lazy(() => new StatefulPromise(this._compute()));

1998 >

1999 > constructor(

2000 private readonly _compute: () => Promise<T>,

2001 ) { }

2002 > async.ts

2003 > /**

2004 > * Returns the resolved value.

2005 > * Throws if the promise is not resolved yet.

2006 > */

2007 > public requireValue(): T {

2008 return this._promise.value.requireValue();

2009 }

2010 > async.ts

2011 > /**

2012 > * Returns the promise (and triggers a computation of the promise if not yet done so).

2013 > */

2014 > public getPromise(): Promise<T> {

2015 return this._promise.value.promise;

2016 }

2017 > async.ts

2018 > /**

2019 > * Reads the current value without triggering a computation of the promise.

2020 > */

2021 > public get currentValue(): T | undefined {

2022 return this._promise.rawValue?.value;

2023 }

2024 > } async.ts

2025 >

2026 > //#endregion

2027 >

2028 > //#region

2029 >

2030 > const enum AsyncIterableSourceState {

2031 > Initial,

2032 > DoneOK,

2033 > DoneError,

2034 > }

2035 >

2036 > /**

2037 > * An object that allows to emit async values asynchronously or bring the iterable to an error state using `reject()`.

2038 > * This emitter is valid only for the duration of the executor (until the promise returned by the executor settles).

2039 > */

2040 > export interface AsyncIterableEmitter<T> {

2041 > /**

2042 > * The value will be appended at the end.

2043 > *

2044 > * **NOTE** If `reject()` has already been called, this method has no effect.

2045 > */

2046 > emitOne(value: T): void;

2047 > /**

2048 > * The values will be appended at the end.

2049 > *

2050 > * **NOTE** If `reject()` has already been called, this method has no effect.

2051 > */

2052 > emitMany(values: T[]): void;

2053 > /**

2054 > * Writing an error will permanently invalidate this iterable.

2055 > * The current users will receive an error thrown, as will all future users.

2056 > *

2057 > * **NOTE** If `reject()` have already been called, this method has no effect.

2058 > */

2059 > reject(error: Error): void;

2060 > }

2061 >

2062 > /**

2063 > * An executor for the `AsyncIterableObject` that has access to an emitter.

2064 > */

2065 > export interface AsyncIterableExecutor<T> {

2066 > /**

2067 > * @param emitter An object that allows to emit async values valid only for the duration of the executor.

2068 > */

2069 > (emitter: AsyncIterableEmitter<T>): unknown | Promise<unknown>;

2070 > }

2071 >

2072 > /**

2073 > * A rich implementation for an `AsyncIterable<T>`.

2074 > */

2075 > export class AsyncIterableObject<T> implements AsyncIterable<T> {

2076 >

2077 > public static fromArray<T>(items: T[]): AsyncIterableObject<T> {

2078 > return new AsyncIterableObject<T>((writer) => {

2079 > writer.emitMany(items);

2080 > });

2081 > }

2082 >

2083 > public static fromPromise<T>(promise: Promise<T[]>): AsyncIterableObject<T> {

2084 return new AsyncIterableObject<T>(async (emitter) => {

2085 emitter.emitMany(await promise);

2086 });

2087 }

2088 > async.ts

2089 > public static fromPromisesResolveOrder<T>(promises: Promise<T>[]): AsyncIterableObject<T> {

2090 return new AsyncIterableObject<T>(async (emitter) => {

2091 await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));

2092 });

2093 }

2094 > async.ts

2095 > public static merge<T>(iterables: AsyncIterable<T>[]): AsyncIterableObject<T> {

2096 return new AsyncIterableObject(async (emitter) => {

2097 await Promise.all(iterables.map(async (iterable) => {

2102 });

2103 }

2104 > async.ts

2105 > public static EMPTY = AsyncIterableObject.fromArray<any>([]);

2106 >

2107 > private _state: AsyncIterableSourceState;

2108 > private _results: T[];

2109 > private _error: Error | null;

2110 > private readonly _onReturn?: () => void | Promise<void>;

2111 > private readonly _onStateChanged: Emitter<void>;

2112 >

2113 > constructor(executor: AsyncIterableExecutor<T>, onReturn?: () => void | Promise<void>) {

2114 > this._state = AsyncIterableSourceState.Initial;

2115 > this._results = [];

2116 > this._error = null;

2117 > this._onReturn = onReturn;

2118 > this._onStateChanged = new Emitter<void>();

2119 >

2120 > queueMicrotask(async () => {

2121 > const writer: AsyncIterableEmitter<T> = {

2122 > emitOne: (item) => this.emitOne(item),

2123 > emitMany: (items) => this.emitMany(items),

2124 > reject: (error) => this.reject(error)

2125 > };

2126 > try {

2127 > await Promise.resolve(executor(writer));

2128 > this.resolve();

2129 > } catch (err) {

2130 this.reject(err);

2131 > } finally { async.ts

2132 > // The executor has settled; emitting afterwards must be a no-op per the

2133 > // documented "no effect after resolve()/reject()" contract (see emitOne).

2134 > writer.emitOne = () => { };

2135 > writer.emitMany = () => { };

2136 > writer.reject = () => { };

2137 > }

2138 > });

2139 > }

2140 >

2141 > [Symbol.asyncIterator](): AsyncIterator<T, undefined, undefined> {

2142 let i = 0;

2143 return {

2162 };

2163 }

2164 > async.ts

2165 > public static map<T, R>(iterable: AsyncIterable<T>, mapFn: (item: T) => R): AsyncIterableObject<R> {

2166 return new AsyncIterableObject<R>(async (emitter) => {

2167 for await (const item of iterable) {

2170 });

2171 }

2172 > async.ts

2173 > public map<R>(mapFn: (item: T) => R): AsyncIterableObject<R> {

2174 return AsyncIterableObject.map(this, mapFn);

2175 }

2176 > async.ts

2177 > public static filter<T>(iterable: AsyncIterable<T>, filterFn: (item: T) => boolean): AsyncIterableObject<T> {

2178 return new AsyncIterableObject<T>(async (emitter) => {

2179 for await (const item of iterable) {

2184 });

2185 }

2186 > async.ts

2187 > public filter<T2 extends T>(filterFn: (item: T) => item is T2): AsyncIterableObject<T2>;

2188 > public filter(filterFn: (item: T) => boolean): AsyncIterableObject<T>;

2189 > public filter(filterFn: (item: T) => boolean): AsyncIterableObject<T> {

2190 return AsyncIterableObject.filter(this, filterFn);

2191 }

2192 > async.ts

2193 > public static coalesce<T>(iterable: AsyncIterable<T | undefined | null>): AsyncIterableObject<T> {

2194 return <AsyncIterableObject<T>>AsyncIterableObject.filter(iterable, item => !!item);

2195 }

2196 > async.ts

2197 > public coalesce(): AsyncIterableObject<NonNullable<T>> {

2198 return AsyncIterableObject.coalesce(this) as AsyncIterableObject<NonNullable<T>>;

2199 }

2200 > async.ts

2201 > public static async toPromise<T>(iterable: AsyncIterable<T>): Promise<T[]> {

2202 const result: T[] = [];

2203 for await (const item of iterable) {

2206 return result;

2207 }

2208 > async.ts

2209 > public toPromise(): Promise<T[]> {

2210 return AsyncIterableObject.toPromise(this);

2211 }

2212 > async.ts

2213 > /**

2214 > * The value will be appended at the end.

2215 > *

2216 > * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.

2217 > */

2218 > private emitOne(value: T): void {

2219 if (this._state !== AsyncIterableSourceState.Initial) {

2220 return;

2225 this._onStateChanged.fire();

2226 }

2227 > async.ts

2228 > /**

2229 > * The values will be appended at the end.

2230 > *

2231 > * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.

2232 > */

2233 > private emitMany(values: T[]): void {

2234 > if (this._state !== AsyncIterableSourceState.Initial) {

2235 return;

2236 }

2237 > // it is important to add new values at the end, async.ts

2238 > // as we may have iterators already running on the array

2239 > this._results = this._results.concat(values);

2240 > this._onStateChanged.fire();

2241 > }

2242 >

2243 > /**

2244 > * Calling `resolve()` will mark the result array as complete.

2245 > *

2246 > * **NOTE** `resolve()` must be called, otherwise all consumers of this iterable will hang indefinitely, similar to a non-resolved promise.

2247 > * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.

2248 > */

2249 > private resolve(): void {

2250 > if (this._state !== AsyncIterableSourceState.Initial) {

2251 return;

2252 }

2253 > this._state = AsyncIterableSourceState.DoneOK; async.ts

2254 > this._onStateChanged.fire();

2255 > }

2256 >

2257 > /**

2258 > * Writing an error will permanently invalidate this iterable.

2259 > * The current users will receive an error thrown, as will all future users.

2260 > *

2261 > * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.

2262 > */

2263 > private reject(error: Error) {

2264 if (this._state !== AsyncIterableSourceState.Initial) {

2265 return;

2269 this._onStateChanged.fire();

2270 }

2271 > } async.ts

2272 >

2273 >

2274 > export function createCancelableAsyncIterableProducer<T>(callback: (token: CancellationToken) => AsyncIterable<T>): CancelableAsyncIterableProducer<T> {

2275 const source = new CancellationTokenSource();

2276 const innerIterable = callback(source.token);

2299 });

2300 }

2301 > async.ts

2302 > export class AsyncIterableSource<T> {

2303 >

2304 > private readonly _deferred = new DeferredPromise<void>();

2305 > private readonly _asyncIterable: AsyncIterableObject<T>;

2306 >

2307 > private _errorFn: (error: Error) => void;

2308 > private _emitOneFn: (item: T) => void;

2309 > private _emitManyFn: (item: T[]) => void;

2310 >

2311 > /**

2312 > *

2313 > * @param onReturn A function that will be called when consuming the async iterable

2314 > * has finished by the consumer, e.g the for-await-loop has be existed (break, return) early.

2315 > * This is NOT called when resolving this source by its owner.

2316 > */

2317 > constructor(onReturn?: () => Promise<void> | void) {

2318 this._asyncIterable = new AsyncIterableObject(emitter => {

2319

2354 };

2355 }

2356 > async.ts

2357 > get asyncIterable(): AsyncIterableObject<T> {

2358 return this._asyncIterable;

2359 }

2360 > async.ts

2361 > resolve(): void {

2362 this._deferred.complete();

2363 }

2364 > async.ts

2365 > reject(error: Error): void {

2366 this._errorFn(error);

2367 this._deferred.complete();

2368 }

2369 > async.ts

2370 > emitOne(item: T): void {

2371 this._emitOneFn(item);

2372 }

2373 > async.ts

2374 > emitMany(items: T[]) {

2375 this._emitManyFn(items);

2376 }

2377 > } async.ts

2378 >

2379 > export function cancellableIterable<T>(iterableOrIterator: AsyncIterator<T> | AsyncIterable<T>, token: CancellationToken): AsyncIterableIterator<T> {

2380 const iterator = Symbol.asyncIterator in iterableOrIterator ? iterableOrIterator[Symbol.asyncIterator]() : iterableOrIterator;

2381

2395 };

2396 }

2397 > async.ts

2398 > type ProducerConsumerValue<T> = {

2399 > ok: true;

2400 > value: T;

2401 > } | {

2402 > ok: false;

2403 > error: Error;

2404 > };

2405 >

2406 > class ProducerConsumer<T> {

2407 > private readonly _unsatisfiedConsumers: DeferredPromise<T>[] = [];

2408 > private readonly _unconsumedValues: ProducerConsumerValue<T>[] = [];

2409 > private _finalValue: ProducerConsumerValue<T> | undefined;

2410 >

2411 > public get hasFinalValue(): boolean {

2412 > return !!this._finalValue;

2413 > }

2414 >

2415 > produce(value: ProducerConsumerValue<T>): void {

2416 this._ensureNoFinalValue();

2417 if (this._unsatisfiedConsumers.length > 0) {

2422 }

2423 }

2424 > async.ts

2425 > produceFinal(value: ProducerConsumerValue<T>): void {

2426 > this._ensureNoFinalValue();

2427 > this._finalValue = value;

2428 > for (const deferred of this._unsatisfiedConsumers) {

2429 this._resolveOrRejectDeferred(deferred, value);

2430 }

2431 > this._unsatisfiedConsumers.length = 0; async.ts

2432 > }

2433 >

2434 > private _ensureNoFinalValue(): void {

2435 > if (this._finalValue) {

2436 throw new BugIndicatingError('ProducerConsumer: cannot produce after final value has been set');

2437 }

2438 > } async.ts

2439 >

2440 > private _resolveOrRejectDeferred(deferred: DeferredPromise<T>, value: ProducerConsumerValue<T>): void {

2441 if (value.ok) {

2442 deferred.complete(value.value);

2445 }

2446 }

2447 > async.ts

2448 > consume(): Promise<T> {

2449 if (this._unconsumedValues.length > 0 || this._finalValue) {

2450 const value = this._unconsumedValues.length > 0 ? this._unconsumedValues.shift()! : this._finalValue!;

2460 }

2461 }

2462 > } async.ts

2463 >

2464 > /**

2465 > * Important difference to AsyncIterableObject:

2466 > * If it is iterated two times, the second iterator will not see the values emitted by the first iterator.

2467 > */

2468 > export class AsyncIterableProducer<T> implements AsyncIterable<T> {

2469 > private readonly _producerConsumer = new ProducerConsumer<IteratorResult<T>>();

2470 >

2471 > constructor(executor: AsyncIterableExecutor<T>, private readonly _onReturn?: () => void) {

2472 > queueMicrotask(async () => {

2473 > const p = executor({

2474 > emitOne: value => this._producerConsumer.produce({ ok: true, value: { done: false, value: value } }),

2475 > emitMany: values => {

2476 > for (const value of values) {

2477 this._producerConsumer.produce({ ok: true, value: { done: false, value: value } });

2478 }

2479 > }, async.ts

2480 > reject: error => this._finishError(error),

2481 > });

2482 >

2483 > if (!this._producerConsumer.hasFinalValue) {

2484 > try {

2485 > await p;

2486 > this._finishOk();

2487 > } catch (error) {

2488 this._finishError(error);

2489 }

2490 > } async.ts

2491 > });

2492 > }

2493 >

2494 > public static fromArray<T>(items: T[]): AsyncIterableProducer<T> {

2495 > return new AsyncIterableProducer<T>((writer) => {

2496 > writer.emitMany(items);

2497 > });

2498 > }

2499 >

2500 > public static fromPromise<T>(promise: Promise<T[]>): AsyncIterableProducer<T> {

2501 return new AsyncIterableProducer<T>(async (emitter) => {

2502 emitter.emitMany(await promise);

2503 });

2504 }

2505 > async.ts

2506 > public static fromPromisesResolveOrder<T>(promises: Promise<T>[]): AsyncIterableProducer<T> {

2507 return new AsyncIterableProducer<T>(async (emitter) => {

2508 await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));

2509 });

2510 }

2511 > async.ts

2512 > public static merge<T>(iterables: AsyncIterable<T>[]): AsyncIterableProducer<T> {

2513 return new AsyncIterableProducer(async (emitter) => {

2514 await Promise.all(iterables.map(async (iterable) => {

2519 });

2520 }

2521 > async.ts

2522 > public static EMPTY = AsyncIterableProducer.fromArray<any>([]);

2523 >

2524 > public static map<T, R>(iterable: AsyncIterable<T>, mapFn: (item: T) => R): AsyncIterableProducer<R> {

2525 return new AsyncIterableProducer<R>(async (emitter) => {

2526 for await (const item of iterable) {

2529 });

2530 }

2531 > async.ts

2532 > public static tee<T>(iterable: AsyncIterable<T>): [AsyncIterableProducer<T>, AsyncIterableProducer<T>] {

2533 let emitter1: AsyncIterableEmitter<T> | undefined;

2534 let emitter2: AsyncIterableEmitter<T> | undefined;

2565 return [p1, p2];

2566 }

2567 > async.ts

2568 > public map<R>(mapFn: (item: T) => R): AsyncIterableProducer<R> {

2569 return AsyncIterableProducer.map(this, mapFn);

2570 }

2571 > async.ts

2572 > public static coalesce<T>(iterable: AsyncIterable<T | undefined | null>): AsyncIterableProducer<T> {

2573 return <AsyncIterableProducer<T>>AsyncIterableProducer.filter(iterable, item => !!item);

2574 }

2575 > async.ts

2576 > public coalesce(): AsyncIterableProducer<NonNullable<T>> {

2577 return AsyncIterableProducer.coalesce(this) as AsyncIterableProducer<NonNullable<T>>;

2578 }

2579 > async.ts

2580 > public static filter<T>(iterable: AsyncIterable<T>, filterFn: (item: T) => boolean): AsyncIterableProducer<T> {

2581 return new AsyncIterableProducer<T>(async (emitter) => {

2582 for await (const item of iterable) {

2587 });

2588 }

2589 > async.ts

2590 > public filter<T2 extends T>(filterFn: (item: T) => item is T2): AsyncIterableProducer<T2>;

2591 > public filter(filterFn: (item: T) => boolean): AsyncIterableProducer<T>;

2592 > public filter(filterFn: (item: T) => boolean): AsyncIterableProducer<T> {

2593 return AsyncIterableProducer.filter(this, filterFn);

2594 }

2595 > async.ts

2596 > private _finishOk(): void {

2597 > if (!this._producerConsumer.hasFinalValue) {

2598 > this._producerConsumer.produceFinal({ ok: true, value: { done: true, value: undefined } });

2599 > }

2600 > }

2601 >

2602 > private _finishError(error: Error): void {

2603 if (!this._producerConsumer.hasFinalValue) {

2604 this._producerConsumer.produceFinal({ ok: false, error: error });

2606 // Warning: this can cause to dropped errors.

2607 }

2608 > async.ts

2609 > private readonly _iterator: AsyncIterator<T, void, void> = {

2610 > next: () => this._producerConsumer.consume(),

2611 > return: () => {

2612 this._onReturn?.();

2613 return Promise.resolve({ done: true, value: undefined });

2614 },

2615 > throw: async (e) => { async.ts

2616 this._finishError(e);

2617 return { done: true, value: undefined };

2618 },

2619 > }; async.ts

2620 >

2621 > [Symbol.asyncIterator](): AsyncIterator<T, void, void> {

2622 return this._iterator;

2623 }

2624 > } async.ts

2625 >

2626 > export class CancelableAsyncIterableProducer<T> extends AsyncIterableProducer<T> {

2627 > constructor(

2628 private readonly _source: CancellationTokenSource,

2629 executor: AsyncIterableExecutor<T>

2631 super(executor);

2632 }

2633 > async.ts

2634 > cancel(): void {

2635 this._source.cancel();

2636 }

2637 > } async.ts

2638 >

2639 > //#endregion

2640 >

2641 > export const AsyncReaderEndOfStream = Symbol('AsyncReaderEndOfStream');

2642 >

2643 > export class AsyncReader<T> {

2644 > private _buffer: T[] = [];

2645 > private _atEnd = false;

2646 >

2647 > public get endOfStream(): boolean { return this._buffer.length === 0 && this._atEnd; }

2648 > private _extendBufferPromise: Promise<void> | undefined;

2649 >

2650 > constructor(

2651 private readonly _source: AsyncIterator<T>

2652 ) {

2653 }

2654 > async.ts

2655 > public async read(): Promise<T | typeof AsyncReaderEndOfStream> {

2656 if (this._buffer.length === 0 && !this._atEnd) {

2657 await this._extendBuffer();

2662 return this._buffer.shift()!;

2663 }

2664 > async.ts

2665 > public async readWhile(predicate: (value: T) => boolean, callback: (element: T) => unknown): Promise<void> {

2666 do {

2667 const piece = await this.peek();

2676 } while (true);

2677 }

2678 > async.ts

2679 > public readBufferedOrThrow(): T | typeof AsyncReaderEndOfStream {

2680 const value = this.peekBufferedOrThrow();

2681 this._buffer.shift();

2682 return value;

2683 }

2684 > async.ts

2685 > public async consumeToEnd(): Promise<void> {

2686 while (!this.endOfStream) {

2687 await this.read();

2688 }

2689 }

2690 > async.ts

2691 > public async peek(): Promise<T | typeof AsyncReaderEndOfStream> {

2692 if (this._buffer.length === 0 && !this._atEnd) {

2693 await this._extendBuffer();

2698 return this._buffer[0];

2699 }

2700 > async.ts

2701 > public peekBufferedOrThrow(): T | typeof AsyncReaderEndOfStream {

2702 if (this._buffer.length === 0) {

2703 if (this._atEnd) {

2709 return this._buffer[0];

2710 }

2711 > async.ts

2712 > public async peekTimeout(timeoutMs: number): Promise<T | typeof AsyncReaderEndOfStream | undefined> {

2713 if (this._buffer.length === 0 && !this._atEnd) {

2714 await raceTimeout(this._extendBuffer(), timeoutMs);

2722 return this._buffer[0];

2723 }

2724 > async.ts

2725 > private _extendBuffer(): Promise<void> {

2726 if (this._atEnd) {

2727 return Promise.resolve();

2742 return this._extendBufferPromise;

2743 }

2744 > } async.ts

2745 >

2746 > export function createTimeout(ms: number, cb: () => void): IDisposable {

2747 const t = setTimeout(cb, ms);

2748 return toDisposable(() => clearTimeout(t));

src/vs/platform/contextkey/common/contextkey.ts 929 covered LOC · 258 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- contextkey.ts

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 { CharCode } from '../../../base/common/charCode.js';

7 > import { Event } from '../../../base/common/event.js';

8 > import { isChrome, isEdge, isFirefox, isLinux, isMacintosh, isSafari, isWeb, isWindows } from '../../../base/common/platform.js';

9 > import { isFalsyOrWhitespace } from '../../../base/common/strings.js';

10 > import { Scanner, LexingError, Token, TokenType } from './scanner.js';

11 > import { createDecorator } from '../../instantiation/common/instantiation.js';

12 > import { localize } from '../../../nls.js';

13 > import { IDisposable } from '../../../base/common/lifecycle.js';

14 > import { illegalArgument } from '../../../base/common/errors.js';

15 >

16 > const CONSTANT_VALUES = new Map<string, boolean>();

17 > CONSTANT_VALUES.set('false', false);

18 > CONSTANT_VALUES.set('true', true);

19 > CONSTANT_VALUES.set('isMac', isMacintosh);

20 > CONSTANT_VALUES.set('isLinux', isLinux);

21 > CONSTANT_VALUES.set('isWindows', isWindows);

22 > CONSTANT_VALUES.set('isWeb', isWeb);

23 > CONSTANT_VALUES.set('isMacNative', isMacintosh && !isWeb);

24 > CONSTANT_VALUES.set('isEdge', isEdge);

25 > CONSTANT_VALUES.set('isFirefox', isFirefox);

26 > CONSTANT_VALUES.set('isChrome', isChrome);

27 > CONSTANT_VALUES.set('isSafari', isSafari);

28 >

29 > /** allow register constant context keys that are known only after startup; requires running `substituteConstants` on the context key - https://github.com/microsoft/vscode/issues/174218#issuecomment-1437972127 */

30 > export function setConstant(key: string, value: boolean) {

31 if (CONSTANT_VALUES.get(key) !== undefined) { throw illegalArgument('contextkey.setConstant(k, v) invoked with already set constant `k`'); }

32

33 CONSTANT_VALUES.set(key, value);

34 }

35 > contextkey.ts

36 > const hasOwnProperty = Object.prototype.hasOwnProperty;

37 >

38 > export const enum ContextKeyExprType {

39 > False = 0,

40 > True = 1,

41 > Defined = 2,

42 > Not = 3,

43 > Equals = 4,

44 > NotEquals = 5,

45 > And = 6,

46 > Regex = 7,

47 > NotRegex = 8,

48 > Or = 9,

49 > In = 10,

50 > NotIn = 11,

51 > Greater = 12,

52 > GreaterEquals = 13,

53 > Smaller = 14,

54 > SmallerEquals = 15,

55 > }

56 >

57 > export interface IContextKeyExprMapper {

58 > mapDefined(key: string): ContextKeyExpression;

59 > mapNot(key: string): ContextKeyExpression;

60 > mapEquals(key: string, value: any): ContextKeyExpression;

61 > mapNotEquals(key: string, value: any): ContextKeyExpression;

62 > mapGreater(key: string, value: any): ContextKeyExpression;

63 > mapGreaterEquals(key: string, value: any): ContextKeyExpression;

64 > mapSmaller(key: string, value: any): ContextKeyExpression;

65 > mapSmallerEquals(key: string, value: any): ContextKeyExpression;

66 > mapRegex(key: string, regexp: RegExp | null): ContextKeyRegexExpr;

67 > mapIn(key: string, valueKey: string): ContextKeyInExpr;

68 > mapNotIn(key: string, valueKey: string): ContextKeyNotInExpr;

69 > }

70 >

71 > export interface IContextKeyExpression {

72 > cmp(other: ContextKeyExpression): number;

73 > equals(other: ContextKeyExpression): boolean;

74 > substituteConstants(): ContextKeyExpression | undefined;

75 > evaluate(context: IContext): boolean;

76 > serialize(): string;

77 > keys(): string[];

78 > map(mapFnc: IContextKeyExprMapper): ContextKeyExpression;

79 > negate(): ContextKeyExpression;

80 >

81 > }

82 >

83 > export type ContextKeyExpression = (

84 > ContextKeyFalseExpr | ContextKeyTrueExpr | ContextKeyDefinedExpr | ContextKeyNotExpr

85 > | ContextKeyEqualsExpr | ContextKeyNotEqualsExpr | ContextKeyRegexExpr

86 > | ContextKeyNotRegexExpr | ContextKeyAndExpr | ContextKeyOrExpr | ContextKeyInExpr

87 > | ContextKeyNotInExpr | ContextKeyGreaterExpr | ContextKeyGreaterEqualsExpr

88 > | ContextKeySmallerExpr | ContextKeySmallerEqualsExpr

89 > );

90 >

91 >

92 > /*

93 >

94 > Syntax grammar:

95 >

96 > ```ebnf

97 >

98 > expression ::= or

99 >

100 > or ::= and { '||' and }*

101 >

102 > and ::= term { '&&' term }*

103 >

104 > term ::=

105 > | '!' (KEY | true | false | parenthesized)

106 > | primary

107 >

108 > primary ::=

109 > | 'true'

110 > | 'false'

111 > | parenthesized

112 > | KEY '=~' REGEX

113 > | KEY [ ('==' | '!=' | '<' | '<=' | '>' | '>=' | 'not' 'in' | 'in') value ]

114 >

115 > parenthesized ::=

116 > | '(' expression ')'

117 >

118 > value ::=

119 > | 'true'

120 > | 'false'

121 > | 'in' // we support `in` as a value because there's an extension that uses it, ie "when": "languageId == in"

122 > | VALUE // matched by the same regex as KEY; consider putting the value in single quotes if it's a string (e.g., with spaces)

123 > | SINGLE_QUOTED_STR

124 > | EMPTY_STR // this allows "when": "foo == " which's used by existing extensions

125 >

126 > ```

127 > */

128 >

129 > export type ParserConfig = {

130 > /**

131 > * with this option enabled, the parser can recover from regex parsing errors, e.g., unescaped slashes: `/src//` is accepted as `/src\//` would be

132 > */

133 > regexParsingWithErrorRecovery: boolean;

134 > };

135 >

136 > const defaultConfig: ParserConfig = {

137 > regexParsingWithErrorRecovery: true

138 > };

139 >

140 > export type ParsingError = {

141 > message: string;

142 > offset: number;

143 > lexeme: string;

144 > additionalInfo?: string;

145 > };

146 >

147 > const errorEmptyString = localize('contextkey.parser.error.emptyString', "Empty context key expression");

148 > const hintEmptyString = localize('contextkey.parser.error.emptyString.hint', "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively.");

149 > const errorNoInAfterNot = localize('contextkey.parser.error.noInAfterNot', "'in' after 'not'.");

150 > const errorClosingParenthesis = localize('contextkey.parser.error.closingParenthesis', "closing parenthesis ')'");

151 > const errorUnexpectedToken = localize('contextkey.parser.error.unexpectedToken', "Unexpected token");

152 > const hintUnexpectedToken = localize('contextkey.parser.error.unexpectedToken.hint', "Did you forget to put && or || before the token?");

153 > const errorUnexpectedEOF = localize('contextkey.parser.error.unexpectedEOF', "Unexpected end of expression");

154 > const hintUnexpectedEOF = localize('contextkey.parser.error.unexpectedEOF.hint', "Did you forget to put a context key?");

155 >

156 > /**

157 > * A parser for context key expressions.

158 > *

159 > * Example:

160 > * ```ts

161 > * const parser = new Parser();

162 > * const expr = parser.parse('foo == "bar" && baz == true');

163 > *

164 > * if (expr === undefined) {

165 > * // there were lexing or parsing errors

166 > * // process lexing errors with `parser.lexingErrors`

167 > * // process parsing errors with `parser.parsingErrors`

168 > * } else {

169 > * // expr is a valid expression

170 > * }

171 > * ```

172 > */

173 > export class Parser {

174 > // Note: this doesn't produce an exact syntax tree but a normalized one

175 > // ContextKeyExpression's that we use as AST nodes do not expose constructors that do not normalize

176 >

177 > private static _parseError = new Error();

178 >

179 > // lifetime note: `_scanner` lives as long as the parser does, i.e., is not reset between calls to `parse`

180 > private readonly _scanner = new Scanner();

181 >

182 > // lifetime note: `_tokens`, `_current`, and `_parsingErrors` must be reset between calls to `parse`

183 > private _tokens: Token[] = [];

184 > private _current = 0; // invariant: 0 <= this._current < this._tokens.length ; any incrementation of this value must first call `_isAtEnd`

185 > private _parsingErrors: ParsingError[] = [];

186 >

187 > get lexingErrors(): Readonly<LexingError[]> {

188 return this._scanner.errors;

189 }

190 > contextkey.ts

191 > get parsingErrors(): Readonly<ParsingError[]> {

192 return this._parsingErrors;

193 }

194 > contextkey.ts

195 > constructor(private readonly _config: ParserConfig = defaultConfig) {

196 > }

197 >

198 > /**

199 > * Parse a context key expression.

200 > *

201 > * @param input the expression to parse

202 > * @returns the parsed expression or `undefined` if there's an error - call `lexingErrors` and `parsingErrors` to see the errors

203 > */

204 > parse(input: string): ContextKeyExpression | undefined {

205

206 if (input === '') {

231 }

232 }

233 > contextkey.ts

234 > private _expr(): ContextKeyExpression | undefined {

235 return this._or();

236 }

237 > contextkey.ts

238 > private _or(): ContextKeyExpression | undefined {

239 const expr = [this._and()];

240

246 return expr.length === 1 ? expr[0] : ContextKeyExpr.or(...expr);

247 }

248 > contextkey.ts

249 > private _and(): ContextKeyExpression | undefined {

250 const expr = [this._term()];

251

257 return expr.length === 1 ? expr[0] : ContextKeyExpr.and(...expr);

258 }

259 > contextkey.ts

260 > private _term(): ContextKeyExpression | undefined {

261 if (this._matchOne(TokenType.Neg)) {

262 const peek = this._peek();

283 return this._primary();

284 }

285 > contextkey.ts

286 > private _primary(): ContextKeyExpression | undefined {

287

288 const peek = this._peek();

498 }

499 }

500 > contextkey.ts

501 > private _value(): string {

502 const token = this._peek();

503 switch (token.type) {

521 }

522 }

523 > contextkey.ts

524 > private _flagsGYRe = /g|y/g;

525 > private _removeFlagsGY(flags: string): string {

526 return flags.replaceAll(this._flagsGYRe, '');

527 }

528 > contextkey.ts

529 > // careful: this can throw if current token is the initial one (ie index = 0)

530 > private _previous() {

531 return this._tokens[this._current - 1];

532 }

533 > contextkey.ts

534 > private _matchOne(token: TokenType) {

535 if (this._check(token)) {

536 this._advance();

540 return false;

541 }

542 > contextkey.ts

543 > private _advance() {

544 if (!this._isAtEnd()) {

545 this._current++;

547 return this._previous();

548 }

549 > contextkey.ts

550 > private _consume(type: TokenType, message: string) {

551 if (this._check(type)) {

552 return this._advance();

555 throw this._errExpectedButGot(message, this._peek());

556 }

557 > contextkey.ts

558 > private _errExpectedButGot(expected: string, got: Token, additionalInfo?: string) {

559 const message = localize('contextkey.parser.error.expectedButGot', "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got));

560 const offset = got.offset;

563 return Parser._parseError;

564 }

565 > contextkey.ts

566 > private _check(type: TokenType) {

567 return this._peek().type === type;

568 }

569 > contextkey.ts

570 > private _peek() {

571 return this._tokens[this._current];

572 }

573 > contextkey.ts

574 > private _isAtEnd() {

575 return this._peek().type === TokenType.EOF;

576 }

577 > } contextkey.ts

578 >

579 > export abstract class ContextKeyExpr {

580 >

581 > public static false(): ContextKeyExpression {

582 return ContextKeyFalseExpr.INSTANCE;

583 }

584 > public static true(): ContextKeyExpression { contextkey.ts

585 return ContextKeyTrueExpr.INSTANCE;

586 }

587 > public static has(key: string): ContextKeyExpression { contextkey.ts

588 > return ContextKeyDefinedExpr.create(key); contextkey.ts

589 > }

590 > public static equals(key: string, value: any): ContextKeyExpression { contextkey.ts

591 return ContextKeyEqualsExpr.create(key, value);

592 }

593 > public static notEquals(key: string, value: any): ContextKeyExpression { contextkey.ts

594 return ContextKeyNotEqualsExpr.create(key, value);

595 }

596 > public static regex(key: string, value: RegExp): ContextKeyExpression { contextkey.ts

597 return ContextKeyRegexExpr.create(key, value);

598 }

599 > public static in(key: string, value: string): ContextKeyExpression { contextkey.ts

600 return ContextKeyInExpr.create(key, value);

601 }

602 > public static notIn(key: string, value: string): ContextKeyExpression { contextkey.ts

603 return ContextKeyNotInExpr.create(key, value);

604 }

605 > public static not(key: string): ContextKeyExpression { contextkey.ts

606 return ContextKeyNotExpr.create(key);

607 }

608 > public static and(...expr: Array<ContextKeyExpression | undefined | null>): ContextKeyExpression | undefined { contextkey.ts

609 > return ContextKeyAndExpr.create(expr, null, true); contextkey.ts

610 > }

611 > public static or(...expr: Array<ContextKeyExpression | undefined | null>): ContextKeyExpression | undefined { contextkey.ts

612 return ContextKeyOrExpr.create(expr, null, true);

613 }

614 > public static greater(key: string, value: number): ContextKeyExpression { contextkey.ts

615 return ContextKeyGreaterExpr.create(key, value);

616 }

617 > public static greaterEquals(key: string, value: number): ContextKeyExpression { contextkey.ts

618 return ContextKeyGreaterEqualsExpr.create(key, value);

619 }

620 > public static smaller(key: string, value: number): ContextKeyExpression { contextkey.ts

621 return ContextKeySmallerExpr.create(key, value);

622 }

623 > public static smallerEquals(key: string, value: number): ContextKeyExpression { contextkey.ts

624 return ContextKeySmallerEqualsExpr.create(key, value);

625 }

626 > contextkey.ts

627 > private static _parser = new Parser({ regexParsingWithErrorRecovery: false });

628 > public static deserialize(serialized: string | null | undefined): ContextKeyExpression | undefined {

629 if (serialized === undefined || serialized === null) { // an empty string needs to be handled by the parser to get a corresponding parsing error reported

630 return undefined;

634 return expr;

635 }

636 > contextkey.ts

637 > }

638 >

639 >

640 > export function validateWhenClauses(whenClauses: string[]): any {

641

642 const parser = new Parser({ regexParsingWithErrorRecovery: false }); // we run with no recovery to guide users to use correct regexes

664 });

665 }

666 > contextkey.ts

667 > export function expressionsAreEqualWithConstantSubstitution(a: ContextKeyExpression | null | undefined, b: ContextKeyExpression | null | undefined): boolean {

668 const aExpr = a ? a.substituteConstants() : undefined;

669 const bExpr = b ? b.substituteConstants() : undefined;

676 return aExpr.equals(bExpr);

677 }

678 > contextkey.ts

679 > function cmp(a: ContextKeyExpression, b: ContextKeyExpression): number { contextkey.ts

680 > return a.cmp(b);

681 > }

682 > contextkey.ts

683 > export class ContextKeyFalseExpr implements IContextKeyExpression {

684 > public static INSTANCE = new ContextKeyFalseExpr();

685 >

686 > public readonly type = ContextKeyExprType.False;

687 >

688 > protected constructor() {

689 > }

690 >

691 > public cmp(other: ContextKeyExpression): number {

692 return this.type - other.type;

693 }

694 > contextkey.ts

695 > public equals(other: ContextKeyExpression): boolean {

696 return (other.type === this.type);

697 }

698 > contextkey.ts

699 > public substituteConstants(): ContextKeyExpression | undefined {

700 return this;

701 }

702 > contextkey.ts

703 > public evaluate(context: IContext): boolean {

704 return false;

705 }

706 > contextkey.ts

707 > public serialize(): string {

708 return 'false';

709 }

710 > contextkey.ts

711 > public keys(): string[] {

712 return [];

713 }

714 > contextkey.ts

715 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

716 return this;

717 }

718 > contextkey.ts

719 > public negate(): ContextKeyExpression {

720 return ContextKeyTrueExpr.INSTANCE;

721 }

722 > } contextkey.ts

723 >

724 > export class ContextKeyTrueExpr implements IContextKeyExpression {

725 > public static INSTANCE = new ContextKeyTrueExpr();

726 >

727 > public readonly type = ContextKeyExprType.True;

728 >

729 > protected constructor() {

730 > }

731 >

732 > public cmp(other: ContextKeyExpression): number {

733 return this.type - other.type;

734 }

735 > contextkey.ts

736 > public equals(other: ContextKeyExpression): boolean {

737 return (other.type === this.type);

738 }

739 > contextkey.ts

740 > public substituteConstants(): ContextKeyExpression | undefined {

741 return this;

742 }

743 > contextkey.ts

744 > public evaluate(context: IContext): boolean {

745 return true;

746 }

747 > contextkey.ts

748 > public serialize(): string {

749 return 'true';

750 }

751 > contextkey.ts

752 > public keys(): string[] {

753 return [];

754 }

755 > contextkey.ts

756 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

757 return this;

758 }

759 > contextkey.ts

760 > public negate(): ContextKeyExpression {

761 return ContextKeyFalseExpr.INSTANCE;

762 }

763 > } contextkey.ts

764 >

765 > export class ContextKeyDefinedExpr implements IContextKeyExpression {

766 > public static create(key: string, negated: ContextKeyExpression | null = null): ContextKeyExpression {

767 > const constantValue = CONSTANT_VALUES.get(key);

768 > if (typeof constantValue === 'boolean') {

769 return constantValue ? ContextKeyTrueExpr.INSTANCE : ContextKeyFalseExpr.INSTANCE;

770 }

771 > return new ContextKeyDefinedExpr(key, negated); contextkey.ts

772 > }

773 >

774 > public readonly type = ContextKeyExprType.Defined;

775 >

776 > protected constructor(

777 > readonly key: string, contextkey.ts

778 > private negated: ContextKeyExpression | null

779 > ) {

780 > }

781 > contextkey.ts

782 > public cmp(other: ContextKeyExpression): number {

783 > if (other.type !== this.type) { contextkey.ts

784 > return this.type - other.type; contextkey.ts

785 > }

786 return cmp1(this.key, other.key);

787 > } contextkey.ts

788 > contextkey.ts

789 > public equals(other: ContextKeyExpression): boolean {

790 > if (other.type === this.type) { contextkey.ts

791 return (this.key === other.key);

792 }

793 > return false; contextkey.ts

794 > } contextkey.ts

795 > contextkey.ts

796 > public substituteConstants(): ContextKeyExpression | undefined {

797 const constantValue = CONSTANT_VALUES.get(this.key);

798 if (typeof constantValue === 'boolean') {

801 return this;

802 }

803 > contextkey.ts

804 > public evaluate(context: IContext): boolean {

805 return (!!context.getValue(this.key));

806 }

807 > contextkey.ts

808 > public serialize(): string {

809 return this.key;

810 }

811 > contextkey.ts

812 > public keys(): string[] {

813 return [this.key];

814 }

815 > contextkey.ts

816 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

817 return mapFnc.mapDefined(this.key);

818 }

819 > contextkey.ts

820 > public negate(): ContextKeyExpression {

821 > if (!this.negated) { contextkey.ts

822 > this.negated = ContextKeyNotExpr.create(this.key, this);

823 > }

824 > return this.negated;

825 > }

826 > } contextkey.ts

827 >

828 > export class ContextKeyEqualsExpr implements IContextKeyExpression {

829 >

830 > public static create(key: string, value: any, negated: ContextKeyExpression | null = null): ContextKeyExpression {

831 > if (typeof value === 'boolean') {

832 > return (value ? ContextKeyDefinedExpr.create(key, negated) : ContextKeyNotExpr.create(key, negated)); contextkey.ts

833 > }

834 > const constantValue = CONSTANT_VALUES.get(key); contextkey.ts

835 > if (typeof constantValue === 'boolean') {

836 > const trueValue = constantValue ? 'true' : 'false'; contextkey.ts

837 > return (value === trueValue ? ContextKeyTrueExpr.INSTANCE : ContextKeyFalseExpr.INSTANCE);

838 > }

839 > return new ContextKeyEqualsExpr(key, value, negated); contextkey.ts

840 > } contextkey.ts

841 >

842 > public readonly type = ContextKeyExprType.Equals;

843 >

844 > private constructor(

845 private readonly key: string,

846 private readonly value: any,

848 ) {

849 }

850 > contextkey.ts

851 > public cmp(other: ContextKeyExpression): number {

852 if (other.type !== this.type) {

853 return this.type - other.type;

855 return cmp2(this.key, this.value, other.key, other.value);

856 }

857 > contextkey.ts

858 > public equals(other: ContextKeyExpression): boolean {

859 if (other.type === this.type) {

860 return (this.key === other.key && this.value === other.value);

862 return false;

863 }

864 > contextkey.ts

865 > public substituteConstants(): ContextKeyExpression | undefined {

866 const constantValue = CONSTANT_VALUES.get(this.key);

867 if (typeof constantValue === 'boolean') {

871 return this;

872 }

873 > contextkey.ts

874 > public evaluate(context: IContext): boolean {

875 // Intentional ==

876 // eslint-disable-next-line eqeqeq

877 return (context.getValue(this.key) == this.value);

878 }

879 > contextkey.ts

880 > public serialize(): string {

881 return `${this.key} == '${this.value}'`;

882 }

883 > contextkey.ts

884 > public keys(): string[] {

885 return [this.key];

886 }

887 > contextkey.ts

888 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

889 return mapFnc.mapEquals(this.key, this.value);

890 }

891 > contextkey.ts

892 > public negate(): ContextKeyExpression {

893 if (!this.negated) {

894 this.negated = ContextKeyNotEqualsExpr.create(this.key, this.value, this);

896 return this.negated;

897 }

898 > } contextkey.ts

899 >

900 > export class ContextKeyInExpr implements IContextKeyExpression {

901 >

902 > public static create(key: string, valueKey: string): ContextKeyInExpr {

903 > return new ContextKeyInExpr(key, valueKey);

904 > }

905 >

906 > public readonly type = ContextKeyExprType.In;

907 > private negated: ContextKeyExpression | null = null;

908 >

909 > private constructor(

910 private readonly key: string,

911 private readonly valueKey: string,

912 ) {

913 }

914 > contextkey.ts

915 > public cmp(other: ContextKeyExpression): number {

916 if (other.type !== this.type) {

917 return this.type - other.type;

919 return cmp2(this.key, this.valueKey, other.key, other.valueKey);

920 }

921 > contextkey.ts

922 > public equals(other: ContextKeyExpression): boolean {

923 if (other.type === this.type) {

924 return (this.key === other.key && this.valueKey === other.valueKey);

926 return false;

927 }

928 > contextkey.ts

929 > public substituteConstants(): ContextKeyExpression | undefined {

930 return this;

931 }

932 > contextkey.ts

933 > public evaluate(context: IContext): boolean {

934 const source = context.getValue(this.valueKey);

935

964 return false;

965 }

966 > contextkey.ts

967 > public serialize(): string {

968 return `${this.key} in '${this.valueKey}'`;

969 }

970 > contextkey.ts

971 > public keys(): string[] {

972 return [this.key, this.valueKey];

973 }

974 > contextkey.ts

975 > public map(mapFnc: IContextKeyExprMapper): ContextKeyInExpr {

976 return mapFnc.mapIn(this.key, this.valueKey);

977 }

978 > contextkey.ts

979 > public negate(): ContextKeyExpression {

980 if (!this.negated) {

981 this.negated = ContextKeyNotInExpr.create(this.key, this.valueKey);

983 return this.negated;

984 }

985 > } contextkey.ts

986 >

987 > export class ContextKeyNotInExpr implements IContextKeyExpression {

988 >

989 > public static create(key: string, valueKey: string): ContextKeyNotInExpr {

990 > return new ContextKeyNotInExpr(key, valueKey);

991 > }

992 >

993 > public readonly type = ContextKeyExprType.NotIn;

994 >

995 > private readonly _negated: ContextKeyInExpr;

996 >

997 > private constructor(

998 private readonly key: string,

999 private readonly valueKey: string,

1001 this._negated = ContextKeyInExpr.create(key, valueKey);

1002 }

1003 > contextkey.ts

1004 > public cmp(other: ContextKeyExpression): number {

1005 if (other.type !== this.type) {

1006 return this.type - other.type;

1008 return this._negated.cmp(other._negated);

1009 }

1010 > contextkey.ts

1011 > public equals(other: ContextKeyExpression): boolean {

1012 if (other.type === this.type) {

1013 return this._negated.equals(other._negated);

1015 return false;

1016 }

1017 > contextkey.ts

1018 > public substituteConstants(): ContextKeyExpression | undefined {

1019 return this;

1020 }

1021 > contextkey.ts

1022 > public evaluate(context: IContext): boolean {

1023 return !this._negated.evaluate(context);

1024 }

1025 > contextkey.ts

1026 > public serialize(): string {

1027 return `${this.key} not in '${this.valueKey}'`;

1028 }

1029 > contextkey.ts

1030 > public keys(): string[] {

1031 return this._negated.keys();

1032 }

1033 > contextkey.ts

1034 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1035 return mapFnc.mapNotIn(this.key, this.valueKey);

1036 }

1037 > contextkey.ts

1038 > public negate(): ContextKeyExpression {

1039 return this._negated;

1040 }

1041 > } contextkey.ts

1042 >

1043 > export class ContextKeyNotEqualsExpr implements IContextKeyExpression {

1044 >

1045 > public static create(key: string, value: any, negated: ContextKeyExpression | null = null): ContextKeyExpression {

1046 > if (typeof value === 'boolean') {

1047 > if (value) { contextkey.ts

1048 > return ContextKeyNotExpr.create(key, negated); contextkey.ts

1049 > }

1050 > return ContextKeyDefinedExpr.create(key, negated); contextkey.ts

1051 > }

1052 > const constantValue = CONSTANT_VALUES.get(key); contextkey.ts

1053 > if (typeof constantValue === 'boolean') {

1054 > const falseValue = constantValue ? 'true' : 'false'; contextkey.ts

1055 > return (value === falseValue ? ContextKeyFalseExpr.INSTANCE : ContextKeyTrueExpr.INSTANCE);

1056 > }

1057 > return new ContextKeyNotEqualsExpr(key, value, negated); contextkey.ts

1058 > } contextkey.ts

1059 >

1060 > public readonly type = ContextKeyExprType.NotEquals;

1061 >

1062 > private constructor(

1063 private readonly key: string,

1064 private readonly value: any,

1066 ) {

1067 }

1068 > contextkey.ts

1069 > public cmp(other: ContextKeyExpression): number {

1070 if (other.type !== this.type) {

1071 return this.type - other.type;

1073 return cmp2(this.key, this.value, other.key, other.value);

1074 }

1075 > contextkey.ts

1076 > public equals(other: ContextKeyExpression): boolean {

1077 if (other.type === this.type) {

1078 return (this.key === other.key && this.value === other.value);

1080 return false;

1081 }

1082 > contextkey.ts

1083 > public substituteConstants(): ContextKeyExpression | undefined {

1084 const constantValue = CONSTANT_VALUES.get(this.key);

1085 if (typeof constantValue === 'boolean') {

1089 return this;

1090 }

1091 > contextkey.ts

1092 > public evaluate(context: IContext): boolean {

1093 // Intentional !=

1094 // eslint-disable-next-line eqeqeq

1095 return (context.getValue(this.key) != this.value);

1096 }

1097 > contextkey.ts

1098 > public serialize(): string {

1099 return `${this.key} != '${this.value}'`;

1100 }

1101 > contextkey.ts

1102 > public keys(): string[] {

1103 return [this.key];

1104 }

1105 > contextkey.ts

1106 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1107 return mapFnc.mapNotEquals(this.key, this.value);

1108 }

1109 > contextkey.ts

1110 > public negate(): ContextKeyExpression {

1111 if (!this.negated) {

1112 this.negated = ContextKeyEqualsExpr.create(this.key, this.value, this);

1114 return this.negated;

1115 }

1116 > } contextkey.ts

1117 >

1118 > export class ContextKeyNotExpr implements IContextKeyExpression {

1119 >

1120 > public static create(key: string, negated: ContextKeyExpression | null = null): ContextKeyExpression {

1121 > const constantValue = CONSTANT_VALUES.get(key);

1122 > if (typeof constantValue === 'boolean') {

1123 return (constantValue ? ContextKeyFalseExpr.INSTANCE : ContextKeyTrueExpr.INSTANCE);

1124 }

1125 > return new ContextKeyNotExpr(key, negated); contextkey.ts

1126 > }

1127 >

1128 > public readonly type = ContextKeyExprType.Not;

1129 >

1130 > private constructor(

1131 > private readonly key: string, contextkey.ts

1132 > private negated: ContextKeyExpression | null

1133 > ) {

1134 > }

1135 > contextkey.ts

1136 > public cmp(other: ContextKeyExpression): number {

1137 > if (other.type !== this.type) { contextkey.ts

1138 return this.type - other.type;

1139 }

1140 > return cmp1(this.key, other.key); contextkey.ts

1141 > } contextkey.ts

1142 > contextkey.ts

1143 > public equals(other: ContextKeyExpression): boolean {

1144 > if (other.type === this.type) { contextkey.ts

1145 > return (this.key === other.key); contextkey.ts

1146 > }

1147 return false;

1148 > } contextkey.ts

1149 > contextkey.ts

1150 > public substituteConstants(): ContextKeyExpression | undefined {

1151 const constantValue = CONSTANT_VALUES.get(this.key);

1152 if (typeof constantValue === 'boolean') {

1155 return this;

1156 }

1157 > contextkey.ts

1158 > public evaluate(context: IContext): boolean {

1159 return (!context.getValue(this.key));

1160 }

1161 > contextkey.ts

1162 > public serialize(): string {

1163 return `!${this.key}`;

1164 }

1165 > contextkey.ts

1166 > public keys(): string[] {

1167 return [this.key];

1168 }

1169 > contextkey.ts

1170 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1171 return mapFnc.mapNot(this.key);

1172 }

1173 > contextkey.ts

1174 > public negate(): ContextKeyExpression {

1175 > if (!this.negated) { contextkey.ts

1176 this.negated = ContextKeyDefinedExpr.create(this.key, this);

1177 }

1178 > return this.negated; contextkey.ts

1179 > }

1180 > } contextkey.ts

1181 >

1182 function withFloatOrStr<T extends ContextKeyExpression>(value: any, callback: (value: number | string) => T): T | ContextKeyFalseExpr {

1183 if (typeof value === 'string') {

1192 return ContextKeyFalseExpr.INSTANCE;

1193 }

1194 > contextkey.ts

1195 > export class ContextKeyGreaterExpr implements IContextKeyExpression {

1196 >

1197 > public static create(key: string, _value: any, negated: ContextKeyExpression | null = null): ContextKeyExpression {

1198 > return withFloatOrStr(_value, (value) => new ContextKeyGreaterExpr(key, value, negated));

1199 > }

1200 >

1201 > public readonly type = ContextKeyExprType.Greater;

1202 >

1203 > private constructor(

1204 private readonly key: string,

1205 private readonly value: number | string,

1206 private negated: ContextKeyExpression | null

1207 ) { }

1208 > contextkey.ts

1209 > public cmp(other: ContextKeyExpression): number {

1210 if (other.type !== this.type) {

1211 return this.type - other.type;

1213 return cmp2(this.key, this.value, other.key, other.value);

1214 }

1215 > contextkey.ts

1216 > public equals(other: ContextKeyExpression): boolean {

1217 if (other.type === this.type) {

1218 return (this.key === other.key && this.value === other.value);

1220 return false;

1221 }

1222 > contextkey.ts

1223 > public substituteConstants(): ContextKeyExpression | undefined {

1224 return this;

1225 }

1226 > contextkey.ts

1227 > public evaluate(context: IContext): boolean {

1228 if (typeof this.value === 'string') {

1229 return false;

1231 return (parseFloat(context.getValue<any>(this.key)) > this.value);

1232 }

1233 > contextkey.ts

1234 > public serialize(): string {

1235 return `${this.key} > ${this.value}`;

1236 }

1237 > contextkey.ts

1238 > public keys(): string[] {

1239 return [this.key];

1240 }

1241 > contextkey.ts

1242 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1243 return mapFnc.mapGreater(this.key, this.value);

1244 }

1245 > contextkey.ts

1246 > public negate(): ContextKeyExpression {

1247 if (!this.negated) {

1248 this.negated = ContextKeySmallerEqualsExpr.create(this.key, this.value, this);

1250 return this.negated;

1251 }

1252 > } contextkey.ts

1253 >

1254 > export class ContextKeyGreaterEqualsExpr implements IContextKeyExpression {

1255 >

1256 > public static create(key: string, _value: any, negated: ContextKeyExpression | null = null): ContextKeyExpression {

1257 > return withFloatOrStr(_value, (value) => new ContextKeyGreaterEqualsExpr(key, value, negated));

1258 > }

1259 >

1260 > public readonly type = ContextKeyExprType.GreaterEquals;

1261 >

1262 > private constructor(

1263 private readonly key: string,

1264 private readonly value: number | string,

1265 private negated: ContextKeyExpression | null

1266 ) { }

1267 > contextkey.ts

1268 > public cmp(other: ContextKeyExpression): number {

1269 if (other.type !== this.type) {

1270 return this.type - other.type;

1272 return cmp2(this.key, this.value, other.key, other.value);

1273 }

1274 > contextkey.ts

1275 > public equals(other: ContextKeyExpression): boolean {

1276 if (other.type === this.type) {

1277 return (this.key === other.key && this.value === other.value);

1279 return false;

1280 }

1281 > contextkey.ts

1282 > public substituteConstants(): ContextKeyExpression | undefined {

1283 return this;

1284 }

1285 > contextkey.ts

1286 > public evaluate(context: IContext): boolean {

1287 if (typeof this.value === 'string') {

1288 return false;

1290 return (parseFloat(context.getValue<any>(this.key)) >= this.value);

1291 }

1292 > contextkey.ts

1293 > public serialize(): string {

1294 return `${this.key} >= ${this.value}`;

1295 }

1296 > contextkey.ts

1297 > public keys(): string[] {

1298 return [this.key];

1299 }

1300 > contextkey.ts

1301 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1302 return mapFnc.mapGreaterEquals(this.key, this.value);

1303 }

1304 > contextkey.ts

1305 > public negate(): ContextKeyExpression {

1306 if (!this.negated) {

1307 this.negated = ContextKeySmallerExpr.create(this.key, this.value, this);

1309 return this.negated;

1310 }

1311 > } contextkey.ts

1312 >

1313 > export class ContextKeySmallerExpr implements IContextKeyExpression {

1314 >

1315 > public static create(key: string, _value: any, negated: ContextKeyExpression | null = null): ContextKeyExpression {

1316 > return withFloatOrStr(_value, (value) => new ContextKeySmallerExpr(key, value, negated));

1317 > }

1318 >

1319 > public readonly type = ContextKeyExprType.Smaller;

1320 >

1321 > private constructor(

1322 private readonly key: string,

1323 private readonly value: number | string,

1325 ) {

1326 }

1327 > contextkey.ts

1328 > public cmp(other: ContextKeyExpression): number {

1329 if (other.type !== this.type) {

1330 return this.type - other.type;

1332 return cmp2(this.key, this.value, other.key, other.value);

1333 }

1334 > contextkey.ts

1335 > public equals(other: ContextKeyExpression): boolean {

1336 if (other.type === this.type) {

1337 return (this.key === other.key && this.value === other.value);

1339 return false;

1340 }

1341 > contextkey.ts

1342 > public substituteConstants(): ContextKeyExpression | undefined {

1343 return this;

1344 }

1345 > contextkey.ts

1346 > public evaluate(context: IContext): boolean {

1347 if (typeof this.value === 'string') {

1348 return false;

1350 return (parseFloat(context.getValue<any>(this.key)) < this.value);

1351 }

1352 > contextkey.ts

1353 > public serialize(): string {

1354 return `${this.key} < ${this.value}`;

1355 }

1356 > contextkey.ts

1357 > public keys(): string[] {

1358 return [this.key];

1359 }

1360 > contextkey.ts

1361 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1362 return mapFnc.mapSmaller(this.key, this.value);

1363 }

1364 > contextkey.ts

1365 > public negate(): ContextKeyExpression {

1366 if (!this.negated) {

1367 this.negated = ContextKeyGreaterEqualsExpr.create(this.key, this.value, this);

1369 return this.negated;

1370 }

1371 > } contextkey.ts

1372 >

1373 > export class ContextKeySmallerEqualsExpr implements IContextKeyExpression {

1374 >

1375 > public static create(key: string, _value: any, negated: ContextKeyExpression | null = null): ContextKeyExpression {

1376 > return withFloatOrStr(_value, (value) => new ContextKeySmallerEqualsExpr(key, value, negated));

1377 > }

1378 >

1379 > public readonly type = ContextKeyExprType.SmallerEquals;

1380 >

1381 > private constructor(

1382 private readonly key: string,

1383 private readonly value: number | string,

1385 ) {

1386 }

1387 > contextkey.ts

1388 > public cmp(other: ContextKeyExpression): number {

1389 if (other.type !== this.type) {

1390 return this.type - other.type;

1392 return cmp2(this.key, this.value, other.key, other.value);

1393 }

1394 > contextkey.ts

1395 > public equals(other: ContextKeyExpression): boolean {

1396 if (other.type === this.type) {

1397 return (this.key === other.key && this.value === other.value);

1399 return false;

1400 }

1401 > contextkey.ts

1402 > public substituteConstants(): ContextKeyExpression | undefined {

1403 return this;

1404 }

1405 > contextkey.ts

1406 > public evaluate(context: IContext): boolean {

1407 if (typeof this.value === 'string') {

1408 return false;

1410 return (parseFloat(context.getValue<any>(this.key)) <= this.value);

1411 }

1412 > contextkey.ts

1413 > public serialize(): string {

1414 return `${this.key} <= ${this.value}`;

1415 }

1416 > contextkey.ts

1417 > public keys(): string[] {

1418 return [this.key];

1419 }

1420 > contextkey.ts

1421 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1422 return mapFnc.mapSmallerEquals(this.key, this.value);

1423 }

1424 > contextkey.ts

1425 > public negate(): ContextKeyExpression {

1426 if (!this.negated) {

1427 this.negated = ContextKeyGreaterExpr.create(this.key, this.value, this);

1429 return this.negated;

1430 }

1431 > } contextkey.ts

1432 >

1433 > export class ContextKeyRegexExpr implements IContextKeyExpression {

1434 >

1435 > public static create(key: string, regexp: RegExp | null): ContextKeyRegexExpr {

1436 > return new ContextKeyRegexExpr(key, regexp);

1437 > }

1438 >

1439 > public readonly type = ContextKeyExprType.Regex;

1440 > private negated: ContextKeyExpression | null = null;

1441 >

1442 > private constructor(

1443 private readonly key: string,

1444 private readonly regexp: RegExp | null

1446 //

1447 }

1448 > contextkey.ts

1449 > public cmp(other: ContextKeyExpression): number {

1450 if (other.type !== this.type) {

1451 return this.type - other.type;

1467 return 0;

1468 }

1469 > contextkey.ts

1470 > public equals(other: ContextKeyExpression): boolean {

1471 if (other.type === this.type) {

1472 const thisSource = this.regexp ? this.regexp.source : '';

1476 return false;

1477 }

1478 > contextkey.ts

1479 > public substituteConstants(): ContextKeyExpression | undefined {

1480 return this;

1481 }

1482 > contextkey.ts

1483 > public evaluate(context: IContext): boolean {

1484 const value = context.getValue<any>(this.key);

1485 return this.regexp ? this.regexp.test(value) : false;

1486 }

1487 > contextkey.ts

1488 > public serialize(): string {

1489 const value = this.regexp

1490 ? `/${this.regexp.source}/${this.regexp.flags}`

1492 return `${this.key} =~ ${value}`;

1493 }

1494 > contextkey.ts

1495 > public keys(): string[] {

1496 return [this.key];

1497 }

1498 > contextkey.ts

1499 > public map(mapFnc: IContextKeyExprMapper): ContextKeyRegexExpr {

1500 return mapFnc.mapRegex(this.key, this.regexp);

1501 }

1502 > contextkey.ts

1503 > public negate(): ContextKeyExpression {

1504 if (!this.negated) {

1505 this.negated = ContextKeyNotRegexExpr.create(this);

1507 return this.negated;

1508 }

1509 > } contextkey.ts

1510 >

1511 > export class ContextKeyNotRegexExpr implements IContextKeyExpression {

1512 >

1513 > public static create(actual: ContextKeyRegexExpr): ContextKeyExpression {

1514 > return new ContextKeyNotRegexExpr(actual);

1515 > }

1516 >

1517 > public readonly type = ContextKeyExprType.NotRegex;

1518 >

1519 > private constructor(private readonly _actual: ContextKeyRegexExpr) {

1520 //

1521 }

1522 > contextkey.ts

1523 > public cmp(other: ContextKeyExpression): number {

1524 if (other.type !== this.type) {

1525 return this.type - other.type;

1527 return this._actual.cmp(other._actual);

1528 }

1529 > contextkey.ts

1530 > public equals(other: ContextKeyExpression): boolean {

1531 if (other.type === this.type) {

1532 return this._actual.equals(other._actual);

1534 return false;

1535 }

1536 > contextkey.ts

1537 > public substituteConstants(): ContextKeyExpression | undefined {

1538 return this;

1539 }

1540 > contextkey.ts

1541 > public evaluate(context: IContext): boolean {

1542 return !this._actual.evaluate(context);

1543 }

1544 > contextkey.ts

1545 > public serialize(): string {

1546 return `!(${this._actual.serialize()})`;

1547 }

1548 > contextkey.ts

1549 > public keys(): string[] {

1550 return this._actual.keys();

1551 }

1552 > contextkey.ts

1553 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1554 return new ContextKeyNotRegexExpr(this._actual.map(mapFnc));

1555 }

1556 > contextkey.ts

1557 > public negate(): ContextKeyExpression {

1558 return this._actual;

1559 }

1560 > } contextkey.ts

1561 >

1562 > /**

1563 > * @returns the same instance if nothing changed.

1564 > */

1565 function eliminateConstantsInArray(arr: ContextKeyExpression[]): (ContextKeyExpression | undefined)[] {

1566 // Allocate array only if there is a difference

1591 return newArr;

1592 }

1593 > contextkey.ts

1594 > export class ContextKeyAndExpr implements IContextKeyExpression {

1595 >

1596 > public static create(_expr: ReadonlyArray<ContextKeyExpression | null | undefined>, negated: ContextKeyExpression | null, extraRedundantCheck: boolean): ContextKeyExpression | undefined {

1597 > return ContextKeyAndExpr._normalizeArr(_expr, negated, extraRedundantCheck);

1598 > }

1599 >

1600 > public readonly type = ContextKeyExprType.And;

1601 >

1602 > private constructor(

1603 > public readonly expr: ContextKeyExpression[], contextkey.ts

1604 > private negated: ContextKeyExpression | null

1605 > ) {

1606 > }

1607 > contextkey.ts

1608 > public cmp(other: ContextKeyExpression): number {

1609 if (other.type !== this.type) {

1610 return this.type - other.type;

1624 return 0;

1625 }

1626 > contextkey.ts

1627 > public equals(other: ContextKeyExpression): boolean {

1628 if (other.type === this.type) {

1629 if (this.expr.length !== other.expr.length) {

1639 return false;

1640 }

1641 > contextkey.ts

1642 > public substituteConstants(): ContextKeyExpression | undefined {

1643 const exprArr = eliminateConstantsInArray(this.expr);

1644 if (exprArr === this.expr) {

1648 return ContextKeyAndExpr.create(exprArr, this.negated, false);

1649 }

1650 > contextkey.ts

1651 > public evaluate(context: IContext): boolean {

1652 for (let i = 0, len = this.expr.length; i < len; i++) {

1653 if (!this.expr[i].evaluate(context)) {

1657 return true;

1658 }

1659 > contextkey.ts

1660 > private static _normalizeArr(arr: ReadonlyArray<ContextKeyExpression | null | undefined>, negated: ContextKeyExpression | null, extraRedundantCheck: boolean): ContextKeyExpression | undefined {

1661 > const expr: ContextKeyExpression[] = []; contextkey.ts

1662 > let hasTrue = false;

1663 >

1664 > for (const e of arr) {

1665 > if (!e) {

1666 continue;

1667 }

1668 > contextkey.ts

1669 > if (e.type === ContextKeyExprType.True) {

1670 // anything && true ==> anything

1671 hasTrue = true;

1672 continue;

1673 }

1674 > contextkey.ts

1675 > if (e.type === ContextKeyExprType.False) {

1676 // anything && false ==> false

1677 return ContextKeyFalseExpr.INSTANCE;

1678 }

1679 > contextkey.ts

1680 > if (e.type === ContextKeyExprType.And) {

1681 expr.push(...e.expr);

1682 continue;

1683 }

1684 > contextkey.ts

1685 > expr.push(e);

1686 > }

1687 >

1688 > if (expr.length === 0 && hasTrue) {

1689 return ContextKeyTrueExpr.INSTANCE;

1690 }

1691 > contextkey.ts

1692 > if (expr.length === 0) {

1693 return undefined;

1694 }

1695 > contextkey.ts

1696 > if (expr.length === 1) {

1697 return expr[0];

1698 }

1699 > contextkey.ts

1700 > expr.sort(cmp);

1701 >

1702 > // eliminate duplicate terms

1703 > for (let i = 1; i < expr.length; i++) {

1704 > if (expr[i - 1].equals(expr[i])) {

1705 expr.splice(i, 1);

1706 i--;

1707 }

1708 > } contextkey.ts

1709 >

1710 > if (expr.length === 1) {

1711 return expr[0];

1712 }

1713 > contextkey.ts

1714 > // We must distribute any OR expression because we don't support parens

1715 > // OR extensions will be at the end (due to sorting rules)

1716 > while (expr.length > 1) {

1717 > const lastElement = expr[expr.length - 1];

1718 > if (lastElement.type !== ContextKeyExprType.Or) {

1719 > break;

1720 > }

1721 // pop the last element

1722 expr.pop();

1738 expr.sort(cmp);

1739 }

1740 > } contextkey.ts

1741 >

1742 > if (expr.length === 1) {

1743 return expr[0];

1744 }

1745 > contextkey.ts

1746 > // resolve false AND expressions

1747 > if (extraRedundantCheck) {

1748 > for (let i = 0; i < expr.length; i++) {

1749 > for (let j = i + 1; j < expr.length; j++) {

1750 > if (expr[i].negate().equals(expr[j])) {

1751 // A && !A case

1752 return ContextKeyFalseExpr.INSTANCE;

1753 }

1754 > } contextkey.ts

1755 > } contextkey.ts

1756 >

1757 > if (expr.length === 1) {

1758 return expr[0];

1759 }

1760 > } contextkey.ts

1761 > contextkey.ts

1762 > return new ContextKeyAndExpr(expr, negated);

1763 > } contextkey.ts

1764 > contextkey.ts

1765 > public serialize(): string {

1766 return this.expr.map(e => e.serialize()).join(' && ');

1767 }

1768 > contextkey.ts

1769 > public keys(): string[] {

1770 const result: string[] = [];

1771 for (const expr of this.expr) {

1774 return result;

1775 }

1776 > contextkey.ts

1777 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1778 return new ContextKeyAndExpr(this.expr.map(expr => expr.map(mapFnc)), null);

1779 }

1780 > contextkey.ts

1781 > public negate(): ContextKeyExpression {

1782 if (!this.negated) {

1783 const result: ContextKeyExpression[] = [];

1789 return this.negated;

1790 }

1791 > } contextkey.ts

1792 >

1793 > export class ContextKeyOrExpr implements IContextKeyExpression {

1794 >

1795 > public static create(_expr: ReadonlyArray<ContextKeyExpression | null | undefined>, negated: ContextKeyExpression | null, extraRedundantCheck: boolean): ContextKeyExpression | undefined {

1796 > return ContextKeyOrExpr._normalizeArr(_expr, negated, extraRedundantCheck);

1797 > }

1798 >

1799 > public readonly type = ContextKeyExprType.Or;

1800 >

1801 > private constructor(

1802 public readonly expr: ContextKeyExpression[],

1803 private negated: ContextKeyExpression | null

1804 ) {

1805 }

1806 > contextkey.ts

1807 > public cmp(other: ContextKeyExpression): number {

1808 if (other.type !== this.type) {

1809 return this.type - other.type;

1823 return 0;

1824 }

1825 > contextkey.ts

1826 > public equals(other: ContextKeyExpression): boolean {

1827 if (other.type === this.type) {

1828 if (this.expr.length !== other.expr.length) {

1838 return false;

1839 }

1840 > contextkey.ts

1841 > public substituteConstants(): ContextKeyExpression | undefined {

1842 const exprArr = eliminateConstantsInArray(this.expr);

1843 if (exprArr === this.expr) {

1847 return ContextKeyOrExpr.create(exprArr, this.negated, false);

1848 }

1849 > contextkey.ts

1850 > public evaluate(context: IContext): boolean {

1851 for (let i = 0, len = this.expr.length; i < len; i++) {

1852 if (this.expr[i].evaluate(context)) {

1856 return false;

1857 }

1858 > contextkey.ts

1859 > private static _normalizeArr(arr: ReadonlyArray<ContextKeyExpression | null | undefined>, negated: ContextKeyExpression | null, extraRedundantCheck: boolean): ContextKeyExpression | undefined {

1860 let expr: ContextKeyExpression[] = [];

1861 let hasFalse = false;

1932 return new ContextKeyOrExpr(expr, negated);

1933 }

1934 > contextkey.ts

1935 > public serialize(): string {

1936 return this.expr.map(e => e.serialize()).join(' || ');

1937 }

1938 > contextkey.ts

1939 > public keys(): string[] {

1940 const result: string[] = [];

1941 for (const expr of this.expr) {

1944 return result;

1945 }

1946 > contextkey.ts

1947 > public map(mapFnc: IContextKeyExprMapper): ContextKeyExpression {

1948 return new ContextKeyOrExpr(this.expr.map(expr => expr.map(mapFnc)), null);

1949 }

1950 > contextkey.ts

1951 > public negate(): ContextKeyExpression {

1952 if (!this.negated) {

1953 const result: ContextKeyExpression[] = [];

1976 return this.negated;

1977 }

1978 > } contextkey.ts

1979 >

1980 > export interface ContextKeyInfo {

1981 > readonly key: string;

1982 > readonly type?: string;

1983 > readonly description?: string;

1984 > }

1985 >

1986 > export class RawContextKey<T extends ContextKeyValue> extends ContextKeyDefinedExpr {

1987 >

1988 > private static _info: ContextKeyInfo[] = [];

1989 >

1990 > static all(): IterableIterator<ContextKeyInfo> {

1991 return RawContextKey._info.values();

1992 }

1993 > contextkey.ts

1994 > private readonly _defaultValue: T | undefined;

1995 >

1996 > constructor(key: string, defaultValue: T | undefined, metaOrHide?: string | true | { type: string; description: string }) {

1997 > super(key, null); contextkey.ts

1998 > this._defaultValue = defaultValue;

1999 >

2000 > // collect all context keys into a central place

2001 > if (typeof metaOrHide === 'object') {

2002 > RawContextKey._info.push({ ...metaOrHide, key }); contextkey.ts

2003 > } else if (metaOrHide !== true) { contextkey.ts

2004 > RawContextKey._info.push({ key, description: metaOrHide, type: defaultValue !== null && defaultValue !== undefined ? typeof defaultValue : undefined }); contextkey.ts

2005 > }

2006 > } contextkey.ts

2007 > contextkey.ts

2008 > public bindTo(target: IContextKeyService): IContextKey<T> {

2009 return target.createKey(this.key, this._defaultValue);

2010 }

2011 > contextkey.ts

2012 > public getValue(target: IContextKeyService): T | undefined {

2013 return target.getContextKeyValue<T>(this.key);

2014 }

2015 > contextkey.ts

2016 > public toNegated(): ContextKeyExpression {

2017 > return this.negate(); contextkey.ts

2018 > }

2019 > contextkey.ts

2020 > public isEqualTo(value: any): ContextKeyExpression {

2021 return ContextKeyEqualsExpr.create(this.key, value);

2022 }

2023 > contextkey.ts

2024 > public notEqualsTo(value: any): ContextKeyExpression {

2025 return ContextKeyNotEqualsExpr.create(this.key, value);

2026 }

2027 > contextkey.ts

2028 > public greater(value: any): ContextKeyExpression {

2029 return ContextKeyGreaterExpr.create(this.key, value);

2030 }

2031 > } contextkey.ts

2032 >

2033 > export type ContextKeyValue = null | undefined | boolean | number | string

2034 > | Array<null | undefined | boolean | number | string>

2035 > | Record<string, null | undefined | boolean | number | string>;

2036 >

2037 > export interface IContext {

2038 > getValue<T extends ContextKeyValue = ContextKeyValue>(key: string): T | undefined;

2039 > }

2040 >

2041 > export interface IContextKey<T extends ContextKeyValue = ContextKeyValue> {

2042 > set(value: T): void;

2043 > reset(): void;

2044 > get(): T | undefined;

2045 > }

2046 >

2047 > export interface IContextKeyServiceTarget {

2048 > parentElement: IContextKeyServiceTarget | null;

2049 > setAttribute(attr: string, value: string): void;

2050 > removeAttribute(attr: string): void;

2051 > hasAttribute(attr: string): boolean;

2052 > getAttribute(attr: string): string | null;

2053 > }

2054 >

2055 > export const IContextKeyService = createDecorator<IContextKeyService>('contextKeyService');

2056 >

2057 > export interface IReadableSet<T> {

2058 > has(value: T): boolean;

2059 > }

2060 >

2061 > export interface IContextKeyChangeEvent {

2062 > affectsSome(keys: IReadableSet<string>): boolean;

2063 > allKeysContainedIn(keys: IReadableSet<string>): boolean;

2064 > }

2065 >

2066 > export type IScopedContextKeyService = IContextKeyService & IDisposable;

2067 >

2068 > export interface IContextKeyService {

2069 > readonly _serviceBrand: undefined;

2070 >

2071 > readonly onDidChangeContext: Event<IContextKeyChangeEvent>;

2072 > bufferChangeEvents(callback: Function): void;

2073 >

2074 > createKey<T extends ContextKeyValue>(key: string, defaultValue: T | undefined): IContextKey<T>;

2075 > contextMatchesRules(rules: ContextKeyExpression | undefined): boolean;

2076 > getContextKeyValue<T>(key: string): T | undefined;

2077 >

2078 > createScoped(target: IContextKeyServiceTarget): IScopedContextKeyService;

2079 > createOverlay(overlay: Iterable<[string, any]>): IContextKeyService;

2080 > getContext(target: IContextKeyServiceTarget | null): IContext;

2081 >

2082 > updateParent(parentContextKeyService: IContextKeyService): void;

2083 > }

2084 >

2085 > function cmp1(key1: string, key2: string): number { contextkey.ts

2086 > if (key1 < key2) {

2087 > return -1; contextkey.ts

2088 > }

2089 > if (key1 > key2) { contextkey.ts

2090 > return 1;

2091 > }

2092 return 0;

2093 }

2094 > contextkey.ts

2095 function cmp2(key1: string, value1: any, key2: string, value2: any): number {

2096 if (key1 < key2) {

2108 return 0;

2109 }

2110 > contextkey.ts

2111 > /**

2112 > * Returns true if it is provable `p` implies `q`.

2113 > */

2114 > export function implies(p: ContextKeyExpression, q: ContextKeyExpression): boolean {

2115

2116 if (p.type === ContextKeyExprType.False || q.type === ContextKeyExprType.True) {

2152 return p.equals(q);

2153 }

2154 > contextkey.ts

2155 > /**

2156 > * Returns true if all elements in `p` are also present in `q`.

2157 > * The two arrays are assumed to be sorted

2158 > */

2159 function allElementsIncluded(p: ContextKeyExpression[], q: ContextKeyExpression[]): boolean {

2160 let pIndex = 0;

2175 return (pIndex === p.length);

2176 }

2177 > contextkey.ts

2178 function getTerminals(node: ContextKeyExpression) {

2179 if (node.type === ContextKeyExprType.Or) {

src/vs/workbench/contrib/chat/common/chatSessionsService.ts 903 covered LOC · 12 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- chatSessionsService.ts

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 { CancellationToken } from '../../../../base/common/cancellation.js';

7 > import { Event } from '../../../../base/common/event.js';

8 > import { IMarkdownString } from '../../../../base/common/htmlContent.js';

9 > import { IDisposable } from '../../../../base/common/lifecycle.js';

10 > import { IObservable } from '../../../../base/common/observable.js';

11 > import { ThemeIcon } from '../../../../base/common/themables.js';

12 > import { URI } from '../../../../base/common/uri.js';

13 > import { IPosition } from '../../../../editor/common/core/position.js';

14 > import { isRemoteAgentHostSessionType } from '../../../../platform/agentHost/common/agentHostSessionType.js';

15 > import { createDecorator, ServicesAccessor } from '../../../../platform/instantiation/common/instantiation.js';

16 > import { Registry } from '../../../../platform/registry/common/platform.js';

17 > import { LOCAL_AGENT_HOST_SCHEME_PREFIX } from '../../../../platform/agentHost/common/agentHostConnectionsService.js';

18 > import { IChatAgentAttachmentCapabilities, IChatAgentRequest } from './participants/chatAgents.js';

19 > import { IChatEditingSession } from './editing/chatEditingService.js';

20 > import { IChatRequestModeInstructions, IChatRequestVariableData, ISerializableChatModelInputState } from './model/chatModel.js';

21 > import { IChatProgress, IChatResponseErrorDetails, IChatSessionTiming } from './chatService/chatService.js';

22 > import { Target } from './promptSyntax/promptTypes.js';

23 >

24 > export const enum ChatSessionsExtensions {

25 > AsyncActivation = 'workbench.contrib.chatSessions.asyncActivation'

26 > }

27 >

28 > export interface IAsyncChatSessionActivationContribution {

29 > matchSessionType(sessionType: string): boolean;

30 > waitForActivation(accessor: ServicesAccessor, sessionType: string): Promise<boolean>;

31 > }

32 >

33 > export interface IAsyncChatSessionActivationRegistry {

34 > register(contribution: IAsyncChatSessionActivationContribution): IDisposable;

35 > getActivators(sessionType: string): readonly IAsyncChatSessionActivationContribution[];

36 > }

37 >

38 > class AsyncChatSessionActivationRegistry implements IAsyncChatSessionActivationRegistry {

39 > private readonly _contributions = new Set<IAsyncChatSessionActivationContribution>();

40 >

41 > register(contribution: IAsyncChatSessionActivationContribution): IDisposable {

42 this._contributions.add(contribution);

43 return {

45 };

46 }

47 > chatSessionsService.ts

48 > getActivators(sessionType: string): readonly IAsyncChatSessionActivationContribution[] {

49 return Array.from(this._contributions).filter(contribution => contribution.matchSessionType(sessionType));

50 }

51 > } chatSessionsService.ts

52 >

53 > Registry.add(ChatSessionsExtensions.AsyncActivation, new AsyncChatSessionActivationRegistry());

54 >

55 > export const enum ChatSessionStatus {

56 > Failed = 0,

57 > Completed = 1,

58 > InProgress = 2,

59 > NeedsInput = 3

60 > }

61 >

62 > export interface IChatSessionCommandContribution {

63 > readonly name: string;

64 > readonly description: string;

65 > readonly when?: string;

66 > }

67 >

68 > export interface IChatSessionProviderOptionModelMetadata {

69 > readonly name: string;

70 > readonly id: string;

71 > readonly vendor?: string;

72 > readonly version?: string;

73 > readonly family?: string;

74 > readonly tooltip?: string;

75 > readonly pricing?: string;

76 > readonly multiplierNumeric?: number;

77 > readonly inputCost?: number;

78 > readonly outputCost?: number;

79 > readonly cacheCost?: number;

80 > readonly cacheWriteCost?: number;

81 > readonly longContextInputCost?: number;

82 > readonly longContextOutputCost?: number;

83 > readonly longContextCacheCost?: number;

84 > readonly longContextCacheWriteCost?: number;

85 > readonly priceCategory?: string;

86 > readonly promo?: {

87 > readonly id: string;

88 > readonly discountPercent: number;

89 > readonly endsAt: string;

90 > readonly message: string;

91 > };

92 > readonly maxInputTokens?: number;

93 > readonly maxOutputTokens?: number;

94 > readonly capabilities?: {

95 > readonly vision?: boolean;

96 > readonly toolCalling?: boolean;

97 > };

98 > }

99 >

100 > export interface IChatSessionProviderOptionItem {

101 > readonly id: string;

102 > readonly name: string;

103 > readonly description?: string;

104 > readonly detail?: string;

105 > readonly locked?: boolean;

106 > readonly icon?: ThemeIcon;

107 > readonly default?: boolean;

108 > readonly slashCommand?: string;

109 > readonly tooltip?: string;

110 > readonly modelMetadata?: IChatSessionProviderOptionModelMetadata;

111 > // [key: string]: any;

112 > }

113 >

114 > export interface IChatSessionProviderOptionGroupCommand {

115 > readonly command: string;

116 > readonly title: string;

117 > readonly tooltip?: string;

118 > readonly arguments?: readonly unknown[];

119 > }

120 >

121 > export interface IChatSessionProviderOptionGroup {

122 > readonly id: string;

123 > readonly name: string;

124 > readonly description?: string;

125 > readonly detail?: string;

126 > readonly selected?: IChatSessionProviderOptionItem;

127 > readonly items: readonly IChatSessionProviderOptionItem[];

128 > /**

129 > * A context key expression that controls visibility of this option group picker.

130 > * When specified, the picker is only visible when the expression evaluates to true.

131 > * The expression can reference other option group values via `chatSessionOption.<groupId>`.

132 > * Example: `"chatSessionOption.models == 'gpt-4'"`

133 > */

134 > readonly when?: string;

135 > readonly icon?: ThemeIcon;

136 > /**

137 > * Custom commands to show in the option group's picker UI.

138 > * These will be shown in a separate section at the end of the picker.

139 > */

140 > readonly commands?: readonly IChatSessionProviderOptionGroupCommand[];

141 > /**

142 > * Optional kind hint that controls how the group is presented.

143 > * - `'permissions'`: the group's items are surfaced inside the chat permission picker

144 > * instead of being rendered as a standalone picker. At most one group per provider

145 > * may use this kind; if multiple are declared, the first one (in declaration order)

146 > * wins. The group has no UI of its own — it is invisible when the permission

147 > * picker is hidden by its own `when` clauses.

148 > */

149 > readonly kind?: 'permissions';

150 > }

151 >

152 > export interface IChatSessionsExtensionPoint {

153 > readonly type: string;

154 > readonly name: string;

155 > readonly displayName: string;

156 > readonly description: string;

157 > readonly when?: string;

158 > readonly icon?: string | { light: string; dark: string };

159 > readonly order?: number;

160 > readonly alternativeIds?: string[];

161 > readonly welcomeTitle?: string;

162 > readonly welcomeMessage?: string;

163 > readonly welcomeTips?: string;

164 > readonly inputPlaceholder?: string;

165 > readonly capabilities?: IChatAgentAttachmentCapabilities;

166 > readonly commands?: IChatSessionCommandContribution[];

167 > readonly canDelegate?: boolean;

168 > readonly isReadOnly?: boolean;

169 > /**

170 > * When set, the chat session will show a filtered mode picker with custom agents

171 > * that have a matching `target` property. This enables contributed chat sessions

172 > * to reuse the standard agent/mode dropdown with filtered custom agents.

173 > * Custom agents without a `target` property are also shown in all filtered lists

174 > */

175 > readonly customAgentTarget?: Target;

176 > readonly requiresCustomModels?: boolean;

177 > /**

178 > * Whether this session type supports the synthetic "Auto" model fallback.

179 > * Defaults to true. When false and no models are available, the picker

180 > * shows a "No models available" state instead of "Auto".

181 > *

182 > * This is distinct from {@link requiresCustomModels}, which only controls

183 > * whether the picker is filtered to the session's own model pool — a

184 > * session can own a custom pool yet still support Auto (e.g. the Copilot

185 > * CLI agent host).

186 > */

187 > readonly supportsAutoModel?: boolean;

188 > /**

189 > * Logical Agent Host provider ID for Agent Host-backed chat sessions.

190 > * For example, both local `agent-host-copilotcli` and remote

191 > * `remote-{authority}-copilotcli` sessions use `copilotcli`.

192 > */

193 > readonly agentHostProviderId?: string;

194 > /**

195 > * Whether this type needs a GitHub Copilot account and so is unusable until the user signs in. Set by

196 > * Copilot-backed types (Copilot CLI / agent host, cloud agent) where BYOK isn't supported. Defaults to false, so

197 > * third-party types that don't depend on Copilot stay usable while signed out.

198 > */

199 > readonly requiresCopilotSignIn?: boolean;

200 > /**

201 > * When false, the delegation picker is hidden for this session type.

202 > * Defaults to true.

203 > */

204 > readonly supportsDelegation?: boolean;

205 > /**

206 > * Decides whether to automatically attach instruction files to chat requests

207 > * for this session type. Defaults to false when not specified.

208 > */

209 > readonly autoAttachReferences?: boolean;

210 > }

211 >

212 > export interface IChatSessionItem {

213 > readonly resource: URI;

214 > readonly label: string;

215 > readonly iconPath?: ThemeIcon;

216 > readonly badge?: string | IMarkdownString;

217 > readonly description?: string | IMarkdownString;

218 > readonly status?: ChatSessionStatus;

219 > readonly tooltip?: string | IMarkdownString;

220 > readonly timing: IChatSessionTiming;

221 > readonly changes?: {

222 > readonly files: number;

223 > readonly insertions: number;

224 > readonly deletions: number;

225 > } | readonly IChatSessionFileChange[] | readonly IChatSessionFileChange2[];

226 > readonly archived?: boolean;

227 > readonly metadata?: IChatSessionItemMetadata;

228 > /**

229 > * Resource identifier the item was previously known by. When set, host-stored

230 > * per-resource state (archive, pin, read) recorded under that URI is adopted

231 > * forward onto {@link resource} on first state read, and the legacy entry is

232 > * removed. Scheme must match {@link resource}'s scheme; otherwise ignored.

233 > */

234 > readonly legacyResource?: URI;

235 > }

236 >

237 > export interface IChatSessionItemMetadata {

238 > //#region Changes metadata (for sessions window)

239 > readonly repositoryPath?: string;

240 > readonly workingDirectoryPath?: string;

241 > readonly firstCheckpointRef?: string;

242 > readonly lastCheckpointRef?: string;

243 > readonly worktreePath?: string;

244 > readonly uncommittedChanges?: number;

245 > readonly baseRefOid?: string;

246 > readonly headRefOid?: string;

247 > readonly branchName?: string;

248 > readonly branch?: string;

249 > readonly baseBranchName?: string;

250 > readonly baseBranch?: string;

251 > readonly baseBranchProtected?: boolean;

252 > readonly hasGitHubRemote?: boolean;

253 > readonly upstreamBranchName?: string;

254 > readonly incomingChanges?: number;

255 > readonly outgoingChanges?: number;

256 > //#endregion

257 >

258 > readonly [key: string]: unknown;

259 > }

260 >

261 > export interface IChatSessionFileChange {

262 > readonly modifiedUri: URI;

263 > readonly originalUri?: URI;

264 > readonly insertions: number;

265 > readonly deletions: number;

266 > readonly reviewed?: boolean;

267 > }

268 >

269 > export interface IChatSessionFileChange2 {

270 > readonly uri: URI;

271 > readonly originalUri?: URI;

272 > readonly modifiedUri?: URI;

273 > readonly insertions: number;

274 > readonly deletions: number;

275 > readonly reviewed?: boolean;

276 > }

277 >

278 > export type IChatSessionHistoryItem = {

279 > id?: string;

280 > type: 'request';

281 > prompt: string;

282 > participant: string;

283 > command?: string;

284 > variableData?: IChatRequestVariableData;

285 > modelId?: string;

286 > timestamp?: number;

287 > modeInstructions?: IChatRequestModeInstructions;

288 > isSystemInitiated?: boolean;

289 > systemInitiatedLabel?: string;

290 > isTerminalRequest?: boolean;

291 > } | {

292 > type: 'response';

293 > parts: IChatProgress[];

294 > participant: string;

295 > details?: string;

296 > elapsedMs?: number;

297 > completedAt?: number;

298 > /**

299 > * Error details for a failed response. Rendered as a proper chat error

300 > * (including the quota-exceeded upgrade affordance), mirroring the live

301 > * agent result's `errorDetails`.

302 > */

303 > errorDetails?: IChatResponseErrorDetails;

304 > };

305 >

306 > export type IChatSessionRequestHistoryItem = Extract<IChatSessionHistoryItem, { type: 'request' }>;

307 >

308 > export interface IChatSessionServerRequest {

309 > readonly prompt: string;

310 > readonly variableData?: IChatRequestVariableData;

311 > readonly timestamp?: number;

312 > readonly isSystemInitiated?: boolean;

313 > readonly systemInitiatedLabel?: string;

314 > readonly isTerminalRequest?: boolean;

315 > }

316 >

317 > /**

318 > * Whether `text` runs as a terminal command for the given command `prefix`

319 > * (e.g. `!`) — it starts with the prefix and has a non-empty command after it.

320 > * Mirrors the agent host's bang parser, where a lone `!` (or `!` followed only

321 > * by whitespace) is forwarded to the agent rather than executed.

322 > */

323 > export function isTerminalCommandPrompt(text: string, prefix: string | undefined): boolean {

324 return !!prefix && text.startsWith(prefix) && text.slice(prefix.length).trim().length > 0;

325 }

326 > chatSessionsService.ts

327 > /**

328 > * A set of well-known session types

329 > */

330 > export namespace SessionType {

331 > export const CopilotCLI = 'copilotcli';

332 > export const CopilotCloud = 'copilot-cloud-agent';

333 > export const Local = 'local';

334 > export const ClaudeCode = 'claude-code';

335 > export const Codex = 'openai-codex';

336 > export const Growth = 'copilot-growth';

337 > export const AgentHostCopilot = 'agent-host-copilotcli';

338 > export const AgentHostClaude = 'agent-host-claude';

339 > export const AgentHostCodex = 'agent-host-codex';

340 > }

341 >

342 > /**

343 > * Returns whether the given session type is a local agent host target.

344 > */

345 > export function isLocalAgentHostTarget(target: string): boolean {

346 return target === SessionType.AgentHostCopilot ||

347 target.startsWith(LOCAL_AGENT_HOST_SCHEME_PREFIX);

348 }

349 > chatSessionsService.ts

350 > /**

351 > * Returns whether the given session type is a remote agent host target.

352 > *

353 > * Note: The `remote-` prefix convention is established by

354 > * `RemoteAgentHostContribution` which generates session types as

355 > * `remote-{sanitizedAddress}-{provider}`. If future remote providers that

356 > * are NOT agent hosts need a different prefix, this function must be updated.

357 > */

358 > export function isRemoteAgentHostTarget(target: string): boolean {

359 return isRemoteAgentHostSessionType(target);

360 }

361 > chatSessionsService.ts

362 > /**

363 > * Returns whether the given session type is an agent host target.

364 > * Matches the local agent host (`agent-host-*`) and remote agent hosts (`remote-*`).

365 > */

366 > export function isAgentHostTarget(target: string): boolean {

367 return isLocalAgentHostTarget(target) || isRemoteAgentHostTarget(target);

368 }

369 > chatSessionsService.ts

370 > /**

371 > * The session type used for local agent chat sessions.

372 > */

373 > export const localChatSessionType = SessionType.Local;

374 >

375 > export interface IChatSession extends IDisposable {

376 > readonly onWillDispose: Event<void>;

377 >

378 > readonly sessionResource: URI;

379 >

380 > readonly title?: string;

381 >

382 > readonly history: readonly IChatSessionHistoryItem[];

383 >

384 >

385 > readonly options?: ReadonlyChatSessionOptionsMap;

386 >

387 > readonly progressObs?: IObservable<IChatProgress[]>;

388 > readonly isCompleteObs?: IObservable<boolean>;

389 > readonly isReadOnly?: IObservable<boolean>;

390 > readonly interruptActiveResponseCallback?: () => Promise<boolean>;

391 >

392 > /**

393 > * Event fired when the server initiates a new request (e.g. from a consumed

394 > * queued message). The consumer should create a new request+response pair in

395 > * the model and prepare to receive progress via {@link progressObs}.

396 > */

397 > readonly onDidStartServerRequest?: Event<IChatSessionServerRequest>;

398 >

399 > /**

400 > * Editing session transferred from a previously-untitled chat session in `onDidCommitChatSessionItem`.

401 > */

402 > transferredState?: {

403 > readonly editingSession: IChatEditingSession | undefined;

404 > readonly inputState: ISerializableChatModelInputState | undefined;

405 > };

406 >

407 > requestHandler?: (

408 > request: IChatAgentRequest,

409 > progress: (progress: IChatProgress[]) => void,

410 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

411 > history: any[], // TODO: Nail down types

412 > token: CancellationToken

413 > ) => Promise<void>;

414 >

415 > /**

416 > * Forks the session from the given request point.

417 > * @param request The request history item to fork from, or undefined to fork from the end.

418 > * @param token Cancellation token.

419 > * @returns The forked session item. The promise is rejected if forking fails.

420 > */

421 > forkSession?: (request: IChatSessionRequestHistoryItem | undefined, token: CancellationToken) => Promise<IChatSessionItem>;

422 >

423 > /**

424 > * Renames the session.

425 > * @param title The new title for the session.

426 > * @param token Cancellation token.

427 > * @returns A promise that resolves once the rename has been dispatched. The promise is rejected if renaming fails.

428 > */

429 > renameSession?: (title: string, token: CancellationToken) => Promise<void>;

430 > }

431 >

432 > export interface IChatSessionContentProvider {

433 > provideChatSessionContent(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;

434 >

435 > /** Resolves a parsed response Markdown URI before it is sanitized and rendered. */

436 > resolveChatResponseUri?(sessionResource: URI, href: string, kind: 'link' | 'image'): string;

437 >

438 > /**

439 > * Optional. Compute completion items for an input being composed in this

440 > * session. Returning `undefined` lets the workbench fall back to its

441 > * default in-process completion providers.

442 > */

443 > provideChatInputCompletions?(sessionResource: URI, params: IChatInputCompletionsParams, token: CancellationToken): Promise<IChatInputCompletionsResult | undefined>;

444 >

445 > /**

446 > * Optional. Trigger characters that, when typed in the chat input,

447 > * SHOULD cause the workbench to issue a `provideChatInputCompletions`

448 > * request. Used to register a Monaco completion provider scoped to

449 > * sessions handled by this content provider.

450 > */

451 > provideChatInputCompletionTriggerCharacters?(): Promise<readonly string[]>;

452 > }

453 >

454 > /**

455 > * Inputs for {@link IChatSessionContentProvider.provideChatInputCompletions}

456 > * and {@link IChatSessionsService.provideChatInputCompletions}.

457 > */

458 > export interface IChatInputCompletionsParams {

459 > /**

460 > * The complete text of the input being completed (e.g. the user message

461 > * the user is currently composing).

462 > */

463 > readonly text: string;

464 > /**

465 > * The character offset within {@link text} at which the completion is

466 > * requested, measured in UTF-16 code units. MUST satisfy

467 > * `0 <= offset <= text.length`.

468 > */

469 > readonly offset: number;

470 > }

471 >

472 > /**

473 > * A neutral completion-item shape returned by

474 > * {@link IChatSessionContentProvider.provideChatInputCompletions}. The

475 > * workbench-side completion glue maps these into Monaco completion items

476 > * and the corresponding chat-input attachment.

477 > */

478 > export interface IChatInputCompletionItem {

479 > /** Text inserted into the input when this item is accepted. */

480 > readonly insertText: string;

481 > /**

482 > * Optional display label shown in the completion picker. When omitted, the

483 > * workbench displays {@link insertText}. Set this when the inserted text

484 > * differs from the label — e.g. an action item that inserts nothing

485 > * (`insertText: ''`) but should still be shown to the user.

486 > */

487 > readonly label?: string;

488 > /**

489 > * Half-open range `[start, end)` in the *current* input text that

490 > * {@link insertText} replaces. Positions use 1-based `lineNumber` and

491 > * `column` to match Monaco. When omitted, the workbench replaces the

492 > * word at the cursor.

493 > */

494 > readonly start?: IPosition;

495 > readonly end?: IPosition;

496 > /** Attachment associated with the item. */

497 > readonly attachment: IChatInputCompletionResourceAttachment | IChatInputCompletionCommandAttachment | IChatInputCompletionSkillAttachment;

498 > }

499 >

500 > /**

501 > * Resource attachment associated with a completion item. The workbench

502 > * adds it to the input's variable model when the item is accepted.

503 > */

504 > export interface IChatInputCompletionResourceAttachment {

505 > readonly kind: 'resource';

506 > readonly uri: URI;

507 > readonly displayName?: string;

508 > readonly isDirectory?: boolean;

509 > /**

510 > * Implementation-defined metadata that MUST be preserved by the

511 > * workbench when the accepted completion is sent back as part of a

512 > * user message attachment.

513 > */

514 > readonly _meta?: Record<string, unknown>;

515 > }

516 >

517 > /**

518 > * Command attachment associated with a completion item.

519 > */

520 > export interface IChatInputCompletionCommandAttachment {

521 > readonly kind: 'command';

522 > readonly command: string;

523 > readonly description: string;

524 > /**

525 > * Implementation-defined metadata that MUST be preserved by the

526 > * workbench when the accepted completion is sent back as part of a

527 > * user message attachment.

528 > */

529 > readonly _meta?: Record<string, unknown>;

530 > }

531 >

532 > /**

533 > * Skill attachment associated with a completion item. The workbench

534 > * adds it to the input's variable model when the item is accepted.

535 > */

536 > export interface IChatInputCompletionSkillAttachment {

537 > readonly kind: 'skill';

538 > readonly uri: URI;

539 > readonly displayName?: string;

540 > readonly description?: string;

541 > /**

542 > * Implementation-defined metadata that MUST be preserved by the

543 > * workbench when the accepted completion is sent back as part of a

544 > * user message attachment.

545 > */

546 > readonly _meta?: Record<string, unknown>;

547 > }

548 >

549 > /**

550 > * Result of {@link IChatSessionContentProvider.provideChatInputCompletions}.

551 > */

552 > export interface IChatInputCompletionsResult {

553 > readonly items: readonly IChatInputCompletionItem[];

554 > }

555 >

556 > export interface IChatNewSessionRequest {

557 > readonly prompt: string;

558 > readonly command?: string;

559 >

560 > readonly initialSessionOptions?: ReadonlyChatSessionOptionsMap;

561 >

562 > /**

563 > * The chat-input session resource the user was typing into when this

564 > * request was issued. Set when the chat infrastructure is rewriting an

565 > * untitled session URI to a real one on first send. Controllers can use

566 > * this to bridge any pre-creation state they tracked under the old URI

567 > * (e.g. provisional agent-host sessions) to the new resource that the

568 > * controller returns.

569 > */

570 > readonly untitledResource?: URI;

571 > }

572 >

573 > export interface IChatSessionItemsDelta {

574 > readonly addedOrUpdated?: readonly IChatSessionItem[];

575 > readonly removed?: readonly URI[];

576 > }

577 >

578 > export interface IChatSessionItemController {

579 >

580 > readonly onDidChangeChatSessionItems: Event<IChatSessionItemsDelta>;

581 >

582 > get items(): readonly IChatSessionItem[];

583 >

584 > refresh(token: CancellationToken): Promise<void>;

585 >

586 > newChatSessionItem?(request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;

587 >

588 > getNewChatSessionInputState?(sessionResource: URI, token: CancellationToken): Promise<readonly IChatSessionProviderOptionGroup[] | undefined>;

589 >

590 > resolveChatSessionItem?(resource: URI, token: CancellationToken): Promise<IChatSessionItem | undefined>;

591 >

592 > /**

593 > * Permanently delete the session identified by `resource`. Implementations should tear down any backend state for

594 > * the session. The controller is expected to fire an `onDidChangeChatSessionItems` event with the removed resource

595 > * as a result of the deletion.

596 > */

597 > deleteChatSessionItem?(resource: URI, token: CancellationToken): Promise<void>;

598 >

599 > /**

600 > * Set the authoritative archived state for the session identified by `resource`.

601 > */

602 > setChatSessionItemArchived?(resource: URI, archived: boolean): void;

603 > }

604 >

605 > export interface IChatSessionOptionsChangeEvent {

606 > readonly sessionResource: URI;

607 > readonly updates: ReadonlyMap<string, string | IChatSessionProviderOptionItem | undefined>;

608 > }

609 >

610 > export type ResolvedChatSessionsExtensionPoint = Omit<IChatSessionsExtensionPoint, 'icon'> & {

611 > readonly icon: ThemeIcon | URI | undefined;

612 > };

613 >

614 > /**

615 > * Session options as key-value pairs.

616 > *

617 > * Keys correspond to option group IDs (e.g., 'models', 'subagents') and values are either the selected option item IDs (string) or full option items (for locked state).

618 > */

619 > export type ChatSessionOptionsMap = Map<string, string | IChatSessionProviderOptionItem>;

620 >

621 > export namespace ChatSessionOptionsMap {

622 > export function fromRecord(obj: { [key: string]: string | IChatSessionProviderOptionItem }): ChatSessionOptionsMap {

623 return new Map(Object.entries(obj));

624 }

625 > chatSessionsService.ts

626 > export function toRecord(map: ReadonlyChatSessionOptionsMap): Record<string, string | IChatSessionProviderOptionItem> {

627 const record: Record<string, string | IChatSessionProviderOptionItem> = Object.create(null);

628 const entries = ensureIterable(map);

632 return record;

633 }

634 > chatSessionsService.ts

635 > export function toStrValueArray(map: ReadonlyChatSessionOptionsMap | undefined): Array<{ optionId: string; value: string }> | undefined {

636 if (!map) {

637 return undefined;

640 return Array.from(entries, ([optionId, value]) => ({ optionId, value: typeof value === 'string' ? value : value.id }));

641 }

642 > chatSessionsService.ts

643 > /**

644 > * Ensures the input is iterable. If a plain object is passed (e.g. due to

645 > * serialization across process boundaries losing the Map prototype), it is

646 > * converted to Map entries on the fly.

647 > */

648 > function ensureIterable(map: ReadonlyChatSessionOptionsMap): Iterable<[string, string | IChatSessionProviderOptionItem]> {

649 if (map instanceof Map) {

650 return map;

653 return Object.entries(map as unknown as Record<string, string | IChatSessionProviderOptionItem>);

654 }

655 > } chatSessionsService.ts

656 >

657 > /**

658 > * Readonly version of {@link ChatSessionOptionsMap}

659 > */

660 > export type ReadonlyChatSessionOptionsMap = ReadonlyMap<string, string | IChatSessionProviderOptionItem>;

661 >

662 > export interface IChatSessionCustomizationItem {

663 > readonly label: string;

664 > readonly description?: string;

665 > readonly uri: URI;

666 > readonly storageLocation: number;

667 > readonly icon?: ThemeIcon;

668 > }

669 >

670 > export interface IChatSessionCustomizationItemGroup {

671 > readonly id: string;

672 > readonly items: IChatSessionCustomizationItem[];

673 > readonly commands?: readonly { readonly id: string; readonly title: string; readonly arguments?: readonly unknown[] }[];

674 > readonly itemCommands?: readonly { readonly id: string; readonly title: string; readonly arguments?: readonly unknown[] }[];

675 > }

676 >

677 > export interface IChatSessionCustomizationsProvider {

678 > readonly onDidChangeCustomizations: Event<void>;

679 > provideCustomizations(token: CancellationToken): Promise<IChatSessionCustomizationItemGroup[] | undefined>;

680 > }

681 >

682 >

683 > export interface IChatSessionCommitEvent {

684 > /** The original (untitled) session resource. */

685 > readonly original: URI;

686 > /** The committed (real) session resource. */

687 > readonly committed: URI;

688 > }

689 >

690 > export const IChatSessionsService = createDecorator<IChatSessionsService>('chatSessionsService');

691 >

692 > export interface IChatSessionsService {

693 > readonly _serviceBrand: undefined;

694 >

695 > // #region Chat session item provider support

696 > readonly onDidChangeItemsProviders: Event<{ readonly chatSessionType: string }>;

697 > readonly onDidChangeSessionItems: Event<IChatSessionItemsDelta>;

698 >

699 > /**

700 > * Fired when an untitled session is committed (URI swapped to a real resource)

701 > * after the first turn completes.

702 > */

703 > readonly onDidCommitSession: Event<IChatSessionCommitEvent>;

704 >

705 > readonly onDidChangeAvailability: Event<void>;

706 > readonly onDidChangeInProgress: Event<void>;

707 >

708 > getChatSessionContribution(chatSessionType: string): ResolvedChatSessionsExtensionPoint | undefined;

709 > getAllChatSessionContributions(): ResolvedChatSessionsExtensionPoint[];

710 >

711 > /**

712 > * Programmatically register a chat session contribution (for internal session types

713 > * that don't go through the extension point).

714 > */

715 > registerChatSessionContribution(contribution: IChatSessionsExtensionPoint): IDisposable;

716 >

717 > registerChatSessionItemController(chatSessionType: string, controller: IChatSessionItemController): IDisposable;

718 > getRegisteredChatSessionItemProviders(): readonly string[];

719 > activateChatSessionItemProvider(chatSessionType: string): Promise<void>;

720 >

721 > /**

722 > * Get the list of current chat session items grouped by session type.

723 > *

724 > * @param providerTypeFilter If specified, only returns items from the given providers. If undefined, returns items from all providers.

725 > *

726 > * @returns An async iterable that produces the list of session items for each provider. The order is not guaranteed. Some provider may take a long time to resolve.

727 > */

728 > getChatSessionItems(providerTypeFilter: readonly string[] | undefined, token: CancellationToken): AsyncIterable<{ readonly chatSessionType: string; readonly items: readonly IChatSessionItem[] }>;

729 >

730 > /**

731 > * Forces the controllers to refresh their session items, optionally filtered by provider type.

732 > */

733 > refreshChatSessionItems(providerTypeFilter: readonly string[] | undefined, token: CancellationToken): Promise<void>;

734 >

735 > /** @deprecated Use `getChatSessionItems` */

736 > getInProgress(): { chatSessionType: string; count: number }[];

737 >

738 > /**

739 > * Lazily resolves a chat session item, filling in expensive details like timing, changes, and badge.

740 > * Returns the resolved item, or undefined if no resolve handler is available.

741 > */

742 > resolveChatSessionItem(chatSessionType: string, resource: URI, token: CancellationToken): Promise<IChatSessionItem | undefined>;

743 >

744 > /**

745 > * Whether the registered item controller owns archived state for the session.

746 > */

747 > canSetChatSessionItemArchived(sessionResource: URI): boolean;

748 >

749 > /**

750 > * Sets archived state by delegating to the registered item controller.

751 > */

752 > setChatSessionItemArchived(sessionResource: URI, archived: boolean): void;

753 >

754 > // #endregion

755 >

756 > // #region Content provider support

757 > readonly onDidChangeContentProviderSchemes: Event<{ readonly added: string[]; readonly removed: string[] }>;

758 >

759 > getContentProviderSchemes(): string[];

760 >

761 > registerChatSessionContentProvider(scheme: string, provider: IChatSessionContentProvider): IDisposable;

762 > canResolveChatSession(sessionType: string): Promise<boolean>;

763 > getOrCreateChatSession(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;

764 > /** Resolves a parsed response Markdown URI through its session content provider. */

765 > resolveChatResponseUri(sessionResource: URI, href: string, kind: 'link' | 'image'): string;

766 >

767 > /**

768 > * Compute completion items for an input being composed in the chat

769 > * session identified by `sessionResource`. Delegates to the registered

770 > * {@link IChatSessionContentProvider} for the session, if it implements

771 > * {@link IChatSessionContentProvider.provideChatInputCompletions}.

772 > * Returns `undefined` when no provider is available, in which case the

773 > * workbench's default in-process providers should be used.

774 > */

775 > provideChatInputCompletions(sessionResource: URI, params: IChatInputCompletionsParams, token: CancellationToken): Promise<IChatInputCompletionsResult | undefined>;

776 >

777 > /**

778 > * Trigger characters announced by the content provider for the given

779 > * session type. Used to dynamically register Monaco completion

780 > * providers per content-provider scheme. Returns `undefined` when the

781 > * scheme has no content provider, or `[]` when the provider does not

782 > * announce any trigger characters.

783 > */

784 > getChatInputCompletionTriggerCharacters(sessionType: string): Promise<readonly string[] | undefined>;

785 >

786 > getSessionOptions(sessionResource: URI): ReadonlyChatSessionOptionsMap | undefined;

787 > getSessionOption(sessionResource: URI, optionId: string): string | IChatSessionProviderOptionItem | undefined;

788 > setSessionOption(sessionResource: URI, optionId: string, value: string | IChatSessionProviderOptionItem): boolean;

789 > updateSessionOptions(sessionResource: URI, updates: ReadonlyChatSessionOptionsMap): boolean;

790 >

791 > /**

792 > * Fired when options for a chat session change.

793 > */

794 > readonly onDidChangeSessionOptions: Event<IChatSessionOptionsChangeEvent>;

795 >

796 > /**

797 > * Get the capabilities for a specific session type

798 > */

799 > getCapabilitiesForSessionType(chatSessionType: string): IChatAgentAttachmentCapabilities | undefined;

800 >

801 > /**

802 > * Get the customAgentTarget for a specific session type.

803 > * When the Target is not `Target.Undefined`, the mode picker should show filtered custom agents matching this target.

804 > */

805 > getCustomAgentTargetForSessionType(chatSessionType: string): Target;

806 >

807 > /**

808 > * Returns whether the session type requires custom models. When true, the model picker should show filtered custom models.

809 > */

810 > requiresCustomModelsForSessionType(chatSessionType: string): boolean;

811 >

812 > /**

813 > * Returns whether the session type supports the synthetic "Auto" model

814 > * fallback. The built-in local chat always supports it; contributed session

815 > * types default to `false` unless they set `supportsAutoModel`. When false

816 > * and no models are available, the picker shows a "No models available"

817 > * state instead of "Auto".

818 > */

819 > supportsAutoModelForSessionType(chatSessionType: string): boolean;

820 >

821 > /**

822 > * Whether the session type needs a Copilot account and so is unusable until the user signs in (BYOK isn't

823 > * supported). Defaults to false, so third-party types stay usable while signed out.

824 > */

825 > requiresCopilotSignInForSessionType(chatSessionType: string): boolean;

826 >

827 > /**

828 > * Returns whether the session type supports delegation.

829 > * Defaults to true when not explicitly set.

830 > */

831 > supportsDelegationForSessionType(chatSessionType: string): boolean;

832 >

833 > /**

834 > * Returns whether the loaded session supports forking conversations.

835 > */

836 > sessionSupportsFork(sessionResource: URI): boolean;

837 >

838 > /**

839 > * Forks a contributed chat session from the given request point.

840 > * @param sessionResource The session resource to fork.

841 > * @param request The request history item to fork from, or undefined to fork from the end.

842 > * @param token Cancellation token.

843 > * @returns The forked session item, or undefined if forking failed.

844 > */

845 > forkChatSession(sessionResource: URI, request: IChatSessionRequestHistoryItem | undefined, token: CancellationToken): Promise<IChatSessionItem>;

846 >

847 > /**

848 > * Returns whether the loaded session supports renaming.

849 > */

850 > sessionSupportsRename(sessionResource: URI): boolean;

851 >

852 > /**

853 > * Renames a contributed chat session.

854 > * @param sessionResource The session resource to rename.

855 > * @param title The new title for the session.

856 > * @param token Cancellation token.

857 > */

858 > renameChatSession(sessionResource: URI, title: string, token: CancellationToken): Promise<void>;

859 >

860 > readonly onDidChangeOptionGroups: Event<string>;

861 >

862 > getOptionGroupsForSessionType(chatSessionType: string): IChatSessionProviderOptionGroup[] | undefined;

863 > setOptionGroupsForSessionType(chatSessionType: string, handle: number, optionGroups?: readonly IChatSessionProviderOptionGroup[]): void;

864 >

865 > /**

866 > * Get the default options for new sessions of this type, derived from option groups'

867 > * `selected` or `default` items.

868 > */

869 > getNewChatSessionInputState(chatSessionType: string, sessionResource: URI): Promise<readonly IChatSessionProviderOptionGroup[] | undefined>;

870 >

871 > /**

872 > * Creates a new chat session item using the controller's newChatSessionItemHandler.

873 > * Returns undefined if the controller doesn't have a handler or if no controller is registered.

874 > */

875 > createNewChatSessionItem(chatSessionType: string, request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;

876 >

877 > /**

878 > * Permanently deletes a chat session item by delegating to the registered controller's `deleteChatSessionItem`

879 > * handler. Throws if the controller does not implement `deleteChatSessionItem`.

880 > */

881 > deleteChatSessionItem(sessionResource: URI, token: CancellationToken): Promise<void>;

882 >

883 > /**

884 > * Records the inverse `real → untitled` alias so option lookups for the real

885 > * session resolve to the untitled session's entry (e.g. {@link updateSessionOptions}).

886 > *

887 > * Call this BEFORE the real session loads, and never remove it — the real

888 > * session keeps reading its options through this alias even after the untitled

889 > * model is disposed. (Only the forward mapping is cleared, via

890 > * {@link clearMaterializedSessionResource}.) Publishing the forward mapping is a

891 > * separate step; see {@link setMaterializedSessionResource}.

892 > */

893 > registerSessionResourceAlias(untitledResource: URI, realResource: URI): void;

894 >

895 > /**

896 > * Records the forward `untitled → real` mapping (read via

897 > * {@link getMaterializedSessionResource}) so a late send still addressed to the

898 > * untitled resource re-targets the real session. Call this only AFTER the real

899 > * session has loaded.

900 > *

901 > * Kept separate from {@link registerSessionResourceAlias} on purpose: the

902 > * inverse alias must exist BEFORE the load (for option lookups), but this

903 > * forward mapping must appear only AFTER the real session exists — published

904 > * earlier, a failed or still-loading session would be re-targeted before it

905 > * exists (a later send would throw "Unknown session").

906 > */

907 > setMaterializedSessionResource(untitledResource: URI, realResource: URI): void;

908 >

909 > /**

910 > * Returns the real session resource that `untitledResource` materialized

911 > * into (via {@link setMaterializedSessionResource}), or `undefined` if it has

912 > * not materialized or the mapping was already cleared.

913 > */

914 > getMaterializedSessionResource(untitledResource: URI): URI | undefined;

915 >

916 > /**

917 > * Clears the forward `untitled → real` mapping for `sessionResource` (passed

918 > * either the untitled key or the real value), so {@link getMaterializedSessionResource}

919 > * stops re-targeting once the session is disposed. Does NOT remove the inverse

920 > * alias, which is intentionally permanent (see {@link registerSessionResourceAlias}).

921 > */

922 > clearMaterializedSessionResource(sessionResource: URI): void;

923 >

924 > /**

925 > * Fires {@link onDidCommitSession} to notify listeners that an untitled

926 > * session has been committed with a real resource URI.

927 > */

928 > fireSessionCommitted(original: URI, committed: URI): void;

929 >

930 > // #region Customizations provider support

931 > readonly onDidChangeCustomizations: Event<{ readonly chatSessionType: string }>;

932 > registerCustomizationsProvider(chatSessionType: string, provider: IChatSessionCustomizationsProvider): IDisposable;

933 > hasCustomizationsProvider(chatSessionType: string): boolean;

934 > getCustomizations(chatSessionType: string, token: CancellationToken): Promise<IChatSessionCustomizationItemGroup[] | undefined>;

935 > // #endregion

936 > }

937 >

938 > export function isSessionInProgressStatus(state: ChatSessionStatus): boolean {

939 return state === ChatSessionStatus.InProgress || state === ChatSessionStatus.NeedsInput;

940 }

941 > chatSessionsService.ts

942 > export function isIChatSessionFileChange2(obj: unknown): obj is IChatSessionFileChange2 {

943 const candidate = obj as IChatSessionFileChange2;

944 return candidate && candidate.uri instanceof URI && typeof candidate.insertions === 'number' && typeof candidate.deletions === 'number';

src/vs/base/common/event.ts 859 covered LOC · 102 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- event.ts

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 { CancelablePromise } from './async.js';

7 > import { CancellationToken } from './cancellation.js';

8 > import { diffSets } from './collections.js';

9 > import { onUnexpectedError } from './errors.js';

10 > import { createSingleCallFunction } from './functional.js';

11 > import { combinedDisposable, Disposable, DisposableMap, DisposableStore, IDisposable, toDisposable } from './lifecycle.js';

12 > import { LinkedList } from './linkedList.js';

13 > import { IObservable, IObservableWithChange, IObserver } from './observable.js';

14 > import { env } from './process.js';

15 > import { StopWatch } from './stopwatch.js';

16 > import { MicrotaskDelay } from './symbols.js';

17 >

18 >

19 > // -----------------------------------------------------------------------------------------------------------------------

20 > // Uncomment the next line to print warnings whenever an emitter with listeners is disposed. That is a sign of code smell.

21 > // -----------------------------------------------------------------------------------------------------------------------

22 > const _enableDisposeWithListenerWarning = false

23 > // || Boolean("TRUE") // causes a linter warning so that it cannot be pushed

24 > ;

25 >

26 >

27 > // -----------------------------------------------------------------------------------------------------------------------

28 > // Uncomment the next line to print warnings whenever a snapshotted event is used repeatedly without cleanup.

29 > // See https://github.com/microsoft/vscode/issues/142851

30 > // -----------------------------------------------------------------------------------------------------------------------

31 > const _enableSnapshotPotentialLeakWarning = false

32 > // || Boolean("TRUE") // causes a linter warning so that it cannot be pushed

33 > ;

34 >

35 >

36 > const _bufferLeakWarnCountThreshold = 100;

37 > const _bufferLeakWarnTimeThreshold = 60_000; // 1 minute

38 >

39 function _isBufferLeakWarningEnabled(): boolean {

40 return !!env['VSCODE_DEV'];

41 }

42 > event.ts

43 > /**

44 > * An event with zero or one parameters that can be subscribed to. The event is a function itself.

45 > */

46 > export interface Event<T> {

47 > (listener: (e: T) => unknown, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;

48 > }

49 >

50 > export namespace Event {

51 > export const None: Event<any> = () => Disposable.None;

52 >

53 > function _addLeakageTraceLogic(options: EmitterOptions) {

54 if (_enableSnapshotPotentialLeakWarning) {

55 const { onDidAddListener: origListenerDidAdd } = options;

65 }

66 }

67 > event.ts

68 > /**

69 > * Given an event, returns another event which debounces calls and defers the listeners to a later task via a shared

70 > * `setTimeout`. The event is converted into a signal (`Event<void>`) to avoid additional object creation as a

71 > * result of merging events and to try prevent race conditions that could arise when using related deferred and

72 > * non-deferred events.

73 > *

74 > * This is useful for deferring non-critical work (eg. general UI updates) to ensure it does not block critical work

75 > * (eg. latency of keypress to text rendered).

76 > *

77 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

78 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

79 > * returned event causes this utility to leak a listener on the original event.

80 > *

81 > * @param event The event source for the new event.

82 > * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not

83 > * specified, some events could go missing. Use this if it's important that all events are processed, even if the

84 > * listener gets disposed before the debounced event fires.

85 > * @param disposable A disposable store to add the new EventEmitter to.

86 > */

87 > export function defer(event: Event<unknown>, flushOnListenerRemove?: boolean, disposable?: DisposableStore): Event<void> {

88 return debounce<unknown, void>(event, () => void 0, 0, undefined, flushOnListenerRemove ?? true, undefined, disposable);

89 }

90 > event.ts

91 > /**

92 > * Given an event, returns another event which only fires once.

93 > *

94 > * @param event The event source for the new event.

95 > */

96 > export function once<T>(event: Event<T>): Event<T> {

97 return (listener, thisArgs = null, disposables?) => {

98 // we need this, in case the event fires during the listener call

118 };

119 }

120 > event.ts

121 > /**

122 > * Given an event, returns another event which only fires once, and only when the condition is met.

123 > *

124 > * @param event The event source for the new event.

125 > */

126 > export function onceIf<T>(event: Event<T>, condition: (e: T) => boolean): Event<T> {

127 return Event.once(Event.filter(event, condition));

128 }

129 > event.ts

130 > /**

131 > * Maps an event of one type into an event of another type using a mapping function, similar to how

132 > * `Array.prototype.map` works.

133 > *

134 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

135 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

136 > * returned event causes this utility to leak a listener on the original event.

137 > *

138 > * @param event The event source for the new event.

139 > * @param map The mapping function.

140 > * @param disposable A disposable store to add the new EventEmitter to.

141 > */

142 > export function map<I, O>(event: Event<I>, map: (i: I) => O, disposable?: DisposableStore): Event<O> {

143 return snapshot((listener, thisArgs = null, disposables?) => event(i => listener.call(thisArgs, map(i)), null, disposables), disposable);

144 }

145 > event.ts

146 > /**

147 > * Wraps an event in another event that performs some function on the event object before firing.

148 > *

149 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

150 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

151 > * returned event causes this utility to leak a listener on the original event.

152 > *

153 > * @param event The event source for the new event.

154 > * @param each The function to perform on the event object.

155 > * @param disposable A disposable store to add the new EventEmitter to.

156 > */

157 > export function forEach<I>(event: Event<I>, each: (i: I) => void, disposable?: DisposableStore): Event<I> {

158 return snapshot((listener, thisArgs = null, disposables?) => event(i => { each(i); listener.call(thisArgs, i); }, null, disposables), disposable);

159 }

160 > event.ts

161 > /**

162 > * Wraps an event in another event that fires only when some condition is met.

163 > *

164 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

165 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

166 > * returned event causes this utility to leak a listener on the original event.

167 > *

168 > * @param event The event source for the new event.

169 > * @param filter The filter function that defines the condition. The event will fire for the object if this function

170 > * returns true.

171 > * @param disposable A disposable store to add the new EventEmitter to.

172 > */

173 > export function filter<T, U>(event: Event<T | U>, filter: (e: T | U) => e is T, disposable?: DisposableStore): Event<T>;

174 > export function filter<T>(event: Event<T>, filter: (e: T) => boolean, disposable?: DisposableStore): Event<T>;

175 > export function filter<T, R>(event: Event<T | R>, filter: (e: T | R) => e is R, disposable?: DisposableStore): Event<R>;

176 > export function filter<T>(event: Event<T>, filter: (e: T) => boolean, disposable?: DisposableStore): Event<T> {

177 return snapshot((listener, thisArgs = null, disposables?) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables), disposable);

178 }

179 > event.ts

180 > /**

181 > * Given an event, returns the same event but typed as `Event<void>`.

182 > */

183 > export function signal<T>(event: Event<T>): Event<void> {

184 return event as Event<any> as Event<void>;

185 }

186 > event.ts

187 > /**

188 > * Given a collection of events, returns a single event which emits whenever any of the provided events emit.

189 > */

190 > export function any<T>(...events: Event<T>[]): Event<T>;

191 > export function any(...events: Event<any>[]): Event<void>;

192 > export function any<T>(...events: Event<T>[]): Event<T> {

193 return (listener, thisArgs = null, disposables?) => {

194 const disposable = combinedDisposable(...events.map(event => event(e => listener.call(thisArgs, e))));

196 };

197 }

198 > event.ts

199 > /**

200 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

201 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

202 > * returned event causes this utility to leak a listener on the original event.

203 > */

204 > export function reduce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, initial?: O, disposable?: DisposableStore): Event<O> {

205 let output: O | undefined = initial;

206

210 }, disposable);

211 }

212 > event.ts

213 > function snapshot<T>(event: Event<T>, disposable: DisposableStore | undefined): Event<T> {

214 let listener: IDisposable | undefined;

215

233 return emitter.event;

234 }

235 > event.ts

236 > /**

237 > * Adds the IDisposable to the store if it's set, and returns it. Useful to

238 > * Event function implementation.

239 > */

240 > function addAndReturnDisposable<T extends IDisposable>(d: T, store: DisposableStore | IDisposable[] | undefined): T {

241 if (store instanceof Array) {

242 store.push(d);

246 return d;

247 }

248 > event.ts

249 > /**

250 > * Given an event, creates a new emitter that event that will debounce events based on {@link delay} and give an

251 > * array event object of all events that fired.

252 > *

253 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

254 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

255 > * returned event causes this utility to leak a listener on the original event.

256 > *

257 > * @param event The original event to debounce.

258 > * @param merge A function that reduces all events into a single event.

259 > * @param delay The number of milliseconds to debounce.

260 > * @param leading Whether to fire a leading event without debouncing.

261 > * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not

262 > * specified, some events could go missing. Use this if it's important that all events are processed, even if the

263 > * listener gets disposed before the debounced event fires.

264 > * @param leakWarningThreshold See {@link EmitterOptions.leakWarningThreshold}.

265 > * @param disposable A disposable store to register the debounce emitter to.

266 > */

267 > export function debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;

268 > export function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;

269 > export function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay: number | typeof MicrotaskDelay = 100, leading = false, flushOnListenerRemove = false, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O> {

270 let subscription: IDisposable;

271 let output: O | undefined = undefined;

330 return emitter.event;

331 }

332 > event.ts

333 > /**

334 > * Debounces an event, firing after some delay (default=0) with an array of all event original objects.

335 > *

336 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

337 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

338 > * returned event causes this utility to leak a listener on the original event.

339 > *

340 > * @param event The event source for the new event.

341 > * @param delay The number of milliseconds to debounce.

342 > * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not

343 > * specified, some events could go missing. Use this if it's important that all events are processed, even if the

344 > * listener gets disposed before the debounced event fires.

345 > * @param disposable A disposable store to add the new EventEmitter to.

346 > */

347 > export function accumulate<T>(event: Event<T>, delay: number | typeof MicrotaskDelay = 0, flushOnListenerRemove?: boolean, disposable?: DisposableStore): Event<T[]> {

348 return Event.debounce<T, T[]>(event, (last, e) => {

349 if (!last) {

354 }, delay, undefined, flushOnListenerRemove ?? true, undefined, disposable);

355 }

356 > event.ts

357 > /**

358 > * Throttles an event, ensuring the event is fired at most once during the specified delay period.

359 > * Unlike debounce, throttle will fire immediately on the leading edge and/or after the delay on the trailing edge.

360 > *

361 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

362 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

363 > * returned event causes this utility to leak a listener on the original event.

364 > *

365 > * @param event The event source for the new event.

366 > * @param merge An accumulator function that merges events if multiple occur during the throttle period.

367 > * @param delay The number of milliseconds to throttle.

368 > * @param leading Whether to fire on the leading edge (immediately on first event).

369 > * @param trailing Whether to fire on the trailing edge (after delay with the last value).

370 > * @param leakWarningThreshold See {@link EmitterOptions.leakWarningThreshold}.

371 > * @param disposable A disposable store to register the throttle emitter to.

372 > */

373 > export function throttle<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number | typeof MicrotaskDelay, leading?: boolean, trailing?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;

374 > export function throttle<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number | typeof MicrotaskDelay, leading?: boolean, trailing?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;

375 > export function throttle<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay: number | typeof MicrotaskDelay = 100, leading = true, trailing = true, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O> {

376 let subscription: IDisposable;

377 let output: O | undefined = undefined;

437 return emitter.event;

438 }

439 > event.ts

440 > /**

441 > * Filters an event such that some condition is _not_ met more than once in a row, effectively ensuring duplicate

442 > * event objects from different sources do not fire the same event object.

443 > *

444 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

445 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

446 > * returned event causes this utility to leak a listener on the original event.

447 > *

448 > * @param event The event source for the new event.

449 > * @param equals The equality condition.

450 > * @param disposable A disposable store to add the new EventEmitter to.

451 > *

452 > * @example

453 > * ```

454 > * // Fire only one time when a single window is opened or focused

455 > * Event.latch(Event.any(onDidOpenWindow, onDidFocusWindow))

456 > * ```

457 > */

458 > export function latch<T>(event: Event<T>, equals: (a: T, b: T) => boolean = (a, b) => a === b, disposable?: DisposableStore): Event<T> {

459 let firstCall = true;

460 let cache: T;

467 }, disposable);

468 }

469 > event.ts

470 > /**

471 > * Splits an event whose parameter is a union type into 2 separate events for each type in the union.

472 > *

473 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

474 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

475 > * returned event causes this utility to leak a listener on the original event.

476 > *

477 > * @example

478 > * ```

479 > * const event = new EventEmitter<number | undefined>().event;

480 > * const [numberEvent, undefinedEvent] = Event.split(event, isUndefined);

481 > * ```

482 > *

483 > * @param event The event source for the new event.

484 > * @param isT A function that determines what event is of the first type.

485 > * @param disposable A disposable store to add the new EventEmitter to.

486 > */

487 > export function split<T, U>(event: Event<T | U>, isT: (e: T | U) => e is T, disposable?: DisposableStore): [Event<T>, Event<U>] {

488 return [

489 Event.filter(event, isT, disposable),

491 ];

492 }

493 > event.ts

494 > /**

495 > * Buffers an event until it has a listener attached.

496 > *

497 > * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned

498 > * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the

499 > * returned event causes this utility to leak a listener on the original event.

500 > *

501 > * @param event The event source for the new event.

502 > * @param debugName A name for this buffer, used in leak detection warnings.

503 > * @param flushAfterTimeout Determines whether to flush the buffer after a timeout immediately or after a

504 > * `setTimeout` when the first event listener is added.

505 > * @param _buffer Internal: A source event array used for tests.

506 > *

507 > * @example

508 > * ```

509 > * // Start accumulating events, when the first listener is attached, flush

510 > * // the event after a timeout such that multiple listeners attached before

511 > * // the timeout would receive the event

512 > * this.onInstallExtension = Event.buffer(service.onInstallExtension, 'onInstallExtension', true);

513 > * ```

514 > */

515 > export function buffer<T>(event: Event<T>, debugName: string, flushAfterTimeout = false, _buffer: T[] = [], disposable?: DisposableStore): Event<T> {

516 let buffer: T[] | null = _buffer.slice();

517

600 return emitter.event;

601 }

602 > /** event.ts

603 > * Wraps the event in an {@link IChainableEvent}, allowing a more functional programming style.

604 > *

605 > * @example

606 > * ```

607 > * // Normal

608 > * const onEnterPressNormal = Event.filter(

609 > * Event.map(onKeyPress.event, e => new StandardKeyboardEvent(e)),

610 > * e.keyCode === KeyCode.Enter

611 > * ).event;

612 > *

613 > * // Using chain

614 > * const onEnterPressChain = Event.chain(onKeyPress.event, $ => $

615 > * .map(e => new StandardKeyboardEvent(e))

616 > * .filter(e => e.keyCode === KeyCode.Enter)

617 > * );

618 > * ```

619 > */

620 > export function chain<T, R>(event: Event<T>, sythensize: ($: IChainableSythensis<T>) => IChainableSythensis<R>): Event<R> {

621 const fn: Event<R> = (listener, thisArgs, disposables) => {

622 const cs = sythensize(new ChainableSynthesis()) as ChainableSynthesis;

631 return fn;

632 }

633 > event.ts

634 > const HaltChainable = Symbol('HaltChainable');

635 >

636 > class ChainableSynthesis implements IChainableSythensis<any> {

637 private readonly steps: ((input: any) => unknown)[] = [];

638 > event.ts

639 > map<O>(fn: (i: any) => O): this {

640 this.steps.push(fn);

641 return this;

642 }

643 > event.ts

644 > forEach(fn: (i: any) => void): this {

645 this.steps.push(v => {

646 fn(v);

649 return this;

650 }

651 > event.ts

652 > filter(fn: (e: any) => boolean): this {

653 this.steps.push(v => fn(v) ? v : HaltChainable);

654 return this;

655 }

656 > event.ts

657 > reduce<R>(merge: (last: R | undefined, event: any) => R, initial?: R | undefined): this {

658 let last = initial;

659 this.steps.push(v => {

663 return this;

664 }

665 > event.ts

666 > latch(equals: (a: any, b: any) => boolean = (a, b) => a === b): ChainableSynthesis {

667 let firstCall = true;

668 let cache: any;

676 return this;

677 }

678 > event.ts

679 > public evaluate(value: any) {

680 for (const step of this.steps) {

681 value = step(value);

687 return value;

688 }

689 > } event.ts

690 >

691 > export interface IChainableSythensis<T> {

692 > map<O>(fn: (i: T) => O): IChainableSythensis<O>;

693 > forEach(fn: (i: T) => void): IChainableSythensis<T>;

694 > filter<R extends T>(fn: (e: T) => e is R): IChainableSythensis<R>;

695 > filter(fn: (e: T) => boolean): IChainableSythensis<T>;

696 > reduce<R>(merge: (last: R, event: T) => R, initial: R): IChainableSythensis<R>;

697 > reduce<R>(merge: (last: R | undefined, event: T) => R): IChainableSythensis<R>;

698 > latch(equals?: (a: T, b: T) => boolean): IChainableSythensis<T>;

699 > }

700 >

701 > export interface NodeEventEmitter {

702 > on(event: string | symbol, listener: Function): unknown;

703 > removeListener(event: string | symbol, listener: Function): unknown;

704 > }

705 >

706 > /**

707 > * Creates an {@link Event} from a node event emitter.

708 > */

709 > export function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map: (...args: any[]) => T = id => id): Event<T> {

710 const fn = (...args: unknown[]) => result.fire(map(...args));

711 const onFirstListenerAdd = () => emitter.on(eventName, fn);

715 return result.event;

716 }

717 > event.ts

718 > export interface DOMEventEmitter {

719 > addEventListener(event: string | symbol, listener: Function): void;

720 > removeEventListener(event: string | symbol, listener: Function): void;

721 > }

722 >

723 > /**

724 > * Creates an {@link Event} from a DOM event emitter.

725 > */

726 > export function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map: (...args: any[]) => T = id => id): Event<T> {

727 const fn = (...args: unknown[]) => result.fire(map(...args));

728 const onFirstListenerAdd = () => emitter.addEventListener(eventName, fn);

732 return result.event;

733 }

734 > event.ts

735 > /**

736 > * Creates a promise out of an event, using the {@link Event.once} helper.

737 > */

738 > export function toPromise<T>(event: Event<T>, disposables?: IDisposable[] | DisposableStore): CancelablePromise<T> {

739 let cancelRef: () => void;

740 let listener: IDisposable;

756 return promise;

757 }

758 > event.ts

759 > /**

760 > * A convenience function for forwarding an event to another emitter which

761 > * improves readability.

762 > *

763 > * This is similar to {@link Relay} but allows instantiating and forwarding

764 > * on a single line and also allows for multiple source events.

765 > * @param from The event to forward.

766 > * @param to The emitter to forward the event to.

767 > * @example

768 > * Event.forward(event, emitter);

769 > * // equivalent to

770 > * event(e => emitter.fire(e));

771 > * // equivalent to

772 > * event(emitter.fire, emitter);

773 > */

774 > export function forward<T>(from: Event<T>, to: Emitter<T>): IDisposable {

775 return from(e => to.fire(e));

776 }

777 > event.ts

778 > /**

779 > * Adds a listener to an event and calls the listener immediately with undefined as the event object.

780 > *

781 > * @example

782 > * ```

783 > * // Initialize the UI and update it when dataChangeEvent fires

784 > * runAndSubscribe(dataChangeEvent, () => this._updateUI());

785 > * ```

786 > */

787 > export function runAndSubscribe<T>(event: Event<T>, handler: (e: T) => unknown, initial: T): IDisposable;

788 > export function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => unknown): IDisposable;

789 > export function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => unknown, initial?: T): IDisposable {

790 handler(initial);

791 return event(e => handler(e));

792 }

793 > event.ts

794 > class EmitterObserver<T> implements IObserver {

795 >

796 > readonly emitter: Emitter<T>;

797 >

798 > private _counter = 0;

799 > private _hasChanged = false;

800 >

801 > constructor(readonly _observable: IObservable<T>, store: DisposableStore | undefined) {

802 const options: EmitterOptions = {

803 onWillAddFirstListener: () => {

819 }

820 }

821 > event.ts

822 > beginUpdate<T>(_observable: IObservable<T>): void {

823 // assert(_observable === this.obs);

824 this._counter++;

825 }

826 > event.ts

827 > handlePossibleChange<T>(_observable: IObservable<T>): void {

828 // assert(_observable === this.obs);

829 }

830 > event.ts

831 > handleChange<T, TChange>(_observable: IObservableWithChange<T, TChange>, _change: TChange): void {

832 // assert(_observable === this.obs);

833 this._hasChanged = true;

834 }

835 > event.ts

836 > endUpdate<T>(_observable: IObservable<T>): void {

837 // assert(_observable === this.obs);

838 this._counter--;

845 }

846 }

847 > } event.ts

848 >

849 > /**

850 > * Creates an event emitter that is fired when the observable changes.

851 > * Each listeners subscribes to the emitter.

852 > */

853 > export function fromObservable<T>(obs: IObservable<T>, store?: DisposableStore): Event<T> {

854 const observer = new EmitterObserver(obs, store);

855 return observer.emitter.event;

856 }

857 > event.ts

858 > /**

859 > * Each listener is attached to the observable directly.

860 > */

861 > export function fromObservableLight(observable: IObservable<unknown>): Event<void> {

862 return (listener, thisArgs, disposables) => {

863 let count = 0;

897 };

898 }

899 > } event.ts

900 >

901 > export interface EmitterOptions {

902 > /**

903 > * Optional function that's called *before* the very first listener is added

904 > */

905 > onWillAddFirstListener?: Function;

906 > /**

907 > * Optional function that's called *after* the very first listener is added

908 > */

909 > onDidAddFirstListener?: Function;

910 > /**

911 > * Optional function that's called after a listener is added

912 > */

913 > onDidAddListener?: Function;

914 > /**

915 > * Optional function that's called *after* remove the very last listener

916 > */

917 > onDidRemoveLastListener?: Function;

918 > /**

919 > * Optional function that's called *before* a listener is removed

920 > */

921 > onWillRemoveListener?: Function;

922 > /**

923 > * Optional function that's called when a listener throws an error. Defaults to

924 > * {@link onUnexpectedError}

925 > */

926 > onListenerError?: (e: any) => void;

927 > /**

928 > * Number of listeners that are allowed before assuming a leak. Default to

929 > * a globally configured value

930 > *

931 > * @see setGlobalLeakWarningThreshold

932 > */

933 > leakWarningThreshold?: number;

934 > /**

935 > * Human-readable name for the emitter, included in leak warning error

936 > * messages to help identify which emitter is leaking in telemetry.

937 > */

938 > leakWarningName?: string;

939 > /**

940 > * Pass in a delivery queue, which is useful for ensuring

941 > * in order event delivery across multiple emitters.

942 > */

943 > deliveryQueue?: EventDeliveryQueue;

944 >

945 > /** ONLY enable this during development */

946 > _profName?: string;

947 > }

948 >

949 >

950 > export class EventProfiling {

951 >

952 > static readonly all = new Set<EventProfiling>();

953 >

954 > private static _idPool = 0;

955 >

956 > readonly name: string;

957 > public listenerCount: number = 0;

958 > public invocationCount = 0;

959 > public elapsedOverall = 0;

960 > public durations: number[] = [];

961 >

962 > private _stopWatch?: StopWatch;

963 >

964 > constructor(name: string) {

965 this.name = `${name}_${EventProfiling._idPool++}`;

966 EventProfiling.all.add(this);

967 }

968 > event.ts

969 > start(listenerCount: number): void {

970 this._stopWatch = new StopWatch();

971 this.listenerCount = listenerCount;

972 }

973 > event.ts

974 > stop(): void {

975 if (this._stopWatch) {

976 const elapsed = this._stopWatch.elapsed();

981 }

982 }

983 > } event.ts

984 >

985 > let _globalLeakWarningThreshold = -1;

986 > export function setGlobalLeakWarningThreshold(n: number): IDisposable {

987 const oldValue = _globalLeakWarningThreshold;

988 _globalLeakWarningThreshold = n;

993 };

994 }

995 > event.ts

996 > class LeakageMonitor {

997 >

998 > private static _idPool = 1;

999 >

1000 > private _stacks: Map<string, number> | undefined;

1001 > private _warnCountdown: number = 0;

1002 >

1003 > constructor(

1004 private readonly _errorHandler: (err: Error) => void,

1005 readonly threshold: number,

1006 readonly name: string = (LeakageMonitor._idPool++).toString(16).padStart(3, '0')

1007 ) { }

1008 > event.ts

1009 > dispose(): void {

1010 this._stacks?.clear();

1011 }

1012 > event.ts

1013 > check(stack: Stacktrace, listenerCount: number): undefined | (() => void) {

1014

1015 const threshold = this.threshold;

1046 };

1047 }

1048 > event.ts

1049 > getMostFrequentStack(): [string, number] | undefined {

1050 if (!this._stacks) {

1051 return undefined;

1061 return topStack;

1062 }

1063 > } event.ts

1064 >

1065 > class Stacktrace {

1066 >

1067 > static create() {

1068 > const err = new Error();

1069 > return new Stacktrace(err.stack ?? '');

1070 > }

1071 >

1072 > private constructor(readonly value: string) { }

1073 >

1074 > print() {

1075 console.warn(this.value.split('\n').slice(2).join('\n'));

1076 }

1077 > } event.ts

1078 >

1079 > // error that is logged when going over the configured listener threshold

1080 > export class ListenerLeakError extends Error {

1081 > readonly kind: string;

1082 > readonly listenerCount: number;

1083 > /**

1084 > * The detailed message including listener count and most frequent stack.

1085 > * Available locally for debugging but intentionally not used as the error

1086 > * `message`. When `emitterName` is provided, errors group by emitter name

1087 > * and kind in telemetry; otherwise they group by kind alone.

1088 > */

1089 > readonly details: string;

1090 > constructor(kind: 'dominated' | 'popular', details: string, stack: string, listenerCount: number, emitterName?: string) {

1091 super(emitterName

1092 ? `[${emitterName}] potential listener LEAK detected, ${kind}`

1098 this.stack = stack;

1099 }

1100 > event.ts

1101 > static is(err: unknown): err is ListenerLeakError {

1102 return err instanceof ListenerLeakError

1103 || (err instanceof Error && typeof (err as Error & { kind: unknown; listenerCount: unknown }).kind === 'string' && typeof (err as Error & { kind: unknown; listenerCount: unknown }).listenerCount === 'number');

1104 }

1105 > } event.ts

1106 >

1107 > // SEVERE error that is logged when having gone way over the configured listener

1108 > // threshold so that the emitter refuses to accept more listeners

1109 > export class ListenerRefusalError extends ListenerLeakError {

1110 > constructor(kind: 'dominated' | 'popular', details: string, stack: string, listenerCount: number, emitterName?: string) {

1111 super(kind, details, stack, listenerCount, emitterName);

1112 this.name = 'ListenerRefusalError';

1113 }

1114 > } event.ts

1115 >

1116 > let id = 0;

1117 > class UniqueContainer<T> {

1118 > stack?: Stacktrace;

1119 > public id = id++;

1120 > constructor(public readonly value: T) { }

1121 > }

1122 > const compactionThreshold = 2;

1123 >

1124 > type ListenerContainer<T> = UniqueContainer<(data: T) => void>;

1125 > type ListenerOrListeners<T> = (ListenerContainer<T> | undefined)[] | ListenerContainer<T>;

1126 >

1127 > const forEachListener = <T>(listeners: ListenerOrListeners<T>, fn: (c: ListenerContainer<T>) => void) => {

1128 if (listeners instanceof UniqueContainer) {

1129 fn(listeners);

1137 }

1138 };

1139 > event.ts

1140 > /**

1141 > * The Emitter can be used to expose an Event to the public

1142 > * to fire it from the insides.

1143 > * Sample:

1144 > class Document {

1145 >

1146 > private readonly _onDidChange = new Emitter<(value:string)=>any>();

1147 >

1148 > public onDidChange = this._onDidChange.event;

1149 >

1150 > // getter-style

1151 > // get onDidChange(): Event<(value:string)=>any> {

1152 > // return this._onDidChange.event;

1153 > // }

1154 >

1155 > private _doIt() {

1156 > //...

1157 > this._onDidChange.fire(value);

1158 > }

1159 > }

1160 > */

1161 > export class Emitter<T> {

1162 >

1163 > private readonly _options?: EmitterOptions;

1164 > private readonly _leakageMon?: LeakageMonitor;

1165 > private readonly _perfMon?: EventProfiling;

1166 > private _disposed?: true;

1167 > private _event?: Event<T>;

1168 >

1169 > /**

1170 > * A listener, or list of listeners. A single listener is the most common

1171 > * for event emitters (#185789), so we optimize that special case to avoid

1172 > * wrapping it in an array (just like Node.js itself.)

1173 > *

1174 > * A list of listeners never 'downgrades' back to a plain function if

1175 > * listeners are removed, for two reasons:

1176 > *

1177 > * 1. That's complicated (especially with the deliveryQueue)

1178 > * 2. A listener with >1 listener is likely to have >1 listener again at

1179 > * some point, and swapping between arrays and functions may[citation needed]

1180 > * introduce unnecessary work and garbage.

1181 > *

1182 > * The array listeners can be 'sparse', to avoid reallocating the array

1183 > * whenever any listener is added or removed. If more than `1 / compactionThreshold`

1184 > * of the array is empty, only then is it resized.

1185 > */

1186 > protected _listeners?: ListenerOrListeners<T>;

1187 >

1188 > /**

1189 > * Always to be defined if _listeners is an array. It's no longer a true

1190 > * queue, but holds the dispatching 'state'. If `fire()` is called on an

1191 > * emitter, any work left in the _deliveryQueue is finished first.

1192 > */

1193 > private _deliveryQueue?: EventDeliveryQueuePrivate;

1194 > protected _size = 0;

1195 >

1196 > constructor(options?: EmitterOptions) {

1197 > this._options = options; event.ts

1198 > this._leakageMon = (_globalLeakWarningThreshold > 0 || this._options?.leakWarningThreshold)

1199 ? new LeakageMonitor(options?.onListenerError ?? onUnexpectedError, this._options?.leakWarningThreshold ?? _globalLeakWarningThreshold, this._options?.leakWarningName) :

1200 > undefined; event.ts

1201 > this._perfMon = this._options?._profName ? new EventProfiling(this._options._profName) : undefined;

1202 > this._deliveryQueue = this._options?.deliveryQueue as EventDeliveryQueuePrivate | undefined;

1203 > }

1204 > event.ts

1205 > dispose() {

1206 if (!this._disposed) {

1207 this._disposed = true;

1235 }

1236 }

1237 > event.ts

1238 > /**

1239 > * For the public to allow to subscribe

1240 > * to events from this Emitter

1241 > */

1242 > get event(): Event<T> {

1243 > this._event ??= (callback: (e: T) => unknown, thisArgs?: any, disposables?: IDisposable[] | DisposableStore) => { event.ts

1244 if (this._leakageMon && this._size > this._leakageMon.threshold ** 2) {

1245 const message = `[${this._leakageMon.name}] REFUSES to accept new listeners because it exceeded its threshold by far (${this._size} vs ${this._leakageMon.threshold})`;

1301 return result;

1302 };

1303 > event.ts

1304 > return this._event;

1305 > }

1306 > event.ts

1307 > private _removeListener(listener: ListenerContainer<T>) {

1308 this._options?.onWillRemoveListener?.(this);

1309

1349 }

1350 }

1351 > event.ts

1352 > private _deliver(listener: undefined | UniqueContainer<(value: T) => void>, value: T) {

1353 if (!listener) {

1354 return;

1367 }

1368 }

1369 > event.ts

1370 > /** Delivers items in the queue. Assumes the queue is ready to go. */

1371 > private _deliverQueue(dq: EventDeliveryQueuePrivate) {

1372 const listeners = dq.current!._listeners! as (ListenerContainer<T> | undefined)[];

1373 while (dq.i < dq.end) {

1377 dq.reset();

1378 }

1379 > event.ts

1380 > /**

1381 > * To be kept private to fire an event to

1382 > * subscribers

1383 > */

1384 > fire(event: T): void {

1385 > if (this._deliveryQueue?.current) { event.ts

1386 this._deliverQueue(this._deliveryQueue);

1387 this._perfMon?.stop(); // last fire() will have starting perfmon, stop it before starting the next dispatch

1388 }

1389 > event.ts

1390 > this._perfMon?.start(this._size);

1391 >

1392 > if (!this._listeners) {

1393 > // no-op event.ts

1394 > } else if (this._listeners instanceof UniqueContainer) { event.ts

1395 this._deliver(this._listeners, event);

1396 } else {

1399 this._deliverQueue(dq);

1400 }

1401 > event.ts

1402 > this._perfMon?.stop();

1403 > }

1404 > event.ts

1405 > hasListeners(): boolean {

1406 return this._size > 0;

1407 }

1408 > } event.ts

1409 >

1410 > export interface EventDeliveryQueue {

1411 > _isEventDeliveryQueue: true;

1412 > }

1413 >

1414 > export const createEventDeliveryQueue = (): EventDeliveryQueue => new EventDeliveryQueuePrivate();

1415 >

1416 class EventDeliveryQueuePrivate implements EventDeliveryQueue {

1417 declare _isEventDeliveryQueue: true;

1426 */

1427 public end = 0;

1428 > event.ts

1429 > /**

1430 > * Emitter currently being dispatched on. Emitter._listeners is always an array.

1431 > */

1432 > public current?: Emitter<any>;

1433 > /**

1434 > * Currently emitting value. Defined whenever `current` is.

1435 > */

1436 > public value?: unknown;

1437 >

1438 > public enqueue<T>(emitter: Emitter<T>, value: T, end: number) {

1439 this.i = 0;

1440 this.end = end;

1442 this.value = value;

1443 }

1444 > event.ts

1445 > public reset() {

1446 this.i = this.end; // force any current emission loop to stop, mainly for during dispose

1447 this.current = undefined;

1448 this.value = undefined;

1449 }

1450 > } event.ts

1451 >

1452 > export interface IWaitUntil {

1453 > token: CancellationToken;

1454 > waitUntil(thenable: Promise<unknown>): void;

1455 > }

1456 >

1457 > export type IWaitUntilData<T> = Omit<Omit<T, 'waitUntil'>, 'token'>;

1458 >

1459 > export class AsyncEmitter<T extends IWaitUntil> extends Emitter<T> {

1460 >

1461 > private _asyncDeliveryQueue?: LinkedList<[(ev: T) => void, IWaitUntilData<T>]>;

1462 >

1463 > async fireAsync(data: IWaitUntilData<T>, token: CancellationToken, promiseJoin?: (p: Promise<unknown>, listener: Function) => Promise<unknown>): Promise<void> {

1464 if (!this._listeners) {

1465 return;

1512 }

1513 }

1514 > } event.ts

1515 >

1516 >

1517 > export class PauseableEmitter<T> extends Emitter<T> {

1518 >

1519 > private _isPaused = 0;

1520 > protected _eventQueue = new LinkedList<T>();

1521 > private _mergeFn?: (input: T[]) => T;

1522 >

1523 > public get isPaused(): boolean {

1524 > return this._isPaused !== 0;

1525 > }

1526 >

1527 > constructor(options?: EmitterOptions & { merge?: (input: T[]) => T }) {

1528 super(options);

1529 this._mergeFn = options?.merge;

1530 }

1531 > event.ts

1532 > pause(): void {

1533 this._isPaused++;

1534 }

1535 > event.ts

1536 > resume(): void {

1537 if (this._isPaused !== 0 && --this._isPaused === 0) {

1538 if (this._mergeFn) {

1554 }

1555 }

1556 > event.ts

1557 > override fire(event: T): void {

1558 if (this._size) {

1559 if (this._isPaused !== 0) {

1564 }

1565 }

1566 > } event.ts

1567 >

1568 > export class DebounceEmitter<T> extends PauseableEmitter<T> {

1569 >

1570 > private readonly _delay: number;

1571 > private _handle: Timeout | undefined;

1572 >

1573 > constructor(options: EmitterOptions & { merge: (input: T[]) => T; delay?: number }) {

1574 super(options);

1575 this._delay = options.delay ?? 100;

1576 }

1577 > event.ts

1578 > override fire(event: T): void {

1579 if (!this._handle) {

1580 this.pause();

1586 super.fire(event);

1587 }

1588 > } event.ts

1589 >

1590 > /**

1591 > * An emitter which queue all events and then process them at the

1592 > * end of the event loop.

1593 > */

1594 > export class MicrotaskEmitter<T> extends Emitter<T> {

1595 > private _queuedEvents: T[] = [];

1596 > private _mergeFn?: (input: T[]) => T;

1597 >

1598 > constructor(options?: EmitterOptions & { merge?: (input: T[]) => T }) {

1599 super(options);

1600 this._mergeFn = options?.merge;

1601 }

1602 > override fire(event: T): void { event.ts

1603

1604 if (!this.hasListeners()) {

1618 }

1619 }

1620 > } event.ts

1621 >

1622 > /**

1623 > * An event emitter that multiplexes many events into a single event.

1624 > *

1625 > * @example Listen to the `onData` event of all `Thing`s, dynamically adding and removing `Thing`s

1626 > * to the multiplexer as needed.

1627 > *

1628 > * ```typescript

1629 > * const anythingDataMultiplexer = new EventMultiplexer<{ data: string }>();

1630 > *

1631 > * const thingListeners = DisposableMap<Thing, IDisposable>();

1632 > *

1633 > * thingService.onDidAddThing(thing => {

1634 > * thingListeners.set(thing, anythingDataMultiplexer.add(thing.onData);

1635 > * });

1636 > * thingService.onDidRemoveThing(thing => {

1637 > * thingListeners.deleteAndDispose(thing);

1638 > * });

1639 > *

1640 > * anythingDataMultiplexer.event(e => {

1641 > * console.log('Something fired data ' + e.data)

1642 > * });

1643 > * ```

1644 > */

1645 > export class EventMultiplexer<T> implements IDisposable {

1646 >

1647 > private readonly emitter: Emitter<T>;

1648 > private hasListeners = false;

1649 > private events: { event: Event<T>; listener: IDisposable | null }[] = [];

1650 >

1651 > constructor() {

1652 this.emitter = new Emitter<T>({

1653 onWillAddFirstListener: () => this.onFirstListenerAdd(),

1655 });

1656 }

1657 > event.ts

1658 > get event(): Event<T> {

1659 return this.emitter.event;

1660 }

1661 > event.ts

1662 > add(event: Event<T>): IDisposable {

1663 const e = { event: event, listener: null };

1664 this.events.push(e);

1679 return toDisposable(createSingleCallFunction(dispose));

1680 }

1681 > event.ts

1682 > private onFirstListenerAdd(): void {

1683 this.hasListeners = true;

1684 this.events.forEach(e => this.hook(e));

1685 }

1686 > event.ts

1687 > private onLastListenerRemove(): void {

1688 this.hasListeners = false;

1689 this.events.forEach(e => this.unhook(e));

1690 }

1691 > event.ts

1692 > private hook(e: { event: Event<T>; listener: IDisposable | null }): void {

1693 e.listener = e.event(r => this.emitter.fire(r));

1694 }

1695 > event.ts

1696 > private unhook(e: { event: Event<T>; listener: IDisposable | null }): void {

1697 e.listener?.dispose();

1698 e.listener = null;

1699 }

1700 > event.ts

1701 > dispose(): void {

1702 this.emitter.dispose();

1703

1707 this.events = [];

1708 }

1709 > } event.ts

1710 >

1711 > export interface IDynamicListEventMultiplexer<TEventType> extends IDisposable {

1712 > readonly event: Event<TEventType>;

1713 > }

1714 > export class DynamicListEventMultiplexer<TItem, TEventType> implements IDynamicListEventMultiplexer<TEventType> {

1715 > private readonly _store = new DisposableStore();

1716 >

1717 > readonly event: Event<TEventType>;

1718 >

1719 > constructor(

1720 items: TItem[],

1721 onAddItem: Event<TItem>,

1747 this.event = multiplexer.event;

1748 }

1749 > event.ts

1750 > dispose() {

1751 this._store.dispose();

1752 }

1753 > } event.ts

1754 >

1755 > /**

1756 > * The EventBufferer is useful in situations in which you want

1757 > * to delay firing your events during some code.

1758 > * You can wrap that code and be sure that the event will not

1759 > * be fired during that wrap.

1760 > *

1761 > * ```

1762 > * const emitter: Emitter;

1763 > * const delayer = new EventDelayer();

1764 > * const delayedEvent = delayer.wrapEvent(emitter.event);

1765 > *

1766 > * delayedEvent(console.log);

1767 > *

1768 > * delayer.bufferEvents(() => {

1769 > * emitter.fire(); // event will not be fired yet

1770 > * });

1771 > *

1772 > * // event will only be fired at this point

1773 > * ```

1774 > */

1775 > export class EventBufferer {

1776

1777 private data: { buffers: Function[] }[] = [];

1778 > event.ts

1779 > wrapEvent<T>(event: Event<T>): Event<T>;

1780 > wrapEvent<T>(event: Event<T>, reduce: (last: T | undefined, event: T) => T): Event<T>;

1781 > wrapEvent<T, O>(event: Event<T>, reduce: (last: O | undefined, event: T) => O, initial: O): Event<O>;

1782 > wrapEvent<T, O>(event: Event<T>, reduce?: (last: T | O | undefined, event: T) => T | O, initial?: O): Event<O | T> {

1783 return (listener, thisArgs?, disposables?) => {

1784 return event(i => {

1832 };

1833 }

1834 > event.ts

1835 > bufferEvents<R = void>(fn: () => R): R {

1836 const data = { buffers: new Array<Function>() };

1837 this.data.push(data);

1841 return r;

1842 }

1843 > } event.ts

1844 >

1845 > /**

1846 > * A Relay is an event forwarder which functions as a replugabble event pipe.

1847 > * Once created, you can connect an input event to it and it will simply forward

1848 > * events from that input event through its own `event` property. The `input`

1849 > * can be changed at any point in time.

1850 > */

1851 > export class Relay<T> implements IDisposable {

1852

1853 private listening = false;

1867

1868 readonly event: Event<T> = this.emitter.event;

1869 > event.ts

1870 > set input(event: Event<T>) {

1871 this.inputEvent = event;

1872

1876 }

1877 }

1878 > event.ts

1879 > dispose() {

1880 this.inputEventListener.dispose();

1881 this.emitter.dispose();

1882 }

1883 > } event.ts

1884 >

1885 > export interface IValueWithChangeEvent<T> {

1886 > readonly onDidChange: Event<void>;

1887 > get value(): T;

1888 > }

1889 >

1890 > export class ValueWithChangeEvent<T> implements IValueWithChangeEvent<T> {

1891 > public static const<T>(value: T): IValueWithChangeEvent<T> {

1892 > return new ConstValueWithChangeEvent(value);

1893 > }

1894 >

1895 > private readonly _onDidChange = new Emitter<void>();

1896 > readonly onDidChange: Event<void> = this._onDidChange.event;

1897 >

1898 > constructor(private _value: T) { }

1899 >

1900 > get value(): T {

1901 return this._value;

1902 }

1903 > event.ts

1904 > set value(value: T) {

1905 if (value !== this._value) {

1906 this._value = value;

1908 }

1909 }

1910 > } event.ts

1911 >

1912 > class ConstValueWithChangeEvent<T> implements IValueWithChangeEvent<T> {

1913 > public readonly onDidChange: Event<void> = Event.None;

1914 >

1915 > constructor(readonly value: T) { }

1916 > }

1917 >

1918 > /**

1919 > * @param handleItem Is called for each item in the set (but only the first time the item is seen in the set).

1920 > * The returned disposable is disposed if the item is no longer in the set.

1921 > */

1922 > export function trackSetChanges<T>(getData: () => ReadonlySet<T>, onDidChangeData: Event<unknown>, handleItem: (d: T) => IDisposable): IDisposable {

1923 const map = new DisposableMap<T, IDisposable>();

1924 let oldData = new Set(getData());

1942 return store;

1943 }

1944 > event.ts

1945 >

1946 function addToDisposables(result: IDisposable, disposables: DisposableStore | IDisposable[] | undefined) {

1947 if (disposables instanceof DisposableStore) {

1951 }

1952 }

1953 > event.ts

1954 function disposeAndRemove(result: IDisposable, disposables: DisposableStore | IDisposable[] | undefined) {

1955 if (disposables instanceof DisposableStore) {

src/vs/base/common/codiconsLibrary.ts 758 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- codiconsLibrary.ts

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 > import { register } from './codiconsUtil.js';

6 >

7 >

8 > // This file is automatically generated by (microsoft/vscode-codicons)/scripts/export-to-ts.js

9 > // Please don't edit it, as your changes will be overwritten.

10 > // Instead, add mappings to codiconsDerived in codicons.ts.

11 > export const codiconsLibrary = {

12 > add: register('add', 0xea60),

13 > plus: register('plus', 0xea60),

14 > gistNew: register('gist-new', 0xea60),

15 > repoCreate: register('repo-create', 0xea60),

16 > lightbulb: register('lightbulb', 0xea61),

17 > lightBulb: register('light-bulb', 0xea61),

18 > repo: register('repo', 0xea62),

19 > repoDelete: register('repo-delete', 0xea62),

20 > gistFork: register('gist-fork', 0xea63),

21 > repoForked: register('repo-forked', 0xea63),

22 > gitPullRequest: register('git-pull-request', 0xea64),

23 > gitPullRequestAbandoned: register('git-pull-request-abandoned', 0xea64),

24 > recordKeys: register('record-keys', 0xea65),

25 > keyboard: register('keyboard', 0xea65),

26 > tag: register('tag', 0xea66),

27 > gitPullRequestLabel: register('git-pull-request-label', 0xea66),

28 > tagAdd: register('tag-add', 0xea66),

29 > tagRemove: register('tag-remove', 0xea66),

30 > person: register('person', 0xea67),

31 > personFollow: register('person-follow', 0xea67),

32 > personOutline: register('person-outline', 0xea67),

33 > personFilled: register('person-filled', 0xea67),

34 > sourceControl: register('source-control', 0xea68),

35 > mirror: register('mirror', 0xea69),

36 > mirrorPublic: register('mirror-public', 0xea69),

37 > star: register('star', 0xea6a),

38 > starAdd: register('star-add', 0xea6a),

39 > starDelete: register('star-delete', 0xea6a),

40 > starEmpty: register('star-empty', 0xea6a),

41 > comment: register('comment', 0xea6b),

42 > commentAdd: register('comment-add', 0xea6b),

43 > alert: register('alert', 0xea6c),

44 > warning: register('warning', 0xea6c),

45 > search: register('search', 0xea6d),

46 > searchSave: register('search-save', 0xea6d),

47 > logOut: register('log-out', 0xea6e),

48 > signOut: register('sign-out', 0xea6e),

49 > logIn: register('log-in', 0xea6f),

50 > signIn: register('sign-in', 0xea6f),

51 > eye: register('eye', 0xea70),

52 > eyeUnwatch: register('eye-unwatch', 0xea70),

53 > eyeWatch: register('eye-watch', 0xea70),

54 > circleFilled: register('circle-filled', 0xea71),

55 > primitiveDot: register('primitive-dot', 0xea71),

56 > closeDirty: register('close-dirty', 0xea71),

57 > debugBreakpoint: register('debug-breakpoint', 0xea71),

58 > debugBreakpointDisabled: register('debug-breakpoint-disabled', 0xea71),

59 > debugHint: register('debug-hint', 0xea71),

60 > terminalDecorationSuccess: register('terminal-decoration-success', 0xea71),

61 > primitiveSquare: register('primitive-square', 0xea72),

62 > edit: register('edit', 0xea73),

63 > pencil: register('pencil', 0xea73),

64 > info: register('info', 0xea74),

65 > issueOpened: register('issue-opened', 0xea74),

66 > gistPrivate: register('gist-private', 0xea75),

67 > gitForkPrivate: register('git-fork-private', 0xea75),

68 > lock: register('lock', 0xea75),

69 > mirrorPrivate: register('mirror-private', 0xea75),

70 > close: register('close', 0xea76),

71 > removeClose: register('remove-close', 0xea76),

72 > x: register('x', 0xea76),

73 > repoSync: register('repo-sync', 0xea77),

74 > sync: register('sync', 0xea77),

75 > clone: register('clone', 0xea78),

76 > desktopDownload: register('desktop-download', 0xea78),

77 > beaker: register('beaker', 0xea79),

78 > microscope: register('microscope', 0xea79),

79 > vm: register('vm', 0xea7a),

80 > deviceDesktop: register('device-desktop', 0xea7a),

81 > file: register('file', 0xea7b),

82 > more: register('more', 0xea7c),

83 > ellipsis: register('ellipsis', 0xea7c),

84 > kebabHorizontal: register('kebab-horizontal', 0xea7c),

85 > mailReply: register('mail-reply', 0xea7d),

86 > reply: register('reply', 0xea7d),

87 > organization: register('organization', 0xea7e),

88 > organizationFilled: register('organization-filled', 0xea7e),

89 > organizationOutline: register('organization-outline', 0xea7e),

90 > newFile: register('new-file', 0xea7f),

91 > fileAdd: register('file-add', 0xea7f),

92 > newFolder: register('new-folder', 0xea80),

93 > fileDirectoryCreate: register('file-directory-create', 0xea80),

94 > trash: register('trash', 0xea81),

95 > trashcan: register('trashcan', 0xea81),

96 > history: register('history', 0xea82),

97 > clock: register('clock', 0xea82),

98 > folder: register('folder', 0xea83),

99 > fileDirectory: register('file-directory', 0xea83),

100 > symbolFolder: register('symbol-folder', 0xea83),

101 > logoGithub: register('logo-github', 0xea84),

102 > markGithub: register('mark-github', 0xea84),

103 > github: register('github', 0xea84),

104 > terminal: register('terminal', 0xea85),

105 > console: register('console', 0xea85),

106 > repl: register('repl', 0xea85),

107 > zap: register('zap', 0xea86),

108 > symbolEvent: register('symbol-event', 0xea86),

109 > error: register('error', 0xea87),

110 > stop: register('stop', 0xea87),

111 > variable: register('variable', 0xea88),

112 > symbolVariable: register('symbol-variable', 0xea88),

113 > array: register('array', 0xea8a),

114 > symbolArray: register('symbol-array', 0xea8a),

115 > symbolModule: register('symbol-module', 0xea8b),

116 > symbolPackage: register('symbol-package', 0xea8b),

117 > symbolNamespace: register('symbol-namespace', 0xea8b),

118 > symbolObject: register('symbol-object', 0xea8b),

119 > symbolMethod: register('symbol-method', 0xea8c),

120 > symbolFunction: register('symbol-function', 0xea8c),

121 > symbolConstructor: register('symbol-constructor', 0xea8c),

122 > symbolBoolean: register('symbol-boolean', 0xea8f),

123 > symbolNull: register('symbol-null', 0xea8f),

124 > symbolNumeric: register('symbol-numeric', 0xea90),

125 > symbolNumber: register('symbol-number', 0xea90),

126 > symbolStructure: register('symbol-structure', 0xea91),

127 > symbolStruct: register('symbol-struct', 0xea91),

128 > symbolParameter: register('symbol-parameter', 0xea92),

129 > symbolTypeParameter: register('symbol-type-parameter', 0xea92),

130 > symbolKey: register('symbol-key', 0xea93),

131 > symbolText: register('symbol-text', 0xea93),

132 > symbolReference: register('symbol-reference', 0xea94),

133 > goToFile: register('go-to-file', 0xea94),

134 > symbolEnum: register('symbol-enum', 0xea95),

135 > symbolValue: register('symbol-value', 0xea95),

136 > symbolRuler: register('symbol-ruler', 0xea96),

137 > symbolUnit: register('symbol-unit', 0xea96),

138 > activateBreakpoints: register('activate-breakpoints', 0xea97),

139 > archive: register('archive', 0xea98),

140 > arrowBoth: register('arrow-both', 0xea99),

141 > arrowDown: register('arrow-down', 0xea9a),

142 > arrowLeft: register('arrow-left', 0xea9b),

143 > arrowRight: register('arrow-right', 0xea9c),

144 > arrowSmallDown: register('arrow-small-down', 0xea9d),

145 > arrowSmallLeft: register('arrow-small-left', 0xea9e),

146 > arrowSmallRight: register('arrow-small-right', 0xea9f),

147 > arrowSmallUp: register('arrow-small-up', 0xeaa0),

148 > arrowUp: register('arrow-up', 0xeaa1),

149 > bell: register('bell', 0xeaa2),

150 > bold: register('bold', 0xeaa3),

151 > book: register('book', 0xeaa4),

152 > bookmark: register('bookmark', 0xeaa5),

153 > debugBreakpointConditionalUnverified: register('debug-breakpoint-conditional-unverified', 0xeaa6),

154 > debugBreakpointConditional: register('debug-breakpoint-conditional', 0xeaa7),

155 > debugBreakpointConditionalDisabled: register('debug-breakpoint-conditional-disabled', 0xeaa7),

156 > debugBreakpointDataUnverified: register('debug-breakpoint-data-unverified', 0xeaa8),

157 > debugBreakpointData: register('debug-breakpoint-data', 0xeaa9),

158 > debugBreakpointDataDisabled: register('debug-breakpoint-data-disabled', 0xeaa9),

159 > debugBreakpointLogUnverified: register('debug-breakpoint-log-unverified', 0xeaaa),

160 > debugBreakpointLog: register('debug-breakpoint-log', 0xeaab),

161 > debugBreakpointLogDisabled: register('debug-breakpoint-log-disabled', 0xeaab),

162 > briefcase: register('briefcase', 0xeaac),

163 > broadcast: register('broadcast', 0xeaad),

164 > browser: register('browser', 0xeaae),

165 > bug: register('bug', 0xeaaf),

166 > calendar: register('calendar', 0xeab0),

167 > caseSensitive: register('case-sensitive', 0xeab1),

168 > check: register('check', 0xeab2),

169 > checklist: register('checklist', 0xeab3),

170 > chevronDown: register('chevron-down', 0xeab4),

171 > chevronLeft: register('chevron-left', 0xeab5),

172 > chevronRight: register('chevron-right', 0xeab6),

173 > chevronUp: register('chevron-up', 0xeab7),

174 > chromeClose: register('chrome-close', 0xeab8),

175 > chromeMaximize: register('chrome-maximize', 0xeab9),

176 > chromeMinimize: register('chrome-minimize', 0xeaba),

177 > chromeRestore: register('chrome-restore', 0xeabb),

178 > circleOutline: register('circle-outline', 0xeabc),

179 > circle: register('circle', 0xeabc),

180 > debugBreakpointUnverified: register('debug-breakpoint-unverified', 0xeabc),

181 > terminalDecorationIncomplete: register('terminal-decoration-incomplete', 0xeabc),

182 > circleSlash: register('circle-slash', 0xeabd),

183 > circuitBoard: register('circuit-board', 0xeabe),

184 > clearAll: register('clear-all', 0xeabf),

185 > clippy: register('clippy', 0xeac0),

186 > closeAll: register('close-all', 0xeac1),

187 > cloudDownload: register('cloud-download', 0xeac2),

188 > cloudUpload: register('cloud-upload', 0xeac3),

189 > code: register('code', 0xeac4),

190 > collapseAll: register('collapse-all', 0xeac5),

191 > colorMode: register('color-mode', 0xeac6),

192 > commentDiscussion: register('comment-discussion', 0xeac7),

193 > creditCard: register('credit-card', 0xeac9),

194 > dash: register('dash', 0xeacc),

195 > dashboard: register('dashboard', 0xeacd),

196 > database: register('database', 0xeace),

197 > debugContinue: register('debug-continue', 0xeacf),

198 > debugDisconnect: register('debug-disconnect', 0xead0),

199 > debugPause: register('debug-pause', 0xead1),

200 > debugRestart: register('debug-restart', 0xead2),

201 > debugStart: register('debug-start', 0xead3),

202 > debugStepInto: register('debug-step-into', 0xead4),

203 > debugStepOut: register('debug-step-out', 0xead5),

204 > debugStepOver: register('debug-step-over', 0xead6),

205 > debugStop: register('debug-stop', 0xead7),

206 > debug: register('debug', 0xead8),

207 > deviceCameraVideo: register('device-camera-video', 0xead9),

208 > deviceCamera: register('device-camera', 0xeada),

209 > deviceMobile: register('device-mobile', 0xeadb),

210 > diffAdded: register('diff-added', 0xeadc),

211 > diffIgnored: register('diff-ignored', 0xeadd),

212 > diffModified: register('diff-modified', 0xeade),

213 > diffRemoved: register('diff-removed', 0xeadf),

214 > diffRenamed: register('diff-renamed', 0xeae0),

215 > diff: register('diff', 0xeae1),

216 > diffSidebyside: register('diff-sidebyside', 0xeae1),

217 > discard: register('discard', 0xeae2),

218 > editorLayout: register('editor-layout', 0xeae3),

219 > emptyWindow: register('empty-window', 0xeae4),

220 > exclude: register('exclude', 0xeae5),

221 > extensions: register('extensions', 0xeae6),

222 > eyeClosed: register('eye-closed', 0xeae7),

223 > fileBinary: register('file-binary', 0xeae8),

224 > fileCode: register('file-code', 0xeae9),

225 > fileMedia: register('file-media', 0xeaea),

226 > filePdf: register('file-pdf', 0xeaeb),

227 > fileSubmodule: register('file-submodule', 0xeaec),

228 > fileSymlinkDirectory: register('file-symlink-directory', 0xeaed),

229 > fileSymlinkFile: register('file-symlink-file', 0xeaee),

230 > fileZip: register('file-zip', 0xeaef),

231 > files: register('files', 0xeaf0),

232 > filter: register('filter', 0xeaf1),

233 > flame: register('flame', 0xeaf2),

234 > foldDown: register('fold-down', 0xeaf3),

235 > foldUp: register('fold-up', 0xeaf4),

236 > fold: register('fold', 0xeaf5),

237 > folderActive: register('folder-active', 0xeaf6),

238 > folderOpened: register('folder-opened', 0xeaf7),

239 > gear: register('gear', 0xeaf8),

240 > gift: register('gift', 0xeaf9),

241 > gistSecret: register('gist-secret', 0xeafa),

242 > gist: register('gist', 0xeafb),

243 > gitCommit: register('git-commit', 0xeafc),

244 > gitCompare: register('git-compare', 0xeafd),

245 > compareChanges: register('compare-changes', 0xeafd),

246 > gitMerge: register('git-merge', 0xeafe),

247 > githubAction: register('github-action', 0xeaff),

248 > githubAlt: register('github-alt', 0xeb00),

249 > globe: register('globe', 0xeb01),

250 > grabber: register('grabber', 0xeb02),

251 > graph: register('graph', 0xeb03),

252 > gripper: register('gripper', 0xeb04),

253 > heart: register('heart', 0xeb05),

254 > home: register('home', 0xeb06),

255 > horizontalRule: register('horizontal-rule', 0xeb07),

256 > hubot: register('hubot', 0xeb08),

257 > inbox: register('inbox', 0xeb09),

258 > issueReopened: register('issue-reopened', 0xeb0b),

259 > issues: register('issues', 0xeb0c),

260 > italic: register('italic', 0xeb0d),

261 > jersey: register('jersey', 0xeb0e),

262 > json: register('json', 0xeb0f),

263 > bracket: register('bracket', 0xeb0f),

264 > kebabVertical: register('kebab-vertical', 0xeb10),

265 > key: register('key', 0xeb11),

266 > law: register('law', 0xeb12),

267 > lightbulbAutofix: register('lightbulb-autofix', 0xeb13),

268 > linkExternal: register('link-external', 0xeb14),

269 > link: register('link', 0xeb15),

270 > listOrdered: register('list-ordered', 0xeb16),

271 > listUnordered: register('list-unordered', 0xeb17),

272 > liveShare: register('live-share', 0xeb18),

273 > loading: register('loading', 0xeb19),

274 > location: register('location', 0xeb1a),

275 > mailRead: register('mail-read', 0xeb1b),

276 > mail: register('mail', 0xeb1c),

277 > markdown: register('markdown', 0xeb1d),

278 > megaphone: register('megaphone', 0xeb1e),

279 > mention: register('mention', 0xeb1f),

280 > milestone: register('milestone', 0xeb20),

281 > gitPullRequestMilestone: register('git-pull-request-milestone', 0xeb20),

282 > mortarBoard: register('mortar-board', 0xeb21),

283 > move: register('move', 0xeb22),

284 > multipleWindows: register('multiple-windows', 0xeb23),

285 > mute: register('mute', 0xeb24),

286 > noNewline: register('no-newline', 0xeb25),

287 > note: register('note', 0xeb26),

288 > octoface: register('octoface', 0xeb27),

289 > openPreview: register('open-preview', 0xeb28),

290 > package: register('package', 0xeb29),

291 > paintcan: register('paintcan', 0xeb2a),

292 > pin: register('pin', 0xeb2b),

293 > play: register('play', 0xeb2c),

294 > run: register('run', 0xeb2c),

295 > plug: register('plug', 0xeb2d),

296 > preserveCase: register('preserve-case', 0xeb2e),

297 > preview: register('preview', 0xeb2f),

298 > project: register('project', 0xeb30),

299 > pulse: register('pulse', 0xeb31),

300 > question: register('question', 0xeb32),

301 > quote: register('quote', 0xeb33),

302 > radioTower: register('radio-tower', 0xeb34),

303 > reactions: register('reactions', 0xeb35),

304 > references: register('references', 0xeb36),

305 > refresh: register('refresh', 0xeb37),

306 > regex: register('regex', 0xeb38),

307 > remoteExplorer: register('remote-explorer', 0xeb39),

308 > remote: register('remote', 0xeb3a),

309 > remove: register('remove', 0xeb3b),

310 > replaceAll: register('replace-all', 0xeb3c),

311 > replace: register('replace', 0xeb3d),

312 > repoClone: register('repo-clone', 0xeb3e),

313 > repoForcePush: register('repo-force-push', 0xeb3f),

314 > repoPull: register('repo-pull', 0xeb40),

315 > repoPush: register('repo-push', 0xeb41),

316 > report: register('report', 0xeb42),

317 > requestChanges: register('request-changes', 0xeb43),

318 > rocket: register('rocket', 0xeb44),

319 > rootFolderOpened: register('root-folder-opened', 0xeb45),

320 > rootFolder: register('root-folder', 0xeb46),

321 > rss: register('rss', 0xeb47),

322 > ruby: register('ruby', 0xeb48),

323 > saveAll: register('save-all', 0xeb49),

324 > saveAs: register('save-as', 0xeb4a),

325 > save: register('save', 0xeb4b),

326 > screenFull: register('screen-full', 0xeb4c),

327 > screenNormal: register('screen-normal', 0xeb4d),

328 > searchStop: register('search-stop', 0xeb4e),

329 > server: register('server', 0xeb50),

330 > settingsGear: register('settings-gear', 0xeb51),

331 > settings: register('settings', 0xeb52),

332 > shield: register('shield', 0xeb53),

333 > smiley: register('smiley', 0xeb54),

334 > sortPrecedence: register('sort-precedence', 0xeb55),

335 > splitHorizontal: register('split-horizontal', 0xeb56),

336 > splitVertical: register('split-vertical', 0xeb57),

337 > squirrel: register('squirrel', 0xeb58),

338 > starFull: register('star-full', 0xeb59),

339 > starHalf: register('star-half', 0xeb5a),

340 > symbolClass: register('symbol-class', 0xeb5b),

341 > symbolColor: register('symbol-color', 0xeb5c),

342 > symbolConstant: register('symbol-constant', 0xeb5d),

343 > symbolEnumMember: register('symbol-enum-member', 0xeb5e),

344 > symbolField: register('symbol-field', 0xeb5f),

345 > symbolFile: register('symbol-file', 0xeb60),

346 > symbolInterface: register('symbol-interface', 0xeb61),

347 > symbolKeyword: register('symbol-keyword', 0xeb62),

348 > symbolMisc: register('symbol-misc', 0xeb63),

349 > symbolOperator: register('symbol-operator', 0xeb64),

350 > symbolProperty: register('symbol-property', 0xeb65),

351 > wrench: register('wrench', 0xeb65),

352 > wrenchSubaction: register('wrench-subaction', 0xeb65),

353 > symbolSnippet: register('symbol-snippet', 0xeb66),

354 > tasklist: register('tasklist', 0xeb67),

355 > telescope: register('telescope', 0xeb68),

356 > textSize: register('text-size', 0xeb69),

357 > threeBars: register('three-bars', 0xeb6a),

358 > thumbsdown: register('thumbsdown', 0xeb6b),

359 > thumbsup: register('thumbsup', 0xeb6c),

360 > tools: register('tools', 0xeb6d),

361 > triangleDown: register('triangle-down', 0xeb6e),

362 > triangleLeft: register('triangle-left', 0xeb6f),

363 > triangleRight: register('triangle-right', 0xeb70),

364 > triangleUp: register('triangle-up', 0xeb71),

365 > twitter: register('twitter', 0xeb72),

366 > unfold: register('unfold', 0xeb73),

367 > unlock: register('unlock', 0xeb74),

368 > unmute: register('unmute', 0xeb75),

369 > unverified: register('unverified', 0xeb76),

370 > verified: register('verified', 0xeb77),

371 > versions: register('versions', 0xeb78),

372 > vmActive: register('vm-active', 0xeb79),

373 > vmOutline: register('vm-outline', 0xeb7a),

374 > vmRunning: register('vm-running', 0xeb7b),

375 > watch: register('watch', 0xeb7c),

376 > whitespace: register('whitespace', 0xeb7d),

377 > wholeWord: register('whole-word', 0xeb7e),

378 > window: register('window', 0xeb7f),

379 > wordWrap: register('word-wrap', 0xeb80),

380 > zoomIn: register('zoom-in', 0xeb81),

381 > zoomOut: register('zoom-out', 0xeb82),

382 > listFilter: register('list-filter', 0xeb83),

383 > listFlat: register('list-flat', 0xeb84),

384 > listSelection: register('list-selection', 0xeb85),

385 > selection: register('selection', 0xeb85),

386 > listTree: register('list-tree', 0xeb86),

387 > debugBreakpointFunctionUnverified: register('debug-breakpoint-function-unverified', 0xeb87),

388 > debugBreakpointFunction: register('debug-breakpoint-function', 0xeb88),

389 > debugBreakpointFunctionDisabled: register('debug-breakpoint-function-disabled', 0xeb88),

390 > debugStackframeActive: register('debug-stackframe-active', 0xeb89),

391 > circleSmallFilled: register('circle-small-filled', 0xeb8a),

392 > debugStackframeDot: register('debug-stackframe-dot', 0xeb8a),

393 > terminalDecorationMark: register('terminal-decoration-mark', 0xeb8a),

394 > debugStackframe: register('debug-stackframe', 0xeb8b),

395 > debugStackframeFocused: register('debug-stackframe-focused', 0xeb8b),

396 > debugBreakpointUnsupported: register('debug-breakpoint-unsupported', 0xeb8c),

397 > symbolString: register('symbol-string', 0xeb8d),

398 > debugReverseContinue: register('debug-reverse-continue', 0xeb8e),

399 > debugStepBack: register('debug-step-back', 0xeb8f),

400 > debugRestartFrame: register('debug-restart-frame', 0xeb90),

401 > debugAlt: register('debug-alt', 0xeb91),

402 > callIncoming: register('call-incoming', 0xeb92),

403 > callOutgoing: register('call-outgoing', 0xeb93),

404 > menu: register('menu', 0xeb94),

405 > expandAll: register('expand-all', 0xeb95),

406 > feedback: register('feedback', 0xeb96),

407 > gitPullRequestReviewer: register('git-pull-request-reviewer', 0xeb96),

408 > groupByRefType: register('group-by-ref-type', 0xeb97),

409 > ungroupByRefType: register('ungroup-by-ref-type', 0xeb98),

410 > account: register('account', 0xeb99),

411 > gitPullRequestAssignee: register('git-pull-request-assignee', 0xeb99),

412 > bellDot: register('bell-dot', 0xeb9a),

413 > debugConsole: register('debug-console', 0xeb9b),

414 > library: register('library', 0xeb9c),

415 > output: register('output', 0xeb9d),

416 > runAll: register('run-all', 0xeb9e),

417 > syncIgnored: register('sync-ignored', 0xeb9f),

418 > pinned: register('pinned', 0xeba0),

419 > githubInverted: register('github-inverted', 0xeba1),

420 > serverProcess: register('server-process', 0xeba2),

421 > serverEnvironment: register('server-environment', 0xeba3),

422 > pass: register('pass', 0xeba4),

423 > issueClosed: register('issue-closed', 0xeba4),

424 > stopCircle: register('stop-circle', 0xeba5),

425 > playCircle: register('play-circle', 0xeba6),

426 > record: register('record', 0xeba7),

427 > debugAltSmall: register('debug-alt-small', 0xeba8),

428 > vmConnect: register('vm-connect', 0xeba9),

429 > cloud: register('cloud', 0xebaa),

430 > merge: register('merge', 0xebab),

431 > export: register('export', 0xebac),

432 > graphLeft: register('graph-left', 0xebad),

433 > magnet: register('magnet', 0xebae),

434 > notebook: register('notebook', 0xebaf),

435 > redo: register('redo', 0xebb0),

436 > checkAll: register('check-all', 0xebb1),

437 > pinnedDirty: register('pinned-dirty', 0xebb2),

438 > passFilled: register('pass-filled', 0xebb3),

439 > circleLargeFilled: register('circle-large-filled', 0xebb4),

440 > circleLarge: register('circle-large', 0xebb5),

441 > circleLargeOutline: register('circle-large-outline', 0xebb5),

442 > combine: register('combine', 0xebb6),

443 > gather: register('gather', 0xebb6),

444 > table: register('table', 0xebb7),

445 > variableGroup: register('variable-group', 0xebb8),

446 > typeHierarchy: register('type-hierarchy', 0xebb9),

447 > typeHierarchySub: register('type-hierarchy-sub', 0xebba),

448 > typeHierarchySuper: register('type-hierarchy-super', 0xebbb),

449 > gitPullRequestCreate: register('git-pull-request-create', 0xebbc),

450 > runAbove: register('run-above', 0xebbd),

451 > runBelow: register('run-below', 0xebbe),

452 > notebookTemplate: register('notebook-template', 0xebbf),

453 > debugRerun: register('debug-rerun', 0xebc0),

454 > workspaceTrusted: register('workspace-trusted', 0xebc1),

455 > workspaceUntrusted: register('workspace-untrusted', 0xebc2),

456 > workspaceUnknown: register('workspace-unknown', 0xebc3),

457 > terminalCmd: register('terminal-cmd', 0xebc4),

458 > terminalDebian: register('terminal-debian', 0xebc5),

459 > terminalLinux: register('terminal-linux', 0xebc6),

460 > terminalPowershell: register('terminal-powershell', 0xebc7),

461 > terminalTmux: register('terminal-tmux', 0xebc8),

462 > terminalUbuntu: register('terminal-ubuntu', 0xebc9),

463 > terminalBash: register('terminal-bash', 0xebca),

464 > arrowSwap: register('arrow-swap', 0xebcb),

465 > copy: register('copy', 0xebcc),

466 > personAdd: register('person-add', 0xebcd),

467 > filterFilled: register('filter-filled', 0xebce),

468 > wand: register('wand', 0xebcf),

469 > debugLineByLine: register('debug-line-by-line', 0xebd0),

470 > inspect: register('inspect', 0xebd1),

471 > layers: register('layers', 0xebd2),

472 > layersDot: register('layers-dot', 0xebd3),

473 > layersActive: register('layers-active', 0xebd4),

474 > compass: register('compass', 0xebd5),

475 > compassDot: register('compass-dot', 0xebd6),

476 > compassActive: register('compass-active', 0xebd7),

477 > azure: register('azure', 0xebd8),

478 > issueDraft: register('issue-draft', 0xebd9),

479 > gitPullRequestClosed: register('git-pull-request-closed', 0xebda),

480 > gitPullRequestDraft: register('git-pull-request-draft', 0xebdb),

481 > debugAll: register('debug-all', 0xebdc),

482 > debugCoverage: register('debug-coverage', 0xebdd),

483 > runErrors: register('run-errors', 0xebde),

484 > folderLibrary: register('folder-library', 0xebdf),

485 > debugContinueSmall: register('debug-continue-small', 0xebe0),

486 > beakerStop: register('beaker-stop', 0xebe1),

487 > graphLine: register('graph-line', 0xebe2),

488 > graphScatter: register('graph-scatter', 0xebe3),

489 > pieChart: register('pie-chart', 0xebe4),

490 > bracketDot: register('bracket-dot', 0xebe5),

491 > bracketError: register('bracket-error', 0xebe6),

492 > lockSmall: register('lock-small', 0xebe7),

493 > azureDevops: register('azure-devops', 0xebe8),

494 > verifiedFilled: register('verified-filled', 0xebe9),

495 > newline: register('newline', 0xebea),

496 > layout: register('layout', 0xebeb),

497 > layoutActivitybarLeft: register('layout-activitybar-left', 0xebec),

498 > layoutActivitybarRight: register('layout-activitybar-right', 0xebed),

499 > layoutPanelLeft: register('layout-panel-left', 0xebee),

500 > layoutPanelCenter: register('layout-panel-center', 0xebef),

501 > layoutPanelJustify: register('layout-panel-justify', 0xebf0),

502 > layoutPanelRight: register('layout-panel-right', 0xebf1),

503 > layoutPanel: register('layout-panel', 0xebf2),

504 > layoutSidebarLeft: register('layout-sidebar-left', 0xebf3),

505 > layoutSidebarRight: register('layout-sidebar-right', 0xebf4),

506 > layoutStatusbar: register('layout-statusbar', 0xebf5),

507 > layoutMenubar: register('layout-menubar', 0xebf6),

508 > layoutCentered: register('layout-centered', 0xebf7),

509 > target: register('target', 0xebf8),

510 > indent: register('indent', 0xebf9),

511 > recordSmall: register('record-small', 0xebfa),

512 > errorSmall: register('error-small', 0xebfb),

513 > terminalDecorationError: register('terminal-decoration-error', 0xebfb),

514 > arrowCircleDown: register('arrow-circle-down', 0xebfc),

515 > arrowCircleLeft: register('arrow-circle-left', 0xebfd),

516 > arrowCircleRight: register('arrow-circle-right', 0xebfe),

517 > arrowCircleUp: register('arrow-circle-up', 0xebff),

518 > layoutSidebarRightOff: register('layout-sidebar-right-off', 0xec00),

519 > layoutPanelOff: register('layout-panel-off', 0xec01),

520 > layoutSidebarLeftOff: register('layout-sidebar-left-off', 0xec02),

521 > blank: register('blank', 0xec03),

522 > heartFilled: register('heart-filled', 0xec04),

523 > map: register('map', 0xec05),

524 > mapHorizontal: register('map-horizontal', 0xec05),

525 > foldHorizontal: register('fold-horizontal', 0xec05),

526 > mapFilled: register('map-filled', 0xec06),

527 > mapHorizontalFilled: register('map-horizontal-filled', 0xec06),

528 > foldHorizontalFilled: register('fold-horizontal-filled', 0xec06),

529 > circleSmall: register('circle-small', 0xec07),

530 > bellSlash: register('bell-slash', 0xec08),

531 > bellSlashDot: register('bell-slash-dot', 0xec09),

532 > commentUnresolved: register('comment-unresolved', 0xec0a),

533 > gitPullRequestGoToChanges: register('git-pull-request-go-to-changes', 0xec0b),

534 > gitPullRequestNewChanges: register('git-pull-request-new-changes', 0xec0c),

535 > searchFuzzy: register('search-fuzzy', 0xec0d),

536 > commentDraft: register('comment-draft', 0xec0e),

537 > send: register('send', 0xec0f),

538 > sparkle: register('sparkle', 0xec10),

539 > insert: register('insert', 0xec11),

540 > mic: register('mic', 0xec12),

541 > thumbsdownFilled: register('thumbsdown-filled', 0xec13),

542 > thumbsupFilled: register('thumbsup-filled', 0xec14),

543 > coffee: register('coffee', 0xec15),

544 > snake: register('snake', 0xec16),

545 > game: register('game', 0xec17),

546 > vr: register('vr', 0xec18),

547 > chip: register('chip', 0xec19),

548 > piano: register('piano', 0xec1a),

549 > music: register('music', 0xec1b),

550 > micFilled: register('mic-filled', 0xec1c),

551 > repoFetch: register('repo-fetch', 0xec1d),

552 > copilot: register('copilot', 0xec1e),

553 > lightbulbSparkle: register('lightbulb-sparkle', 0xec1f),

554 > robot: register('robot', 0xec20),

555 > sparkleFilled: register('sparkle-filled', 0xec21),

556 > diffSingle: register('diff-single', 0xec22),

557 > diffMultiple: register('diff-multiple', 0xec23),

558 > surroundWith: register('surround-with', 0xec24),

559 > share: register('share', 0xec25),

560 > gitStash: register('git-stash', 0xec26),

561 > gitStashApply: register('git-stash-apply', 0xec27),

562 > gitStashPop: register('git-stash-pop', 0xec28),

563 > vscode: register('vscode', 0xec29),

564 > vscodeInsiders: register('vscode-insiders', 0xec2a),

565 > codeOss: register('code-oss', 0xec2b),

566 > runCoverage: register('run-coverage', 0xec2c),

567 > runAllCoverage: register('run-all-coverage', 0xec2d),

568 > coverage: register('coverage', 0xec2e),

569 > githubProject: register('github-project', 0xec2f),

570 > mapVertical: register('map-vertical', 0xec30),

571 > foldVertical: register('fold-vertical', 0xec30),

572 > mapVerticalFilled: register('map-vertical-filled', 0xec31),

573 > foldVerticalFilled: register('fold-vertical-filled', 0xec31),

574 > goToSearch: register('go-to-search', 0xec32),

575 > percentage: register('percentage', 0xec33),

576 > sortPercentage: register('sort-percentage', 0xec33),

577 > attach: register('attach', 0xec34),

578 > goToEditingSession: register('go-to-editing-session', 0xec35),

579 > editSession: register('edit-session', 0xec36),

580 > codeReview: register('code-review', 0xec37),

581 > copilotWarning: register('copilot-warning', 0xec38),

582 > python: register('python', 0xec39),

583 > copilotLarge: register('copilot-large', 0xec3a),

584 > copilotWarningLarge: register('copilot-warning-large', 0xec3b),

585 > keyboardTab: register('keyboard-tab', 0xec3c),

586 > copilotBlocked: register('copilot-blocked', 0xec3d),

587 > copilotNotConnected: register('copilot-not-connected', 0xec3e),

588 > flag: register('flag', 0xec3f),

589 > lightbulbEmpty: register('lightbulb-empty', 0xec40),

590 > symbolMethodArrow: register('symbol-method-arrow', 0xec41),

591 > copilotUnavailable: register('copilot-unavailable', 0xec42),

592 > repoPinned: register('repo-pinned', 0xec43),

593 > keyboardTabAbove: register('keyboard-tab-above', 0xec44),

594 > keyboardTabBelow: register('keyboard-tab-below', 0xec45),

595 > gitPullRequestDone: register('git-pull-request-done', 0xec46),

596 > mcp: register('mcp', 0xec47),

597 > extensionsLarge: register('extensions-large', 0xec48),

598 > layoutPanelDock: register('layout-panel-dock', 0xec49),

599 > layoutSidebarLeftDock: register('layout-sidebar-left-dock', 0xec4a),

600 > layoutSidebarRightDock: register('layout-sidebar-right-dock', 0xec4b),

601 > copilotInProgress: register('copilot-in-progress', 0xec4c),

602 > copilotError: register('copilot-error', 0xec4d),

603 > copilotSuccess: register('copilot-success', 0xec4e),

604 > chatSparkle: register('chat-sparkle', 0xec4f),

605 > searchSparkle: register('search-sparkle', 0xec50),

606 > editSparkle: register('edit-sparkle', 0xec51),

607 > copilotSnooze: register('copilot-snooze', 0xec52),

608 > sendToRemoteAgent: register('send-to-remote-agent', 0xec53),

609 > commentDiscussionSparkle: register('comment-discussion-sparkle', 0xec54),

610 > chatSparkleWarning: register('chat-sparkle-warning', 0xec55),

611 > chatSparkleError: register('chat-sparkle-error', 0xec56),

612 > collection: register('collection', 0xec57),

613 > newCollection: register('new-collection', 0xec58),

614 > thinking: register('thinking', 0xec59),

615 > build: register('build', 0xec5a),

616 > commentDiscussionQuote: register('comment-discussion-quote', 0xec5b),

617 > cursor: register('cursor', 0xec5c),

618 > eraser: register('eraser', 0xec5d),

619 > fileText: register('file-text', 0xec5e),

620 > quotes: register('quotes', 0xec60),

621 > rename: register('rename', 0xec61),

622 > runWithDeps: register('run-with-deps', 0xec62),

623 > debugConnected: register('debug-connected', 0xec63),

624 > strikethrough: register('strikethrough', 0xec64),

625 > openInProduct: register('open-in-product', 0xec65),

626 > indexZero: register('index-zero', 0xec66),

627 > agent: register('agent', 0xec67),

628 > editCode: register('edit-code', 0xec68),

629 > repoSelected: register('repo-selected', 0xec69),

630 > skip: register('skip', 0xec6a),

631 > mergeInto: register('merge-into', 0xec6b),

632 > gitBranchChanges: register('git-branch-changes', 0xec6c),

633 > gitBranchStagedChanges: register('git-branch-staged-changes', 0xec6d),

634 > gitBranchConflicts: register('git-branch-conflicts', 0xec6e),

635 > gitBranch: register('git-branch', 0xec6f),

636 > gitBranchCreate: register('git-branch-create', 0xec6f),

637 > gitBranchDelete: register('git-branch-delete', 0xec6f),

638 > searchLarge: register('search-large', 0xec70),

639 > terminalGitBash: register('terminal-git-bash', 0xec71),

640 > windowActive: register('window-active', 0xec72),

641 > forward: register('forward', 0xec73),

642 > download: register('download', 0xec74),

643 > clockface: register('clockface', 0xec75),

644 > unarchive: register('unarchive', 0xec76),

645 > sessionInProgress: register('session-in-progress', 0xec77),

646 > collectionSmall: register('collection-small', 0xec78),

647 > vmSmall: register('vm-small', 0xec79),

648 > cloudSmall: register('cloud-small', 0xec7a),

649 > addSmall: register('add-small', 0xec7b),

650 > removeSmall: register('remove-small', 0xec7c),

651 > worktreeSmall: register('worktree-small', 0xec7d),

652 > worktree: register('worktree', 0xec7e),

653 > screenCut: register('screen-cut', 0xec7f),

654 > ask: register('ask', 0xec80),

655 > openai: register('openai', 0xec81),

656 > claude: register('claude', 0xec82),

657 > openInWindow: register('open-in-window', 0xec83),

658 > newSession: register('new-session', 0xec84),

659 > terminalSecure: register('terminal-secure', 0xec85),

660 > chatImport: register('chat-import', 0xec86),

661 > chatExport: register('chat-export', 0xec87),

662 > shareWindow: register('share-window', 0xec88),

663 > circleSlashCompact: register('circle-slash-compact', 0xec89),

664 > copilotCompact: register('copilot-compact', 0xec8a),

665 > folderOpenedCompact: register('folder-opened-compact', 0xec8b),

666 > folderCompact: register('folder-compact', 0xec8c),

667 > gearCompact: register('gear-compact', 0xec8d),

668 > gitBranchCompact: register('git-branch-compact', 0xec8e),

669 > libraryCompact: register('library-compact', 0xec8f),

670 > recordKeysCompact: register('record-keys-compact', 0xec90),

671 > remoteCompact: register('remote-compact', 0xec91),

672 > repoForkedCompact: register('repo-forked-compact', 0xec92),

673 > repoCompact: register('repo-compact', 0xec93),

674 > shieldCompact: register('shield-compact', 0xec94),

675 > sparkleCompact: register('sparkle-compact', 0xec95),

676 > symbolColorCompact: register('symbol-color-compact', 0xec96),

677 > windowCompact: register('window-compact', 0xec97),

678 > errorCompact: register('error-compact', 0xec98),

679 > warningCompact: register('warning-compact', 0xec99),

680 > passCompact: register('pass-compact', 0xec9a),

681 > important: register('important', 0xec9b),

682 > importantCompact: register('important-compact', 0xec9c),

683 > rocketCompact: register('rocket-compact', 0xec9d),

684 > unpin: register('unpin', 0xec9e),

685 > addCompact: register('add-compact', 0xec9f),

686 > attachCompact: register('attach-compact', 0xeca0),

687 > beakerCompact: register('beaker-compact', 0xeca1),

688 > checkCompact: register('check-compact', 0xeca2),

689 > checklistCompact: register('checklist-compact', 0xeca3),

690 > chevronDownCompact: register('chevron-down-compact', 0xeca4),

691 > chevronLeftCompact: register('chevron-left-compact', 0xeca5),

692 > chevronRightCompact: register('chevron-right-compact', 0xeca6),

693 > chevronUpCompact: register('chevron-up-compact', 0xeca7),

694 > circleFilledCompact: register('circle-filled-compact', 0xeca8),

695 > circleSmallFilledCompact: register('circle-small-filled-compact', 0xeca9),

696 > closeCompact: register('close-compact', 0xecaa),

697 > collapseAllCompact: register('collapse-all-compact', 0xecab),

698 > commentCompact: register('comment-compact', 0xecac),

699 > commentUnresolvedCompact: register('comment-unresolved-compact', 0xecad),

700 > debugConnectedCompact: register('debug-connected-compact', 0xecae),

701 > debugDisconnectCompact: register('debug-disconnect-compact', 0xecaf),

702 > editCompact: register('edit-compact', 0xecb0),

703 > fileMediaCompact: register('file-media-compact', 0xecb1),

704 > gitFetch: register('git-fetch', 0xecb2),

705 > lightbulbCompact: register('lightbulb-compact', 0xecb3),

706 > loadingCompact: register('loading-compact', 0xecb4),

707 > passFilledCompact: register('pass-filled-compact', 0xecb5),

708 > projectCompact: register('project-compact', 0xecb6),

709 > refreshCompact: register('refresh-compact', 0xecb7),

710 > searchCompact: register('search-compact', 0xecb8),

711 > sessionInProgressCompact: register('session-in-progress-compact', 0xecb9),

712 > syncCompact: register('sync-compact', 0xecba),

713 > terminalCompact: register('terminal-compact', 0xecbb),

714 > vmPending: register('vm-pending', 0xecbc),

715 > worktreeCompact: register('worktree-compact', 0xecbd),

716 > developerTools: register('developer-tools', 0xecbe),

717 > cloudCompact: register('cloud-compact', 0xecbf),

718 > agentCompact: register('agent-compact', 0xecc0),

719 > askCompact: register('ask-compact', 0xecc1),

720 > settingsCompact: register('settings-compact', 0xecc2),

721 > vmCompact: register('vm-compact', 0xecc3),

722 > runCompact: register('run-compact', 0xecc4),

723 > gitPullRequestComment: register('git-pull-request-comment', 0xecc5),

724 > gitPullRequestError: register('git-pull-request-error', 0xecc6),

725 > rightPanelHide: register('right-panel-hide', 0xecc7),

726 > rightPanelShow: register('right-panel-show', 0xecc8),

727 > vscodeInsidersOutline: register('vscode-insiders-outline', 0xecc9),

728 > vscodeOutline: register('vscode-outline', 0xecca),

729 > voiceMode: register('voice-mode', 0xeccb),

730 > voiceModeCompact: register('voice-mode-compact', 0xeccc),

731 > micDownload: register('mic-download', 0xeccd),

732 > micDownloadCompact: register('mic-download-compact', 0xecce),

733 > voiceModeDownload: register('voice-mode-download', 0xeccf),

734 > voiceModeDownloadCompact: register('voice-mode-download-compact', 0xecd0),

735 > googleGemini: register('google-gemini', 0xecd1),

736 > kimi: register('kimi', 0xecd2),

737 > microsoft: register('microsoft', 0xecd3),

738 > fish1Happy: register('fish1-happy', 0xecd4),

739 > fish1Neutral: register('fish1-neutral', 0xecd5),

740 > fish1Sad: register('fish1-sad', 0xecd6),

741 > fish1VerySad: register('fish1-very-sad', 0xecd7),

742 > fish2Happy: register('fish2-happy', 0xecd8),

743 > fish2Neutral: register('fish2-neutral', 0xecd9),

744 > fish2Sad: register('fish2-sad', 0xecda),

745 > fish2VerySad: register('fish2-very-sad', 0xecdb),

746 > fish3Happy: register('fish3-happy', 0xecdc),

747 > fish3Neutral: register('fish3-neutral', 0xecdd),

748 > fish3Sad: register('fish3-sad', 0xecde),

749 > fish3VerySad: register('fish3-very-sad', 0xecdf),

750 > fish4Happy: register('fish4-happy', 0xece0),

751 > fish4Neutral: register('fish4-neutral', 0xece1),

752 > fish4Sad: register('fish4-sad', 0xece2),

753 > fish4VerySad: register('fish4-very-sad', 0xece3),

754 > personVoice: register('person-voice', 0xece4),

755 > personVoiceCompact: register('person-voice-compact', 0xece5),

756 > personVoiceFilled: register('person-voice-filled', 0xece6),

757 > personVoiceFilledCompact: register('person-voice-filled-compact', 0xece7),

758 > } as const;

src/vs/workbench/services/chat/common/chatEntitlementService.ts 651 covered LOC · 52 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- chatEntitlementService.ts

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 product from '../../../../platform/product/common/product.js';

7 > import { Barrier } from '../../../../base/common/async.js';

8 > import { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';

9 > import { Emitter, Event } from '../../../../base/common/event.js';

10 > import { Lazy } from '../../../../base/common/lazy.js';

11 > import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';

12 > import { IRequestContext } from '../../../../base/parts/request/common/request.js';

13 > import { localize } from '../../../../nls.js';

14 > import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';

15 > import { IContextKey, IContextKeyService, RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';

16 > import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';

17 > import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';

18 > import { ILogService, LogLevel } from '../../../../platform/log/common/log.js';

19 > import { IProductService } from '../../../../platform/product/common/productService.js';

20 > import { asText, IRequestService } from '../../../../platform/request/common/request.js';

21 > import { IStorageService, StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';

22 > import { ITelemetryService, TelemetryLevel } from '../../../../platform/telemetry/common/telemetry.js';

23 > import { AuthenticationSession, IAuthenticationService } from '../../authentication/common/authentication.js';

24 > import { IOpenerService } from '../../../../platform/opener/common/opener.js';

25 > import { URI } from '../../../../base/common/uri.js';

26 > import Severity from '../../../../base/common/severity.js';

27 > import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';

28 > import { isWeb } from '../../../../base/common/platform.js';

29 > import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';

30 > import { Mutable } from '../../../../base/common/types.js';

31 > import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';

32 > import { IObservable, observableFromEvent } from '../../../../base/common/observable.js';

33 > import { IDefaultAccountService } from '../../../../platform/defaultAccount/common/defaultAccount.js';

34 > import { IDefaultAccount, IEntitlementsData } from '../../../../base/common/defaultAccount.js';

35 >

36 > export namespace ChatEntitlementContextKeys {

37 >

38 > export const Setup = {

39 > hidden: new RawContextKey<boolean>('chatSetupHidden', false, true), // True when chat setup is explicitly hidden.

40 > installed: new RawContextKey<boolean>('chatSetupInstalled', false, true), // True when the chat extension is installed and enabled.

41 > disabled: new RawContextKey<boolean>('chatSetupDisabled', false, true), // True when the chat extension is disabled due to any other reason than workspace trust.

42 > disabledInWorkspace: new RawContextKey<boolean>('chatSetupDisabledInWorkspace', false, true), // True when chat is disabled at the workspace level via settings.

43 > untrusted: new RawContextKey<boolean>('chatSetupUntrusted', false, true), // True when the chat extension is disabled due to workspace trust.

44 > later: new RawContextKey<boolean>('chatSetupLater', false, true), // True when the user wants to finish setup later.

45 > registered: new RawContextKey<boolean>('chatSetupRegistered', false, true), // True when the user has registered as Free or Pro user.

46 > completed: new RawContextKey<boolean>('chatSetupCompleted', false, true) // True when the user has completed the setup flow, regardless of the outcome.

47 > };

48 >

49 > export const Entitlement = {

50 > signedOut: new RawContextKey<boolean>('chatEntitlementSignedOut', false, true), // True when user is signed out.

51 > canSignUp: new RawContextKey<boolean>('chatPlanCanSignUp', false, true), // True when user can sign up to be a chat free user.

52 >

53 > planFree: new RawContextKey<boolean>('chatPlanFree', false, true), // True when user is a chat free user.

54 > planPro: new RawContextKey<boolean>('chatPlanPro', false, true), // True when user is a chat pro user.

55 > planEdu: new RawContextKey<boolean>('chatPlanEdu', false, true), // True when user is a chat edu user.

56 > planProPlus: new RawContextKey<boolean>('chatPlanProPlus', false, true), // True when user is a chat pro plus user.

57 > planMax: new RawContextKey<boolean>('chatPlanMax', false, true), // True when user is a chat max user.

58 > planBusiness: new RawContextKey<boolean>('chatPlanBusiness', false, true), // True when user is a chat business user.

59 > planEnterprise: new RawContextKey<boolean>('chatPlanEnterprise', false, true), // True when user is a chat enterprise user.

60 >

61 > organisations: new RawContextKey<string[]>('chatEntitlementOrganisations', undefined, true), // The organizations the user belongs to.

62 > internal: new RawContextKey<boolean>('chatEntitlementInternal', false, true), // True when user belongs to internal organisation.

63 > sku: new RawContextKey<string>('chatEntitlementSku', undefined, true), // The SKU of the user.

64 > };

65 >

66 > export const chatQuotaExceeded = new RawContextKey<boolean>('chatQuotaExceeded', false, true);

67 > export const completionsQuotaExceeded = new RawContextKey<boolean>('completionsQuotaExceeded', false, true);

68 >

69 > export const chatAnonymous = new RawContextKey<boolean>('chatAnonymous', false, true);

70 >

71 > export const clientByokEnabled = new RawContextKey<boolean>('github.copilot.clientByokEnabled', true, true);

72 >

73 > export const hasByokModels = new RawContextKey<boolean>('github.copilot.hasByokModels', false, true);

74 > }

75 >

76 > export const IChatEntitlementService = createDecorator<IChatEntitlementService>('chatEntitlementService');

77 >

78 > export enum ChatEntitlement {

79 > /** Signed out */

80 > Unknown = 1,

81 > /** Signed in but not yet resolved */

82 > Unresolved = 2,

83 > /** Signed in and entitled to Free */

84 > Available = 3,

85 > /** Signed in but not entitled to Free */

86 > Unavailable = 4,

87 > /** Signed-up to Free */

88 > Free = 5,

89 > /** Signed-up to EDU */

90 > EDU = 10,

91 > /** Signed-up to Pro */

92 > Pro = 6,

93 > /** Signed-up to Pro Plus */

94 > ProPlus = 7,

95 > /** Signed-up to Business */

96 > Business = 8,

97 > /** Signed-up to Enterprise */

98 > Enterprise = 9,

99 > /** Signed-up to Max */

100 > Max = 11,

101 > }

102 >

103 > export interface IChatSentiment {

104 >

105 > /**

106 > * Whether the user has completed the setup flow or not, regardless of the outcome

107 > */

108 > completed?: boolean;

109 >

110 > /**

111 > * User has Chat installed.

112 > */

113 > installed?: boolean;

114 >

115 > /**

116 > * User signals no intent in using Chat.

117 > *

118 > * Note: in contrast to `disabled`, this should not only disable

119 > * Chat but also hide all of its UI.

120 > */

121 > hidden?: boolean;

122 >

123 > /**

124 > * User signals intent to disable Chat.

125 > *

126 > * Note: in contrast to `hidden`, this should not hide

127 > * Chat but but disable its functionality.

128 > */

129 > disabled?: boolean;

130 >

131 > /**

132 > * Chat is disabled at the workspace level

133 > *

134 > * Note: in contrast to `hidden` (which hides all UI globally),

135 > * this only disables Chat in the current workspace while

136 > * keeping its UI visible so the user can re-enable it.

137 > */

138 > disabledInWorkspace?: boolean;

139 >

140 > /**

141 > * Chat is disabled due to missing workspace trust.

142 > *

143 > * Note: even though this disables Chat, we want to treat it

144 > * different from the `disabled` state that is by explicit

145 > * user choice.

146 > */

147 > untrusted?: boolean;

148 >

149 > /**

150 > * User signals intent to use Chat later.

151 > */

152 > later?: boolean;

153 >

154 > /**

155 > * User has registered as Free or Pro user.

156 > */

157 > registered?: boolean;

158 > }

159 >

160 > /**

161 > * The inputs needed to decide whether Chat still requires the user to run setup

162 > * (sign in / sign up / trust / enable) before it can service a request.

163 > */

164 > export interface IChatSetupRequirement {

165 > /** Whether the setup flow has been completed (any outcome). */

166 > readonly completed: boolean;

167 > /** Whether the chat extension is disabled for a reason other than trust. */

168 > readonly disabled: boolean;

169 > /** Whether the chat extension is disabled because the workspace is untrusted. */

170 > readonly untrusted: boolean;

171 > /** The user's last known or resolved entitlement. */

172 > readonly entitlement: ChatEntitlement;

173 > /** Whether anonymous (signed-out) Chat access is enabled. */

174 > readonly anonymous: boolean;

175 > /** Whether BYOK models are available. */

176 > readonly hasByokModels: boolean;

177 > }

178 >

179 > /**

180 > * Single source of truth for whether Chat still requires setup before it can

181 > * service a request. Shared by the setup agent (which routes a sent message

182 > * through setup) and the model picker (which surfaces a "Sign in to use Copilot"

183 > * state instead of a misleading lone "Auto"). BYOK models and anonymous access

184 > * intentionally satisfy the entitlement-based checks so those flows keep working.

185 > */

186 > export function chatRequiresSetup(context: IChatSetupRequirement): boolean {

187 return (

188 (!context.completed && !context.hasByokModels) || // Setup not completed (unless BYOK models are available)

197 );

198 }

199 > chatEntitlementService.ts

200 > export interface IChatEntitlementService {

201 >

202 > _serviceBrand: undefined;

203 >

204 > readonly onDidChangeEntitlement: Event<void>;

205 >

206 > readonly entitlement: ChatEntitlement;

207 > readonly entitlementObs: IObservable<ChatEntitlement>;

208 >

209 > readonly clientByokEnabled: boolean;

210 > readonly hasByokModels: boolean;

211 >

212 > readonly organisations: string[] | undefined;

213 > readonly isInternal: boolean;

214 > readonly sku: string | undefined;

215 > readonly copilotTrackingId: string | undefined;

216 >

217 > readonly onDidChangeQuotaExceeded: Event<void>;

218 > readonly onDidChangeQuotaRemaining: Event<void>;

219 > readonly onDidChangeUsageBasedBilling: Event<void>;

220 >

221 > readonly quotas: IQuotas;

222 >

223 > readonly onDidChangeSentiment: Event<void>;

224 >

225 > readonly sentiment: IChatSentiment;

226 > readonly sentimentObs: IObservable<IChatSentiment>;

227 >

228 > // TODO@bpasero eventually this will become enabled by default

229 > // and in that case we only need to check on entitlements change

230 > // between `unknown` and any other entitlement.

231 > readonly onDidChangeAnonymous: Event<void>;

232 > readonly anonymous: boolean;

233 > readonly anonymousObs: IObservable<boolean>;

234 >

235 > acceptQuotas(quotas: IQuotas): void;

236 >

237 > /**

238 > * Clear all quota state.

239 > */

240 > clearQuotas(): void;

241 >

242 > markAnonymousRateLimited(): void;

243 >

244 > /**

245 > * Mark the chat setup flow as completed.

246 > */

247 > markSetupCompleted(): void;

248 >

249 > /**

250 > * Force the hidden state on or off, overriding the normal entitlement logic.

251 > * Used by the account policy gate to hide all AI features when the gate is

252 > * active and unsatisfied.

253 > */

254 > setForceHidden(hidden: boolean): void;

255 >

256 > update(token: CancellationToken): Promise<void>;

257 > }

258 >

259 > //#region Helper Functions

260 >

261 > /**

262 > * Checks the chat entitlements to see if the user falls into the paid category

263 > * @param chatEntitlement The chat entitlement to check

264 > * @returns Whether or not they are a paid user

265 > */

266 > export function isProUser(chatEntitlement: ChatEntitlement): boolean {

267 return chatEntitlement === ChatEntitlement.EDU ||

268 chatEntitlement === ChatEntitlement.Pro ||

272 chatEntitlement === ChatEntitlement.Enterprise;

273 }

274 > chatEntitlementService.ts

275 > /**

276 > * Gets the full plan name for the given chat entitlement

277 > * @param chatEntitlement The chat entitlement to get the plan name for

278 > * @returns The localized full plan name (e.g., "Copilot Pro", "Copilot Free")

279 > */

280 > export function getChatPlanName(chatEntitlement: ChatEntitlement): string {

281 switch (chatEntitlement) {

282 case ChatEntitlement.EDU:

296 }

297 }

298 > chatEntitlementService.ts

299 > //#region Service Implementation

300 >

301 > const defaultChatAgent = {

302 > upgradePlanUrl: product.defaultChatAgent?.upgradePlanUrl ?? '',

303 > providerUriSetting: product.defaultChatAgent?.providerUriSetting ?? '',

304 > entitlementSignupLimitedUrl: product.defaultChatAgent?.entitlementSignupLimitedUrl ?? '',

305 > chatQuotaExceededContext: product.defaultChatAgent?.chatQuotaExceededContext ?? '',

306 > completionsQuotaExceededContext: product.defaultChatAgent?.completionsQuotaExceededContext ?? ''

307 > };

308 >

309 > interface IChatQuotasAccessor {

310 > clearQuotas(): void;

311 > acceptQuotas(quotas: IQuotas): void;

312 > }

313 >

314 > const CHAT_ALLOW_ANONYMOUS_CONFIGURATION_KEY = 'chat.allowAnonymousAccess';

315 >

316 function isAnonymous(configurationService: IConfigurationService, entitlement: ChatEntitlement, sentiment: IChatSentiment): boolean {

317 if (configurationService.getValue(CHAT_ALLOW_ANONYMOUS_CONFIGURATION_KEY) !== true) {

329 return true;

330 }

331 > chatEntitlementService.ts

332 > type ChatEntitlementClassification = {

333 > owner: 'bpasero';

334 > comment: 'Provides insight into chat entitlements.';

335 > chatHidden: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether chat is hidden or not.' };

336 > chatEntitlement: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The current chat entitlement of the user.' };

337 > chatAnonymous: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user is anonymously using chat.' };

338 > chatRegistered: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user is registered for chat.' };

339 > chatDisabled: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether chat is disabled or not.' };

340 > };

341 > type ChatEntitlementEvent = {

342 > chatHidden: boolean;

343 > chatEntitlement: ChatEntitlement;

344 > chatAnonymous: boolean;

345 > chatRegistered: boolean;

346 > chatDisabled: boolean;

347 > };

348 >

349 function logChatEntitlements(state: IChatEntitlementContextState, configurationService: IConfigurationService, telemetryService: ITelemetryService): void {

350 telemetryService.publicLog2<ChatEntitlementEvent, ChatEntitlementClassification>('chatEntitlements', {

356 });

357 }

358 > chatEntitlementService.ts

359 > type ChatAdditionalSpendConfigurationClassification = {

360 > owner: 'pwang347';

361 > comment: 'Tracks when a user enables or disables additional spend.';

362 > enabled: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether additional spend is now enabled or disabled.' };

363 > entitlement: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The current chat entitlement of the user.' };

364 > };

365 > type ChatAdditionalSpendConfigurationEvent = {

366 > enabled: boolean;

367 > entitlement: ChatEntitlement;

368 > };

369 >

370 > type ChatAdditionalSpendActiveClassification = {

371 > owner: 'pwang347';

372 > comment: 'Tracks when a user enters additional spend (included quota exhausted while additional spend is enabled).';

373 > entitlement: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The current chat entitlement of the user.' };

374 > additionalUsageCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The number of additional spend interactions used so far.' };

375 > };

376 > type ChatAdditionalSpendActiveEvent = {

377 > entitlement: ChatEntitlement;

378 > additionalUsageCount: number;

379 > };

380 >

381 > export class ChatEntitlementService extends Disposable implements IChatEntitlementService {

382 >

383 > declare _serviceBrand: undefined;

384 >

385 > private static readonly CACHED_UBB_STORAGE_KEY = 'chat.usageBasedBilling';

386 >

387 > readonly context: Lazy<ChatEntitlementContext> | undefined;

388 > readonly requests: Lazy<ChatEntitlementRequests> | undefined;

389 >

390 > constructor(

391 @IInstantiationService instantiationService: IInstantiationService,

392 @IProductService productService: IProductService,

467 this.registerListeners();

468 }

469 > chatEntitlementService.ts

470 > //#region --- Entitlements

471 >

472 > readonly onDidChangeEntitlement: Event<void>;

473 > readonly entitlementObs: IObservable<ChatEntitlement>;

474 >

475 > get entitlement(): ChatEntitlement {

476 if (this.contextKeyService.getContextKeyValue<boolean>(ChatEntitlementContextKeys.Entitlement.planEdu.key) === true) {

477 return ChatEntitlement.EDU;

496 return ChatEntitlement.Unresolved;

497 }

498 > chatEntitlementService.ts

499 > get isInternal(): boolean {

500 return this.contextKeyService.getContextKeyValue<boolean>(ChatEntitlementContextKeys.Entitlement.internal.key) === true;

501 }

502 > chatEntitlementService.ts

503 > get organisations(): string[] | undefined {

504 return this.contextKeyService.getContextKeyValue<string[]>(ChatEntitlementContextKeys.Entitlement.organisations.key);

505 }

506 > chatEntitlementService.ts

507 > get sku(): string | undefined {

508 return this.contextKeyService.getContextKeyValue<string>(ChatEntitlementContextKeys.Entitlement.sku.key);

509 }

510 > chatEntitlementService.ts

511 > get copilotTrackingId(): string | undefined {

512 return this.context?.value.state.copilotTrackingId;

513 }

514 > chatEntitlementService.ts

515 > get clientByokEnabled(): boolean {

516 return this.contextKeyService.getContextKeyValue<boolean>('github.copilot.clientByokEnabled') === true;

517 }

518 > chatEntitlementService.ts

519 > get hasByokModels(): boolean {

520 return this.contextKeyService.getContextKeyValue<boolean>('github.copilot.hasByokModels') === true;

521 }

522 > chatEntitlementService.ts

523 > //#endregion

524 >

525 > //#region --- Quotas

526 >

527 > private readonly _onDidChangeQuotaExceeded = this._register(new Emitter<void>());

528 > readonly onDidChangeQuotaExceeded = this._onDidChangeQuotaExceeded.event;

529 >

530 > private readonly _onDidChangeQuotaRemaining = this._register(new Emitter<void>());

531 > readonly onDidChangeQuotaRemaining = this._onDidChangeQuotaRemaining.event;

532 >

533 > private readonly _onDidChangeUsageBasedBilling = this._register(new Emitter<void>());

534 > readonly onDidChangeUsageBasedBilling = this._onDidChangeUsageBasedBilling.event;

535 >

536 > private _quotas: IQuotas;

537 > private quotaCopilotTrackingId: string | undefined;

538 > get quotas() { return this._quotas; }

539 >

540 > private readonly chatQuotaExceededContextKey: IContextKey<boolean>;

541 > private readonly completionsQuotaExceededContextKey: IContextKey<boolean>;

542 >

543 > private ExtensionQuotaContextKeys = {

544 > chatQuotaExceeded: defaultChatAgent.chatQuotaExceededContext,

545 > completionsQuotaExceeded: defaultChatAgent.completionsQuotaExceededContext,

546 > };

547 >

548 > private registerListeners(): void {

549 const quotaExceededSet = new Set([this.ExtensionQuotaContextKeys.chatQuotaExceeded, this.ExtensionQuotaContextKeys.completionsQuotaExceeded]);

550

585 this._register(this.onDidChangeSentiment(() => updateAnonymousUsage()));

586 }

587 > chatEntitlementService.ts

588 > acceptQuotas(incomingQuotas: IQuotas): void {

589 const oldQuota = this._quotas;

590 const cachedQuota = this.quotaCopilotTrackingId === this.copilotTrackingId ? oldQuota : {};

649 }

650 }

651 > chatEntitlementService.ts

652 > private compareQuotas(oldQuota: IQuotaSnapshot | undefined, newQuota: IQuotaSnapshot | undefined): { changed: { exceeded: boolean; remaining: boolean } } {

653 return {

654 changed: {

659 };

660 }

661 > chatEntitlementService.ts

662 > clearQuotas(): void {

663 this.acceptQuotas({});

664 }

665 > chatEntitlementService.ts

666 > private updateContextKeys(): void {

667 const chatExhausted = this._quotas.chat?.percentRemaining === 0;

668 const premiumChatExhausted = this._quotas.premiumChat?.unlimited

677 this.completionsQuotaExceededContextKey.set(this._quotas.completions?.percentRemaining === 0);

678 }

679 > chatEntitlementService.ts

680 > //#endregion

681 >

682 > //#region --- Sentiment

683 >

684 > readonly onDidChangeSentiment: Event<void>;

685 > readonly sentimentObs: IObservable<IChatSentiment>;

686 >

687 > get sentiment(): IChatSentiment {

688 return {

689 completed: this.contextKeyService.getContextKeyValue<boolean>(ChatEntitlementContextKeys.Setup.completed.key) === true,

697 };

698 }

699 > chatEntitlementService.ts

700 > //#endregion

701 >

702 > //region --- Anonymous

703 >

704 > private readonly anonymousContextKey: IContextKey<boolean>;

705 >

706 > private readonly _onDidChangeAnonymous = this._register(new Emitter<void>());

707 > readonly onDidChangeAnonymous = this._onDidChangeAnonymous.event;

708 >

709 > readonly anonymousObs = observableFromEvent(this.onDidChangeAnonymous, () => this.anonymous);

710 >

711 > get anonymous(): boolean {

712 return isAnonymous(this.configurationService, this.entitlement, this.sentiment);

713 }

714 > chatEntitlementService.ts

715 > //#endregion

716 >

717 > markAnonymousRateLimited(): void {

718 if (!this.anonymous) {

719 return;

723 this._onDidChangeQuotaExceeded.fire();

724 }

725 > chatEntitlementService.ts

726 > markSetupCompleted(): void {

727 this.context?.value.update({ completed: true });

728 }

729 > chatEntitlementService.ts

730 > setForceHidden(hidden: boolean): void {

731 if (this.context) {

732 this.context.value.setForceHidden(hidden);

737 }

738 }

739 > chatEntitlementService.ts

740 > async update(token: CancellationToken): Promise<void> {

741 await this.requests?.value.forceResolveEntitlement(token);

742 }

743 > } chatEntitlementService.ts

744 >

745 > //#endregion

746 >

747 > //#region Chat Entitlement Request Service

748 >

749 > type EntitlementClassification = {

750 > tid: { classification: 'EndUserPseudonymizedInformation'; purpose: 'BusinessInsight'; comment: 'The anonymized analytics id returned by the service'; endpoint: 'GoogleAnalyticsId' };

751 > entitlement: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Flag indicating the chat entitlement state' };

752 > sku: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The SKU of the chat entitlement' };

753 > quotaChatUnlimited: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user has unlimited chat requests' };

754 > quotaChatHasQuota: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user currently has chat quota available' };

755 > quotaChatEntitlement: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The raw chat quota entitlement count' };

756 > quotaPremiumChat: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The percentage of premium chat requests remaining for the user' };

757 > quotaPremiumChatUnlimited: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user has unlimited premium chat requests' };

758 > quotaPremiumChatHasQuota: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user currently has premium chat quota available' };

759 > quotaPremiumChatEntitlement: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The raw premium chat quota entitlement count' };

760 > quotaCompletions: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The percentage of completions remaining for the user' };

761 > quotaCompletionsUnlimited: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user has unlimited completions' };

762 > quotaCompletionsHasQuota: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user currently has completions quota available' };

763 > quotaCompletionsEntitlement: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The raw completions quota entitlement count' };

764 > quotaResetDate: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The date the quota will reset' };

765 > usageBasedBilling: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user is on usage-based billing' };

766 > additionalUsageEnabled: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether overage / additional spend is enabled' };

767 > additionalUsageCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The number of overage interactions used' };

768 > canUpgradePlan: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the user is eligible to upgrade their plan' };

769 > owner: 'bpasero';

770 > comment: 'Reporting chat entitlements';

771 > };

772 >

773 > type EntitlementEvent = {

774 > entitlement: ChatEntitlement;

775 > tid: string;

776 > sku: string | undefined;

777 > quotaChatUnlimited: boolean | undefined;

778 > quotaChatHasQuota: boolean | undefined;

779 > quotaChatEntitlement: number | undefined;

780 > quotaPremiumChat: number | undefined;

781 > quotaPremiumChatUnlimited: boolean | undefined;

782 > quotaPremiumChatHasQuota: boolean | undefined;

783 > quotaPremiumChatEntitlement: number | undefined;

784 > quotaCompletions: number | undefined;

785 > quotaCompletionsUnlimited: boolean | undefined;

786 > quotaCompletionsHasQuota: boolean | undefined;

787 > quotaCompletionsEntitlement: number | undefined;

788 > quotaResetDate: string | undefined;

789 > usageBasedBilling: boolean | undefined;

790 > additionalUsageEnabled: boolean | undefined;

791 > additionalUsageCount: number | undefined;

792 > canUpgradePlan: boolean | undefined;

793 > };

794 >

795 > interface IEntitlements {

796 > readonly entitlement: ChatEntitlement;

797 > readonly organisations?: string[];

798 > readonly sku?: string;

799 > readonly copilotTrackingId?: string;

800 > readonly quotas?: IQuotas;

801 > }

802 >

803 > export interface IQuotaSnapshot {

804 > readonly percentRemaining: number;

805 > readonly unlimited: boolean;

806 > readonly hasQuota?: boolean;

807 > readonly resetAt?: number;

808 > readonly usageBasedBilling?: boolean;

809 > readonly entitlement?: number;

810 > readonly quotaRemaining?: number;

811 > readonly creditsUsed?: number;

812 > }

813 >

814 > export interface IRateLimitSnapshot {

815 > readonly percentRemaining: number;

816 > readonly unlimited: boolean;

817 > readonly resetDate?: string;

818 > }

819 >

820 > interface IQuotas {

821 > readonly resetDate?: string;

822 > readonly resetDateHasTime?: boolean;

823 >

824 > readonly usageBasedBilling?: boolean;

825 > readonly canUpgradePlan?: boolean;

826 >

827 > readonly chat?: IQuotaSnapshot;

828 > readonly completions?: IQuotaSnapshot;

829 > readonly premiumChat?: IQuotaSnapshot;

830 > readonly additionalUsageEnabled?: boolean;

831 > readonly additionalUsageCount?: number;

832 > readonly additionalUsageEntitlement?: number;

833 >

834 > readonly sessionRateLimit?: IRateLimitSnapshot;

835 > readonly weeklyRateLimit?: IRateLimitSnapshot;

836 > }

837 >

838 function mergeDefinedSnapshot<T extends object>(previous: T | undefined, current: T): T {

839 const result = { ...previous, ...current };

845 return result;

846 }

847 > chatEntitlementService.ts

848 > export function parseQuotas(entitlementsData: IEntitlementsData): IQuotas {

849 const quotas: Mutable<IQuotas> = {

850 resetDate: entitlementsData.quota_reset_date_utc ?? entitlementsData.quota_reset_date ?? entitlementsData.limited_user_reset_date,

919 return quotas;

920 }

921 > chatEntitlementService.ts

922 > export class ChatEntitlementRequests extends Disposable {

923 >

924 > private state: IEntitlements;

925 >

926 > private pendingResolveCts = new CancellationTokenSource();

927 >

928 > constructor(

929 private readonly context: ChatEntitlementContext,

930 private readonly chatQuotasAccessor: IChatQuotasAccessor,

946 this.resolve();

947 }

948 > chatEntitlementService.ts

949 > private registerListeners(): void {

950 this._register(this.defaultAccountService.onDidChangeDefaultAccount(() => this.resolve()));

951

959 }));

960 }

961 > chatEntitlementService.ts

962 > private async resolve(): Promise<void> {

963 this.pendingResolveCts.dispose(true);

964 const cts = this.pendingResolveCts = new CancellationTokenSource();

989 }

990 }

991 > chatEntitlementService.ts

992 > private async resolveEntitlement(defaultAccount: IDefaultAccount, token: CancellationToken): Promise<IEntitlements | undefined> {

993 const entitlements = await this.doResolveEntitlement(defaultAccount, token);

994 if (typeof entitlements?.entitlement === 'number' && !token.isCancellationRequested) {

997 return entitlements;

998 }

999 > chatEntitlementService.ts

1000 > private async doResolveEntitlement(defaultAccount: IDefaultAccount, token: CancellationToken): Promise<IEntitlements | undefined> {

1001 if (token.isCancellationRequested) {

1002 return undefined;

1065 return entitlements;

1066 }

1067 > chatEntitlementService.ts

1068 > private toQuotas(entitlementsData: IEntitlementsData): IQuotas {

1069 return parseQuotas(entitlementsData);

1070 }

1071 > chatEntitlementService.ts

1072 > private async request(url: string, type: 'GET', body: undefined, sessions: AuthenticationSession[], token: CancellationToken, callSite: string): Promise<IRequestContext | undefined>;

1073 > private async request(url: string, type: 'POST', body: object, sessions: AuthenticationSession[], token: CancellationToken, callSite: string): Promise<IRequestContext | undefined>;

1074 > private async request(url: string, type: 'GET' | 'POST', body: object | undefined, sessions: AuthenticationSession[], token: CancellationToken, callSite: string): Promise<IRequestContext | undefined> {

1075 let lastRequest: IRequestContext | undefined;

1076

1108 return lastRequest;

1109 }

1110 > chatEntitlementService.ts

1111 > private update(state: IEntitlements): void {

1112 this.state = state;

1113

1118 }

1119 }

1120 > chatEntitlementService.ts

1121 > async forceResolveEntitlement(token = CancellationToken.None): Promise<IEntitlements | undefined> {

1122 const defaultAccount = await this.defaultAccountService.refresh({ forceRefresh: true });

1123 if (!defaultAccount) {

1127 return this.resolveEntitlement(defaultAccount, token);

1128 }

1129 > chatEntitlementService.ts

1130 > async signUpFree(): Promise<true /* signed up */ | false /* already signed up */ | { errorCode: number } /* error */ | undefined /* no session */> {

1131 const sessions = await this.getSessions();

1132 if (sessions.length === 0) {

1135 return this.doSignUpFree(sessions);

1136 }

1137 > chatEntitlementService.ts

1138 > private async doSignUpFree(sessions: AuthenticationSession[]): Promise<true /* signed up */ | false /* already signed up */ | { errorCode: number } /* error */> {

1139 const body = {

1140 restricted_telemetry: this.telemetryService.telemetryLevel === TelemetryLevel.NONE ? 'disabled' : 'enabled',

1194 return Boolean(parsedResult?.subscribed);

1195 }

1196 > chatEntitlementService.ts

1197 > private async getSessions(): Promise<AuthenticationSession[]> {

1198 const defaultAccount = await this.defaultAccountService.getDefaultAccount();

1199 if (defaultAccount) {

1206 return [...(await this.authenticationService.getSessions(this.defaultAccountService.getDefaultAccountAuthenticationProvider().id))];

1207 }

1208 > chatEntitlementService.ts

1209 > private async onUnknownSignUpError(detail: string, logMessage: string): Promise<boolean> {

1210 this.logService.error(logMessage);

1211

1223 return false;

1224 }

1225 > chatEntitlementService.ts

1226 > private onUnprocessableSignUpError(logMessage: string, logDetails: string): void {

1227 this.logService.error(logMessage);

1228

1245 }

1246 }

1247 > chatEntitlementService.ts

1248 > async signIn(options?: { useSocialProvider?: string; additionalScopes?: readonly string[] }): Promise<{ defaultAccount?: IDefaultAccount; entitlements?: IEntitlements }> {

1249 const defaultAccount = await this.defaultAccountService.signIn({

1250 additionalScopes: options?.additionalScopes,

1259 return { defaultAccount, entitlements };

1260 }

1261 > chatEntitlementService.ts

1262 > override dispose(): void {

1263 this.pendingResolveCts.dispose(true);

1264

1265 super.dispose();

1266 }

1267 > } chatEntitlementService.ts

1268 >

1269 > //#endregion

1270 >

1271 > //#region Context

1272 >

1273 > export interface IChatEntitlementContextState extends IChatSentiment {

1274 >

1275 > /**

1276 > * Users last known or resolved entitlement.

1277 > */

1278 > entitlement: ChatEntitlement;

1279 >

1280 > /**

1281 > * User's last known or resolved raw SKU type.

1282 > */

1283 > sku: string | undefined;

1284 >

1285 > /**

1286 > * User's last known or resolved organisations.

1287 > */

1288 > organisations: string[] | undefined;

1289 >

1290 > /**

1291 > * User's Copilot tracking ID from the entitlement API.

1292 > */

1293 > copilotTrackingId: string | undefined;

1294 > }

1295 >

1296 > export class ChatEntitlementContext extends Disposable {

1297 >

1298 > private static readonly CHAT_ENTITLEMENT_CONTEXT_STORAGE_KEY = 'chat.setupContext';

1299 > private static readonly CHAT_ENTITLEMENT_CONTEXT_MIGRATED_STORAGE_KEY = 'chat.setupContext.migrated.v1';

1300 >

1301 > private static readonly CHAT_DISABLED_CONFIGURATION_KEY = 'chat.disableAIFeatures';

1302 >

1303 > private readonly canSignUpContextKey: IContextKey<boolean>;

1304 > private readonly signedOutContextKey: IContextKey<boolean>;

1305 >

1306 > private readonly freeContextKey: IContextKey<boolean>;

1307 > private readonly eduContextKey: IContextKey<boolean>;

1308 > private readonly proContextKey: IContextKey<boolean>;

1309 > private readonly proPlusContextKey: IContextKey<boolean>;

1310 > private readonly maxContextKey: IContextKey<boolean>;

1311 > private readonly businessContextKey: IContextKey<boolean>;

1312 > private readonly enterpriseContextKey: IContextKey<boolean>;

1313 >

1314 > private readonly organisationsContextKey: IContextKey<string[] | undefined>;

1315 > private readonly isInternalContextKey: IContextKey<boolean>;

1316 > private readonly skuContextKey: IContextKey<string | undefined>;

1317 >

1318 > private readonly completedContext: IContextKey<boolean>;

1319 > private readonly hiddenContext: IContextKey<boolean>;

1320 > private readonly disabledInWorkspaceContext: IContextKey<boolean>;

1321 > private readonly laterContext: IContextKey<boolean>;

1322 > private readonly installedContext: IContextKey<boolean>;

1323 > private readonly disabledContext: IContextKey<boolean>;

1324 > private readonly untrustedContext: IContextKey<boolean>;

1325 > private readonly registeredContext: IContextKey<boolean>;

1326 >

1327 > private _state: IChatEntitlementContextState;

1328 > private suspendedState: IChatEntitlementContextState | undefined = undefined;

1329 > get state(): IChatEntitlementContextState { return this.withConfiguration(this.suspendedState ?? this._state); }

1330 >

1331 > private readonly _onDidChange = this._register(new Emitter<void>());

1332 > readonly onDidChange = this._onDidChange.event;

1333 >

1334 > private updateBarrier: Barrier | undefined = undefined;

1335 >

1336 > constructor(

1337 @IContextKeyService contextKeyService: IContextKeyService,

1338 @IStorageService private readonly storageService: IStorageService,

1387 this.registerListeners();

1388 }

1389 > chatEntitlementService.ts

1390 > private registerListeners(): void {

1391 this._register(this.configurationService.onDidChangeConfiguration(e => {

1392 if (e.affectsConfiguration(ChatEntitlementContext.CHAT_DISABLED_CONFIGURATION_KEY)) {

1395 }));

1396 }

1397 > chatEntitlementService.ts

1398 > private _forceHidden = false;

1399 >

1400 > private withConfiguration(state: IChatEntitlementContextState): IChatEntitlementContextState {

1401 if (this._forceHidden || this.configurationService.getValue(ChatEntitlementContext.CHAT_DISABLED_CONFIGURATION_KEY) === true) {

1402 return {

1408 return state;

1409 }

1410 > chatEntitlementService.ts

1411 > setForceHidden(hidden: boolean): void {

1412 if (this._forceHidden !== hidden) {

1413 this._forceHidden = hidden;

1415 }

1416 }

1417 > chatEntitlementService.ts

1418 > update(context: { installed: boolean; disabled: boolean; untrusted: boolean; disabledInWorkspace: boolean }): Promise<void>;

1419 > update(context: { completed: true }): Promise<void>;

1420 > update(context: { hidden: false }): Promise<void>; // legacy UI state from before we had a setting to hide, keep around to still support users who used this

1421 > update(context: { later: boolean }): Promise<void>;

1422 > update(context: { entitlement: ChatEntitlement; organisations: string[] | undefined; sku: string | undefined; copilotTrackingId: string | undefined }): Promise<void>;

1423 > async update(context: { completed?: boolean; installed?: boolean; disabled?: boolean; untrusted?: boolean; disabledInWorkspace?: boolean; hidden?: false; later?: boolean; entitlement?: ChatEntitlement; organisations?: string[]; sku?: string; copilotTrackingId?: string }): Promise<void> {

1424 this.logService.trace(`[chat entitlement context] update(): ${JSON.stringify(context)}`);

1425

1477 return this.updateContext();

1478 }

1479 > chatEntitlementService.ts

1480 > private async updateContext(): Promise<void> {

1481 await this.updateBarrier?.wait();

1482

1483 this.updateContextSync();

1484 }

1485 > chatEntitlementService.ts

1486 > private updateContextSync(): void {

1487 const state = this.withConfiguration(this._state);

1488

1516 this._onDidChange.fire();

1517 }

1518 > chatEntitlementService.ts

1519 > suspend(): void {

1520 this.suspendedState = { ...this._state };

1521 this.updateBarrier = new Barrier();

1522 }

1523 > chatEntitlementService.ts

1524 > resume(): void {

1525 this.suspendedState = undefined;

1526 this.updateBarrier?.open();

1527 this.updateBarrier = undefined;

1528 }

1529 > } chatEntitlementService.ts

1530 >

1531 > //#endregion

1532 >

1533 > registerSingleton(IChatEntitlementService, ChatEntitlementService, InstantiationType.Eager /* To ensure context keys are set asap */);

src/vs/platform/configuration/common/configurationRegistry.ts 615 covered LOC · 87 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- configurationRegistry.ts

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 { distinct } from '../../../base/common/arrays.js';

7 > import { IStringDictionary } from '../../../base/common/collections.js';

8 > import { Emitter, Event } from '../../../base/common/event.js';

9 > import { IJSONSchema } from '../../../base/common/jsonSchema.js';

10 > import * as types from '../../../base/common/types.js';

11 > import * as nls from '../../../nls.js';

12 > import { getLanguageTagSettingPlainKey } from './configuration.js';

13 > import { Extensions as JSONExtensions, IJSONContributionRegistry } from '../../jsonschemas/common/jsonContributionRegistry.js';

14 > import { Registry } from '../../registry/common/platform.js';

15 > import { IPolicy, IPolicyReference, PolicyName } from '../../../base/common/policy.js';

16 > import { Disposable } from '../../../base/common/lifecycle.js';

17 > import product from '../../product/common/product.js';

18 >

19 > export enum EditPresentationTypes {

20 > Multiline = 'multilineText',

21 > Singleline = 'singlelineText'

22 > }

23 >

24 > export const Extensions = {

25 > Configuration: 'base.contributions.configuration'

26 > };

27 >

28 > export interface IConfigurationDelta {

29 > removedDefaults?: IConfigurationDefaults[];

30 > removedConfigurations?: IConfigurationNode[];

31 > addedDefaults?: IConfigurationDefaults[];

32 > addedConfigurations?: IConfigurationNode[];

33 > }

34 >

35 > export interface IConfigurationRegistry {

36 >

37 > /**

38 > * Register a configuration to the registry.

39 > */

40 > registerConfiguration(configuration: IConfigurationNode): IConfigurationNode;

41 >

42 > /**

43 > * Register multiple configurations to the registry.

44 > */

45 > registerConfigurations(configurations: IConfigurationNode[], validate?: boolean): void;

46 >

47 > /**

48 > * Deregister multiple configurations from the registry.

49 > */

50 > deregisterConfigurations(configurations: IConfigurationNode[]): void;

51 >

52 > /**

53 > * update the configuration registry by

54 > * - registering the configurations to add

55 > * - dereigstering the configurations to remove

56 > */

57 > updateConfigurations(configurations: { add: IConfigurationNode[]; remove: IConfigurationNode[] }): void;

58 >

59 > /**

60 > * Register multiple default configurations to the registry.

61 > */

62 > registerDefaultConfigurations(defaultConfigurations: IConfigurationDefaults[]): void;

63 >

64 > /**

65 > * Deregister multiple default configurations from the registry.

66 > */

67 > deregisterDefaultConfigurations(defaultConfigurations: IConfigurationDefaults[]): void;

68 >

69 > /**

70 > * Bulk update of the configuration registry (default and configurations, remove and add)

71 > * @param delta

72 > */

73 > deltaConfiguration(delta: IConfigurationDelta): void;

74 >

75 > /**

76 > * Return the registered default configurations

77 > */

78 > getRegisteredDefaultConfigurations(): IConfigurationDefaults[];

79 >

80 > /**

81 > * Return the registered configuration defaults overrides

82 > */

83 > getConfigurationDefaultsOverrides(): Map<string, IConfigurationDefaultOverrideValue>;

84 >

85 > /**

86 > * Signal that the schema of a configuration setting has changes. It is currently only supported to change enumeration values.

87 > * Property or default value changes are not allowed.

88 > */

89 > notifyConfigurationSchemaUpdated(...configurations: IConfigurationNode[]): void;

90 >

91 > /**

92 > * Event that fires whenever a configuration has been

93 > * registered.

94 > */

95 > readonly onDidSchemaChange: Event<void>;

96 >

97 > /**

98 > * Event that fires whenever a configuration has been

99 > * registered.

100 > */

101 > readonly onDidUpdateConfiguration: Event<{ properties: ReadonlySet<string>; defaultsOverrides?: boolean }>;

102 >

103 > /**

104 > * Returns all configuration nodes contributed to this registry.

105 > */

106 > getConfigurations(): IConfigurationNode[];

107 >

108 > /**

109 > * Returns all configurations settings of all configuration nodes contributed to this registry.

110 > */

111 > getConfigurationProperties(): IStringDictionary<IRegisteredConfigurationPropertySchema>;

112 >

113 > /**

114 > * Returns the owning setting key per policy name (at most one owner per name).

115 > */

116 > getPolicyConfigurations(): Map<PolicyName, string>;

117 >

118 > /**

119 > * Returns the referencing setting keys per policy name.

120 > */

121 > getPolicyReferenceConfigurations(): Map<PolicyName, Set<string>>;

122 >

123 > /**

124 > * Returns all excluded configurations settings of all configuration nodes contributed to this registry.

125 > */

126 > getExcludedConfigurationProperties(): IStringDictionary<IRegisteredConfigurationPropertySchema>;

127 >

128 > /**

129 > * Register the identifiers for editor configurations

130 > */

131 > registerOverrideIdentifiers(identifiers: string[]): void;

132 > }

133 >

134 > export const enum ConfigurationScope {

135 > /**

136 > * Application specific configuration, which can be configured only in default profile user settings.

137 > */

138 > APPLICATION = 1,

139 > /**

140 > * Machine specific configuration, which can be configured only in local and remote user settings.

141 > */

142 > MACHINE,

143 > /**

144 > * An application machine specific configuration, which can be configured only in default profile user settings and remote user settings.

145 > */

146 > APPLICATION_MACHINE,

147 > /**

148 > * Window specific configuration, which can be configured in the user or workspace settings.

149 > */

150 > WINDOW,

151 > /**

152 > * Resource specific configuration, which can be configured in the user, workspace or folder settings.

153 > */

154 > RESOURCE,

155 > /**

156 > * Resource specific configuration that can be configured in language specific settings

157 > */

158 > LANGUAGE_OVERRIDABLE,

159 > /**

160 > * Machine specific configuration that can also be configured in workspace or folder settings.

161 > */

162 > MACHINE_OVERRIDABLE,

163 > }

164 >

165 >

166 > export interface IConfigurationPropertySchema extends IJSONSchema {

167 >

168 > scope?: ConfigurationScope;

169 >

170 > /**

171 > * When restricted, value of this configuration will be read only from trusted sources.

172 > * For eg., If the workspace is not trusted, then the value of this configuration is not read from workspace settings file.

173 > */

174 > restricted?: boolean;

175 >

176 > /**

177 > * When `false` this property is excluded from the registry. Default is to include.

178 > */

179 > included?: boolean;

180 >

181 > /**

182 > * List of tags associated to the property.

183 > * - A tag can be used for filtering

184 > * - Use `experimental` tag for marking the setting as experimental.

185 > */

186 > tags?: string[];

187 >

188 > /**

189 > * When enabled this setting is ignored during sync and user can override this.

190 > */

191 > ignoreSync?: boolean;

192 >

193 > /**

194 > * When enabled this setting is ignored during sync and user cannot override this.

195 > */

196 > disallowSyncIgnore?: boolean;

197 >

198 > /**

199 > * Disallow extensions to contribute configuration default value for this setting.

200 > */

201 > disallowConfigurationDefault?: boolean;

202 >

203 > /**

204 > * Labels for enumeration items

205 > */

206 > enumItemLabels?: string[];

207 >

208 > /**

209 > * Optional keywords used for search purposes.

210 > */

211 > keywords?: string[];

212 >

213 > /**

214 > * When specified, controls the presentation format of string settings.

215 > * Otherwise, the presentation format defaults to `singleline`.

216 > */

217 > editPresentation?: EditPresentationTypes;

218 >

219 > /**

220 > * When specified, gives an order number for the setting

221 > * within the settings editor. Otherwise, the setting is placed at the end.

222 > */

223 > order?: number;

224 >

225 > /**

226 > * When specified, this setting's value can always be overwritten by

227 > * a system-wide policy. Exactly one setting may *own* a given policy name.

228 > */

229 > policy?: IPolicy;

230 >

231 > /**

232 > * When specified, this setting is governed by a policy owned by another setting.

233 > * A setting must not declare both `policy` and `policyReference`.

234 > * The type must match the owning setting (enforced when exporting the policy catalog).

235 > */

236 > policyReference?: IPolicyReference;

237 >

238 > /**

239 > * When specified, this setting's default value can always be overwritten by

240 > * an experiment.

241 > */

242 > experiment?: {

243 > /**

244 > * The mode of the experiment.

245 > * - `startup`: The setting value is updated to the experiment value only on startup.

246 > * - `auto`: The setting value is updated to the experiment value automatically (whenever the experiment value changes).

247 > */

248 > mode: 'startup' | 'auto';

249 >

250 > /**

251 > * The name of the experiment. By default, this is `config.${settingId}`

252 > */

253 > name?: string;

254 > };

255 >

256 > /**

257 > * When specified, provides configuration overrides for the Agents window.

258 > */

259 > agentsWindow?: {

260 > /**

261 > * Override default value for this setting in the Agents window.

262 > */

263 > default?: unknown;

264 >

265 > /**

266 > * When `true`, this setting is read-only in the Agents window

267 > * and cannot be changed by the user.

268 > */

269 > readOnly?: boolean;

270 > };

271 > }

272 >

273 > export interface IExtensionInfo {

274 > id: string;

275 > displayName?: string;

276 > }

277 >

278 > export interface IConfigurationNode {

279 > id?: string;

280 > order?: number;

281 > type?: string | string[];

282 > title?: string;

283 > description?: string;

284 > properties?: IStringDictionary<IConfigurationPropertySchema>;

285 > allOf?: IConfigurationNode[];

286 > scope?: ConfigurationScope;

287 > extensionInfo?: IExtensionInfo;

288 > restrictedProperties?: string[];

289 > }

290 >

291 > export type ConfigurationDefaultSource = IExtensionInfo | string;

292 >

293 > export function isConfigurationDefaultSourceEquals(a: ConfigurationDefaultSource | undefined, b: ConfigurationDefaultSource | undefined): boolean {

294 if (a === b) {

295 return true;

303 return a.id === b.id;

304 }

305 > configurationRegistry.ts

306 > export type ConfigurationDefaultValueSource = ConfigurationDefaultSource | Map<string, ConfigurationDefaultSource>;

307 >

308 > export interface IConfigurationDefaults {

309 > overrides: IStringDictionary<unknown>;

310 > source?: ConfigurationDefaultSource;

311 > donotCache?: boolean;

312 > preventExperimentOverride?: boolean;

313 > }

314 >

315 > export type IRegisteredConfigurationPropertySchema = IConfigurationPropertySchema & {

316 > section?: {

317 > id?: string;

318 > title?: string;

319 > order?: number;

320 > extensionInfo?: IExtensionInfo;

321 > };

322 > defaultDefaultValue?: unknown;

323 > source?: ConfigurationDefaultSource; // Source of the Property

324 > defaultValueSource?: ConfigurationDefaultValueSource; // Source of the Default Value

325 > };

326 >

327 > export interface IConfigurationDefaultOverride {

328 > readonly value: unknown;

329 > readonly source?: ConfigurationDefaultSource; // Source of the default override

330 > }

331 >

332 > export interface IConfigurationDefaultOverrideValue {

333 > readonly value: unknown;

334 > readonly source?: ConfigurationDefaultValueSource;

335 > }

336 >

337 > export const allSettings: { properties: IStringDictionary<IConfigurationPropertySchema>; patternProperties: IStringDictionary<IConfigurationPropertySchema> } = { properties: {}, patternProperties: {} };

338 > export const applicationSettings: { properties: IStringDictionary<IConfigurationPropertySchema>; patternProperties: IStringDictionary<IConfigurationPropertySchema> } = { properties: {}, patternProperties: {} };

339 > export const applicationMachineSettings: { properties: IStringDictionary<IConfigurationPropertySchema>; patternProperties: IStringDictionary<IConfigurationPropertySchema> } = { properties: {}, patternProperties: {} };

340 > export const machineSettings: { properties: IStringDictionary<IConfigurationPropertySchema>; patternProperties: IStringDictionary<IConfigurationPropertySchema> } = { properties: {}, patternProperties: {} };

341 > export const machineOverridableSettings: { properties: IStringDictionary<IConfigurationPropertySchema>; patternProperties: IStringDictionary<IConfigurationPropertySchema> } = { properties: {}, patternProperties: {} };

342 > export const windowSettings: { properties: IStringDictionary<IConfigurationPropertySchema>; patternProperties: IStringDictionary<IConfigurationPropertySchema> } = { properties: {}, patternProperties: {} };

343 > export const resourceSettings: { properties: IStringDictionary<IConfigurationPropertySchema>; patternProperties: IStringDictionary<IConfigurationPropertySchema> } = { properties: {}, patternProperties: {} };

344 >

345 > export const resourceLanguageSettingsSchemaId = 'vscode://schemas/settings/resourceLanguage';

346 > export const configurationDefaultsSchemaId = 'vscode://schemas/settings/configurationDefaults';

347 >

348 > const contributionRegistry = Registry.as<IJSONContributionRegistry>(JSONExtensions.JSONContribution);

349 >

350 > class ConfigurationRegistry extends Disposable implements IConfigurationRegistry {

351 >

352 > private readonly registeredConfigurationDefaults: IConfigurationDefaults[] = [];

353 > private readonly configurationDefaultsOverrides: Map<string, { configurationDefaultOverrides: IConfigurationDefaultOverride[]; configurationDefaultOverrideValue?: IConfigurationDefaultOverrideValue }>;

354 > private readonly defaultLanguageConfigurationOverridesNode: IConfigurationNode;

355 > private readonly configurationContributors: IConfigurationNode[];

356 > private readonly configurationProperties: IStringDictionary<IRegisteredConfigurationPropertySchema>;

357 > private readonly policyConfigurations: Map<PolicyName, string>;

358 > private readonly policyReferenceConfigurations: Map<PolicyName, Set<string>>;

359 > private readonly excludedConfigurationProperties: IStringDictionary<IRegisteredConfigurationPropertySchema>;

360 > private readonly resourceLanguageSettingsSchema: IJSONSchema;

361 > private readonly overrideIdentifiers = new Set<string>();

362 >

363 > private readonly _onDidSchemaChange = this._register(new Emitter<void>());

364 > readonly onDidSchemaChange: Event<void> = this._onDidSchemaChange.event;

365 >

366 > private readonly _onDidUpdateConfiguration = this._register(new Emitter<{ properties: ReadonlySet<string>; defaultsOverrides?: boolean }>());

367 > readonly onDidUpdateConfiguration = this._onDidUpdateConfiguration.event;

368 >

369 > constructor() {

370 > super();

371 > this.configurationDefaultsOverrides = new Map();

372 > this.defaultLanguageConfigurationOverridesNode = {

373 > id: 'defaultOverrides',

374 > title: nls.localize('defaultLanguageConfigurationOverrides.title', "Default Language Configuration Overrides"),

375 > properties: {}

376 > };

377 > this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];

378 > this.resourceLanguageSettingsSchema = {

379 > properties: {},

380 > patternProperties: {},

381 > additionalProperties: true,

382 > allowTrailingCommas: true,

383 > allowComments: true

384 > };

385 > this.configurationProperties = {};

386 > this.policyConfigurations = new Map<PolicyName, string>();

387 > this.policyReferenceConfigurations = new Map<PolicyName, Set<string>>();

388 > this.excludedConfigurationProperties = {};

389 >

390 > contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);

391 > this.registerOverridePropertyPatternKey();

392 > }

393 >

394 > public registerConfiguration(configuration: IConfigurationNode, validate: boolean = true): IConfigurationNode {

395 this.registerConfigurations([configuration], validate);

396 return configuration;

397 }

398 > configurationRegistry.ts

399 > public registerConfigurations(configurations: IConfigurationNode[], validate: boolean = true): void {

400 const properties = new Set<string>();

401 this.doRegisterConfigurations(configurations, validate, properties);

405 this._onDidUpdateConfiguration.fire({ properties });

406 }

407 > configurationRegistry.ts

408 > public deregisterConfigurations(configurations: IConfigurationNode[]): void {

409 const properties = new Set<string>();

410 this.doDeregisterConfigurations(configurations, properties);

414 this._onDidUpdateConfiguration.fire({ properties });

415 }

416 > configurationRegistry.ts

417 > public updateConfigurations({ add, remove }: { add: IConfigurationNode[]; remove: IConfigurationNode[] }): void {

418 > const properties = new Set<string>(); configurationRegistry.ts

419 > this.doDeregisterConfigurations(remove, properties);

420 > this.doRegisterConfigurations(add, false, properties);

421 >

422 > contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);

423 > this._onDidSchemaChange.fire();

424 > this._onDidUpdateConfiguration.fire({ properties });

425 > }

426 > configurationRegistry.ts

427 > public registerDefaultConfigurations(configurationDefaults: IConfigurationDefaults[]): void {

428 const properties = new Set<string>();

429 this.doRegisterDefaultConfigurations(configurationDefaults, properties);

431 this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });

432 }

433 > configurationRegistry.ts

434 > private doRegisterDefaultConfigurations(configurationDefaults: IConfigurationDefaults[], bucket: Set<string>) {

435

436 this.registeredConfigurationDefaults.push(...configurationDefaults);

480 this.doRegisterOverrideIdentifiers(overrideIdentifiers);

481 }

482 > configurationRegistry.ts

483 > public deregisterDefaultConfigurations(defaultConfigurations: IConfigurationDefaults[]): void {

484 const properties = new Set<string>();

485 this.doDeregisterDefaultConfigurations(defaultConfigurations, properties);

487 this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });

488 }

489 > configurationRegistry.ts

490 > private doDeregisterDefaultConfigurations(defaultConfigurations: IConfigurationDefaults[], bucket: Set<string>): void {

491 for (const defaultConfiguration of defaultConfigurations) {

492 const index = this.registeredConfigurationDefaults.indexOf(defaultConfiguration);

544 this.updateOverridePropertyPatternKey();

545 }

546 > configurationRegistry.ts

547 > private updateDefaultOverrideProperty(key: string, newDefaultOverride: IConfigurationDefaultOverrideValue, source: ConfigurationDefaultSource | undefined): void {

548 const property: IRegisteredConfigurationPropertySchema = {

549 section: {

564 this.defaultLanguageConfigurationOverridesNode.properties![key] = property;

565 }

566 > configurationRegistry.ts

567 > private mergeDefaultConfigurationsForOverrideIdentifier(overrideIdentifier: string, configurationValueObject: IStringDictionary<unknown>, valueSource: ConfigurationDefaultSource | undefined, existingDefaultOverride: IConfigurationDefaultOverrideValue | undefined): IConfigurationDefaultOverrideValue | undefined {

568 const defaultValue = existingDefaultOverride?.value || {};

569 const source = existingDefaultOverride?.source ?? new Map<string, ConfigurationDefaultSource>();

605 return { value: defaultValue, source };

606 }

607 > configurationRegistry.ts

608 > private mergeDefaultConfigurationsForConfigurationProperty(propertyKey: string, value: unknown, valuesSource: ConfigurationDefaultSource | undefined, existingDefaultOverride: IConfigurationDefaultOverrideValue | undefined): IConfigurationDefaultOverrideValue | undefined {

609 const property = this.configurationProperties[propertyKey];

610 const existingDefaultValue = existingDefaultOverride?.value ?? property?.defaultDefaultValue;

637 return { value, source };

638 }

639 > configurationRegistry.ts

640 > public deltaConfiguration(delta: IConfigurationDelta): void {

641 // defaults: remove

642 let defaultsOverrides = false;

662 this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides });

663 }

664 > configurationRegistry.ts

665 > public notifyConfigurationSchemaUpdated(...configurations: IConfigurationNode[]) {

666 this._onDidSchemaChange.fire();

667 }

668 > configurationRegistry.ts

669 > public registerOverrideIdentifiers(overrideIdentifiers: string[]): void {

670 this.doRegisterOverrideIdentifiers(overrideIdentifiers);

671 this._onDidSchemaChange.fire();

672 }

673 > configurationRegistry.ts

674 > private doRegisterOverrideIdentifiers(overrideIdentifiers: string[]) {

675 for (const overrideIdentifier of overrideIdentifiers) {

676 this.overrideIdentifiers.add(overrideIdentifier);

678 this.updateOverridePropertyPatternKey();

679 }

680 > configurationRegistry.ts

681 > private doRegisterConfigurations(configurations: IConfigurationNode[], validate: boolean, bucket: Set<string>): void {

682 > configurationRegistry.ts

683 > configurations.forEach(configuration => {

684 >

685 > this.validateAndRegisterProperties(configuration, validate, configuration.extensionInfo, configuration.restrictedProperties, undefined, bucket);

686 >

687 > this.configurationContributors.push(configuration);

688 > this.registerJSONConfiguration(configuration);

689 > });

690 > }

691 > configurationRegistry.ts

692 > private doDeregisterConfigurations(configurations: IConfigurationNode[], bucket: Set<string>): void {

693 > configurationRegistry.ts

694 > const deregisterConfiguration = (configuration: IConfigurationNode) => {

695 if (configuration.properties) {

696 for (const key in configuration.properties) {

715 configuration.allOf?.forEach(node => deregisterConfiguration(node));

716 };

717 > for (const configuration of configurations) { configurationRegistry.ts

718 deregisterConfiguration(configuration);

719 const index = this.configurationContributors.indexOf(configuration);

722 }

723 }

724 > } configurationRegistry.ts

725 > configurationRegistry.ts

726 > private validateAndRegisterProperties(configuration: IConfigurationNode, validate: boolean = true, extensionInfo: IExtensionInfo | undefined, restrictedProperties: string[] | undefined, scope: ConfigurationScope = ConfigurationScope.WINDOW, bucket: Set<string>): void {

727 > scope = types.isUndefinedOrNull(configuration.scope) ? scope : configuration.scope; configurationRegistry.ts

728 > const properties = configuration.properties;

729 > if (properties) {

730 > for (const key in properties) {

731 > const property: IRegisteredConfigurationPropertySchema = properties[key];

732 > property.section = {

733 > id: configuration.id,

734 > title: configuration.title,

735 > order: configuration.order,

736 > extensionInfo: configuration.extensionInfo

737 > };

738 > if (validate && validateProperty(key, property, extensionInfo?.id)) {

739 delete properties[key];

740 continue;

741 }

742 > configurationRegistry.ts

743 > property.source = extensionInfo;

744 >

745 > // update default value

746 > property.defaultDefaultValue = properties[key].default;

747 > this.updatePropertyDefaultValue(key, property);

748 >

749 > // update scope

750 > if (OVERRIDE_PROPERTY_REGEX.test(key)) {

751 property.scope = undefined; // No scope for overridable properties `[${identifier}]`

752 > } else { configurationRegistry.ts

753 > property.scope = types.isUndefinedOrNull(property.scope) ? scope : property.scope;

754 > property.restricted = types.isUndefinedOrNull(property.restricted) ? !!restrictedProperties?.includes(key) : property.restricted;

755 > }

756 >

757 > if (property.experiment) {

758 > if (!property.tags?.some(tag => tag.toLowerCase() === 'onexp')) { configurationRegistry.ts

759 > property.tags = property.tags ?? [];

760 > property.tags.push('onExP');

761 > }

762 > } else if (property.tags?.some(tag => tag.toLowerCase() === 'onexp')) { configurationRegistry.ts

763 console.error(`Invalid tag 'onExP' found for property '${key}'. Please use 'experiment' property instead.`);

764 property.experiment = { mode: 'startup' };

765 }

766 > configurationRegistry.ts

767 > const excluded = properties[key].hasOwnProperty('included') && !properties[key].included;

768 > const policyName = properties[key].policy?.name; configurationRegistry.ts

769 > const policyReferenceName = properties[key].policyReference?.name;

770 >

771 > if (excluded) {

772 this.excludedConfigurationProperties[key] = properties[key];

773 if (policyName) {

780 }

781 delete properties[key];

782 > } else { configurationRegistry.ts

783 > bucket.add(key);

784 > if (policyName) {

785 this.policyConfigurations.set(policyName, key);

786 }

787 > if (policyReferenceName) { configurationRegistry.ts

788 this.addPolicyReferenceConfiguration(policyReferenceName, key);

789 }

790 > this.configurationProperties[key] = properties[key]; configurationRegistry.ts

791 > if (!properties[key].deprecationMessage && properties[key].markdownDeprecationMessage) {

792 // If not set, default deprecationMessage to the markdown source

793 properties[key].deprecationMessage = properties[key].markdownDeprecationMessage;

794 }

795 > } configurationRegistry.ts

796 > configurationRegistry.ts

797 >

798 > }

799 > }

800 > const subNodes = configuration.allOf;

801 > if (subNodes) {

802 for (const node of subNodes) {

803 this.validateAndRegisterProperties(node, validate, extensionInfo, restrictedProperties, scope, bucket);

804 }

805 }

806 > } configurationRegistry.ts

807 > configurationRegistry.ts

808 > private addPolicyReferenceConfiguration(policyName: PolicyName, key: string): void {

809 let keys = this.policyReferenceConfigurations.get(policyName);

810 if (!keys) {

814 keys.add(key);

815 }

816 > configurationRegistry.ts

817 > // Only for tests

818 > getConfigurations(): IConfigurationNode[] {

819 return this.configurationContributors;

820 }

821 > configurationRegistry.ts

822 > getConfigurationProperties(): IStringDictionary<IRegisteredConfigurationPropertySchema> {

823 return this.configurationProperties;

824 }

825 > configurationRegistry.ts

826 > getPolicyConfigurations(): Map<PolicyName, string> {

827 return this.policyConfigurations;

828 }

829 > configurationRegistry.ts

830 > getPolicyReferenceConfigurations(): Map<PolicyName, Set<string>> {

831 return this.policyReferenceConfigurations;

832 }

833 > configurationRegistry.ts

834 > getExcludedConfigurationProperties(): IStringDictionary<IRegisteredConfigurationPropertySchema> {

835 return this.excludedConfigurationProperties;

836 }

837 > configurationRegistry.ts

838 > getRegisteredDefaultConfigurations(): IConfigurationDefaults[] {

839 return [...this.registeredConfigurationDefaults];

840 }

841 > configurationRegistry.ts

842 > getConfigurationDefaultsOverrides(): Map<string, IConfigurationDefaultOverrideValue> {

843 const configurationDefaultsOverrides = new Map<string, IConfigurationDefaultOverrideValue>();

844 for (const [key, value] of this.configurationDefaultsOverrides) {

849 return configurationDefaultsOverrides;

850 }

851 > configurationRegistry.ts

852 > private registerJSONConfiguration(configuration: IConfigurationNode) {

853 > const register = (configuration: IConfigurationNode) => { configurationRegistry.ts

854 > const properties = configuration.properties;

855 > if (properties) {

856 > for (const key in properties) {

857 > this.updateSchema(key, properties[key]); configurationRegistry.ts

858 > }

859 > } configurationRegistry.ts

860 > const subNodes = configuration.allOf;

861 > subNodes?.forEach(register);

862 > };

863 > register(configuration);

864 > }

865 > configurationRegistry.ts

866 > private updateSchema(key: string, property: IConfigurationPropertySchema): void {

867 > allSettings.properties[key] = property; configurationRegistry.ts

868 > switch (property.scope) {

869 > case ConfigurationScope.APPLICATION:

870 > applicationSettings.properties[key] = property; configurationRegistry.ts

871 > break;

872 > case ConfigurationScope.MACHINE: configurationRegistry.ts

873 > machineSettings.properties[key] = property; configurationRegistry.ts

874 > break;

875 > case ConfigurationScope.APPLICATION_MACHINE: configurationRegistry.ts

876 applicationMachineSettings.properties[key] = property;

877 break;

878 > case ConfigurationScope.MACHINE_OVERRIDABLE: configurationRegistry.ts

879 machineOverridableSettings.properties[key] = property;

880 break;

881 > case ConfigurationScope.WINDOW: configurationRegistry.ts

882 windowSettings.properties[key] = property;

883 break;

884 > case ConfigurationScope.RESOURCE: configurationRegistry.ts

885 resourceSettings.properties[key] = property;

886 break;

887 > case ConfigurationScope.LANGUAGE_OVERRIDABLE: configurationRegistry.ts

888 resourceSettings.properties[key] = property;

889 this.resourceLanguageSettingsSchema.properties![key] = property;

890 break;

891 > } configurationRegistry.ts

892 > }

893 > configurationRegistry.ts

894 > private removeFromSchema(key: string, property: IConfigurationPropertySchema): void {

895 delete allSettings.properties[key];

896 switch (property.scope) {

917 }

918 }

919 > configurationRegistry.ts

920 > private updateOverridePropertyPatternKey(): void {

921 for (const overrideIdentifier of this.overrideIdentifiers.values()) {

922 const overrideIdentifierProperty = `[${overrideIdentifier}]`;

937 }

938 }

939 > configurationRegistry.ts

940 > private registerOverridePropertyPatternKey(): void {

941 > const resourceLanguagePropertiesSchema: IJSONSchema = {

942 > type: 'object',

943 > description: nls.localize('overrideSettings.defaultDescription', "Configure editor settings to be overridden for a language."),

944 > errorMessage: nls.localize('overrideSettings.errorMessage', "This setting does not support per-language configuration."),

945 > $ref: resourceLanguageSettingsSchemaId,

946 > };

947 > allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;

948 > applicationSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;

949 > applicationMachineSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;

950 > machineSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;

951 > machineOverridableSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;

952 > windowSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;

953 > resourceSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;

954 > this._onDidSchemaChange.fire();

955 > }

956 >

957 > private updatePropertyDefaultValue(key: string, property: IRegisteredConfigurationPropertySchema): void {

958 > const configurationdefaultOverride = this.configurationDefaultsOverrides.get(key)?.configurationDefaultOverrideValue; configurationRegistry.ts

959 > let defaultValue = undefined;

960 > let defaultSource = undefined;

961 > if (configurationdefaultOverride

962 && (!property.disallowConfigurationDefault || !configurationdefaultOverride.source) // Prevent overriding the default value if the property is disallowed to be overridden by configuration defaults from extensions

963 > ) { configurationRegistry.ts

964 defaultValue = configurationdefaultOverride.value;

965 defaultSource = configurationdefaultOverride.source;

966 }

967 > if (types.isUndefined(defaultValue)) { configurationRegistry.ts

968 > defaultValue = property.defaultDefaultValue; configurationRegistry.ts

969 > defaultSource = undefined;

970 > }

971 > if (types.isUndefined(defaultValue)) { configurationRegistry.ts

972 > defaultValue = getDefaultValue(property.type); configurationRegistry.ts

973 > }

974 > property.default = defaultValue; configurationRegistry.ts

975 > property.defaultValueSource = defaultSource;

976 > }

977 > } configurationRegistry.ts

978 >

979 > const OVERRIDE_IDENTIFIER_PATTERN = `\\[([^\\]]+)\\]`;

980 > const OVERRIDE_IDENTIFIER_REGEX = new RegExp(OVERRIDE_IDENTIFIER_PATTERN, 'g');

981 > export const OVERRIDE_PROPERTY_PATTERN = `^(${OVERRIDE_IDENTIFIER_PATTERN})+$`;

982 > export const OVERRIDE_PROPERTY_REGEX = new RegExp(OVERRIDE_PROPERTY_PATTERN);

983 >

984 > export function overrideIdentifiersFromKey(key: string): string[] {

985 const identifiers: string[] = [];

986 if (OVERRIDE_PROPERTY_REGEX.test(key)) {

996 return distinct(identifiers);

997 }

998 > configurationRegistry.ts

999 > export function keyFromOverrideIdentifiers(overrideIdentifiers: string[]): string {

1000 return overrideIdentifiers.reduce((result, overrideIdentifier) => `${result}[${overrideIdentifier}]`, '');

1001 }

1002 > configurationRegistry.ts

1003 > export function getDefaultValue(type: string | string[] | undefined) {

1004 > const t = Array.isArray(type) ? type[0] : <string>type; configurationRegistry.ts

1005 > switch (t) {

1006 > case 'boolean':

1007 return false;

1008 > case 'integer': configurationRegistry.ts

1009 > case 'number':

1010 return 0;

1011 > case 'string': configurationRegistry.ts

1012 > return ''; configurationRegistry.ts

1013 > case 'array': configurationRegistry.ts

1014 > return []; configurationRegistry.ts

1015 > case 'object': configurationRegistry.ts

1016 return {};

1017 > default: configurationRegistry.ts

1018 return null;

1019 > } configurationRegistry.ts

1020 > }

1021 > configurationRegistry.ts

1022 > const configurationRegistry = new ConfigurationRegistry();

1023 > Registry.add(Extensions.Configuration, configurationRegistry);

1024 >

1025 > export function validateProperty(property: string, schema: IRegisteredConfigurationPropertySchema, extensionId?: string): string | null {

1026 if (!property.trim()) {

1027 return nls.localize('config.property.empty', "Cannot register an empty property");

1041 return null;

1042 }

1043 > configurationRegistry.ts

1044 > export function getScopes(): [string, ConfigurationScope | undefined][] {

1045 const scopes: [string, ConfigurationScope | undefined][] = [];

1046 const configurationProperties = configurationRegistry.getConfigurationProperties();

1052 return scopes;

1053 }

1054 > configurationRegistry.ts

1055 > export function getAllConfigurationProperties(configurationNode: IConfigurationNode[]): IStringDictionary<IRegisteredConfigurationPropertySchema> {

1056 const result: IStringDictionary<IRegisteredConfigurationPropertySchema> = {};

1057 for (const configuration of configurationNode) {

1068 return result;

1069 }

1070 > configurationRegistry.ts

1071 > export function parseScope(scope: string): ConfigurationScope {

1072 switch (scope) {

1073 case 'application':

1085 }

1086 }

1087 > configurationRegistry.ts

1088 > // Used for extension unification. Should be removed when complete.

1089 > export const EXTENSION_UNIFICATION_EXTENSION_IDS: Set<string> = new Set(product.defaultChatAgent ? [product.defaultChatAgent.extensionId, product.defaultChatAgent.chatExtensionId].map(id => id.toLowerCase()) : []);

src/vs/workbench/contrib/chat/common/tools/languageModelToolsService.ts 603 covered LOC · 35 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- languageModelToolsService.ts

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 { Separator } from '../../../../../base/common/actions.js';

7 > import { VSBuffer } from '../../../../../base/common/buffer.js';

8 > import { CancellationToken } from '../../../../../base/common/cancellation.js';

9 > import { Event } from '../../../../../base/common/event.js';

10 > import { IMarkdownString } from '../../../../../base/common/htmlContent.js';

11 > import { Iterable } from '../../../../../base/common/iterator.js';

12 > import { IJSONSchema } from '../../../../../base/common/jsonSchema.js';

13 > import { Disposable, IDisposable, toDisposable } from '../../../../../base/common/lifecycle.js';

14 > import { Schemas } from '../../../../../base/common/network.js';

15 > import { derived, IObservable, IReader, ITransaction, ObservableSet } from '../../../../../base/common/observable.js';

16 > import { ThemeIcon } from '../../../../../base/common/themables.js';

17 > import { URI } from '../../../../../base/common/uri.js';

18 > import { Location } from '../../../../../editor/common/languages.js';

19 > import { localize } from '../../../../../nls.js';

20 > import { ConfirmationOption } from '../../../../../platform/agentHost/common/state/protocol/state.js';

21 > import { ContextKeyExpression, IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';

22 > import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';

23 > import { ByteSize } from '../../../../../platform/files/common/files.js';

24 > import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';

25 > import { IProgress } from '../../../../../platform/progress/common/progress.js';

26 > import { ChatRequestToolReferenceEntry } from '../attachments/chatVariableEntries.js';

27 > import { IVariableReference } from '../chatModes.js';

28 > import { ConfirmedReason, IChatAgentFeedbackReviewConfirmationData, IChatAutomationConfigurationData, IChatAutomationConfiguredData, IChatExtensionsContent, IChatModifiedFilesConfirmationData, IChatSearchToolInvocationData, IChatSessionCreatedData, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, IChatToolInvocation, type IChatTerminalToolInvocationData } from '../chatService/chatService.js';

29 > import { ILanguageModelChatMetadata, LanguageModelPartAudience } from '../languageModels.js';

30 > import { UserSelectedTools } from '../participants/chatAgents.js';

31 > import { PromptElementJSON, stringifyPromptElementJSON } from './promptTsxTypes.js';

32 >

33 > /**

34 > * Selector for matching language models by vendor, family, version, or id.

35 > * Used to filter tools to specific models or model families.

36 > */

37 > export interface ILanguageModelChatSelector {

38 > readonly vendor?: string;

39 > readonly family?: string;

40 > readonly version?: string;

41 > readonly id?: string;

42 > }

43 >

44 > export interface IToolData {

45 > readonly id: string;

46 > readonly source: ToolDataSource;

47 > readonly toolReferenceName?: string;

48 > readonly legacyToolReferenceFullNames?: readonly string[];

49 > readonly icon?: { dark: URI; light?: URI } | ThemeIcon;

50 > readonly when?: ContextKeyExpression;

51 > readonly tags?: readonly string[];

52 > readonly displayName: string;

53 > readonly userDescription?: string;

54 > readonly modelDescription: string;

55 > readonly inputSchema?: IJSONSchema;

56 > readonly canBeReferencedInPrompt?: boolean;

57 > /**

58 > * True if the tool runs in the (possibly remote) workspace, false if it runs

59 > * on the host, undefined if known.

60 > */

61 > readonly runsInWorkspace?: boolean;

62 > readonly alwaysDisplayInputOutput?: boolean;

63 > /** True if this tool might ask for pre-approval */

64 > readonly canRequestPreApproval?: boolean;

65 > /** True if this tool might ask for post-approval */

66 > readonly canRequestPostApproval?: boolean;

67 > /**

68 > * Model selectors that this tool is available for.

69 > * If defined, the tool is only available when the selected model matches one of the selectors.

70 > */

71 > readonly models?: readonly ILanguageModelChatSelector[];

72 > }

73 >

74 > /**

75 > * Check if a tool matches the given model metadata based on the tool's `models` selectors.

76 > * If the tool has no `models` defined, it matches all models.

77 > * If model is undefined, model-specific filtering is skipped (tool is included).

78 > */

79 > export function toolMatchesModel(toolData: IToolData, model: ILanguageModelChatMetadata | undefined): boolean {

80 // If no model selectors are defined, the tool is available for all models

81 if (!toolData.models || toolData.models.length === 0) {

94 );

95 }

96 > languageModelToolsService.ts

97 > export interface IToolProgressStep {

98 > readonly message: string | IMarkdownString | undefined;

99 > /** 0-1 progress of the tool call */

100 > readonly progress?: number;

101 > }

102 >

103 > export type ToolProgress = IProgress<IToolProgressStep>;

104 >

105 > export type ToolDataSource =

106 > | {

107 > type: 'extension';

108 > label: string;

109 > extensionId: ExtensionIdentifier;

110 > }

111 > | {

112 > type: 'mcp';

113 > label: string;

114 > serverLabel: string | undefined;

115 > instructions: string | undefined;

116 > collectionId: string;

117 > definitionId: string;

118 > }

119 > | {

120 > type: 'user';

121 > label: string;

122 > file: URI;

123 > }

124 > | {

125 > type: 'internal';

126 > label: string;

127 > } | {

128 > type: 'external';

129 > label: string;

130 > };

131 >

132 > export namespace ToolDataSource {

133 >

134 > export const Internal: ToolDataSource = { type: 'internal', label: 'Built-In' };

135 >

136 > /** External tools may not be contributed or invoked, but may be invoked externally and described in an IChatToolInvocationSerialized */

137 > export const External: ToolDataSource = { type: 'external', label: 'External' };

138 >

139 > export function toKey(source: ToolDataSource): string {

140 switch (source.type) {

141 case 'extension': return `extension:${source.extensionId.value}`;

146 }

147 }

148 > languageModelToolsService.ts

149 > export function equals(a: ToolDataSource, b: ToolDataSource): boolean {

150 return toKey(a) === toKey(b);

151 }

152 > languageModelToolsService.ts

153 > export function classify(source: ToolDataSource): { readonly ordinal: number; readonly label: string } {

154 if (source.type === 'internal') {

155 return { ordinal: 1, label: localize('builtin', 'Built-In') };

162 }

163 }

164 > } languageModelToolsService.ts

165 >

166 > /**

167 > * Pre-tool-use hook result passed from the extension when the hook was executed externally.

168 > */

169 > export interface IExternalPreToolUseHookResult {

170 > permissionDecision?: 'allow' | 'deny' | 'ask';

171 > permissionDecisionReason?: string;

172 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

173 > updatedInput?: Record<string, any>;

174 > }

175 >

176 > export interface IToolInvocation {

177 > callId: string;

178 > toolId: string;

179 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

180 > parameters: Record<string, any>;

181 > tokenBudget?: number;

182 > context: IToolInvocationContext | undefined;

183 > chatRequestId?: string;

184 > chatInteractionId?: string;

185 > /**

186 > * Optional tool call ID from the chat stream, used to correlate with pending streaming tool calls.

187 > */

188 > chatStreamToolCallId?: string;

189 > /**

190 > * Lets us add some nicer UI to toolcalls that came from a sub-agent, but in the long run, this should probably just be rendered in a similar way to thinking text + tool call groups

191 > */

192 > subAgentInvocationId?: string;

193 > toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData | IChatSessionCreatedData | IChatAutomationConfigurationData | IChatAutomationConfiguredData;

194 > modelId?: string;

195 > userSelectedTools?: UserSelectedTools;

196 > /** The label of the custom button selected by the user during confirmation, if custom buttons were used. */

197 > selectedCustomButton?: string;

198 > /** Pre-tool-use hook result passed from the extension, if the hook was already executed externally. */

199 > preToolUseResult?: IExternalPreToolUseHookResult;

200 > /**

201 > * A confirmation reason resolved out-of-band by the caller (e.g. the agent

202 > * host, which decides auto-approval server-side). When set, the invocation

203 > * is treated as already auto-approved and transitions straight to executing

204 > * without ever entering the `WaitingForConfirmation` state. This avoids a

205 > * transient "needs input" flicker in surfaces (like the sessions list) that

206 > * observe pending confirmations, for tool calls that will be auto-approved

207 > * anyway.

208 > */

209 > preApproved?: ConfirmedReason;

210 > /**

211 > * Optional W3C trace context `traceparent` value identifying the parent distributed

212 > * tracing span for this tool invocation. Forwarded to MCP tool implementations as

213 > * `_meta.traceparent` (MCP SEP-414).

214 > */

215 > traceparent?: string;

216 > /** Optional W3C trace context `tracestate` value paired with {@link traceparent}. */

217 > tracestate?: string;

218 > }

219 >

220 > export interface IToolInvocationContext {

221 > readonly sessionResource: URI;

222 > /**

223 > * The working directory URI associated with this session.

224 > * Only set in the agents window context where each session can

225 > * have its own working directory that differs from the workspace folders.

226 > */

227 > readonly workingDirectory?: URI;

228 > }

229 >

230 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

231 > export function isToolInvocationContext(obj: any): obj is IToolInvocationContext {

232 return obj !== null && typeof obj === 'object' && URI.isUri(obj.sessionResource);

233 }

234 > languageModelToolsService.ts

235 > export interface IToolInvocationPreparationContext {

236 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

237 > parameters: any;

238 > toolCallId: string;

239 > chatRequestId?: string;

240 > chatSessionResource: URI | undefined;

241 > chatInteractionId?: string;

242 > modelId?: string;

243 > /** If set, tells the tool that it should include confirmation messages. */

244 > forceConfirmationReason?: string;

245 > /**

246 > * The working directory URI for the session, if set.

247 > * Used by tools to resolve relative paths and check file access.

248 > */

249 > workingDirectory?: URI;

250 > }

251 >

252 > export type ToolInputOutputBase = {

253 > /** Mimetype of the value, optional */

254 > mimeType?: string;

255 > /** URI of the resource on the MCP server. */

256 > uri?: URI;

257 > /** If true, this part came in as a resource reference rather than direct data. */

258 > asResource?: boolean;

259 > /** Audience of the data part */

260 > audience?: LanguageModelPartAudience[];

261 > };

262 >

263 > export type ToolInputOutputEmbedded = ToolInputOutputBase & {

264 > type: 'embed';

265 > value: string;

266 > /** If true, value is text. If false or not given, value is base64 */

267 > isText?: boolean;

268 > };

269 >

270 > export type ToolInputOutputReference = ToolInputOutputBase & { type: 'ref'; uri: URI };

271 >

272 > export interface IToolResultInputOutputDetails {

273 > readonly input: string;

274 > /** Language identifier for syntax highlighting the input. Defaults to 'json'. */

275 > readonly inputLanguage?: string;

276 > readonly output: (ToolInputOutputEmbedded | ToolInputOutputReference)[];

277 > readonly isError?: boolean;

278 > /** Raw MCP tool result for MCP App UI rendering */

279 > readonly mcpOutput?: unknown;

280 > }

281 >

282 > export interface IToolResultOutputDetails {

283 > readonly output: { type: 'data'; mimeType: string; value: VSBuffer };

284 > }

285 >

286 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

287 > export function isToolResultInputOutputDetails(obj: any): obj is IToolResultInputOutputDetails {

288 return typeof obj === 'object' && typeof obj?.input === 'string' && (typeof obj?.output === 'string' || Array.isArray(obj?.output));

289 }

290 > languageModelToolsService.ts

291 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

292 > export function isToolResultOutputDetails(obj: any): obj is IToolResultOutputDetails {

293 return typeof obj === 'object' && typeof obj?.output === 'object' && typeof obj?.output?.mimeType === 'string' && obj?.output?.type === 'data';

294 }

295 > languageModelToolsService.ts

296 > export interface IToolResult {

297 > content: (IToolResultPromptTsxPart | IToolResultTextPart | IToolResultDataPart)[];

298 > toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData | IChatSessionCreatedData | IChatAutomationConfiguredData;

299 > toolResultMessage?: string | IMarkdownString;

300 > toolResultDetails?: Array<URI | Location> | IToolResultInputOutputDetails | IToolResultOutputDetails;

301 > toolResultError?: string | boolean;

302 > toolMetadata?: unknown;

303 > /** Whether to ask the user to confirm these tool results. Overrides {@link IToolConfirmationMessages.confirmResults}. */

304 > confirmResults?: boolean;

305 > }

306 >

307 > export function toolContentToA11yString(part: IToolResult['content']) {

308 return part.map(p => {

309 switch (p.kind) {

317 }).join(', ');

318 }

319 > languageModelToolsService.ts

320 > export function toolResultHasBuffers(result: IToolResult): boolean {

321 return result.content.some(part => part.kind === 'data');

322 }

323 > languageModelToolsService.ts

324 > export interface IToolResultPromptTsxPart {

325 > kind: 'promptTsx';

326 > value: unknown;

327 > }

328 >

329 > export function stringifyPromptTsxPart(part: IToolResultPromptTsxPart): string {

330 return stringifyPromptElementJSON(part.value as PromptElementJSON);

331 }

332 > languageModelToolsService.ts

333 > export interface IToolResultTextPart {

334 > kind: 'text';

335 > value: string;

336 > audience?: LanguageModelPartAudience[];

337 > title?: string;

338 > }

339 >

340 > export interface IToolResultDataPart {

341 > kind: 'data';

342 > value: {

343 > mimeType: string;

344 > data: VSBuffer;

345 > };

346 > audience?: LanguageModelPartAudience[];

347 > title?: string;

348 > }

349 >

350 > export type IToolApprovalReason =

351 > | { readonly status: 'loading' }

352 > | {

353 > readonly status: 'complete';

354 > readonly explanation: string | IMarkdownString;

355 > readonly safety: number;

356 > };

357 >

358 > export interface IToolConfirmationMessages {

359 > /** Title for the confirmation. If set, the user will be asked to confirm execution of the tool */

360 > title?: string | IMarkdownString;

361 > /** MUST be set if `title` is also set */

362 > message?: string | IMarkdownString;

363 > disclaimer?: string | IMarkdownString;

364 > /** Model-provided assessment of whether automatic approval is safe. */

365 > approvalReason?: IToolApprovalReason;

366 > /** Whether this confirmation is eligible for automatic approval. */

367 > allowAutoConfirm?: boolean;

368 > terminalCustomActions?: ToolConfirmationAction[];

369 > /** If true, confirmation will be requested after the tool executes and before results are sent to the model */

370 > confirmResults?: boolean;

371 > /** If title is not set (no confirmation needed), this reason will be shown to explain why confirmation was not needed */

372 > confirmationNotNeededReason?: string | IMarkdownString;

373 > /** Custom options to display instead of the default Allow/Skip buttons. */

374 > customOptions?: ConfirmationOption[];

375 > /** When set, shows an additional approval option to approve this particular combination of tool and arguments */

376 > approveCombination?: {

377 > /** Human-readable label for the approval option */

378 > label: string | IMarkdownString;

379 > /** Precomputed SHA-256 key for the combination (set during tool preparation) */

380 > key: string;

381 > /** String representation of the arguments for this combination */

382 > arguments?: string;

383 > };

384 > }

385 >

386 > export interface IToolConfirmationAction {

387 > label: string;

388 > disabled?: boolean;

389 > tooltip?: string;

390 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

391 > data: any;

392 > }

393 >

394 > export type ToolConfirmationAction = IToolConfirmationAction | Separator;

395 >

396 > export enum ToolInvocationPresentation {

397 > Hidden = 'hidden',

398 > HiddenAfterComplete = 'hiddenAfterComplete'

399 > }

400 >

401 > export interface IToolInvocationStreamContext {

402 > toolCallId: string;

403 > rawInput: unknown;

404 > chatRequestId?: string;

405 > chatSessionResource?: URI;

406 > chatInteractionId?: string;

407 > }

408 >

409 > export interface IStreamedToolInvocation {

410 > invocationMessage?: string | IMarkdownString;

411 > }

412 >

413 > export interface IPreparedToolInvocation {

414 > invocationMessage?: string | IMarkdownString;

415 > pastTenseMessage?: string | IMarkdownString;

416 > originMessage?: string | IMarkdownString;

417 > confirmationMessages?: IToolConfirmationMessages;

418 > presentation?: ToolInvocationPresentation;

419 > icon?: ThemeIcon;

420 > toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData | IChatSessionCreatedData | IChatAutomationConfigurationData | IChatAutomationConfiguredData;

421 > }

422 >

423 > export interface IToolImpl {

424 > invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;

425 > prepareToolInvocation?(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;

426 > handleToolStream?(context: IToolInvocationStreamContext, token: CancellationToken): Promise<IStreamedToolInvocation | undefined>;

427 > }

428 >

429 > export interface IToolSet {

430 > readonly id: string;

431 > readonly referenceName: string;

432 > readonly icon: ThemeIcon;

433 > readonly source: ToolDataSource;

434 > readonly description?: string;

435 > /** A longer, human-readable description of what the tool set is for, shown as a subtitle in the Chat Customizations "Tools" section. */

436 > readonly detail?: string;

437 > readonly legacyFullNames?: string[];

438 > /** When true, this tool set is deprecated: it is hidden from the Chat Customizations "Tools" section and these groupings will be removed when the Local harness is dropped. */

439 > readonly deprecated?: boolean;

440 > /** When true, this tool set is hidden from the chat tools picker (e.g. a customizations-only grouping). */

441 > readonly hiddenInToolsPicker?: boolean;

442 >

443 > getTools(r?: IReader): Iterable<IToolData>;

444 > }

445 >

446 >

447 >

448 > /**

449 > * Maps tools and tool sets to their enablement state. Use a class to control creation of the map and ensure

450 > * that it is not mutated after creation.

451 > */

452 > export class ToolAndToolSetEnablementMap implements Iterable<[IToolData | IToolSet, boolean]> {

453 >

454 > static fromEntries(entries: Iterable<[IToolData | IToolSet, boolean]>): ToolAndToolSetEnablementMap {

455 > return new ToolAndToolSetEnablementMap(new Map(entries));

456 > }

457 >

458 > static fromMap(map: Map<IToolData | IToolSet, boolean>): ToolAndToolSetEnablementMap {

459 return new ToolAndToolSetEnablementMap(new Map(map));

460 }

461 > languageModelToolsService.ts

462 > private constructor(private readonly _map: Map<IToolData | IToolSet, boolean>) {

463 }

464 > languageModelToolsService.ts

465 > [Symbol.iterator](): IterableIterator<[IToolData | IToolSet, boolean]> {

466 return this._map[Symbol.iterator]();

467 }

468 > languageModelToolsService.ts

469 > public get(toolOrToolSet: IToolData | IToolSet): boolean | undefined {

470 return this._map.get(toolOrToolSet);

471 }

472 > languageModelToolsService.ts

473 > public has(toolOrToolSet: IToolData | IToolSet): boolean {

474 return this._map.has(toolOrToolSet);

475 }

476 > languageModelToolsService.ts

477 > public get size(): number {

478 return this._map.size;

479 }

480 > languageModelToolsService.ts

481 > public entries(): IterableIterator<[IToolData | IToolSet, boolean]> {

482 return this._map.entries();

483 }

484 > } languageModelToolsService.ts

485 >

486 > export function isToolSet(obj: IToolData | IToolSet | undefined): obj is IToolSet {

487 return !!obj && (obj as IToolSet).getTools !== undefined;

488 }

489 > languageModelToolsService.ts

490 > export class ToolSet implements IToolSet {

491 >

492 > protected readonly _tools = new ObservableSet<IToolData>();

493 >

494 > protected readonly _toolSets = new ObservableSet<IToolSet>();

495 >

496 > /**

497 > * A homogenous tool set only contains tools from the same source as the tool set itself

498 > */

499 > readonly isHomogenous: IObservable<boolean>;

500 >

501 > constructor(

502 readonly id: string,

503 readonly referenceName: string,

517 });

518 }

519 > languageModelToolsService.ts

520 > addTool(data: IToolData, tx?: ITransaction): IDisposable {

521 this._tools.add(data, tx);

522 return toDisposable(() => {

524 });

525 }

526 > languageModelToolsService.ts

527 > addToolSet(toolSet: IToolSet, tx?: ITransaction): IDisposable {

528 if (toolSet === this) {

529 return Disposable.None;

534 });

535 }

536 > languageModelToolsService.ts

537 > getTools(r?: IReader): Iterable<IToolData> {

538 return Iterable.concat(

539 Iterable.filter(this._tools.observable.read(r), toolData => this._contextKeyService.contextMatchesRules(toolData.when)),

541 );

542 }

543 > } languageModelToolsService.ts

544 >

545 > export class ToolSetForModel {

546 > public get id() {

547 > return this._toolSet.id;

548 > }

549 >

550 > public get referenceName() {

551 return this._toolSet.referenceName;

552 }

553 > languageModelToolsService.ts

554 > public get icon() {

555 return this._toolSet.icon;

556 }

557 > languageModelToolsService.ts

558 > public get source() {

559 return this._toolSet.source;

560 }

561 > languageModelToolsService.ts

562 > public get description() {

563 return this._toolSet.description;

564 }

565 > languageModelToolsService.ts

566 > public get detail() {

567 return this._toolSet.detail;

568 }

569 > languageModelToolsService.ts

570 > public get legacyFullNames() {

571 return this._toolSet.legacyFullNames;

572 }

573 > languageModelToolsService.ts

574 > public get deprecated() {

575 return this._toolSet.deprecated;

576 }

577 > languageModelToolsService.ts

578 > public get hiddenInToolsPicker() {

579 return this._toolSet.hiddenInToolsPicker;

580 }

581 > languageModelToolsService.ts

582 > constructor(

583 private readonly _toolSet: IToolSet,

584 private readonly model: ILanguageModelChatMetadata | undefined,

585 private readonly toolFilter?: (toolData: IToolData) => boolean,

586 ) { }

587 > languageModelToolsService.ts

588 > public getTools(r?: IReader): Iterable<IToolData> {

589 return Iterable.filter(this._toolSet.getTools(r), toolData => toolMatchesModel(toolData, this.model) && (!this.toolFilter || this.toolFilter(toolData)));

590 }

591 > } languageModelToolsService.ts

592 >

593 >

594 > export interface IBeginToolCallOptions {

595 > toolCallId: string;

596 > toolId: string;

597 > chatRequestId?: string;

598 > sessionResource?: URI;

599 > subagentInvocationId?: string;

600 > /**

601 > * Create the streaming invocation even when the tool does not

602 > * implement `handleToolStream`. Used by callers that need a

603 > * `ChatToolInvocation` handle to observe state transitions (e.g.

604 > * confirmation) before invoking the tool.

605 > */

606 > force?: boolean;

607 > }

608 >

609 > export interface IToolInvokedEvent {

610 > readonly toolId: string;

611 > readonly sessionResource: URI | undefined;

612 > readonly requestId: string | undefined;

613 > readonly subagentInvocationId: string | undefined;

614 > }

615 >

616 > export const ILanguageModelToolsService = createDecorator<ILanguageModelToolsService>('ILanguageModelToolsService');

617 >

618 > export type CountTokensCallback = (input: string, token: CancellationToken) => Promise<number>;

619 >

620 > export interface ILanguageModelToolsService {

621 > _serviceBrand: undefined;

622 > readonly vscodeToolSet: ToolSet;

623 > readonly executeToolSet: ToolSet;

624 > readonly readToolSet: ToolSet;

625 > readonly agentToolSet: ToolSet;

626 > readonly onDidChangeTools: Event<void>;

627 > readonly onDidPrepareToolCallBecomeUnresponsive: Event<{ readonly sessionResource: URI; readonly toolData: IToolData }>;

628 > readonly onDidInvokeTool: Event<IToolInvokedEvent>;

629 > registerToolData(toolData: IToolData): IDisposable;

630 > registerToolImplementation(id: string, tool: IToolImpl): IDisposable;

631 > registerTool(toolData: IToolData, tool: IToolImpl): IDisposable;

632 >

633 > /**

634 > * Get all tools currently enabled (matching `when` clauses and model).

635 > * @param model The language model metadata to filter tools by. If undefined, model-specific filtering is skipped.

636 > */

637 > getTools(model: ILanguageModelChatMetadata | undefined): Iterable<IToolData>;

638 >

639 > /**

640 > * Creats an observable of enabled tools in the context. Note the observable

641 > * should be created and reused, not created per reader, for example:

642 > *

643 > * ```

644 > * const toolsObs = toolsService.observeTools(model);

645 > * autorun(reader => {

646 > * const tools = toolsObs.read(reader);

647 > * ...

648 > * });

649 > * ```

650 > * @param model The language model metadata to filter tools by. If undefined, model-specific filtering is skipped.

651 > */

652 > observeTools(model: ILanguageModelChatMetadata | undefined): IObservable<readonly IToolData[]>;

653 >

654 > /**

655 > * Get all registered tools regardless of enablement state.

656 > * Use this for configuration UIs, completions, etc. where all tools should be visible.

657 > */

658 > getAllToolsIncludingDisabled(): Iterable<IToolData>;

659 >

660 > /**

661 > * Get a tool by its ID. Does not check when clauses.

662 > */

663 > getTool(id: string): IToolData | undefined;

664 >

665 > /**

666 > * Get a tool by its reference name. Does not check when clauses.

667 > */

668 > getToolByName(name: string): IToolData | undefined;

669 >

670 > /**

671 > * Begin a tool call in the streaming phase.

672 > * Creates a ChatToolInvocation in the Streaming state and appends it to the chat.

673 > * Returns the invocation so it can be looked up later when invokeTool is called.

674 > */

675 > beginToolCall(options: IBeginToolCallOptions): IChatToolInvocation | undefined;

676 >

677 > /**

678 > * Update the streaming state of a pending tool call.

679 > * Calls the tool's handleToolStream method to get a custom invocation message.

680 > */

681 > updateToolStream(toolCallId: string, partialInput: unknown, token: CancellationToken): Promise<void>;

682 >

683 > invokeTool(invocation: IToolInvocation, countTokens: CountTokensCallback, token: CancellationToken): Promise<IToolResult>;

684 > cancelToolCallsForRequest(requestId: string): void;

685 > /** Flush any pending tool updates to the extension hosts. */

686 > flushToolUpdates(): void;

687 >

688 > readonly toolSets: IObservable<Iterable<IToolSet>>;

689 > getToolSetsForModel(model: ILanguageModelChatMetadata | undefined, reader?: IReader): Iterable<IToolSet>;

690 > getToolSet(id: string): IToolSet | undefined;

691 > getToolSetByName(name: string): IToolSet | undefined;

692 > createToolSet(source: ToolDataSource, id: string, referenceName: string, options?: { icon?: ThemeIcon; description?: string; detail?: string; legacyFullNames?: string[]; deprecated?: boolean; hiddenInToolsPicker?: boolean }): ToolSet & IDisposable;

693 >

694 > // tool names in prompt and agent files ('full reference names')

695 > getFullReferenceNames(): Iterable<string>;

696 > getFullReferenceName(tool: IToolData | IToolSet, toolSet?: IToolSet): string;

697 > getFullReferenceNameMap(): Map<IToolData | IToolSet, string>;

698 > getToolByFullReferenceName(fullReferenceName: string): IToolData | IToolSet | undefined;

699 > getDeprecatedFullReferenceNames(): Map<string, Set<string>>;

700 >

701 > /**

702 > * Gets the enablement maps based on the given set of references.

703 > * @param fullReferenceNames The full reference names of the tools and tool sets to enable.

704 > * @param model Optional language model metadata to filter tools by.

705 > * If undefined is passed, all tools will be returned, even if normally disabled.

706 > */

707 > toToolAndToolSetEnablementMap(fullReferenceNames: readonly string[], model: ILanguageModelChatMetadata | undefined): ToolAndToolSetEnablementMap;

708 >

709 > toFullReferenceNames(map: ToolAndToolSetEnablementMap): string[];

710 > toToolReferences(variableReferences: readonly IVariableReference[]): ChatRequestToolReferenceEntry[];

711 > }

712 >

713 >

714 > export function createToolInputUri(toolCallId: string): URI {

715 return URI.from({ scheme: Schemas.inMemory, path: `/lm/tool/${toolCallId}/tool_input.json` });

716 }

717 > languageModelToolsService.ts

718 > export function createToolSchemaUri(toolOrId: IToolData | string): URI {

719 if (typeof toolOrId !== 'string') {

720 toolOrId = toolOrId.id;

722 return URI.from({ scheme: Schemas.vscode, authority: 'schemas', path: `/lm/tool/${toolOrId}` });

723 }

724 > languageModelToolsService.ts

725 > export namespace SpecedToolAliases {

726 > export const execute = 'execute';

727 > export const edit = 'edit';

728 > export const search = 'search';

729 > export const agent = 'agent';

730 > export const read = 'read';

731 > export const web = 'web';

732 > export const todo = 'todo';

733 > }

734 >

735 > export namespace VSCodeToolReference {

736 > export const runSubagent = 'runSubagent';

737 > export const vscode = 'vscode';

738 >

739 > }

src/vs/base/common/lifecycle.ts 542 covered LOC · 122 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- lifecycle.ts

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 { compareBy, numberComparator } from './arrays.js';

7 > import { groupBy } from './collections.js';

8 > import { SetMap, ResourceMap } from './map.js';

9 > import { URI } from './uri.js';

10 > import { createSingleCallFunction } from './functional.js';

11 > import { Iterable } from './iterator.js';

12 > import { BugIndicatingError, onUnexpectedError } from './errors.js';

13 >

14 > // #region Disposable Tracking

15 >

16 > /**

17 > * Enables logging of potentially leaked disposables.

18 > *

19 > * A disposable is considered leaked if it is not disposed or not registered as the child of

20 > * another disposable. This tracking is very simple an only works for classes that either

21 > * extend Disposable or use a DisposableStore. This means there are a lot of false positives.

22 > */

23 > const TRACK_DISPOSABLES = false;

24 > let disposableTracker: IDisposableTracker | null = null;

25 >

26 > export interface IDisposableTracker {

27 > /**

28 > * Is called on construction of a disposable.

29 > */

30 > trackDisposable(disposable: IDisposable): void;

31 >

32 > /**

33 > * Is called when a disposable is registered as child of another disposable (e.g. {@link DisposableStore}).

34 > * If parent is `null`, the disposable is removed from its former parent.

35 > */

36 > setParent(child: IDisposable, parent: IDisposable | null): void;

37 >

38 > /**

39 > * Is called after a disposable is disposed.

40 > */

41 > markAsDisposed(disposable: IDisposable): void;

42 >

43 > /**

44 > * Indicates that the given object is a singleton which does not need to be disposed.

45 > */

46 > markAsSingleton(disposable: IDisposable): void;

47 > }

48 >

49 > export class GCBasedDisposableTracker implements IDisposableTracker {

50

51 private readonly _registry = new FinalizationRegistry<string>(heldValue => {

52 console.warn(`[LEAKED DISPOSABLE] ${heldValue}`);

53 });

54 > lifecycle.ts

55 > trackDisposable(disposable: IDisposable): void {

56 const stack = new Error('CREATED via:').stack!;

57 this._registry.register(disposable, stack, disposable);

58 }

59 > lifecycle.ts

60 > setParent(child: IDisposable, parent: IDisposable | null): void {

61 if (parent) {

62 this._registry.unregister(child);

65 }

66 }

67 > lifecycle.ts

68 > markAsDisposed(disposable: IDisposable): void {

69 this._registry.unregister(disposable);

70 }

71 > lifecycle.ts

72 > markAsSingleton(disposable: IDisposable): void {

73 this._registry.unregister(disposable);

74 }

75 > } lifecycle.ts

76 >

77 > export interface DisposableInfo {

78 > value: IDisposable;

79 > source: string | null;

80 > parent: IDisposable | null;

81 > isSingleton: boolean;

82 > idx: number;

83 > }

84 >

85 > export class DisposableTracker implements IDisposableTracker {

86 > private static idx = 0; lifecycle.ts

87 >

88 > private readonly livingDisposables = new Map<IDisposable, DisposableInfo>();

89 > lifecycle.ts

90 > private getDisposableData(d: IDisposable): DisposableInfo {

91 > let val = this.livingDisposables.get(d); lifecycle.ts

92 > if (!val) {

93 > val = { parent: null, source: null, isSingleton: false, value: d, idx: DisposableTracker.idx++ };

94 > this.livingDisposables.set(d, val);

95 > }

96 > return val;

97 > }

98 > lifecycle.ts

99 > trackDisposable(d: IDisposable): void {

100 > const data = this.getDisposableData(d); lifecycle.ts

101 > if (!data.source) {

102 > data.source =

103 > new Error().stack!;

104 > }

105 > }

106 > lifecycle.ts

107 > setParent(child: IDisposable, parent: IDisposable | null): void {

108 > const data = this.getDisposableData(child); lifecycle.ts

109 > data.parent = parent;

110 > }

111 > lifecycle.ts

112 > markAsDisposed(x: IDisposable): void {

113 > this.livingDisposables.delete(x); lifecycle.ts

114 > }

115 > lifecycle.ts

116 > markAsSingleton(disposable: IDisposable): void {

117 this.getDisposableData(disposable).isSingleton = true;

118 }

119 > lifecycle.ts

120 > private getRootParent(data: DisposableInfo, cache: Map<DisposableInfo, DisposableInfo>): DisposableInfo {

121 const cacheValue = cache.get(data);

122 if (cacheValue) {

128 return result;

129 }

130 > lifecycle.ts

131 > getTrackedDisposables(): IDisposable[] {

132 const rootParentCache = new Map<DisposableInfo, DisposableInfo>();

133

138 return leaking;

139 }

140 > lifecycle.ts

141 > computeLeakingDisposables(maxReported = 10, preComputedLeaks?: DisposableInfo[]): { leaks: DisposableInfo[]; details: string } | undefined {

142 > let uncoveredLeakingObjs: DisposableInfo[] | undefined; lifecycle.ts

143 > if (preComputedLeaks) {

144 uncoveredLeakingObjs = preComputedLeaks;

145 > } else { lifecycle.ts

146 > const rootParentCache = new Map<DisposableInfo, DisposableInfo>();

147 >

148 > const leakingObjects = [...this.livingDisposables.values()]

149 > .filter((info) => info.source !== null && !this.getRootParent(info, rootParentCache).isSingleton);

150 >

151 > if (leakingObjects.length === 0) {

152 > return; lifecycle.ts

153 > }

154 const leakingObjsSet = new Set(leakingObjects.map(o => o.value));

155

162 throw new Error('There are cyclic diposable chains!');

163 }

164 > } lifecycle.ts

165

166 if (!uncoveredLeakingObjs) {

224

225 return { leaks: uncoveredLeakingObjs, details: message };

226 > } lifecycle.ts

227 > } lifecycle.ts

228 >

229 > export function setDisposableTracker(tracker: IDisposableTracker | null): void {

230 > disposableTracker = tracker; lifecycle.ts

231 > }

232 > lifecycle.ts

233 > if (TRACK_DISPOSABLES) {

234 const __is_disposable_tracked__ = '__is_disposable_tracked__';

235 setDisposableTracker(new class implements IDisposableTracker {

268 });

269 }

270 > lifecycle.ts

271 > export function trackDisposable<T extends IDisposable>(x: T): T {

272 > disposableTracker?.trackDisposable(x); lifecycle.ts

273 > return x;

274 > }

275 > lifecycle.ts

276 > export function markAsDisposed(disposable: IDisposable): void {

277 > disposableTracker?.markAsDisposed(disposable); lifecycle.ts

278 > }

279 > lifecycle.ts

280 > function setParentOfDisposable(child: IDisposable, parent: IDisposable | null): void { lifecycle.ts

281 > disposableTracker?.setParent(child, parent);

282 > }

283 > lifecycle.ts

284 function setParentOfDisposables(children: IDisposable[], parent: IDisposable | null): void {

285 if (!disposableTracker) {

290 }

291 }

292 > lifecycle.ts

293 > /**

294 > * Indicates that the given object is a singleton which does not need to be disposed.

295 > */

296 > export function markAsSingleton<T extends IDisposable>(singleton: T): T {

297 disposableTracker?.markAsSingleton(singleton);

298 return singleton;

299 }

300 > lifecycle.ts

301 > // #endregion

302 >

303 > /**

304 > * An object that performs a cleanup operation when `.dispose()` is called.

305 > *

306 > * Some examples of how disposables are used:

307 > *

308 > * - An event listener that removes itself when `.dispose()` is called.

309 > * - A resource such as a file system watcher that cleans up the resource when `.dispose()` is called.

310 > * - The return value from registering a provider. When `.dispose()` is called, the provider is unregistered.

311 > */

312 > export interface IDisposable {

313 > dispose(): void;

314 > }

315 >

316 > /**

317 > * Check if `thing` is {@link IDisposable disposable}.

318 > */

319 > export function isDisposable<E>(thing: E): thing is E & IDisposable {

320 // eslint-disable-next-line local/code-no-any-casts

321 return typeof thing === 'object' && thing !== null && typeof (<IDisposable><any>thing).dispose === 'function' && (<IDisposable><any>thing).dispose.length === 0;

322 }

323 > lifecycle.ts

324 > /**

325 > * Disposes of the value(s) passed in.

326 > */

327 > export function dispose<T extends IDisposable>(disposable: T): T;

328 > export function dispose<T extends IDisposable>(disposable: T | undefined): T | undefined;

329 > export function dispose<T extends IDisposable, A extends Iterable<T> = Iterable<T>>(disposables: A): A;

330 > export function dispose<T extends IDisposable>(disposables: Array<T>): Array<T>;

331 > export function dispose<T extends IDisposable>(disposables: ReadonlyArray<T>): ReadonlyArray<T>;

332 > export function dispose<T extends IDisposable>(arg: T | Iterable<T> | undefined): any {

333 > if (Iterable.is(arg)) { lifecycle.ts

334 > const errors: any[] = []; lifecycle.ts

335 >

336 > for (const d of arg) {

337 > if (d) { lifecycle.ts

338 > try {

339 > d.dispose();

340 > } catch (e) {

341 errors.push(e);

342 }

343 > } lifecycle.ts

344 > }

345 > lifecycle.ts

346 > if (errors.length === 1) {

347 throw errors[0];

348 > } else if (errors.length > 1) { lifecycle.ts

349 throw new AggregateError(errors, 'Encountered errors while disposing of store');

350 }

351 > lifecycle.ts

352 > return Array.isArray(arg) ? [] : arg; lifecycle.ts

353 > } else if (arg) { lifecycle.ts

354 arg.dispose();

355 return arg;

356 }

357 > } lifecycle.ts

358 > lifecycle.ts

359 > export function disposeIfDisposable<T extends IDisposable | object>(disposables: Array<T>): Array<T> {

360 for (const d of disposables) {

361 if (isDisposable(d)) {

365 return [];

366 }

367 > lifecycle.ts

368 > /**

369 > * Combine multiple disposable values into a single {@link IDisposable}.

370 > */

371 > export function combinedDisposable(...disposables: IDisposable[]): IDisposable {

372 const parent = toDisposable(() => dispose(disposables));

373 setParentOfDisposables(disposables, parent);

374 return parent;

375 }

376 > lifecycle.ts

377 > class FunctionDisposable implements IDisposable {

378 > private _isDisposed: boolean;

379 > private readonly _fn: () => void;

380 >

381 > constructor(fn: () => void) {

382 this._isDisposed = false;

383 this._fn = fn;

384 trackDisposable(this);

385 }

386 > lifecycle.ts

387 > dispose() {

388 if (this._isDisposed) {

389 return;

396 this._fn();

397 }

398 > } lifecycle.ts

399 >

400 > /**

401 > * Turn a function that implements dispose into an {@link IDisposable}.

402 > *

403 > * @param fn Clean up function, guaranteed to be called only **once**.

404 > */

405 > export function toDisposable(fn: () => void): IDisposable {

406 return new FunctionDisposable(fn);

407 }

408 > lifecycle.ts

409 > /**

410 > * Manages a collection of disposable values.

411 > *

412 > * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an

413 > * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a

414 > * store that has already been disposed of.

415 > */

416 > export class DisposableStore implements IDisposable {

417 >

418 > static DISABLE_DISPOSED_WARNING = false;

419 >

420 > private readonly _toDispose = new Set<IDisposable>();

421 > private _isDisposed = false;

422 >

423 > constructor() {

424 > trackDisposable(this); lifecycle.ts

425 > }

426 > lifecycle.ts

427 > /**

428 > * Dispose of all registered disposables and mark this object as disposed.

429 > *

430 > * Any future disposables added to this object will be disposed of on `add`.

431 > */

432 > public dispose(): void {

433 > if (this._isDisposed) { lifecycle.ts

434 return;

435 }

436 > lifecycle.ts

437 > markAsDisposed(this);

438 > this._isDisposed = true;

439 > this.clear();

440 > }

441 > lifecycle.ts

442 > /**

443 > * @return `true` if this object has been disposed of.

444 > */

445 > public get isDisposed(): boolean {

446 return this._isDisposed;

447 }

448 > lifecycle.ts

449 > /**

450 > * Dispose of all registered disposables but do not mark this object as disposed.

451 > */

452 > public clear(): void {

453 > if (this._toDispose.size === 0) { lifecycle.ts

454 > return; lifecycle.ts

455 > }

456 > lifecycle.ts

457 > try {

458 > dispose(this._toDispose);

459 > } finally {

460 > this._toDispose.clear();

461 > }

462 > } lifecycle.ts

463 > lifecycle.ts

464 > /**

465 > * Add a new {@link IDisposable disposable} to the collection.

466 > */

467 > public add<T extends IDisposable>(o: T): T {

468 > if (!o || o === Disposable.None) { lifecycle.ts

469 return o;

470 }

471 > if ((o as unknown as DisposableStore) === this) { lifecycle.ts

472 throw new Error('Cannot register a disposable on itself!');

473 }

474 > lifecycle.ts

475 > setParentOfDisposable(o, this);

476 > if (this._isDisposed) {

477 if (!DisposableStore.DISABLE_DISPOSED_WARNING) {

478 console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack);

479 }

480 > } else { lifecycle.ts

481 > this._toDispose.add(o);

482 > }

483 >

484 > return o;

485 > } lifecycle.ts

486 > lifecycle.ts

487 > /**

488 > * Deletes a disposable from store and disposes of it. This will not throw or warn and proceed to dispose the

489 > * disposable even when the disposable is not part in the store.

490 > */

491 > public delete<T extends IDisposable>(o: T): void {

492 if (!o) {

493 return;

499 o.dispose();

500 }

501 > lifecycle.ts

502 > /**

503 > * Deletes the value from the store, but does not dispose it.

504 > */

505 > public deleteAndLeak<T extends IDisposable>(o: T): void {

506 if (!o) {

507 return;

511 }

512 }

513 > lifecycle.ts

514 > public assertNotDisposed(): void {

515 if (this._isDisposed) {

516 onUnexpectedError(new BugIndicatingError('Object disposed'));

517 }

518 }

519 > } lifecycle.ts

520 >

521 > /**

522 > * Abstract base class for a {@link IDisposable disposable} object.

523 > *

524 > * Subclasses can {@linkcode _register} disposables that will be automatically cleaned up when this object is disposed of.

525 > */

526 > export abstract class Disposable implements IDisposable {

527 >

528 > /**

529 > * A disposable that does nothing when it is disposed of.

530 > *

531 > * TODO: This should not be a static property.

532 > */

533 > static readonly None = Object.freeze<IDisposable>({ dispose() { } });

534 >

535 > protected readonly _store = new DisposableStore();

536 >

537 > constructor() {

538 > trackDisposable(this); lifecycle.ts

539 > setParentOfDisposable(this._store, this);

540 > }

541 > lifecycle.ts

542 > public dispose(): void {

543 > markAsDisposed(this); lifecycle.ts

544 >

545 > this._store.dispose();

546 > }

547 > lifecycle.ts

548 > /**

549 > * Adds `o` to the collection of disposables managed by this object.

550 > */

551 > protected _register<T extends IDisposable>(o: T): T {

552 > if ((o as unknown as Disposable) === this) { lifecycle.ts

553 throw new Error('Cannot register a disposable on itself!');

554 }

555 > return this._store.add(o); lifecycle.ts

556 > }

557 > } lifecycle.ts

558 >

559 > /**

560 > * Manages the lifecycle of a disposable value that may be changed.

561 > *

562 > * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can

563 > * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.

564 > */

565 > export class MutableDisposable<T extends IDisposable> implements IDisposable {

566 > private _value?: T;

567 > private _isDisposed = false;

568 >

569 > constructor() {

570 trackDisposable(this);

571 }

572 > lifecycle.ts

573 > /**

574 > * Get the currently held disposable value, or `undefined` if this MutableDisposable has been disposed

575 > */

576 > get value(): T | undefined {

577 return this._isDisposed ? undefined : this._value;

578 }

579 > lifecycle.ts

580 > /**

581 > * Set a new disposable value.

582 > *

583 > * Behaviour:

584 > * - If the MutableDisposable has been disposed, the setter is a no-op.

585 > * - If the new value is strictly equal to the current value, the setter is a no-op.

586 > * - Otherwise the previous value (if any) is disposed and the new value is stored.

587 > *

588 > * Related helpers:

589 > * - clear() resets the value to `undefined` (and disposes the previous value).

590 > * - clearAndLeak() returns the old value without disposing it and removes its parent.

591 > */

592 > set value(value: T | undefined) {

593 if (this._isDisposed || value === this._value) {

594 return;

601 this._value = value;

602 }

603 > lifecycle.ts

604 > /**

605 > * Resets the stored value and disposed of the previously stored value.

606 > */

607 > clear(): void {

608 this.value = undefined;

609 }

610 > lifecycle.ts

611 > dispose(): void {

612 this._isDisposed = true;

613 markAsDisposed(this);

615 this._value = undefined;

616 }

617 > lifecycle.ts

618 > /**

619 > * Clears the value, but does not dispose it.

620 > * The old value is returned.

621 > */

622 > clearAndLeak(): T | undefined {

623 const oldValue = this._value;

624 this._value = undefined;

628 return oldValue;

629 }

630 > } lifecycle.ts

631 >

632 > /**

633 > * Manages the lifecycle of a disposable value that may be changed like {@link MutableDisposable}, but the value must

634 > * exist and cannot be undefined.

635 > */

636 > export class MandatoryMutableDisposable<T extends IDisposable> implements IDisposable {

637 > private readonly _disposable = new MutableDisposable<T>();

638 > private _isDisposed = false;

639 >

640 > constructor(initialValue: T) {

641 this._disposable.value = initialValue;

642 }

643 > lifecycle.ts

644 > get value(): T {

645 return this._disposable.value!;

646 }

647 > lifecycle.ts

648 > set value(value: T) {

649 if (this._isDisposed || value === this._disposable.value) {

650 return;

652 this._disposable.value = value;

653 }

654 > lifecycle.ts

655 > dispose() {

656 this._isDisposed = true;

657 this._disposable.dispose();

658 }

659 > } lifecycle.ts

660 >

661 > export class RefCountedDisposable {

662 >

663 > private _counter: number = 1;

664 >

665 > constructor(

666 private readonly _disposable: IDisposable,

667 ) { }

668 > lifecycle.ts

669 > acquire() {

670 this._counter++;

671 return this;

672 }

673 > lifecycle.ts

674 > release() {

675 if (--this._counter === 0) {

676 this._disposable.dispose();

678 return this;

679 }

680 > } lifecycle.ts

681 >

682 > export interface IReference<T> extends IDisposable {

683 > readonly object: T;

684 > }

685 >

686 > export abstract class ReferenceCollection<T> {

687

688 private readonly references: Map<string, { readonly object: T; counter: number }> = new Map();

689 > lifecycle.ts

690 > acquire(key: string, ...args: unknown[]): IReference<T> {

691 let reference = this.references.get(key);

692

708 return { object, dispose };

709 }

710 > lifecycle.ts

711 > protected abstract createReferencedObject(key: string, ...args: unknown[]): T;

712 > protected abstract destroyReferencedObject(key: string, object: T): void;

713 > }

714 >

715 > /**

716 > * Unwraps a reference collection of promised values. Makes sure

717 > * references are disposed whenever promises get rejected.

718 > */

719 > export class AsyncReferenceCollection<T> {

720 >

721 > constructor(private referenceCollection: ReferenceCollection<Promise<T>>) { }

722 >

723 > async acquire(key: string, ...args: unknown[]): Promise<IReference<T>> {

724 const ref = this.referenceCollection.acquire(key, ...args);

725

736 }

737 }

738 > } lifecycle.ts

739 >

740 > export class ImmortalReference<T> implements IReference<T> {

741 > constructor(public object: T) { }

742 > dispose(): void { /* noop */ }

743 > }

744 >

745 > export function disposeOnReturn(fn: (store: DisposableStore) => void): void {

746 const store = new DisposableStore();

747 try {

751 }

752 }

753 > lifecycle.ts

754 > /**

755 > * A map the manages the lifecycle of the values that it stores.

756 > */

757 > export class DisposableMap<K, V extends IDisposable = IDisposable> implements IDisposable {

758 >

759 > private readonly _store: Map<K, V>;

760 > private _isDisposed = false;

761 >

762 > constructor(store: Map<K, V> = new Map<K, V>()) {

763 this._store = store;

764 trackDisposable(this);

765 }

766 > lifecycle.ts

767 > /**

768 > * Disposes of all stored values and mark this object as disposed.

769 > *

770 > * Trying to use this object after it has been disposed of is an error.

771 > */

772 > dispose(): void {

773 markAsDisposed(this);

774 this._isDisposed = true;

775 this.clearAndDisposeAll();

776 }

777 > lifecycle.ts

778 > /**

779 > * Disposes of all stored values and clear the map, but DO NOT mark this object as disposed.

780 > */

781 > clearAndDisposeAll(): void {

782 if (!this._store.size) {

783 return;

790 }

791 }

792 > lifecycle.ts

793 > has(key: K): boolean {

794 return this._store.has(key);

795 }

796 > lifecycle.ts

797 > get size(): number {

798 return this._store.size;

799 }

800 > lifecycle.ts

801 > get(key: K): V | undefined {

802 return this._store.get(key);

803 }

804 > lifecycle.ts

805 > set(key: K, value: V, skipDisposeOnOverwrite = false): void {

806 if (this._isDisposed) {

807 console.warn(new Error('Trying to add a disposable to a DisposableMap that has already been disposed of. The added object will be leaked!').stack);

815 setParentOfDisposable(value, this);

816 }

817 > lifecycle.ts

818 > /**

819 > * Delete the value stored for `key` from this map and also dispose of it.

820 > */

821 > deleteAndDispose(key: K): void {

822 this._store.get(key)?.dispose();

823 this._store.delete(key);

824 }

825 > lifecycle.ts

826 > /**

827 > * Delete the value stored for `key` from this map but return it. The caller is

828 > * responsible for disposing of the value.

829 > */

830 > deleteAndLeak(key: K): V | undefined {

831 const value = this._store.get(key);

832 if (value) {

836 return value;

837 }

838 > lifecycle.ts

839 > keys(): IterableIterator<K> {

840 return this._store.keys();

841 }

842 > lifecycle.ts

843 > values(): IterableIterator<V> {

844 return this._store.values();

845 }

846 > lifecycle.ts

847 > [Symbol.iterator](): IterableIterator<[K, V]> {

848 return this._store[Symbol.iterator]();

849 }

850 > } lifecycle.ts

851 >

852 > /**

853 > * A set that manages the lifecycle of the values that it stores.

854 > */

855 > export class DisposableSet<V extends IDisposable = IDisposable> implements IDisposable {

856 >

857 > private readonly _store: Set<V>;

858 > private _isDisposed = false;

859 >

860 > constructor(store: Set<V> = new Set<V>()) {

861 this._store = store;

862 trackDisposable(this);

863 }

864 > lifecycle.ts

865 > /**

866 > * Disposes of all stored values and mark this object as disposed.

867 > *

868 > * Trying to use this object after it has been disposed of is an error.

869 > */

870 > dispose(): void {

871 markAsDisposed(this);

872 this._isDisposed = true;

873 this.clearAndDisposeAll();

874 }

875 > lifecycle.ts

876 > /**

877 > * Disposes of all stored values and clear the set, but DO NOT mark this object as disposed.

878 > */

879 > clearAndDisposeAll(): void {

880 if (!this._store.size) {

881 return;

888 }

889 }

890 > lifecycle.ts

891 > has(value: V): boolean {

892 return this._store.has(value);

893 }

894 > lifecycle.ts

895 > get size(): number {

896 return this._store.size;

897 }

898 > lifecycle.ts

899 > add(value: V): void {

900 if (this._isDisposed) {

901 console.warn(new Error('Trying to add a disposable to a DisposableSet that has already been disposed of. The added object will be leaked!').stack);

905 setParentOfDisposable(value, this);

906 }

907 > lifecycle.ts

908 > /**

909 > * Delete the value from this set and also dispose of it.

910 > */

911 > deleteAndDispose(value: V): void {

912 if (this._store.delete(value)) {

913 value.dispose();

914 }

915 }

916 > lifecycle.ts

917 > /**

918 > * Delete the value from this set but return it. The caller is

919 > * responsible for disposing of the value.

920 > */

921 > deleteAndLeak(value: V): V | undefined {

922 if (this._store.delete(value)) {

923 setParentOfDisposable(value, null);

926 return undefined;

927 }

928 > lifecycle.ts

929 > values(): IterableIterator<V> {

930 return this._store.values();

931 }

932 > lifecycle.ts

933 > [Symbol.iterator](): IterableIterator<V> {

934 return this._store[Symbol.iterator]();

935 }

936 > } lifecycle.ts

937 >

938 > /**

939 > * Call `then` on a Promise, unless the returned disposable is disposed.

940 > */

941 > export function thenIfNotDisposed<T>(promise: Promise<T>, then: (result: T) => void): IDisposable {

942 let disposed = false;

943 promise.then(result => {

951 });

952 }

953 > lifecycle.ts

954 > /**

955 > * Call `then` on a promise that resolves to a {@link IDisposable}, then either register the

956 > * disposable or register it to the {@link DisposableStore}, depending on whether the store is

957 > * disposed or not.

958 > */

959 > export function thenRegisterOrDispose<T extends IDisposable>(promise: Promise<T>, store: DisposableStore): Promise<T> {

960 return promise.then(disposable => {

961 if (store.isDisposed) {

967 });

968 }

969 > lifecycle.ts

970 > export class DisposableResourceMap<V extends IDisposable = IDisposable> extends DisposableMap<URI, V> {

971 > constructor() {

972 super(new ResourceMap());

973 }

974 > } lifecycle.ts

src/vs/platform/dialogs/common/dialogs.ts 511 covered LOC · 8 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- dialogs.ts

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 { CancellationToken } from '../../../base/common/cancellation.js';

7 > import { Event } from '../../../base/common/event.js';

8 > import { ThemeIcon } from '../../../base/common/themables.js';

9 > import { IMarkdownString } from '../../../base/common/htmlContent.js';

10 > import { basename } from '../../../base/common/resources.js';

11 > import Severity from '../../../base/common/severity.js';

12 > import { URI } from '../../../base/common/uri.js';

13 > import { localize } from '../../../nls.js';

14 > import { createDecorator } from '../../instantiation/common/instantiation.js';

15 > import { ITelemetryData } from '../../telemetry/common/telemetry.js';

16 >

17 > export interface IDialogArgs {

18 > readonly confirmArgs?: IConfirmDialogArgs;

19 > readonly inputArgs?: IInputDialogArgs;

20 > readonly promptArgs?: IPromptDialogArgs;

21 > }

22 >

23 > export interface IBaseDialogOptions {

24 > readonly type?: Severity | DialogType;

25 >

26 > readonly title?: string;

27 > readonly message: string;

28 > readonly detail?: string;

29 >

30 > readonly checkbox?: ICheckbox;

31 >

32 > /**

33 > * Allows to enforce use of custom dialog even in native environments.

34 > */

35 > readonly custom?: boolean | ICustomDialogOptions;

36 >

37 > /**

38 > * An optional cancellation token that can be used to dismiss the dialog

39 > * programmatically for custom dialog implementations.

40 > *

41 > * When cancelled, the custom dialog resolves as if the cancel button was

42 > * pressed. Native dialog handlers cannot currently be dismissed

43 > * programmatically and ignore this option unless a custom dialog is

44 > * explicitly enforced via the {@link custom} option.

45 > */

46 > readonly token?: CancellationToken;

47 > }

48 >

49 > export interface IConfirmDialogArgs {

50 > readonly confirmation: IConfirmation;

51 > }

52 >

53 > export interface IConfirmation extends IBaseDialogOptions {

54 >

55 > /**

56 > * If not provided, defaults to `Yes`.

57 > */

58 > readonly primaryButton?: string;

59 >

60 > /**

61 > * If not provided, defaults to `Cancel`.

62 > */

63 > readonly cancelButton?: string;

64 > }

65 >

66 > export interface IConfirmationResult extends ICheckboxResult {

67 >

68 > /**

69 > * Will be true if the dialog was confirmed with the primary button pressed.

70 > */

71 > readonly confirmed: boolean;

72 > }

73 >

74 > export interface IInputDialogArgs {

75 > readonly input: IInput;

76 > }

77 >

78 > export interface IInput extends IConfirmation {

79 > readonly inputs: IInputElement[];

80 >

81 > /**

82 > * If not provided, defaults to `Ok`.

83 > */

84 > readonly primaryButton?: string;

85 > }

86 >

87 > export interface IInputElement {

88 > readonly type?: 'text' | 'password';

89 > readonly value?: string;

90 > readonly placeholder?: string;

91 > }

92 >

93 > export interface IInputResult extends IConfirmationResult {

94 >

95 > /**

96 > * Values for the input fields as provided by the user or `undefined` if none.

97 > */

98 > readonly values?: string[];

99 > }

100 >

101 > export interface IPromptDialogArgs {

102 > readonly prompt: IPrompt<unknown>;

103 > }

104 >

105 > export interface IPromptBaseButton<T> {

106 >

107 > /**

108 > * @returns the result of the prompt button will be returned

109 > * as result from the `prompt()` call.

110 > */

111 > run(checkbox: ICheckboxResult): T | Promise<T>;

112 > }

113 >

114 > export interface IPromptButton<T> extends IPromptBaseButton<T> {

115 > readonly label: string;

116 > }

117 >

118 > export interface IPromptCancelButton<T> extends IPromptBaseButton<T> {

119 >

120 > /**

121 > * The cancel button to show in the prompt. Defaults to

122 > * `Cancel` if not provided.

123 > */

124 > readonly label?: string;

125 > }

126 >

127 > export interface IPrompt<T> extends IBaseDialogOptions {

128 >

129 > /**

130 > * The buttons to show in the prompt. Defaults to `OK`

131 > * if no buttons or cancel button is provided.

132 > */

133 > readonly buttons?: IPromptButton<T>[];

134 >

135 > /**

136 > * The cancel button to show in the prompt. Defaults to

137 > * `Cancel` if set to `true`.

138 > */

139 > readonly cancelButton?: IPromptCancelButton<T> | true | string;

140 > }

141 >

142 > export interface IPromptWithCustomCancel<T> extends IPrompt<T> {

143 > readonly cancelButton: IPromptCancelButton<T>;

144 > }

145 >

146 > export interface IPromptWithDefaultCancel<T> extends IPrompt<T> {

147 > readonly cancelButton: true | string;

148 > }

149 >

150 > export interface IPromptResult<T> extends ICheckboxResult {

151 >

152 > /**

153 > * The result of the `IPromptButton` that was pressed or `undefined` if none.

154 > */

155 > readonly result?: T;

156 > }

157 >

158 > export interface IPromptResultWithCancel<T> extends IPromptResult<T> {

159 > readonly result: T;

160 > }

161 >

162 > export interface IAsyncPromptResult<T> extends ICheckboxResult {

163 >

164 > /**

165 > * The result of the `IPromptButton` that was pressed or `undefined` if none.

166 > */

167 > readonly result?: Promise<T>;

168 > }

169 >

170 > export interface IAsyncPromptResultWithCancel<T> extends IAsyncPromptResult<T> {

171 > readonly result: Promise<T>;

172 > }

173 >

174 > export type IDialogResult = IConfirmationResult | IInputResult | IAsyncPromptResult<unknown>;

175 >

176 > export type DialogType = 'none' | 'info' | 'error' | 'question' | 'warning';

177 >

178 > export interface ICheckbox {

179 > readonly label: string;

180 > readonly checked?: boolean;

181 > }

182 >

183 > export interface ICheckboxResult {

184 >

185 > /**

186 > * This will only be defined if the confirmation was created

187 > * with the checkbox option defined.

188 > */

189 > readonly checkboxChecked?: boolean;

190 > }

191 >

192 > export interface IPickAndOpenOptions {

193 > readonly forceNewWindow?: boolean;

194 > defaultUri?: URI;

195 > readonly telemetryExtraData?: ITelemetryData;

196 > availableFileSystems?: string[];

197 > remoteAuthority?: string | null;

198 > }

199 >

200 > export interface FileFilter {

201 > readonly extensions: string[];

202 > readonly name: string;

203 > }

204 >

205 > export interface ISaveDialogOptions {

206 >

207 > /**

208 > * A human-readable string for the dialog title

209 > */

210 > title?: string;

211 >

212 > /**

213 > * The resource the dialog shows when opened.

214 > */

215 > defaultUri?: URI;

216 >

217 > /**

218 > * A set of file filters that are used by the dialog. Each entry is a human readable label,

219 > * like "TypeScript", and an array of extensions.

220 > */

221 > filters?: FileFilter[];

222 >

223 > /**

224 > * A human-readable string for the ok button

225 > */

226 > readonly saveLabel?: { readonly withMnemonic: string; readonly withoutMnemonic: string } | string;

227 >

228 > /**

229 > * Specifies a list of schemas for the file systems the user can save to. If not specified, uses the schema of the defaultURI or, if also not specified,

230 > * the schema of the current window.

231 > */

232 > availableFileSystems?: readonly string[];

233 > }

234 >

235 > export interface IOpenDialogOptions {

236 >

237 > /**

238 > * A human-readable string for the dialog title

239 > */

240 > readonly title?: string;

241 >

242 > /**

243 > * The resource the dialog shows when opened.

244 > */

245 > defaultUri?: URI;

246 >

247 > /**

248 > * A human-readable string for the open button.

249 > */

250 > readonly openLabel?: { readonly withMnemonic: string; readonly withoutMnemonic: string } | string;

251 >

252 > /**

253 > * Allow to select files, defaults to `true`.

254 > */

255 > canSelectFiles?: boolean;

256 >

257 > /**

258 > * Allow to select folders, defaults to `false`.

259 > */

260 > canSelectFolders?: boolean;

261 >

262 > /**

263 > * Allow to select many files or folders.

264 > */

265 > readonly canSelectMany?: boolean;

266 >

267 > /**

268 > * A set of file filters that are used by the dialog. Each entry is a human readable label,

269 > * like "TypeScript", and an array of extensions.

270 > */

271 > filters?: FileFilter[];

272 >

273 > /**

274 > * Specifies a list of schemas for the file systems the user can load from. If not specified, uses the schema of the defaultURI or, if also not available,

275 > * the schema of the current window.

276 > */

277 > availableFileSystems?: readonly string[];

278 > }

279 >

280 > export const IDialogService = createDecorator<IDialogService>('dialogService');

281 >

282 > export interface ICustomDialogOptions {

283 > readonly buttonDetails?: string[];

284 > readonly markdownDetails?: ICustomDialogMarkdown[];

285 > readonly classes?: string[];

286 > readonly icon?: ThemeIcon;

287 > readonly disableCloseAction?: boolean;

288 > }

289 >

290 > export interface ICustomDialogMarkdown {

291 > readonly markdown: IMarkdownString;

292 > readonly classes?: string[];

293 > /** Custom link handler for markdown content, see {@link IContentActionHandler}. Defaults to {@link openLinkFromMarkdown}. */

294 > actionHandler?(link: string): Promise<boolean>;

295 > }

296 >

297 > /**

298 > * A handler to bring up modal dialogs.

299 > */

300 > export interface IDialogHandler {

301 >

302 > /**

303 > * Ask the user for confirmation with a modal dialog.

304 > */

305 > confirm(confirmation: IConfirmation): Promise<IConfirmationResult>;

306 >

307 > /**

308 > * Prompt the user with a modal dialog.

309 > */

310 > prompt<T>(prompt: IPrompt<T>): Promise<IAsyncPromptResult<T>>;

311 >

312 > /**

313 > * Present a modal dialog to the user asking for input.

314 > */

315 > input(input: IInput): Promise<IInputResult>;

316 >

317 > /**

318 > * Present the about dialog to the user.

319 > */

320 > about(title: string, details: string, detailsToCopy: string): Promise<void>;

321 > }

322 >

323 > enum DialogKind {

324 > Confirmation = 1,

325 > Prompt,

326 > Input

327 > }

328 >

329 > export abstract class AbstractDialogHandler implements IDialogHandler {

330 >

331 > protected getConfirmationButtons(dialog: IConfirmation): string[] {

332 return this.getButtons(dialog, DialogKind.Confirmation);

333 }

334 > dialogs.ts

335 > protected getPromptButtons(dialog: IPrompt<unknown>): string[] {

336 return this.getButtons(dialog, DialogKind.Prompt);

337 }

338 > dialogs.ts

339 > protected getInputButtons(dialog: IInput): string[] {

340 return this.getButtons(dialog, DialogKind.Input);

341 }

342 > dialogs.ts

343 > private getButtons(dialog: IConfirmation, kind: DialogKind.Confirmation): string[];

344 > private getButtons(dialog: IPrompt<unknown>, kind: DialogKind.Prompt): string[];

345 > private getButtons(dialog: IInput, kind: DialogKind.Input): string[];

346 > private getButtons(dialog: IConfirmation | IInput | IPrompt<unknown>, kind: DialogKind): string[] {

347

348 // We put buttons in the order of "default" button first and "cancel"

418 return buttons;

419 }

420 > dialogs.ts

421 > protected getDialogType(type: Severity | DialogType | undefined): DialogType | undefined {

422 if (typeof type === 'string') {

423 return type;

430 return undefined;

431 }

432 > dialogs.ts

433 > protected getPromptResult<T>(prompt: IPrompt<T>, buttonIndex: number, checkboxChecked: boolean | undefined): IAsyncPromptResult<T> {

434 const promptButtons: IPromptBaseButton<T>[] = [...(prompt.buttons ?? [])];

435 if (prompt.cancelButton && typeof prompt.cancelButton !== 'string' && typeof prompt.cancelButton !== 'boolean') {

444 return { result, checkboxChecked };

445 }

446 > dialogs.ts

447 > abstract confirm(confirmation: IConfirmation): Promise<IConfirmationResult>;

448 > abstract input(input: IInput): Promise<IInputResult>;

449 > abstract prompt<T>(prompt: IPrompt<T>): Promise<IAsyncPromptResult<T>>;

450 > abstract about(title: string, details: string, detailsToCopy: string): Promise<void>;

451 > }

452 >

453 > /**

454 > * A service to bring up modal dialogs.

455 > *

456 > * Note: use the `INotificationService.prompt()` method for a non-modal way to ask

457 > * the user for input.

458 > */

459 > export interface IDialogService {

460 >

461 > readonly _serviceBrand: undefined;

462 >

463 > /**

464 > * An event that fires when a dialog is about to show.

465 > */

466 > readonly onWillShowDialog: Event<void>;

467 >

468 > /**

469 > * An event that fires when a dialog did show (closed).

470 > */

471 > readonly onDidShowDialog: Event<void>;

472 >

473 > /**

474 > * Ask the user for confirmation with a modal dialog.

475 > */

476 > confirm(confirmation: IConfirmation): Promise<IConfirmationResult>;

477 >

478 > /**

479 > * Prompt the user with a modal dialog. Provides a bit

480 > * more control over the dialog compared to the simpler

481 > * `confirm` method. Specifically, allows to show more

482 > * than 2 buttons and makes it easier to just show a

483 > * message to the user.

484 > *

485 > * @returns a promise that resolves to the `T` result

486 > * from the provided `IPromptButton<T>` or `undefined`.

487 > */

488 > prompt<T>(prompt: IPromptWithCustomCancel<T>): Promise<IPromptResultWithCancel<T>>;

489 > prompt<T>(prompt: IPromptWithDefaultCancel<T>): Promise<IPromptResult<T>>;

490 > prompt<T>(prompt: IPrompt<T>): Promise<IPromptResult<T>>;

491 >

492 > /**

493 > * Present a modal dialog to the user asking for input.

494 > */

495 > input(input: IInput): Promise<IInputResult>;

496 >

497 > /**

498 > * Show a modal info dialog.

499 > */

500 > info(message: string, detail?: string): Promise<void>;

501 >

502 > /**

503 > * Show a modal warning dialog.

504 > */

505 > warn(message: string, detail?: string): Promise<void>;

506 >

507 > /**

508 > * Show a modal error dialog.

509 > */

510 > error(message: string, detail?: string): Promise<void>;

511 >

512 > /**

513 > * Present the about dialog to the user.

514 > */

515 > about(): Promise<void>;

516 > }

517 >

518 > export const IFileDialogService = createDecorator<IFileDialogService>('fileDialogService');

519 >

520 > /**

521 > * A service to bring up file dialogs.

522 > */

523 > export interface IFileDialogService {

524 >

525 > readonly _serviceBrand: undefined;

526 >

527 > /**

528 > * The default path for a new file based on previously used files.

529 > * @param schemeFilter The scheme of the file path. If no filter given, the scheme of the current window is used.

530 > * Falls back to user home in the absence of enough information to find a better URI.

531 > */

532 > defaultFilePath(schemeFilter?: string): Promise<URI>;

533 >

534 > /**

535 > * The default path for a new folder based on previously used folders.

536 > * @param schemeFilter The scheme of the folder path. If no filter given, the scheme of the current window is used.

537 > * Falls back to user home in the absence of enough information to find a better URI.

538 > */

539 > defaultFolderPath(schemeFilter?: string): Promise<URI>;

540 >

541 > /**

542 > * The default path for a new workspace based on previously used workspaces.

543 > * @param schemeFilter The scheme of the workspace path. If no filter given, the scheme of the current window is used.

544 > * Falls back to user home in the absence of enough information to find a better URI.

545 > */

546 > defaultWorkspacePath(schemeFilter?: string): Promise<URI>;

547 >

548 > /**

549 > * Shows a file-folder selection dialog and opens the selected entry.

550 > */

551 > pickFileFolderAndOpen(options: IPickAndOpenOptions): Promise<void>;

552 >

553 > /**

554 > * Shows a file selection dialog and opens the selected entry.

555 > */

556 > pickFileAndOpen(options: IPickAndOpenOptions): Promise<void>;

557 >

558 > /**

559 > * Shows a folder selection dialog and opens the selected entry.

560 > */

561 > pickFolderAndOpen(options: IPickAndOpenOptions): Promise<void>;

562 >

563 > /**

564 > * Shows a workspace selection dialog and opens the selected entry.

565 > */

566 > pickWorkspaceAndOpen(options: IPickAndOpenOptions): Promise<void>;

567 >

568 > /**

569 > * Shows a save file dialog and save the file at the chosen file URI.

570 > */

571 > pickFileToSave(defaultUri: URI, availableFileSystems?: string[]): Promise<URI | undefined>;

572 >

573 > /**

574 > * The preferred folder path to open the dialog at.

575 > * @param schemeFilter The scheme of the file path. If no filter given, the scheme of the current window is used.

576 > * Falls back to user home in the absence of a setting.

577 > */

578 > preferredHome(schemeFilter?: string): Promise<URI>;

579 >

580 > /**

581 > * Shows a save file dialog and returns the chosen file URI.

582 > */

583 > showSaveDialog(options: ISaveDialogOptions): Promise<URI | undefined>;

584 >

585 > /**

586 > * Shows a confirm dialog for saving 1-N files.

587 > */

588 > showSaveConfirm(fileNamesOrResources: (string | URI)[]): Promise<ConfirmResult>;

589 >

590 > /**

591 > * Shows a open file dialog and returns the chosen file URI.

592 > */

593 > showOpenDialog(options: IOpenDialogOptions): Promise<URI[] | undefined>;

594 > }

595 >

596 > export const enum ConfirmResult {

597 > SAVE,

598 > DONT_SAVE,

599 > CANCEL

600 > }

601 >

602 > const MAX_CONFIRM_FILES = 10;

603 > export function getFileNamesMessage(fileNamesOrResources: readonly (string | URI)[]): string {

604 const message: string[] = [];

605 message.push(...fileNamesOrResources.slice(0, MAX_CONFIRM_FILES).map(fileNameOrResource => typeof fileNameOrResource === 'string' ? fileNameOrResource : basename(fileNameOrResource)));

616 return message.join('\n');

617 }

618 > dialogs.ts

619 > export interface INativeOpenDialogOptions {

620 > readonly forceNewWindow?: boolean;

621 >

622 > readonly defaultPath?: string;

623 >

624 > readonly telemetryEventName?: string;

625 > readonly telemetryExtraData?: ITelemetryData;

626 > }

src/vs/workbench/services/authentication/common/authentication.ts 507 covered LOC · 4 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- authentication.ts

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 > import { Event } from '../../../../base/common/event.js';

6 > import { IDisposable } from '../../../../base/common/lifecycle.js';

7 > import { IAuthenticationChallenge, IAuthorizationProtectedResourceMetadata, IAuthorizationServerMetadata } from '../../../../base/common/oauth.js';

8 > import { URI } from '../../../../base/common/uri.js';

9 > import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';

10 >

11 > /**

12 > * Use this if you don't want the onDidChangeSessions event to fire in the extension host

13 > */

14 > export const INTERNAL_AUTH_PROVIDER_PREFIX = '__';

15 >

16 > export interface AuthenticationSessionAccount {

17 > label: string;

18 > id: string;

19 > }

20 >

21 > export interface AuthenticationSession {

22 > id: string;

23 > accessToken: string;

24 > account: AuthenticationSessionAccount;

25 > scopes: ReadonlyArray<string>;

26 > idToken?: string;

27 > }

28 >

29 > export interface AuthenticationSessionsChangeEvent {

30 > added: ReadonlyArray<AuthenticationSession> | undefined;

31 > removed: ReadonlyArray<AuthenticationSession> | undefined;

32 > changed: ReadonlyArray<AuthenticationSession> | undefined;

33 > }

34 >

35 > export interface AuthenticationProviderInformation {

36 > id: string;

37 > label: string;

38 > authorizationServerGlobs?: ReadonlyArray<string>;

39 > }

40 >

41 > /**

42 > * Options for creating an authentication session via the service.

43 > */

44 > export interface IAuthenticationCreateSessionOptions {

45 > activateImmediate?: boolean;

46 > /**

47 > * The account that is being asked about. If this is passed in, the provider should

48 > * attempt to return the sessions that are only related to this account.

49 > */

50 > account?: AuthenticationSessionAccount;

51 > /**

52 > * The authorization server URI to use for this creation request. If passed in, first we validate that

53 > * the provider can use this authorization server, then it is passed down to the auth provider.

54 > */

55 > authorizationServer?: URI;

56 > /**

57 > * When specified, the authentication provider will request a token bound to this resource URI

58 > * (RFC 8707 resource indicator).

59 > */

60 > resource?: string;

61 > /**

62 > * The audience for the requested access token. Primarily used for OAuth Identity Assertion

63 > * Authorization Grant (ID-JAG, defined in `draft-ietf-oauth-identity-assertion-authz-grant` using RFC 8693 token-exchange semantics) flows where the audience identifies the authorization server of the resource that

64 > * will redeem the assertion (typically the resource's authorization server URL). Providers that do not understand audience-bound tokens should

65 > * ignore this option.

66 > */

67 > audience?: string;

68 > /**

69 > * Allows the authentication provider to take in additional parameters.

70 > * It is up to the provider to define what these parameters are and handle them.

71 > * This is useful for passing in additional information that is specific to the provider

72 > * and not part of the standard authentication flow.

73 > */

74 > [key: string]: any;

75 > }

76 >

77 > export interface IAuthenticationWwwAuthenticateRequest {

78 > /**

79 > * The raw WWW-Authenticate header value that triggered this challenge.

80 > * This will be parsed by the authentication provider to extract the necessary

81 > * challenge information.

82 > */

83 > readonly wwwAuthenticate: string;

84 >

85 > /**

86 > * Optional scopes for the session. If not provided, the authentication provider

87 > * may use default scopes or extract them from the challenge.

88 > */

89 > readonly fallbackScopes?: readonly string[];

90 > }

91 >

92 > export function isAuthenticationWwwAuthenticateRequest(obj: unknown): obj is IAuthenticationWwwAuthenticateRequest {

93 return typeof obj === 'object'

94 && obj !== null

96 && (typeof obj.wwwAuthenticate === 'string');

97 }

98 > authentication.ts

99 > /**

100 > * Represents constraints for authentication, including challenges and optional scopes.

101 > * This is used when creating or retrieving sessions that must satisfy specific authentication

102 > * requirements from WWW-Authenticate headers.

103 > */

104 > export interface IAuthenticationConstraint {

105 > /**

106 > * Array of authentication challenges parsed from WWW-Authenticate headers.

107 > */

108 > readonly challenges: readonly IAuthenticationChallenge[];

109 >

110 > /**

111 > * Optional scopes for the session. If not provided, the authentication provider

112 > * may extract scopes from the challenges or use default scopes.

113 > */

114 > readonly fallbackScopes?: readonly string[];

115 > }

116 >

117 > /**

118 > * Options for getting authentication sessions via the service.

119 > */

120 > export interface IAuthenticationGetSessionsOptions {

121 > /**

122 > * Whether the provider must avoid user interaction while resolving existing sessions.

123 > */

124 > silent?: boolean;

125 > /**

126 > * The account that is being asked about. If this is passed in, the provider should

127 > * attempt to return the sessions that are only related to this account.

128 > */

129 > account?: AuthenticationSessionAccount;

130 > /**

131 > * The authorization server URI to use for this request. If passed in, first we validate that

132 > * the provider can use this authorization server, then it is passed down to the auth provider.

133 > */

134 > authorizationServer?: URI;

135 > /**

136 > * When specified, the authentication provider will request a token bound to this resource URI

137 > * (RFC 8707 resource indicator).

138 > */

139 > resource?: string;

140 > /**

141 > * The audience for the requested access token. Primarily used for OAuth Identity Assertion

142 > * Authorization Grant (ID-JAG, defined in `draft-ietf-oauth-identity-assertion-authz-grant` using RFC 8693 token-exchange semantics) flows where the audience identifies the authorization server of the resource that

143 > * will redeem the assertion (typically the resource's authorization server URL). Providers that do not understand audience-bound tokens should

144 > * ignore this option.

145 > */

146 > audience?: string;

147 > /**

148 > * Allows the authentication provider to take in additional parameters.

149 > * It is up to the provider to define what these parameters are and handle them.

150 > * This is useful for passing in additional information that is specific to the provider

151 > * and not part of the standard authentication flow.

152 > */

153 > [key: string]: any;

154 > }

155 >

156 > export interface AllowedExtension {

157 > id: string;

158 > name: string;

159 > /**

160 > * If true or undefined, the extension is allowed to use the account

161 > * If false, the extension is not allowed to use the account

162 > * TODO: undefined shouldn't be a valid value, but it is for now

163 > */

164 > allowed?: boolean;

165 > lastUsed?: number;

166 > // If true, this comes from the product.json

167 > trusted?: boolean;

168 > }

169 >

170 > export interface IAuthenticationProviderHostDelegate {

171 > /** Priority for this delegate, delegates are tested in descending priority order */

172 > readonly priority: number;

173 > create(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resource: IAuthorizationProtectedResourceMetadata | undefined, clientId?: string, clientSecret?: string): Promise<string>;

174 > /**

175 > * Creates an XAA (enterprise-managed, ID-JAG) authentication provider for the given SSO issuer.

176 > * The returned string is the provider id.

177 > */

178 > createXaa?(issuer: URI): Promise<string>;

179 > }

180 >

181 > export function getDynamicAuthenticationProviderId(authorizationServer: URI, resource: IAuthorizationProtectedResourceMetadata | undefined): string {

182 return resource ? `${authorizationServer.toString(true)} ${resource.resource}` : authorizationServer.toString(true);

183 }

184 > authentication.ts

185 > export const IAuthenticationService = createDecorator<IAuthenticationService>('IAuthenticationService');

186 >

187 > export interface IAuthenticationService {

188 > readonly _serviceBrand: undefined;

189 >

190 > /**

191 > * Fires when an authentication provider has been registered

192 > */

193 > readonly onDidRegisterAuthenticationProvider: Event<AuthenticationProviderInformation>;

194 > /**

195 > * Fires when an authentication provider has been unregistered

196 > */

197 > readonly onDidUnregisterAuthenticationProvider: Event<AuthenticationProviderInformation>;

198 >

199 > /**

200 > * Fires when the list of sessions for a provider has been added, removed or changed

201 > */

202 > readonly onDidChangeSessions: Event<{ providerId: string; label: string; event: AuthenticationSessionsChangeEvent }>;

203 >

204 > /**

205 > * Fires when the list of declaredProviders has changed

206 > */

207 > readonly onDidChangeDeclaredProviders: Event<void>;

208 >

209 > /**

210 > * All providers that have been statically declared by extensions. These may not actually be registered or active yet.

211 > */

212 > readonly declaredProviders: AuthenticationProviderInformation[];

213 >

214 > /**

215 > * Registers that an extension has declared an authentication provider in their package.json

216 > * @param provider The provider information to register

217 > */

218 > registerDeclaredAuthenticationProvider(provider: AuthenticationProviderInformation): void;

219 >

220 > /**

221 > * Unregisters a declared authentication provider

222 > * @param id The id of the provider to unregister

223 > */

224 > unregisterDeclaredAuthenticationProvider(id: string): void;

225 >

226 > /**

227 > * Checks if an authentication provider has been registered

228 > * @param id The id of the provider to check

229 > */

230 > isAuthenticationProviderRegistered(id: string): boolean;

231 >

232 > /**

233 > * Checks if an authentication provider is dynamic

234 > * @param id The id of the provider to check

235 > */

236 > isDynamicAuthenticationProvider(id: string): boolean;

237 >

238 > /**

239 > * Registers an authentication provider

240 > * @param id The id of the provider

241 > * @param provider The implementation of the provider

242 > */

243 > registerAuthenticationProvider(id: string, provider: IAuthenticationProvider): void;

244 >

245 > /**

246 > * Unregisters an authentication provider

247 > * @param id The id of the provider to unregister

248 > */

249 > unregisterAuthenticationProvider(id: string): void;

250 >

251 > /**

252 > * Gets the provider ids of all registered authentication providers

253 > */

254 > getProviderIds(): string[];

255 >

256 > /**

257 > * Gets the provider with the given id.

258 > * @param id The id of the provider to get

259 > * @throws if the provider is not registered

260 > */

261 > getProvider(id: string): IAuthenticationProvider;

262 >

263 > /**

264 > * Gets all accounts that are currently logged in across all sessions

265 > * @param id The id of the provider to ask for accounts

266 > * @returns A promise that resolves to an array of accounts

267 > */

268 > getAccounts(id: string): Promise<ReadonlyArray<AuthenticationSessionAccount>>;

269 >

270 > /**

271 > * Gets all sessions that satisfy the given scopes from the provider with the given id

272 > * @param id The id of the provider to ask for a session

273 > * @param scopes The scopes for the session

274 > * @param options Additional options for getting sessions

275 > * @param activateImmediate If true, the provider should activate immediately if it is not already

276 > */

277 > getSessions(id: string, scopeListOrRequest?: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, options?: IAuthenticationGetSessionsOptions, activateImmediate?: boolean): Promise<ReadonlyArray<AuthenticationSession>>;

278 >

279 > /**

280 > * Creates an AuthenticationSession with the given provider and scopes

281 > * @param providerId The id of the provider

282 > * @param scopes The scopes to request

283 > * @param options Additional options for creating the session

284 > */

285 > createSession(providerId: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, options?: IAuthenticationCreateSessionOptions): Promise<AuthenticationSession>;

286 >

287 > /**

288 > * Removes the session with the given id from the provider with the given id

289 > * @param providerId The id of the provider

290 > * @param sessionId The id of the session to remove

291 > */

292 > removeSession(providerId: string, sessionId: string): Promise<void>;

293 >

294 > /**

295 > * Gets a provider id for a specified authorization server

296 > * @param authorizationServer The authorization server url that this provider is responsible for

297 > * @param resourceServer The resource server URI that should match the provider's resourceServer (if defined)

298 > */

299 > getOrActivateProviderIdForServer(authorizationServer: URI, resourceServer?: URI): Promise<string | undefined>;

300 >

301 > /**

302 > * Allows the ability register a delegate that will be used to start authentication providers

303 > * @param delegate The delegate to register

304 > */

305 > registerAuthenticationProviderHostDelegate(delegate: IAuthenticationProviderHostDelegate): IDisposable;

306 >

307 > /**

308 > * Creates a dynamic authentication provider for the given server metadata

309 > * @param serverMetadata The metadata for the server that is being authenticated against

310 > */

311 > createDynamicAuthenticationProvider(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resourceMetadata: IAuthorizationProtectedResourceMetadata | undefined, clientId?: string, clientSecret?: string): Promise<IAuthenticationProvider | undefined>;

312 >

313 > /**

314 > * Gets or creates a built-in XAA (enterprise-managed, ID-JAG) authentication provider for the given

315 > * SSO issuer. Subsequent calls with the same issuer return the existing provider. The returned id

316 > * can be used with {@link getSessions}/{@link createSession} just like any other provider.

317 > *

318 > * @param issuer The OAuth/OIDC issuer URL (typically read from `mcp.enterpriseManagedAuth.idp`).

319 > */

320 > createOrGetXaaProvider(issuer: URI): Promise<string | undefined>;

321 > }

322 >

323 > export function isAuthenticationSession(thing: unknown): thing is AuthenticationSession {

324 if (typeof thing !== 'object' || !thing) {

325 return false;

349 return true;

350 }

351 > authentication.ts

352 > // TODO: Move this into MainThreadAuthentication

353 > export const IAuthenticationExtensionsService = createDecorator<IAuthenticationExtensionsService>('IAuthenticationExtensionsService');

354 > export interface IAuthenticationExtensionsService {

355 > readonly _serviceBrand: undefined;

356 >

357 > /**

358 > * Fires when an account preference for a specific provider has changed for the specified extensions. Does not fire when:

359 > * * An account preference is removed

360 > * * A session preference is changed (because it's deprecated)

361 > * * A session preference is removed (because it's deprecated)

362 > */

363 > readonly onDidChangeAccountPreference: Event<{ extensionIds: string[]; providerId: string }>;

364 > /**

365 > * Returns the accountName (also known as account.label) to pair with `IAuthenticationAccessService` to get the account preference

366 > * @param providerId The authentication provider id

367 > * @param extensionId The extension id to get the preference for

368 > * @returns The accountName of the preference, or undefined if there is no preference set

369 > */

370 > getAccountPreference(extensionId: string, providerId: string): string | undefined;

371 > /**

372 > * Sets the account preference for the given provider and extension

373 > * @param providerId The authentication provider id

374 > * @param extensionId The extension id to set the preference for

375 > * @param account The account to set the preference to

376 > */

377 > updateAccountPreference(extensionId: string, providerId: string, account: AuthenticationSessionAccount): void;

378 > /**

379 > * Removes the account preference for the given provider and extension

380 > * @param providerId The authentication provider id

381 > * @param extensionId The extension id to remove the preference for

382 > */

383 > removeAccountPreference(extensionId: string, providerId: string): void;

384 > /**

385 > * @deprecated Sets the session preference for the given provider and extension

386 > * @param providerId

387 > * @param extensionId

388 > * @param session

389 > */

390 > updateSessionPreference(providerId: string, extensionId: string, session: AuthenticationSession): void;

391 > /**

392 > * @deprecated Gets the session preference for the given provider and extension

393 > * @param providerId

394 > * @param extensionId

395 > * @param scopes

396 > */

397 > getSessionPreference(providerId: string, extensionId: string, scopes: string[]): string | undefined;

398 > /**

399 > * @deprecated Removes the session preference for the given provider and extension

400 > * @param providerId

401 > * @param extensionId

402 > * @param scopes

403 > */

404 > removeSessionPreference(providerId: string, extensionId: string, scopes: string[]): void;

405 > selectSession(providerId: string, extensionId: string, extensionName: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, possibleSessions: readonly AuthenticationSession[]): Promise<AuthenticationSession>;

406 > requestSessionAccess(providerId: string, extensionId: string, extensionName: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, possibleSessions: readonly AuthenticationSession[]): void;

407 > requestNewSession(providerId: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, extensionId: string, extensionName: string): Promise<void>;

408 > updateNewSessionRequests(providerId: string, addedSessions: readonly AuthenticationSession[]): void;

409 > }

410 >

411 > /**

412 > * Options passed to the authentication provider when asking for sessions.

413 > */

414 > export interface IAuthenticationProviderSessionOptions {

415 > /**

416 > * Whether the provider must avoid user interaction while resolving existing sessions.

417 > */

418 > silent?: boolean;

419 > /**

420 > * The account that is being asked about. If this is passed in, the provider should

421 > * attempt to return the sessions that are only related to this account.

422 > */

423 > account?: AuthenticationSessionAccount;

424 > /**

425 > * The authorization server that is being asked about. If this is passed in, the provider should

426 > * attempt to return sessions that are only related to this authorization server.

427 > */

428 > authorizationServer?: URI;

429 > /**

430 > * When specified, the authentication provider will request a token bound to this resource URI

431 > * (RFC 8707 resource indicator).

432 > */

433 > resource?: string;

434 > /**

435 > * The audience for the requested access token. Primarily used for OAuth Identity Assertion

436 > * Authorization Grant (ID-JAG, defined in `draft-ietf-oauth-identity-assertion-authz-grant` using RFC 8693 token-exchange semantics) flows where the audience identifies the authorization server of the resource that

437 > * will redeem the assertion (typically the resource's authorization server URL). Providers that do not understand audience-bound tokens should

438 > * ignore this option.

439 > */

440 > audience?: string;

441 > /**

442 > * Allows the authentication provider to take in additional parameters.

443 > * It is up to the provider to define what these parameters are and handle them.

444 > * This is useful for passing in additional information that is specific to the provider

445 > * and not part of the standard authentication flow.

446 > */

447 > [key: string]: any;

448 > }

449 >

450 > /**

451 > * Represents an authentication provider.

452 > */

453 > export interface IAuthenticationProvider {

454 > /**

455 > * The unique identifier of the authentication provider.

456 > */

457 > readonly id: string;

458 >

459 > /**

460 > * The display label of the authentication provider.

461 > */

462 > readonly label: string;

463 >

464 > /**

465 > * The resource server URI that this provider is responsible for, if any.

466 > * TODO@TylerLeonhardt: Rather than this being added to the provider, it should be passed in to

467 > * getSessions/createSession/etc... this way we can have providers that handle multiple resource servers.

468 > */

469 > readonly resourceServer?: URI;

470 >

471 > /**

472 > * The resolved authorization servers. These can still contain globs, but should be concrete URIs

473 > */

474 > readonly authorizationServers?: ReadonlyArray<URI>;

475 >

476 > /**

477 > * Indicates whether the authentication provider supports multiple accounts.

478 > */

479 > readonly supportsMultipleAccounts: boolean;

480 >

481 > /**

482 > * Optional function to provide a custom confirmation message for authentication prompts.

483 > * If not implemented, the default confirmation messages will be used.

484 > * @param extensionName - The name of the extension requesting authentication.

485 > * @param recreatingSession - Whether this is recreating an existing session.

486 > * @returns A custom confirmation message or undefined to use the default message.

487 > */

488 > readonly confirmation?: (extensionName: string, recreatingSession: boolean) => string | undefined;

489 >

490 > /**

491 > * An {@link Event} which fires when the array of sessions has changed, or data

492 > * within a session has changed.

493 > */

494 > readonly onDidChangeSessions: Event<AuthenticationSessionsChangeEvent>;

495 >

496 > /**

497 > * Retrieves a list of authentication sessions.

498 > * @param scopes - An optional list of scopes. If provided, the sessions returned should match these permissions, otherwise all sessions should be returned.

499 > * @param options - Additional options for getting sessions.

500 > * @returns A promise that resolves to an array of authentication sessions.

501 > */

502 > getSessions(scopes: string[] | undefined, options: IAuthenticationProviderSessionOptions): Promise<readonly AuthenticationSession[]>;

503 >

504 > /**

505 > * Prompts the user to log in.

506 > * If login is successful, the `onDidChangeSessions` event should be fired.

507 > * If login fails, a rejected promise should be returned.

508 > * If the provider does not support multiple accounts, this method should not be called if there is already an existing session matching the provided scopes.

509 > * @param scopes - A list of scopes that the new session should be created with.

510 > * @param options - Additional options for creating the session.

511 > * @returns A promise that resolves to an authentication session.

512 > */

513 > createSession(scopes: string[], options: IAuthenticationProviderSessionOptions): Promise<AuthenticationSession>;

514 >

515 > /**

516 > * Get existing sessions that match the given authentication constraints.

517 > *

518 > * @param constraint The authentication constraint containing challenges and optional scopes

519 > * @param options Options for the session request

520 > * @returns A thenable that resolves to an array of existing authentication sessions

521 > */

522 > getSessionsFromChallenges?(constraint: IAuthenticationConstraint, options: IAuthenticationProviderSessionOptions): Promise<readonly AuthenticationSession[]>;

523 >

524 > /**

525 > * Create a new session based on authentication constraints.

526 > * This is called when no existing session matches the constraint requirements.

527 > *

528 > * @param constraint The authentication constraint containing challenges and optional scopes

529 > * @param options Options for the session creation

530 > * @returns A thenable that resolves to a new authentication session

531 > */

532 > createSessionFromChallenges?(constraint: IAuthenticationConstraint, options: IAuthenticationProviderSessionOptions): Promise<AuthenticationSession>;

533 >

534 > /**

535 > * Removes the session corresponding to the specified session ID.

536 > * If the removal is successful, the `onDidChangeSessions` event should be fired.

537 > * If a session cannot be removed, the provider should reject with an error message.

538 > * @param sessionId - The ID of the session to remove.

539 > */

540 > removeSession(sessionId: string): Promise<void>;

541 > }

src/vs/base/common/strings.ts 454 covered LOC · 101 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- strings.ts

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 { LRUCachedFunction } from './cache.js';

7 > import { CharCode } from './charCode.js';

8 > import { Lazy } from './lazy.js';

9 > import { Constants } from './uint.js';

10 >

11 > export function isFalsyOrWhitespace(str: string | undefined): boolean {

12 if (!str || typeof str !== 'string') {

13 return true;

15 return str.trim().length === 0;

16 }

17 > strings.ts

18 > const _formatRegexp = /{(\d+)}/g;

19 >

20 > /**

21 > * Helper to produce a string with a variable number of arguments. Insert variable segments

22 > * into the string using the {n} notation where N is the index of the argument following the string.

23 > * @param value string to which formatting is applied

24 > * @param args replacements for {n}-entries

25 > */

26 > // eslint-disable-next-line @typescript-eslint/no-explicit-any

27 > export function format(value: string, ...args: any[]): string {

28 if (args.length === 0) {

29 return value;

36 });

37 }

38 > strings.ts

39 > const _format2Regexp = /{([^}]+)}/g;

40 >

41 > /**

42 > * Helper to create a string from a template and a string record.

43 > * Similar to `format` but with objects instead of positional arguments.

44 > */

45 > export function format2(template: string, values: Record<string, unknown>): string {

46 if (Object.keys(values).length === 0) {

47 return template;

49 return template.replace(_format2Regexp, (match, group) => (values[group] ?? match) as string);

50 }

51 > strings.ts

52 > /**

53 > * Encodes the given value so that it can be used as literal value in html attributes.

54 > *

55 > * In other words, computes `$val`, such that `attr` in `<div attr="$val" />` has the runtime value `value`.

56 > * This prevents XSS injection.

57 > */

58 > export function htmlAttributeEncodeValue(value: string): string {

59 return value.replace(/[<>"'&]/g, ch => {

60 switch (ch) {

68 });

69 }

70 > strings.ts

71 > /**

72 > * Converts HTML characters inside the string to use entities instead. Makes the string safe from

73 > * being used e.g. in HTMLElement.innerHTML.

74 > */

75 > export function escape(html: string): string {

76 return html.replace(/[<>&]/g, function (match) {

77 switch (match) {

83 });

84 }

85 > strings.ts

86 > /**

87 > * Escapes regular expression characters in a given string

88 > */

89 > export function escapeRegExpCharacters(value: string): string {

90 return value.replace(/[\\\{\}\*\+\?\|\^\$\.\[\]\(\)]/g, '\\$&');

91 }

92 > strings.ts

93 > /**

94 > * Counts how often `substr` occurs inside `value`.

95 > */

96 > export function count(value: string, substr: string): number {

97 let result = 0;

98 let index = value.indexOf(substr);

103 return result;

104 }

105 > strings.ts

106 > export function truncate(value: string, maxLength: number, suffix = Ellipsis): string {

107 if (value.length <= maxLength) {

108 return value;

111 return `${value.substr(0, maxLength)}${suffix}`;

112 }

113 > strings.ts

114 > export function truncateMiddle(value: string, maxLength: number, suffix = Ellipsis): string {

115 if (value.length <= maxLength) {

116 return value;

122 return `${value.substr(0, prefixLength)}${suffix}${value.substr(value.length - suffixLength)}`;

123 }

124 > strings.ts

125 > /**

126 > * Removes all occurrences of needle from the beginning and end of haystack.

127 > * @param haystack string to trim

128 > * @param needle the thing to trim (default is a blank)

129 > */

130 > export function trim(haystack: string, needle: string = ' '): string {

131 const trimmed = ltrim(haystack, needle);

132 return rtrim(trimmed, needle);

133 }

134 > strings.ts

135 > /**

136 > * Removes all occurrences of needle from the beginning of haystack.

137 > * @param haystack string to trim

138 > * @param needle the thing to trim

139 > */

140 > export function ltrim(haystack: string, needle: string): string {

141 if (!haystack || !needle) {

142 return haystack;

157 return haystack.substring(offset);

158 }

159 > strings.ts

160 > /**

161 > * Removes all occurrences of needle from the end of haystack.

162 > * @param haystack string to trim

163 > * @param needle the thing to trim

164 > */

165 > export function rtrim(haystack: string, needle: string): string {

166 if (!haystack || !needle) {

167 return haystack;

187 return haystack.substring(0, offset);

188 }

189 > strings.ts

190 > export function convertSimple2RegExpPattern(pattern: string): string {

191 return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');

192 }

193 > strings.ts

194 > export interface RegExpOptions {

195 > matchCase?: boolean;

196 > wholeWord?: boolean;

197 > multiline?: boolean;

198 > global?: boolean;

199 > unicode?: boolean;

200 > }

201 >

202 > export function createRegExp(searchString: string, isRegex: boolean, options: RegExpOptions = {}): RegExp {

203 if (!searchString) {

204 throw new Error('Cannot create regex from empty string');

231 return new RegExp(searchString, modifiers);

232 }

233 > strings.ts

234 > export function regExpLeadsToEndlessLoop(regexp: RegExp): boolean {

235 // Exit early if it's one of these special cases which are meant to match

236 // against an empty string

244 return !!(match && regexp.lastIndex === 0);

245 }

246 > strings.ts

247 > export function joinStrings(items: (string | undefined | null | false)[], separator: string): string {

248 return items.filter(item => item !== undefined && item !== null && item !== false).join(separator);

249 }

250 > strings.ts

251 > export function splitLines(str: string): string[] {

252 return str.split(/\r\n|\r|\n/);

253 }

254 > strings.ts

255 > export function splitLinesIncludeSeparators(str: string): string[] {

256 const linesWithSeparators: string[] = [];

257 const splitLinesAndSeparators = str.split(/(\r\n|\r|\n)/);

261 return linesWithSeparators;

262 }

263 > strings.ts

264 > export function indexOfPattern(str: string, re: RegExp) {

265 const match = re.exec(str);

266 if (match) {

269 return -1;

270 }

271 > strings.ts

272 > /**

273 > * Returns first index of the string that is not whitespace.

274 > * If string is empty or contains only whitespaces, returns -1

275 > */

276 > export function firstNonWhitespaceIndex(str: string): number {

277 for (let i = 0, len = str.length; i < len; i++) {

278 const chCode = str.charCodeAt(i);

283 return -1;

284 }

285 > strings.ts

286 > /**

287 > * Returns the leading whitespace of the string.

288 > * If the string contains only whitespaces, returns entire string

289 > */

290 > export function getLeadingWhitespace(str: string, start: number = 0, end: number = str.length): string {

291 for (let i = start; i < end; i++) {

292 const chCode = str.charCodeAt(i);

297 return str.substring(start, end);

298 }

299 > strings.ts

300 > /**

301 > * Returns last index of the string that is not whitespace.

302 > * If string is empty or contains only whitespaces, returns -1

303 > */

304 > export function lastNonWhitespaceIndex(str: string, startIndex: number = str.length - 1): number {

305 for (let i = startIndex; i >= 0; i--) {

306 const chCode = str.charCodeAt(i);

311 return -1;

312 }

313 > strings.ts

314 > export function getIndentationLength(str: string): number {

315 const idx = firstNonWhitespaceIndex(str);

316 if (idx === -1) { return str.length; }

317 return idx;

318 }

319 > strings.ts

320 > /**

321 > * Function that works identically to String.prototype.replace, except, the

322 > * replace function is allowed to be async and return a Promise.

323 > */

324 > export function replaceAsync(str: string, search: RegExp, replacer: (match: string, ...args: unknown[]) => Promise<string>): Promise<string> {

325 const parts: (string | Promise<string>)[] = [];

326

340 return Promise.all(parts).then(p => p.join(''));

341 }

342 > strings.ts

343 > export function compare(a: string, b: string): number {

344 if (a < b) {

345 return -1;

350 }

351 }

352 > strings.ts

353 > export function compareSubstring(a: string, b: string, aStart: number = 0, aEnd: number = a.length, bStart: number = 0, bEnd: number = b.length): number {

354 for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {

355 const codeA = a.charCodeAt(aStart);

370 return 0;

371 }

372 > strings.ts

373 > export function compareIgnoreCase(a: string, b: string): number {

374 return compareSubstringIgnoreCase(a, b, 0, a.length, 0, b.length);

375 }

376 > strings.ts

377 > export function compareSubstringIgnoreCase(a: string, b: string, aStart: number = 0, aEnd: number = a.length, bStart: number = 0, bEnd: number = b.length): number {

378

379 for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {

421 return 0;

422 }

423 > strings.ts

424 > export function isAsciiDigit(code: number): boolean {

425 return code >= CharCode.Digit0 && code <= CharCode.Digit9;

426 }

427 > strings.ts

428 > export function isLowerAsciiLetter(code: number): boolean {

429 return code >= CharCode.a && code <= CharCode.z;

430 }

431 > strings.ts

432 > export function isUpperAsciiLetter(code: number): boolean {

433 return code >= CharCode.A && code <= CharCode.Z;

434 }

435 > strings.ts

436 > export function equalsIgnoreCase(a: string, b: string): boolean {

437 return a.length === b.length && compareSubstringIgnoreCase(a, b) === 0;

438 }

439 > strings.ts

440 > export function equals(a: string | undefined, b: string | undefined, ignoreCase?: boolean): boolean {

441 return a === b || (!!ignoreCase && a !== undefined && b !== undefined && equalsIgnoreCase(a, b));

442 }

443 > strings.ts

444 > export function startsWithIgnoreCase(str: string, candidate: string): boolean {

445 const len = candidate.length;

446 return len <= str.length && compareSubstringIgnoreCase(str, candidate, 0, len) === 0;

447 }

448 > strings.ts

449 > export function endsWithIgnoreCase(str: string, candidate: string): boolean {

450 const len = str.length;

451 const start = len - candidate.length;

452 return start >= 0 && compareSubstringIgnoreCase(str, candidate, start, len) === 0;

453 }

454 > strings.ts

455 > /**

456 > * @returns the length of the common prefix of the two strings.

457 > */

458 > export function commonPrefixLength(a: string, b: string): number {

459

460 const len = Math.min(a.length, b.length);

469 return len;

470 }

471 > strings.ts

472 > /**

473 > * @returns the length of the common suffix of the two strings.

474 > */

475 > export function commonSuffixLength(a: string, b: string): number {

476

477 const len = Math.min(a.length, b.length);

489 return len;

490 }

491 > strings.ts

492 > /**

493 > * See http://en.wikipedia.org/wiki/Surrogate_pair

494 > */

495 > export function isHighSurrogate(charCode: number): boolean {

496 return (0xD800 <= charCode && charCode <= 0xDBFF);

497 }

498 > strings.ts

499 > /**

500 > * See http://en.wikipedia.org/wiki/Surrogate_pair

501 > */

502 > export function isLowSurrogate(charCode: number): boolean {

503 return (0xDC00 <= charCode && charCode <= 0xDFFF);

504 }

505 > strings.ts

506 > /**

507 > * See http://en.wikipedia.org/wiki/Surrogate_pair

508 > */

509 > export function computeCodePoint(highSurrogate: number, lowSurrogate: number): number {

510 return ((highSurrogate - 0xD800) << 10) + (lowSurrogate - 0xDC00) + 0x10000;

511 }

512 > strings.ts

513 > /**

514 > * get the code point that begins at offset `offset`

515 > */

516 > export function getNextCodePoint(str: string, len: number, offset: number): number {

517 const charCode = str.charCodeAt(offset);

518 if (isHighSurrogate(charCode) && offset + 1 < len) {

524 return charCode;

525 }

526 > strings.ts

527 > /**

528 > * get the code point that ends right before offset `offset`

529 > */

530 function getPrevCodePoint(str: string, offset: number): number {

531 const charCode = str.charCodeAt(offset - 1);

538 return charCode;

539 }

540 > strings.ts

541 > export class CodePointIterator {

542 >

543 > private readonly _str: string;

544 > private readonly _len: number;

545 > private _offset: number;

546 >

547 > public get offset(): number {

548 return this._offset;

549 }

550 > strings.ts

551 > constructor(str: string, offset: number = 0) {

552 this._str = str;

553 this._len = str.length;

554 this._offset = offset;

555 }

556 > strings.ts

557 > public setOffset(offset: number): void {

558 this._offset = offset;

559 }

560 > strings.ts

561 > public prevCodePoint(): number {

562 const codePoint = getPrevCodePoint(this._str, this._offset);

563 this._offset -= (codePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);

564 return codePoint;

565 }

566 > strings.ts

567 > public nextCodePoint(): number {

568 const codePoint = getNextCodePoint(this._str, this._len, this._offset);

569 this._offset += (codePoint >= Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);

570 return codePoint;

571 }

572 > strings.ts

573 > public eol(): boolean {

574 return (this._offset >= this._len);

575 }

576 > } strings.ts

577 >

578 > export class GraphemeIterator {

579 >

580 > private readonly _iterator: CodePointIterator;

581 >

582 > public get offset(): number {

583 return this._iterator.offset;

584 }

585 > strings.ts

586 > constructor(str: string, offset: number = 0) {

587 this._iterator = new CodePointIterator(str, offset);

588 }

589 > strings.ts

590 > public nextGraphemeLength(): number {

591 const graphemeBreakTree = GraphemeBreakTree.getInstance();

592 const iterator = this._iterator;

606 return (iterator.offset - initialOffset);

607 }

608 > strings.ts

609 > public prevGraphemeLength(): number {

610 const graphemeBreakTree = GraphemeBreakTree.getInstance();

611 const iterator = this._iterator;

625 return (initialOffset - iterator.offset);

626 }

627 > strings.ts

628 > public eol(): boolean {

629 return this._iterator.eol();

630 }

631 > } strings.ts

632 >

633 > export function nextCharLength(str: string, initialOffset: number): number {

634 const iterator = new GraphemeIterator(str, initialOffset);

635 return iterator.nextGraphemeLength();

636 }

637 > strings.ts

638 > export function prevCharLength(str: string, initialOffset: number): number {

639 const iterator = new GraphemeIterator(str, initialOffset);

640 return iterator.prevGraphemeLength();

641 }

642 > strings.ts

643 > export function getCharContainingOffset(str: string, offset: number): [number, number] {

644 if (offset > 0 && isLowSurrogate(str.charCodeAt(offset))) {

645 offset--;

649 return [startOffset, endOffset];

650 }

651 > strings.ts

652 > export function charCount(str: string): number {

653 const iterator = new GraphemeIterator(str);

654 let length = 0;

659 return length;

660 }

661 > strings.ts

662 > let CONTAINS_RTL: RegExp | undefined = undefined;

663 >

664 function makeContainsRtl() {

665 // Generated using https://github.com/alexdima/unicode-utils/blob/main/rtl-test.js

666 return /(?:[\u05BE\u05C0\u05C3\u05C6\u05D0-\u05F4\u0608\u060B\u060D\u061B-\u064A\u066D-\u066F\u0671-\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u0710\u0712-\u072F\u074D-\u07A5\u07B1-\u07EA\u07F4\u07F5\u07FA\u07FE-\u0815\u081A\u0824\u0828\u0830-\u0858\u085E-\u088E\u08A0-\u08C9\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFD3D\uFD50-\uFDC7\uFDF0-\uFDFC\uFE70-\uFEFC]|\uD802[\uDC00-\uDD1B\uDD20-\uDE00\uDE10-\uDE35\uDE40-\uDEE4\uDEEB-\uDF35\uDF40-\uDFFF]|\uD803[\uDC00-\uDD23\uDE80-\uDEA9\uDEAD-\uDF45\uDF51-\uDF81\uDF86-\uDFF6]|\uD83A[\uDC00-\uDCCF\uDD00-\uDD43\uDD4B-\uDFFF]|\uD83B[\uDC00-\uDEBB])/;

667 }

668 > strings.ts

669 > /**

670 > * Returns true if `str` contains any Unicode character that is classified as "R" or "AL".

671 > */

672 > export function containsRTL(str: string): boolean {

673 if (!CONTAINS_RTL) {

674 CONTAINS_RTL = makeContainsRtl();

677 return CONTAINS_RTL.test(str);

678 }

679 > strings.ts

680 > const IS_BASIC_ASCII = /^[\t\n\r\x20-\x7E]*$/;

681 > /**

682 > * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \n, \r, \t

683 > */

684 > export function isBasicASCII(str: string): boolean {

685 return IS_BASIC_ASCII.test(str);

686 }

687 > strings.ts

688 > export const UNUSUAL_LINE_TERMINATORS = /[\u2028\u2029]/; // LINE SEPARATOR (LS) or PARAGRAPH SEPARATOR (PS)

689 > /**

690 > * Returns true if `str` contains unusual line terminators, like LS or PS

691 > */

692 > export function containsUnusualLineTerminators(str: string): boolean {

693 return UNUSUAL_LINE_TERMINATORS.test(str);

694 }

695 > strings.ts

696 > export function isFullWidthCharacter(charCode: number): boolean {

697 // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns

698 // http://jrgraphix.net/research/unicode_blocks.php

741 );

742 }

743 > strings.ts

744 > /**

745 > * A fast function (therefore imprecise) to check if code points are emojis.

746 > * Generated using https://github.com/alexdima/unicode-utils/blob/main/emoji-test.js

747 > */

748 > export function isEmojiImprecise(x: number): boolean {

749 return (

750 (x >= 0x1F1E6 && x <= 0x1F1FF) || (x === 8986) || (x === 8987) || (x === 9200)

755 );

756 }

757 > strings.ts

758 > /**

759 > * Given a string and a max length returns a shorted version. Shorting

760 > * happens at favorable positions - such as whitespace or punctuation characters.

761 > * The return value can be longer than the given value of `n`. Leading whitespace is always trimmed.

762 > */

763 > export function lcut(text: string, n: number, prefix = ''): string {

764 const trimmed = text.trimStart();

765

785 return prefix + trimmed.substring(i).trimStart();

786 }

787 > strings.ts

788 > /**

789 > * Given a string and a max length returns a shortened version keeping the beginning.

790 > * Shortening happens at favorable positions - such as whitespace or punctuation characters.

791 > * Trailing whitespace is always trimmed.

792 > */

793 > export function rcut(text: string, n: number, suffix = ''): string {

794 const trimmed = text.trimEnd();

795

832 return result + suffix;

833 }

834 > strings.ts

835 > // Defacto standard: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html

836 > const CSI_SEQUENCE = /(?:\x1b\[|\x9b)[=?>!]?[\d;:]*["$#'* ]?[a-zA-Z@^`{}|~]/;

837 > const OSC_SEQUENCE = /(?:\x1b\]|\x9d).*?(?:\x1b\\|\x07|\x9c)/;

838 > const ESC_SEQUENCE = /\x1b(?:[ #%\(\)\*\+\-\.\/]?[a-zA-Z0-9\|}~@])/;

839 > const CONTROL_SEQUENCES = new RegExp('(?:' + [

840 > CSI_SEQUENCE.source,

841 > OSC_SEQUENCE.source,

842 > ESC_SEQUENCE.source,

843 > ].join('|') + ')', 'g');

844 >

845 > /** Iterates over parts of a string with CSI sequences */

846 > export function* forAnsiStringParts(str: string) {

847 let last = 0;

848 for (const match of str.matchAll(CONTROL_SEQUENCES)) {

859 }

860 }

861 > strings.ts

862 > /**

863 > * Strips ANSI escape sequences from a string.

864 > * @param str The dastringa stringo strip the ANSI escape sequences from.

865 > *

866 > * @example

867 > * removeAnsiEscapeCodes('\u001b[31mHello, World!\u001b[0m');

868 > * // 'Hello, World!'

869 > */

870 > export function removeAnsiEscapeCodes(str: string): string {

871 if (str) {

872 str = str.replace(CONTROL_SEQUENCES, '');

875 return str;

876 }

877 > strings.ts

878 > const PROMPT_NON_PRINTABLE = /\\\[.*?\\\]/g;

879 >

880 > /**

881 > * Strips ANSI escape sequences from a UNIX-style prompt string (eg. `$PS1`).

882 > * @param str The string to strip the ANSI escape sequences from.

883 > *

884 > * @example

885 > * removeAnsiEscapeCodesFromPrompt('\n\\[\u001b[01;34m\\]\\w\\[\u001b[00m\\]\n\\[\u001b[1;32m\\]> \\[\u001b[0m\\]');

886 > * // '\n\\w\n> '

887 > */

888 > export function removeAnsiEscapeCodesFromPrompt(str: string): string {

889 return removeAnsiEscapeCodes(str).replace(PROMPT_NON_PRINTABLE, '');

890 }

891 > strings.ts

892 >

893 > // -- UTF-8 BOM

894 >

895 > export const UTF8_BOM_CHARACTER = String.fromCharCode(CharCode.UTF8_BOM);

896 >

897 > export function startsWithUTF8BOM(str: string): boolean {

898 return !!(str && str.length > 0 && str.charCodeAt(0) === CharCode.UTF8_BOM);

899 }

900 > strings.ts

901 > export function stripUTF8BOM(str: string): string {

902 return startsWithUTF8BOM(str) ? str.substr(1) : str;

903 }

904 > strings.ts

905 > /**

906 > * Checks if the characters of the provided query string are included in the

907 > * target string. The characters do not have to be contiguous within the string.

908 > */

909 > export function fuzzyContains(target: string, query: string): boolean {

910 if (!target || !query) {

911 return false; // return early if target or query are undefined

936 return true;

937 }

938 > strings.ts

939 > export function containsUppercaseCharacter(target: string, ignoreEscapedChars = false): boolean {

940 if (!target) {

941 return false;

948 return target.toLowerCase() !== target;

949 }

950 > strings.ts

951 > export function uppercaseFirstLetter(str: string): string {

952 return str.charAt(0).toUpperCase() + str.slice(1);

953 }

954 > strings.ts

955 > export function getNLines(str: string, n = 1): string {

956 if (n === 0) {

957 return '';

974 return str.substr(0, idx);

975 }

976 > strings.ts

977 > /**

978 > * Produces 'a'-'z', followed by 'A'-'Z'... followed by 'a'-'z', etc.

979 > */

980 > export function singleLetterHash(n: number): string {

981 const LETTERS_CNT = (CharCode.Z - CharCode.A + 1);

982

989 return String.fromCharCode(CharCode.A + n - LETTERS_CNT);

990 }

991 > strings.ts

992 > //#region Unicode Grapheme Break

993 >

994 > export function getGraphemeBreakType(codePoint: number): GraphemeBreakType {

995 const graphemeBreakTree = GraphemeBreakTree.getInstance();

996 return graphemeBreakTree.getGraphemeBreakType(codePoint);

997 }

998 > strings.ts

999 function breakBetweenGraphemeBreakType(breakTypeA: GraphemeBreakType, breakTypeB: GraphemeBreakType): boolean {

1000 // http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules

1076 return true;

1077 }

1078 > strings.ts

1079 > export const enum GraphemeBreakType {

1080 > Other = 0,

1081 > Prepend = 1,

1082 > CR = 2,

1083 > LF = 3,

1084 > Control = 4,

1085 > Extend = 5,

1086 > Regional_Indicator = 6,

1087 > SpacingMark = 7,

1088 > L = 8,

1089 > V = 9,

1090 > T = 10,

1091 > LV = 11,

1092 > LVT = 12,

1093 > ZWJ = 13,

1094 > Extended_Pictographic = 14

1095 > }

1096 >

1097 > class GraphemeBreakTree {

1098 >

1099 > private static _INSTANCE: GraphemeBreakTree | null = null;

1100 > public static getInstance(): GraphemeBreakTree {

1101 if (!GraphemeBreakTree._INSTANCE) {

1102 GraphemeBreakTree._INSTANCE = new GraphemeBreakTree();

1104 return GraphemeBreakTree._INSTANCE;

1105 }

1106 > strings.ts

1107 > private readonly _data: number[];

1108 >

1109 > constructor() {

1110 this._data = getGraphemeBreakRawData();

1111 }

1112 > strings.ts

1113 > public getGraphemeBreakType(codePoint: number): GraphemeBreakType {

1114 // !!! Let's make 7bit ASCII a bit faster: 0..31

1115 if (codePoint < 32) {

1145 return GraphemeBreakType.Other;

1146 }

1147 > } strings.ts

1148 >

1149 function getGraphemeBreakRawData(): number[] {

1150 // generated using https://github.com/alexdima/unicode-utils/blob/main/grapheme-break.js

1151 return JSON.parse('[0,0,0,51229,51255,12,44061,44087,12,127462,127487,6,7083,7085,5,47645,47671,12,54813,54839,12,128678,128678,14,3270,3270,5,9919,9923,14,45853,45879,12,49437,49463,12,53021,53047,12,71216,71218,7,128398,128399,14,129360,129374,14,2519,2519,5,4448,4519,9,9742,9742,14,12336,12336,14,44957,44983,12,46749,46775,12,48541,48567,12,50333,50359,12,52125,52151,12,53917,53943,12,69888,69890,5,73018,73018,5,127990,127990,14,128558,128559,14,128759,128760,14,129653,129655,14,2027,2035,5,2891,2892,7,3761,3761,5,6683,6683,5,8293,8293,4,9825,9826,14,9999,9999,14,43452,43453,5,44509,44535,12,45405,45431,12,46301,46327,12,47197,47223,12,48093,48119,12,48989,49015,12,49885,49911,12,50781,50807,12,51677,51703,12,52573,52599,12,53469,53495,12,54365,54391,12,65279,65279,4,70471,70472,7,72145,72147,7,119173,119179,5,127799,127818,14,128240,128244,14,128512,128512,14,128652,128652,14,128721,128722,14,129292,129292,14,129445,129450,14,129734,129743,14,1476,1477,5,2366,2368,7,2750,2752,7,3076,3076,5,3415,3415,5,4141,4144,5,6109,6109,5,6964,6964,5,7394,7400,5,9197,9198,14,9770,9770,14,9877,9877,14,9968,9969,14,10084,10084,14,43052,43052,5,43713,43713,5,44285,44311,12,44733,44759,12,45181,45207,12,45629,45655,12,46077,46103,12,46525,46551,12,46973,46999,12,47421,47447,12,47869,47895,12,48317,48343,12,48765,48791,12,49213,49239,12,49661,49687,12,50109,50135,12,50557,50583,12,51005,51031,12,51453,51479,12,51901,51927,12,52349,52375,12,52797,52823,12,53245,53271,12,53693,53719,12,54141,54167,12,54589,54615,12,55037,55063,12,69506,69509,5,70191,70193,5,70841,70841,7,71463,71467,5,72330,72342,5,94031,94031,5,123628,123631,5,127763,127765,14,127941,127941,14,128043,128062,14,128302,128317,14,128465,128467,14,128539,128539,14,128640,128640,14,128662,128662,14,128703,128703,14,128745,128745,14,129004,129007,14,129329,129330,14,129402,129402,14,129483,129483,14,129686,129704,14,130048,131069,14,173,173,4,1757,1757,1,2200,2207,5,2434,2435,7,2631,2632,5,2817,2817,5,3008,3008,5,3201,3201,5,3387,3388,5,3542,3542,5,3902,3903,7,4190,4192,5,6002,6003,5,6439,6440,5,6765,6770,7,7019,7027,5,7154,7155,7,8205,8205,13,8505,8505,14,9654,9654,14,9757,9757,14,9792,9792,14,9852,9853,14,9890,9894,14,9937,9937,14,9981,9981,14,10035,10036,14,11035,11036,14,42654,42655,5,43346,43347,7,43587,43587,5,44006,44007,7,44173,44199,12,44397,44423,12,44621,44647,12,44845,44871,12,45069,45095,12,45293,45319,12,45517,45543,12,45741,45767,12,45965,45991,12,46189,46215,12,46413,46439,12,46637,46663,12,46861,46887,12,47085,47111,12,47309,47335,12,47533,47559,12,47757,47783,12,47981,48007,12,48205,48231,12,48429,48455,12,48653,48679,12,48877,48903,12,49101,49127,12,49325,49351,12,49549,49575,12,49773,49799,12,49997,50023,12,50221,50247,12,50445,50471,12,50669,50695,12,50893,50919,12,51117,51143,12,51341,51367,12,51565,51591,12,51789,51815,12,52013,52039,12,52237,52263,12,52461,52487,12,52685,52711,12,52909,52935,12,53133,53159,12,53357,53383,12,53581,53607,12,53805,53831,12,54029,54055,12,54253,54279,12,54477,54503,12,54701,54727,12,54925,54951,12,55149,55175,12,68101,68102,5,69762,69762,7,70067,70069,7,70371,70378,5,70720,70721,7,71087,71087,5,71341,71341,5,71995,71996,5,72249,72249,7,72850,72871,5,73109,73109,5,118576,118598,5,121505,121519,5,127245,127247,14,127568,127569,14,127777,127777,14,127872,127891,14,127956,127967,14,128015,128016,14,128110,128172,14,128259,128259,14,128367,128368,14,128424,128424,14,128488,128488,14,128530,128532,14,128550,128551,14,128566,128566,14,128647,128647,14,128656,128656,14,128667,128673,14,128691,128693,14,128715,128715,14,128728,128732,14,128752,128752,14,128765,128767,14,129096,129103,14,129311,129311,14,129344,129349,14,129394,129394,14,129413,129425,14,129466,129471,14,129511,129535,14,129664,129666,14,129719,129722,14,129760,129767,14,917536,917631,5,13,13,2,1160,1161,5,1564,1564,4,1807,1807,1,2085,2087,5,2307,2307,7,2382,2383,7,2497,2500,5,2563,2563,7,2677,2677,5,2763,2764,7,2879,2879,5,2914,2915,5,3021,3021,5,3142,3144,5,3263,3263,5,3285,3286,5,3398,3400,7,3530,3530,5,3633,3633,5,3864,3865,5,3974,3975,5,4155,4156,7,4229,4230,5,5909,5909,7,6078,6085,7,6277,6278,5,6451,6456,7,6744,6750,5,6846,6846,5,6972,6972,5,7074,7077,5,7146,7148,7,7222,7223,5,7416,7417,5,8234,8238,4,8417,8417,5,9000,9000,14,9203,9203,14,9730,9731,14,9748,9749,14,9762,9763,14,9776,9783,14,9800,9811,14,9831,9831,14,9872,9873,14,9882,9882,14,9900,9903,14,9929,9933,14,9941,9960,14,9974,9974,14,9989,9989,14,10006,10006,14,10062,10062,14,10160,10160,14,11647,11647,5,12953,12953,14,43019,43019,5,43232,43249,5,43443,43443,5,43567,43568,7,43696,43696,5,43765,43765,7,44013,44013,5,44117,44143,12,44229,44255,12,44341,44367,12,44453,44479,12,44565,44591,12,44677,44703,12,44789,44815,12,44901,44927,12,45013,45039,12,45125,45151,12,45237,45263,12,45349,45375,12,45461,45487,12,45573,45599,12,45685,45711,12,45797,45823,12,45909,45935,12,46021,46047,12,46133,46159,12,46245,46271,12,46357,46383,12,46469,46495,12,46581,46607,12,46693,46719,12,46805,46831,12,46917,46943,12,47029,47055,12,47141,47167,12,47253,47279,12,47365,47391,12,47477,47503,12,47589,47615,12,47701,47727,12,47813,47839,12,47925,47951,12,48037,48063,12,48149,48175,12,48261,48287,12,48373,48399,12,48485,48511,12,48597,48623,12,48709,48735,12,48821,48847,12,48933,48959,12,49045,49071,12,49157,49183,12,49269,49295,12,49381,49407,12,49493,49519,12,49605,49631,12,49717,49743,12,49829,49855,12,49941,49967,12,50053,50079,12,50165,50191,12,50277,50303,12,50389,50415,12,50501,50527,12,50613,50639,12,50725,50751,12,50837,50863,12,50949,50975,12,51061,51087,12,51173,51199,12,51285,51311,12,51397,51423,12,51509,51535,12,51621,51647,12,51733,51759,12,51845,51871,12,51957,51983,12,52069,52095,12,52181,52207,12,52293,52319,12,52405,52431,12,52517,52543,12,52629,52655,12,52741,52767,12,52853,52879,12,52965,52991,12,53077,53103,12,53189,53215,12,53301,53327,12,53413,53439,12,53525,53551,12,53637,53663,12,53749,53775,12,53861,53887,12,53973,53999,12,54085,54111,12,54197,54223,12,54309,54335,12,54421,54447,12,54533,54559,12,54645,54671,12,54757,54783,12,54869,54895,12,54981,55007,12,55093,55119,12,55243,55291,10,66045,66045,5,68325,68326,5,69688,69702,5,69817,69818,5,69957,69958,7,70089,70092,5,70198,70199,5,70462,70462,5,70502,70508,5,70750,70750,5,70846,70846,7,71100,71101,5,71230,71230,7,71351,71351,5,71737,71738,5,72000,72000,7,72160,72160,5,72273,72278,5,72752,72758,5,72882,72883,5,73031,73031,5,73461,73462,7,94192,94193,7,119149,119149,7,121403,121452,5,122915,122916,5,126980,126980,14,127358,127359,14,127535,127535,14,127759,127759,14,127771,127771,14,127792,127793,14,127825,127867,14,127897,127899,14,127945,127945,14,127985,127986,14,128000,128007,14,128021,128021,14,128066,128100,14,128184,128235,14,128249,128252,14,128266,128276,14,128335,128335,14,128379,128390,14,128407,128419,14,128444,128444,14,128481,128481,14,128499,128499,14,128526,128526,14,128536,128536,14,128543,128543,14,128556,128556,14,128564,128564,14,128577,128580,14,128643,128645,14,128649,128649,14,128654,128654,14,128660,128660,14,128664,128664,14,128675,128675,14,128686,128689,14,128695,128696,14,128705,128709,14,128717,128719,14,128725,128725,14,128736,128741,14,128747,128748,14,128755,128755,14,128762,128762,14,128981,128991,14,129009,129023,14,129160,129167,14,129296,129304,14,129320,129327,14,129340,129342,14,129356,129356,14,129388,129392,14,129399,129400,14,129404,129407,14,129432,129442,14,129454,129455,14,129473,129474,14,129485,129487,14,129648,129651,14,129659,129660,14,129671,129679,14,129709,129711,14,129728,129730,14,129751,129753,14,129776,129782,14,917505,917505,4,917760,917999,5,10,10,3,127,159,4,768,879,5,1471,1471,5,1536,1541,1,1648,1648,5,1767,1768,5,1840,1866,5,2070,2073,5,2137,2139,5,2274,2274,1,2363,2363,7,2377,2380,7,2402,2403,5,2494,2494,5,2507,2508,7,2558,2558,5,2622,2624,7,2641,2641,5,2691,2691,7,2759,2760,5,2786,2787,5,2876,2876,5,2881,2884,5,2901,2902,5,3006,3006,5,3014,3016,7,3072,3072,5,3134,3136,5,3157,3158,5,3260,3260,5,3266,3266,5,3274,3275,7,3328,3329,5,3391,3392,7,3405,3405,5,3457,3457,5,3536,3537,7,3551,3551,5,3636,3642,5,3764,3772,5,3895,3895,5,3967,3967,7,3993,4028,5,4146,4151,5,4182,4183,7,4226,4226,5,4253,4253,5,4957,4959,5,5940,5940,7,6070,6070,7,6087,6088,7,6158,6158,4,6432,6434,5,6448,6449,7,6679,6680,5,6742,6742,5,6754,6754,5,6783,6783,5,6912,6915,5,6966,6970,5,6978,6978,5,7042,7042,7,7080,7081,5,7143,7143,7,7150,7150,7,7212,7219,5,7380,7392,5,7412,7412,5,8203,8203,4,8232,8232,4,8265,8265,14,8400,8412,5,8421,8432,5,8617,8618,14,9167,9167,14,9200,9200,14,9410,9410,14,9723,9726,14,9733,9733,14,9745,9745,14,9752,9752,14,9760,9760,14,9766,9766,14,9774,9774,14,9786,9786,14,9794,9794,14,9823,9823,14,9828,9828,14,9833,9850,14,9855,9855,14,9875,9875,14,9880,9880,14,9885,9887,14,9896,9897,14,9906,9916,14,9926,9927,14,9935,9935,14,9939,9939,14,9962,9962,14,9972,9972,14,9978,9978,14,9986,9986,14,9997,9997,14,10002,10002,14,10017,10017,14,10055,10055,14,10071,10071,14,10133,10135,14,10548,10549,14,11093,11093,14,12330,12333,5,12441,12442,5,42608,42610,5,43010,43010,5,43045,43046,5,43188,43203,7,43302,43309,5,43392,43394,5,43446,43449,5,43493,43493,5,43571,43572,7,43597,43597,7,43703,43704,5,43756,43757,5,44003,44004,7,44009,44010,7,44033,44059,12,44089,44115,12,44145,44171,12,44201,44227,12,44257,44283,12,44313,44339,12,44369,44395,12,44425,44451,12,44481,44507,12,44537,44563,12,44593,44619,12,44649,44675,12,44705,44731,12,44761,44787,12,44817,44843,12,44873,44899,12,44929,44955,12,44985,45011,12,45041,45067,12,45097,45123,12,45153,45179,12,45209,45235,12,45265,45291,12,45321,45347,12,45377,45403,12,45433,45459,12,45489,45515,12,45545,45571,12,45601,45627,12,45657,45683,12,45713,45739,12,45769,45795,12,45825,45851,12,45881,45907,12,45937,45963,12,45993,46019,12,46049,46075,12,46105,46131,12,46161,46187,12,46217,46243,12,46273,46299,12,46329,46355,12,46385,46411,12,46441,46467,12,46497,46523,12,46553,46579,12,46609,46635,12,46665,46691,12,46721,46747,12,46777,46803,12,46833,46859,12,46889,46915,12,46945,46971,12,47001,47027,12,47057,47083,12,47113,47139,12,47169,47195,12,47225,47251,12,47281,47307,12,47337,47363,12,47393,47419,12,47449,47475,12,47505,47531,12,47561,47587,12,47617,47643,12,47673,47699,12,47729,47755,12,47785,47811,12,47841,47867,12,47897,47923,12,47953,47979,12,48009,48035,12,48065,48091,12,48121,48147,12,48177,48203,12,48233,48259,12,48289,48315,12,48345,48371,12,48401,48427,12,48457,48483,12,48513,48539,12,48569,48595,12,48625,48651,12,48681,48707,12,48737,48763,12,48793,48819,12,48849,48875,12,48905,48931,12,48961,48987,12,49017,49043,12,49073,49099,12,49129,49155,12,49185,49211,12,49241,49267,12,49297,49323,12,49353,49379,12,49409,49435,12,49465,49491,12,49521,49547,12,49577,49603,12,49633,49659,12,49689,49715,12,49745,49771,12,49801,49827,12,49857,49883,12,49913,49939,12,49969,49995,12,50025,50051,12,50081,50107,12,50137,50163,12,50193,50219,12,50249,50275,12,50305,50331,12,50361,50387,12,50417,50443,12,50473,50499,12,50529,50555,12,50585,50611,12,50641,50667,12,50697,50723,12,50753,50779,12,50809,50835,12,50865,50891,12,50921,50947,12,50977,51003,12,51033,51059,12,51089,51115,12,51145,51171,12,51201,51227,12,51257,51283,12,51313,51339,12,51369,51395,12,51425,51451,12,51481,51507,12,51537,51563,12,51593,51619,12,51649,51675,12,51705,51731,12,51761,51787,12,51817,51843,12,51873,51899,12,51929,51955,12,51985,52011,12,52041,52067,12,52097,52123,12,52153,52179,12,52209,52235,12,52265,52291,12,52321,52347,12,52377,52403,12,52433,52459,12,52489,52515,12,52545,52571,12,52601,52627,12,52657,52683,12,52713,52739,12,52769,52795,12,52825,52851,12,52881,52907,12,52937,52963,12,52993,53019,12,53049,53075,12,53105,53131,12,53161,53187,12,53217,53243,12,53273,53299,12,53329,53355,12,53385,53411,12,53441,53467,12,53497,53523,12,53553,53579,12,53609,53635,12,53665,53691,12,53721,53747,12,53777,53803,12,53833,53859,12,53889,53915,12,53945,53971,12,54001,54027,12,54057,54083,12,54113,54139,12,54169,54195,12,54225,54251,12,54281,54307,12,54337,54363,12,54393,54419,12,54449,54475,12,54505,54531,12,54561,54587,12,54617,54643,12,54673,54699,12,54729,54755,12,54785,54811,12,54841,54867,12,54897,54923,12,54953,54979,12,55009,55035,12,55065,55091,12,55121,55147,12,55177,55203,12,65024,65039,5,65520,65528,4,66422,66426,5,68152,68154,5,69291,69292,5,69633,69633,5,69747,69748,5,69811,69814,5,69826,69826,5,69932,69932,7,70016,70017,5,70079,70080,7,70095,70095,5,70196,70196,5,70367,70367,5,70402,70403,7,70464,70464,5,70487,70487,5,70709,70711,7,70725,70725,7,70833,70834,7,70843,70844,7,70849,70849,7,71090,71093,5,71103,71104,5,71227,71228,7,71339,71339,5,71344,71349,5,71458,71461,5,71727,71735,5,71985,71989,7,71998,71998,5,72002,72002,7,72154,72155,5,72193,72202,5,72251,72254,5,72281,72283,5,72344,72345,5,72766,72766,7,72874,72880,5,72885,72886,5,73023,73029,5,73104,73105,5,73111,73111,5,92912,92916,5,94095,94098,5,113824,113827,4,119142,119142,7,119155,119162,4,119362,119364,5,121476,121476,5,122888,122904,5,123184,123190,5,125252,125258,5,127183,127183,14,127340,127343,14,127377,127386,14,127491,127503,14,127548,127551,14,127744,127756,14,127761,127761,14,127769,127769,14,127773,127774,14,127780,127788,14,127796,127797,14,127820,127823,14,127869,127869,14,127894,127895,14,127902,127903,14,127943,127943,14,127947,127950,14,127972,127972,14,127988,127988,14,127992,127994,14,128009,128011,14,128019,128019,14,128023,128041,14,128064,128064,14,128102,128107,14,128174,128181,14,128238,128238,14,128246,128247,14,128254,128254,14,128264,128264,14,128278,128299,14,128329,128330,14,128348,128359,14,128371,128377,14,128392,128393,14,128401,128404,14,128421,128421,14,128433,128434,14,128450,128452,14,128476,128478,14,128483,128483,14,128495,128495,14,128506,128506,14,128519,128520,14,128528,128528,14,128534,128534,14,128538,128538,14,128540,128542,14,128544,128549,14,128552,128555,14,128557,128557,14,128560,128563,14,128565,128565,14,128567,128576,14,128581,128591,14,128641,128642,14,128646,128646,14,128648,128648,14,128650,128651,14,128653,128653,14,128655,128655,14,128657,128659,14,128661,128661,14,128663,128663,14,128665,128666,14,128674,128674,14,128676,128677,14,128679,128685,14,128690,128690,14,128694,128694,14,128697,128702,14,128704,128704,14,128710,128714,14,128716,128716,14,128720,128720,14,128723,128724,14,128726,128727,14,128733,128735,14,128742,128744,14,128746,128746,14,128749,128751,14,128753,128754,14,128756,128758,14,128761,128761,14,128763,128764,14,128884,128895,14,128992,129003,14,129008,129008,14,129036,129039,14,129114,129119,14,129198,129279,14,129293,129295,14,129305,129310,14,129312,129319,14,129328,129328,14,129331,129338,14,129343,129343,14,129351,129355,14,129357,129359,14,129375,129387,14,129393,129393,14,129395,129398,14,129401,129401,14,129403,129403,14,129408,129412,14,129426,129431,14,129443,129444,14,129451,129453,14,129456,129465,14,129472,129472,14,129475,129482,14,129484,129484,14,129488,129510,14,129536,129647,14,129652,129652,14,129656,129658,14,129661,129663,14,129667,129670,14,129680,129685,14,129705,129708,14,129712,129718,14,129723,129727,14,129731,129733,14,129744,129750,14,129754,129759,14,129768,129775,14,129783,129791,14,917504,917504,4,917506,917535,4,917632,917759,4,918000,921599,4,0,9,4,11,12,4,14,31,4,169,169,14,174,174,14,1155,1159,5,1425,1469,5,1473,1474,5,1479,1479,5,1552,1562,5,1611,1631,5,1750,1756,5,1759,1764,5,1770,1773,5,1809,1809,5,1958,1968,5,2045,2045,5,2075,2083,5,2089,2093,5,2192,2193,1,2250,2273,5,2275,2306,5,2362,2362,5,2364,2364,5,2369,2376,5,2381,2381,5,2385,2391,5,2433,2433,5,2492,2492,5,2495,2496,7,2503,2504,7,2509,2509,5,2530,2531,5,2561,2562,5,2620,2620,5,2625,2626,5,2635,2637,5,2672,2673,5,2689,2690,5,2748,2748,5,2753,2757,5,2761,2761,7,2765,2765,5,2810,2815,5,2818,2819,7,2878,2878,5,2880,2880,7,2887,2888,7,2893,2893,5,2903,2903,5,2946,2946,5,3007,3007,7,3009,3010,7,3018,3020,7,3031,3031,5,3073,3075,7,3132,3132,5,3137,3140,7,3146,3149,5,3170,3171,5,3202,3203,7,3262,3262,7,3264,3265,7,3267,3268,7,3271,3272,7,3276,3277,5,3298,3299,5,3330,3331,7,3390,3390,5,3393,3396,5,3402,3404,7,3406,3406,1,3426,3427,5,3458,3459,7,3535,3535,5,3538,3540,5,3544,3550,7,3570,3571,7,3635,3635,7,3655,3662,5,3763,3763,7,3784,3789,5,3893,3893,5,3897,3897,5,3953,3966,5,3968,3972,5,3981,3991,5,4038,4038,5,4145,4145,7,4153,4154,5,4157,4158,5,4184,4185,5,4209,4212,5,4228,4228,7,4237,4237,5,4352,4447,8,4520,4607,10,5906,5908,5,5938,5939,5,5970,5971,5,6068,6069,5,6071,6077,5,6086,6086,5,6089,6099,5,6155,6157,5,6159,6159,5,6313,6313,5,6435,6438,7,6441,6443,7,6450,6450,5,6457,6459,5,6681,6682,7,6741,6741,7,6743,6743,7,6752,6752,5,6757,6764,5,6771,6780,5,6832,6845,5,6847,6862,5,6916,6916,7,6965,6965,5,6971,6971,7,6973,6977,7,6979,6980,7,7040,7041,5,7073,7073,7,7078,7079,7,7082,7082,7,7142,7142,5,7144,7145,5,7149,7149,5,7151,7153,5,7204,7211,7,7220,7221,7,7376,7378,5,7393,7393,7,7405,7405,5,7415,7415,7,7616,7679,5,8204,8204,5,8206,8207,4,8233,8233,4,8252,8252,14,8288,8292,4,8294,8303,4,8413,8416,5,8418,8420,5,8482,8482,14,8596,8601,14,8986,8987,14,9096,9096,14,9193,9196,14,9199,9199,14,9201,9202,14,9208,9210,14,9642,9643,14,9664,9664,14,9728,9729,14,9732,9732,14,9735,9741,14,9743,9744,14,9746,9746,14,9750,9751,14,9753,9756,14,9758,9759,14,9761,9761,14,9764,9765,14,9767,9769,14,9771,9773,14,9775,9775,14,9784,9785,14,9787,9791,14,9793,9793,14,9795,9799,14,9812,9822,14,9824,9824,14,9827,9827,14,9829,9830,14,9832,9832,14,9851,9851,14,9854,9854,14,9856,9861,14,9874,9874,14,9876,9876,14,9878,9879,14,9881,9881,14,9883,9884,14,9888,9889,14,9895,9895,14,9898,9899,14,9904,9905,14,9917,9918,14,9924,9925,14,9928,9928,14,9934,9934,14,9936,9936,14,9938,9938,14,9940,9940,14,9961,9961,14,9963,9967,14,9970,9971,14,9973,9973,14,9975,9977,14,9979,9980,14,9982,9985,14,9987,9988,14,9992,9996,14,9998,9998,14,10000,10001,14,10004,10004,14,10013,10013,14,10024,10024,14,10052,10052,14,10060,10060,14,10067,10069,14,10083,10083,14,10085,10087,14,10145,10145,14,10175,10175,14,11013,11015,14,11088,11088,14,11503,11505,5,11744,11775,5,12334,12335,5,12349,12349,14,12951,12951,14,42607,42607,5,42612,42621,5,42736,42737,5,43014,43014,5,43043,43044,7,43047,43047,7,43136,43137,7,43204,43205,5,43263,43263,5,43335,43345,5,43360,43388,8,43395,43395,7,43444,43445,7,43450,43451,7,43454,43456,7,43561,43566,5,43569,43570,5,43573,43574,5,43596,43596,5,43644,43644,5,43698,43700,5,43710,43711,5,43755,43755,7,43758,43759,7,43766,43766,5,44005,44005,5,44008,44008,5,44012,44012,7,44032,44032,11,44060,44060,11,44088,44088,11,44116,44116,11,44144,44144,11,44172,44172,11,44200,44200,11,44228,44228,11,44256,44256,11,44284,44284,11,44312,44312,11,44340,44340,11,44368,44368,11,44396,44396,11,44424,44424,11,44452,44452,11,44480,44480,11,44508,44508,11,44536,44536,11,44564,44564,11,44592,44592,11,44620,44620,11,44648,44648,11,44676,44676,11,44704,44704,11,44732,44732,11,44760,44760,11,44788,44788,11,44816,44816,11,44844,44844,11,44872,44872,11,44900,44900,11,44928,44928,11,44956,44956,11,44984,44984,11,45012,45012,11,45040,45040,11,45068,45068,11,45096,45096,11,45124,45124,11,45152,45152,11,45180,45180,11,45208,45208,11,45236,45236,11,45264,45264,11,45292,45292,11,45320,45320,11,45348,45348,11,45376,45376,11,45404,45404,11,45432,45432,11,45460,45460,11,45488,45488,11,45516,45516,11,45544,45544,11,45572,45572,11,45600,45600,11,45628,45628,11,45656,45656,11,45684,45684,11,45712,45712,11,45740,45740,11,45768,45768,11,45796,45796,11,45824,45824,11,45852,45852,11,45880,45880,11,45908,45908,11,45936,45936,11,45964,45964,11,45992,45992,11,46020,46020,11,46048,46048,11,46076,46076,11,46104,46104,11,46132,46132,11,46160,46160,11,46188,46188,11,46216,46216,11,46244,46244,11,46272,46272,11,46300,46300,11,46328,46328,11,46356,46356,11,46384,46384,11,46412,46412,11,46440,46440,11,46468,46468,11,46496,46496,11,46524,46524,11,46552,46552,11,46580,46580,11,46608,46608,11,46636,46636,11,46664,46664,11,46692,46692,11,46720,46720,11,46748,46748,11,46776,46776,11,46804,46804,11,46832,46832,11,46860,46860,11,46888,46888,11,46916,46916,11,46944,46944,11,46972,46972,11,47000,47000,11,47028,47028,11,47056,47056,11,47084,47084,11,47112,47112,11,47140,47140,11,47168,47168,11,47196,47196,11,47224,47224,11,47252,47252,11,47280,47280,11,47308,47308,11,47336,47336,11,47364,47364,11,47392,47392,11,47420,47420,11,47448,47448,11,47476,47476,11,47504,47504,11,47532,47532,11,47560,47560,11,47588,47588,11,47616,47616,11,47644,47644,11,47672,47672,11,47700,47700,11,47728,47728,11,47756,47756,11,47784,47784,11,47812,47812,11,47840,47840,11,47868,47868,11,47896,47896,11,47924,47924,11,47952,47952,11,47980,47980,11,48008,48008,11,48036,48036,11,48064,48064,11,48092,48092,11,48120,48120,11,48148,48148,11,48176,48176,11,48204,48204,11,48232,48232,11,48260,48260,11,48288,48288,11,48316,48316,11,48344,48344,11,48372,48372,11,48400,48400,11,48428,48428,11,48456,48456,11,48484,48484,11,48512,48512,11,48540,48540,11,48568,48568,11,48596,48596,11,48624,48624,11,48652,48652,11,48680,48680,11,48708,48708,11,48736,48736,11,48764,48764,11,48792,48792,11,48820,48820,11,48848,48848,11,48876,48876,11,48904,48904,11,48932,48932,11,48960,48960,11,48988,48988,11,49016,49016,11,49044,49044,11,49072,49072,11,49100,49100,11,49128,49128,11,49156,49156,11,49184,49184,11,49212,49212,11,49240,49240,11,49268,49268,11,49296,49296,11,49324,49324,11,49352,49352,11,49380,49380,11,49408,49408,11,49436,49436,11,49464,49464,11,49492,49492,11,49520,49520,11,49548,49548,11,49576,49576,11,49604,49604,11,49632,49632,11,49660,49660,11,49688,49688,11,49716,49716,11,49744,49744,11,49772,49772,11,49800,49800,11,49828,49828,11,49856,49856,11,49884,49884,11,49912,49912,11,49940,49940,11,49968,49968,11,49996,49996,11,50024,50024,11,50052,50052,11,50080,50080,11,50108,50108,11,50136,50136,11,50164,50164,11,50192,50192,11,50220,50220,11,50248,50248,11,50276,50276,11,50304,50304,11,50332,50332,11,50360,50360,11,50388,50388,11,50416,50416,11,50444,50444,11,50472,50472,11,50500,50500,11,50528,50528,11,50556,50556,11,50584,50584,11,50612,50612,11,50640,50640,11,50668,50668,11,50696,50696,11,50724,50724,11,50752,50752,11,50780,50780,11,50808,50808,11,50836,50836,11,50864,50864,11,50892,50892,11,50920,50920,11,50948,50948,11,50976,50976,11,51004,51004,11,51032,51032,11,51060,51060,11,51088,51088,11,51116,51116,11,51144,51144,11,51172,51172,11,51200,51200,11,51228,51228,11,51256,51256,11,51284,51284,11,51312,51312,11,51340,51340,11,51368,51368,11,51396,51396,11,51424,51424,11,51452,51452,11,51480,51480,11,51508,51508,11,51536,51536,11,51564,51564,11,51592,51592,11,51620,51620,11,51648,51648,11,51676,51676,11,51704,51704,11,51732,51732,11,51760,51760,11,51788,51788,11,51816,51816,11,51844,51844,11,51872,51872,11,51900,51900,11,51928,51928,11,51956,51956,11,51984,51984,11,52012,52012,11,52040,52040,11,52068,52068,11,52096,52096,11,52124,52124,11,52152,52152,11,52180,52180,11,52208,52208,11,52236,52236,11,52264,52264,11,52292,52292,11,52320,52320,11,52348,52348,11,52376,52376,11,52404,52404,11,52432,52432,11,52460,52460,11,52488,52488,11,52516,52516,11,52544,52544,11,52572,52572,11,52600,52600,11,52628,52628,11,52656,52656,11,52684,52684,11,52712,52712,11,52740,52740,11,52768,52768,11,52796,52796,11,52824,52824,11,52852,52852,11,52880,52880,11,52908,52908,11,52936,52936,11,52964,52964,11,52992,52992,11,53020,53020,11,53048,53048,11,53076,53076,11,53104,53104,11,53132,53132,11,53160,53160,11,53188,53188,11,53216,53216,11,53244,53244,11,53272,53272,11,53300,53300,11,53328,53328,11,53356,53356,11,53384,53384,11,53412,53412,11,53440,53440,11,53468,53468,11,53496,53496,11,53524,53524,11,53552,53552,11,53580,53580,11,53608,53608,11,53636,53636,11,53664,53664,11,53692,53692,11,53720,53720,11,53748,53748,11,53776,53776,11,53804,53804,11,53832,53832,11,53860,53860,11,53888,53888,11,53916,53916,11,53944,53944,11,53972,53972,11,54000,54000,11,54028,54028,11,54056,54056,11,54084,54084,11,54112,54112,11,54140,54140,11,54168,54168,11,54196,54196,11,54224,54224,11,54252,54252,11,54280,54280,11,54308,54308,11,54336,54336,11,54364,54364,11,54392,54392,11,54420,54420,11,54448,54448,11,54476,54476,11,54504,54504,11,54532,54532,11,54560,54560,11,54588,54588,11,54616,54616,11,54644,54644,11,54672,54672,11,54700,54700,11,54728,54728,11,54756,54756,11,54784,54784,11,54812,54812,11,54840,54840,11,54868,54868,11,54896,54896,11,54924,54924,11,54952,54952,11,54980,54980,11,55008,55008,11,55036,55036,11,55064,55064,11,55092,55092,11,55120,55120,11,55148,55148,11,55176,55176,11,55216,55238,9,64286,64286,5,65056,65071,5,65438,65439,5,65529,65531,4,66272,66272,5,68097,68099,5,68108,68111,5,68159,68159,5,68900,68903,5,69446,69456,5,69632,69632,7,69634,69634,7,69744,69744,5,69759,69761,5,69808,69810,7,69815,69816,7,69821,69821,1,69837,69837,1,69927,69931,5,69933,69940,5,70003,70003,5,70018,70018,7,70070,70078,5,70082,70083,1,70094,70094,7,70188,70190,7,70194,70195,7,70197,70197,7,70206,70206,5,70368,70370,7,70400,70401,5,70459,70460,5,70463,70463,7,70465,70468,7,70475,70477,7,70498,70499,7,70512,70516,5,70712,70719,5,70722,70724,5,70726,70726,5,70832,70832,5,70835,70840,5,70842,70842,5,70845,70845,5,70847,70848,5,70850,70851,5,71088,71089,7,71096,71099,7,71102,71102,7,71132,71133,5,71219,71226,5,71229,71229,5,71231,71232,5,71340,71340,7,71342,71343,7,71350,71350,7,71453,71455,5,71462,71462,7,71724,71726,7,71736,71736,7,71984,71984,5,71991,71992,7,71997,71997,7,71999,71999,1,72001,72001,1,72003,72003,5,72148,72151,5,72156,72159,7,72164,72164,7,72243,72248,5,72250,72250,1,72263,72263,5,72279,72280,7,72324,72329,1,72343,72343,7,72751,72751,7,72760,72765,5,72767,72767,5,72873,72873,7,72881,72881,7,72884,72884,7,73009,73014,5,73020,73021,5,73030,73030,1,73098,73102,7,73107,73108,7,73110,73110,7,73459,73460,5,78896,78904,4,92976,92982,5,94033,94087,7,94180,94180,5,113821,113822,5,118528,118573,5,119141,119141,5,119143,119145,5,119150,119154,5,119163,119170,5,119210,119213,5,121344,121398,5,121461,121461,5,121499,121503,5,122880,122886,5,122907,122913,5,122918,122922,5,123566,123566,5,125136,125142,5,126976,126979,14,126981,127182,14,127184,127231,14,127279,127279,14,127344,127345,14,127374,127374,14,127405,127461,14,127489,127490,14,127514,127514,14,127538,127546,14,127561,127567,14,127570,127743,14,127757,127758,14,127760,127760,14,127762,127762,14,127766,127768,14,127770,127770,14,127772,127772,14,127775,127776,14,127778,127779,14,127789,127791,14,127794,127795,14,127798,127798,14,127819,127819,14,127824,127824,14,127868,127868,14,127870,127871,14,127892,127893,14,127896,127896,14,127900,127901,14,127904,127940,14,127942,127942,14,127944,127944,14,127946,127946,14,127951,127955,14,127968,127971,14,127973,127984,14,127987,127987,14,127989,127989,14,127991,127991,14,127995,127999,5,128008,128008,14,128012,128014,14,128017,128018,14,128020,128020,14,128022,128022,14,128042,128042,14,128063,128063,14,128065,128065,14,128101,128101,14,128108,128109,14,128173,128173,14,128182,128183,14,128236,128237,14,128239,128239,14,128245,128245,14,128248,128248,14,128253,128253,14,128255,128258,14,128260,128263,14,128265,128265,14,128277,128277,14,128300,128301,14,128326,128328,14,128331,128334,14,128336,128347,14,128360,128366,14,128369,128370,14,128378,128378,14,128391,128391,14,128394,128397,14,128400,128400,14,128405,128406,14,128420,128420,14,128422,128423,14,128425,128432,14,128435,128443,14,128445,128449,14,128453,128464,14,128468,128475,14,128479,128480,14,128482,128482,14,128484,128487,14,128489,128494,14,128496,128498,14,128500,128505,14,128507,128511,14,128513,128518,14,128521,128525,14,128527,128527,14,128529,128529,14,128533,128533,14,128535,128535,14,128537,128537,14]');

1152 }

1153 > strings.ts

1154 > //#endregion

1155 >

1156 > /**

1157 > * Computes the offset after performing a left delete on the given string,

1158 > * while considering unicode grapheme/emoji rules.

1159 > */

1160 > export function getLeftDeleteOffset(offset: number, str: string): number {

1161 if (offset === 0) {

1162 return 0;

1174 return iterator.offset;

1175 }

1176 > strings.ts

1177 function getOffsetBeforeLastEmojiComponent(initialOffset: number, str: string): number | undefined {

1178 // See https://www.unicode.org/reports/tr51/tr51-14.html#EBNF_and_Regex for the

1210 return resultOffset;

1211 }

1212 > strings.ts

1213 function isEmojiModifier(codePoint: number): boolean {

1214 return 0x1F3FB <= codePoint && codePoint <= 0x1F3FF;

1215 }

1216 > strings.ts

1217 > const enum CodePoint {

1218 > zwj = 0x200D,

1219 >

1220 > /**

1221 > * Variation Selector-16 (VS16)

1222 > */

1223 > emojiVariantSelector = 0xFE0F,

1224 >

1225 > /**

1226 > * Combining Enclosing Keycap

1227 > */

1228 > enclosingKeyCap = 0x20E3,

1229 >

1230 > space = 0x0020,

1231 > }

1232 >

1233 > export const noBreakWhitespace = '\xa0';

1234 >

1235 > export class AmbiguousCharacters {

1236 > private static readonly ambiguousCharacterData = new Lazy<

1237 > Record<

1238 > string | '_common' | '_default',

1239 > /* code point -> ascii code point */ number[]

1240 > >

1241 > >(() => {

1242 // Generated using https://github.com/hediet/vscode-unicode-data

1243 // Stored as key1, value1, key2, value2, ...

1245 '{\"_common\":[8232,32,8233,32,5760,32,8192,32,8193,32,8194,32,8195,32,8196,32,8197,32,8198,32,8200,32,8201,32,8202,32,8287,32,8199,32,8239,32,2042,95,65101,95,65102,95,65103,95,8208,45,8209,45,8210,45,65112,45,1748,45,8259,45,727,45,8722,45,10134,45,11450,45,1549,44,1643,44,184,44,42233,44,894,59,2307,58,2691,58,1417,58,1795,58,1796,58,5868,58,65072,58,6147,58,6153,58,8282,58,1475,58,760,58,42889,58,8758,58,720,58,42237,58,451,33,11601,33,660,63,577,63,2429,63,5038,63,42731,63,119149,46,8228,46,1793,46,1794,46,42510,46,68176,46,1632,46,1776,46,42232,46,1373,96,65287,96,8219,96,1523,96,8242,96,1370,96,8175,96,65344,96,900,96,8189,96,8125,96,8127,96,8190,96,697,96,884,96,712,96,714,96,715,96,756,96,699,96,701,96,700,96,702,96,42892,96,1497,96,2036,96,2037,96,5194,96,5836,96,94033,96,94034,96,65339,91,10088,40,10098,40,12308,40,64830,40,65341,93,10089,41,10099,41,12309,41,64831,41,10100,123,119060,123,10101,125,65342,94,8270,42,1645,42,8727,42,66335,42,5941,47,8257,47,8725,47,8260,47,9585,47,10187,47,10744,47,119354,47,12755,47,12339,47,11462,47,20031,47,12035,47,65340,92,65128,92,8726,92,10189,92,10741,92,10745,92,119311,92,119355,92,12756,92,20022,92,12034,92,42872,38,708,94,710,94,5869,43,10133,43,66203,43,8249,60,10094,60,706,60,119350,60,5176,60,5810,60,5120,61,11840,61,12448,61,42239,61,8250,62,10095,62,707,62,119351,62,5171,62,94015,62,8275,126,732,126,8128,126,8764,126,65372,124,65293,45,118002,50,120784,50,120794,50,120804,50,120814,50,120824,50,130034,50,42842,50,423,50,1000,50,42564,50,5311,50,42735,50,119302,51,118003,51,120785,51,120795,51,120805,51,120815,51,120825,51,130035,51,42923,51,540,51,439,51,42858,51,11468,51,1248,51,94011,51,71882,51,118004,52,120786,52,120796,52,120806,52,120816,52,120826,52,130036,52,5070,52,71855,52,118005,53,120787,53,120797,53,120807,53,120817,53,120827,53,130037,53,444,53,71867,53,118006,54,120788,54,120798,54,120808,54,120818,54,120828,54,130038,54,11474,54,5102,54,71893,54,119314,55,118007,55,120789,55,120799,55,120809,55,120819,55,120829,55,130039,55,66770,55,71878,55,2819,56,2538,56,2666,56,125131,56,118008,56,120790,56,120800,56,120810,56,120820,56,120830,56,130040,56,547,56,546,56,66330,56,2663,57,2920,57,2541,57,3437,57,118009,57,120791,57,120801,57,120811,57,120821,57,120831,57,130041,57,42862,57,11466,57,71884,57,71852,57,71894,57,9082,97,65345,97,119834,97,119886,97,119938,97,119990,97,120042,97,120094,97,120146,97,120198,97,120250,97,120302,97,120354,97,120406,97,120458,97,593,97,945,97,120514,97,120572,97,120630,97,120688,97,120746,97,65313,65,117974,65,119808,65,119860,65,119912,65,119964,65,120016,65,120068,65,120120,65,120172,65,120224,65,120276,65,120328,65,120380,65,120432,65,913,65,120488,65,120546,65,120604,65,120662,65,120720,65,5034,65,5573,65,42222,65,94016,65,66208,65,119835,98,119887,98,119939,98,119991,98,120043,98,120095,98,120147,98,120199,98,120251,98,120303,98,120355,98,120407,98,120459,98,388,98,5071,98,5234,98,5551,98,65314,66,8492,66,117975,66,119809,66,119861,66,119913,66,120017,66,120069,66,120121,66,120173,66,120225,66,120277,66,120329,66,120381,66,120433,66,42932,66,914,66,120489,66,120547,66,120605,66,120663,66,120721,66,5108,66,5623,66,42192,66,66178,66,66209,66,66305,66,65347,99,8573,99,119836,99,119888,99,119940,99,119992,99,120044,99,120096,99,120148,99,120200,99,120252,99,120304,99,120356,99,120408,99,120460,99,7428,99,1010,99,11429,99,43951,99,66621,99,128844,67,71913,67,71922,67,65315,67,8557,67,8450,67,8493,67,117976,67,119810,67,119862,67,119914,67,119966,67,120018,67,120174,67,120226,67,120278,67,120330,67,120382,67,120434,67,1017,67,11428,67,5087,67,42202,67,66210,67,66306,67,66581,67,66844,67,8574,100,8518,100,119837,100,119889,100,119941,100,119993,100,120045,100,120097,100,120149,100,120201,100,120253,100,120305,100,120357,100,120409,100,120461,100,1281,100,5095,100,5231,100,42194,100,8558,68,8517,68,117977,68,119811,68,119863,68,119915,68,119967,68,120019,68,120071,68,120123,68,120175,68,120227,68,120279,68,120331,68,120383,68,120435,68,5024,68,5598,68,5610,68,42195,68,8494,101,65349,101,8495,101,8519,101,119838,101,119890,101,119942,101,120046,101,120098,101,120150,101,120202,101,120254,101,120306,101,120358,101,120410,101,120462,101,43826,101,1213,101,8959,69,65317,69,8496,69,117978,69,119812,69,119864,69,119916,69,120020,69,120072,69,120124,69,120176,69,120228,69,120280,69,120332,69,120384,69,120436,69,917,69,120492,69,120550,69,120608,69,120666,69,120724,69,11577,69,5036,69,42224,69,71846,69,71854,69,66182,69,119839,102,119891,102,119943,102,119995,102,120047,102,120099,102,120151,102,120203,102,120255,102,120307,102,120359,102,120411,102,120463,102,43829,102,42905,102,383,102,7837,102,1412,102,119315,70,8497,70,117979,70,119813,70,119865,70,119917,70,120021,70,120073,70,120125,70,120177,70,120229,70,120281,70,120333,70,120385,70,120437,70,42904,70,988,70,120778,70,5556,70,42205,70,71874,70,71842,70,66183,70,66213,70,66853,70,65351,103,8458,103,119840,103,119892,103,119944,103,120048,103,120100,103,120152,103,120204,103,120256,103,120308,103,120360,103,120412,103,120464,103,609,103,7555,103,397,103,1409,103,117980,71,119814,71,119866,71,119918,71,119970,71,120022,71,120074,71,120126,71,120178,71,120230,71,120282,71,120334,71,120386,71,120438,71,1292,71,5056,71,5107,71,42198,71,65352,104,8462,104,119841,104,119945,104,119997,104,120049,104,120101,104,120153,104,120205,104,120257,104,120309,104,120361,104,120413,104,120465,104,1211,104,1392,104,5058,104,65320,72,8459,72,8460,72,8461,72,117981,72,119815,72,119867,72,119919,72,120023,72,120179,72,120231,72,120283,72,120335,72,120387,72,120439,72,919,72,120494,72,120552,72,120610,72,120668,72,120726,72,11406,72,5051,72,5500,72,42215,72,66255,72,731,105,9075,105,65353,105,8560,105,8505,105,8520,105,119842,105,119894,105,119946,105,119998,105,120050,105,120102,105,120154,105,120206,105,120258,105,120310,105,120362,105,120414,105,120466,105,120484,105,618,105,617,105,953,105,8126,105,890,105,120522,105,120580,105,120638,105,120696,105,120754,105,1110,105,42567,105,1231,105,43893,105,5029,105,71875,105,65354,106,8521,106,119843,106,119895,106,119947,106,119999,106,120051,106,120103,106,120155,106,120207,106,120259,106,120311,106,120363,106,120415,106,120467,106,1011,106,1112,106,65322,74,117983,74,119817,74,119869,74,119921,74,119973,74,120025,74,120077,74,120129,74,120181,74,120233,74,120285,74,120337,74,120389,74,120441,74,42930,74,895,74,1032,74,5035,74,5261,74,42201,74,119844,107,119896,107,119948,107,120000,107,120052,107,120104,107,120156,107,120208,107,120260,107,120312,107,120364,107,120416,107,120468,107,8490,75,65323,75,117984,75,119818,75,119870,75,119922,75,119974,75,120026,75,120078,75,120130,75,120182,75,120234,75,120286,75,120338,75,120390,75,120442,75,922,75,120497,75,120555,75,120613,75,120671,75,120729,75,11412,75,5094,75,5845,75,42199,75,66840,75,1472,108,8739,73,9213,73,65512,73,1633,108,1777,73,66336,108,125127,108,118001,108,120783,73,120793,73,120803,73,120813,73,120823,73,130033,73,65321,73,8544,73,8464,73,8465,73,117982,108,119816,73,119868,73,119920,73,120024,73,120128,73,120180,73,120232,73,120284,73,120336,73,120388,73,120440,73,65356,108,8572,73,8467,108,119845,108,119897,108,119949,108,120001,108,120053,108,120105,73,120157,73,120209,73,120261,73,120313,73,120365,73,120417,73,120469,73,448,73,120496,73,120554,73,120612,73,120670,73,120728,73,11410,73,1030,73,1216,73,1493,108,1503,108,1575,108,126464,108,126592,108,65166,108,65165,108,1994,108,11599,73,5825,73,42226,73,93992,73,66186,124,66313,124,119338,76,8556,76,8466,76,117985,76,119819,76,119871,76,119923,76,120027,76,120079,76,120131,76,120183,76,120235,76,120287,76,120339,76,120391,76,120443,76,11472,76,5086,76,5290,76,42209,76,93974,76,71843,76,71858,76,66587,76,66854,76,65325,77,8559,77,8499,77,117986,77,119820,77,119872,77,119924,77,120028,77,120080,77,120132,77,120184,77,120236,77,120288,77,120340,77,120392,77,120444,77,924,77,120499,77,120557,77,120615,77,120673,77,120731,77,1018,77,11416,77,5047,77,5616,77,5846,77,42207,77,66224,77,66321,77,119847,110,119899,110,119951,110,120003,110,120055,110,120107,110,120159,110,120211,110,120263,110,120315,110,120367,110,120419,110,120471,110,1400,110,1404,110,65326,78,8469,78,117987,78,119821,78,119873,78,119925,78,119977,78,120029,78,120081,78,120185,78,120237,78,120289,78,120341,78,120393,78,120445,78,925,78,120500,78,120558,78,120616,78,120674,78,120732,78,11418,78,42208,78,66835,78,3074,111,3202,111,3330,111,3458,111,2406,111,2662,111,2790,111,3046,111,3174,111,3302,111,3430,111,3664,111,3792,111,4160,111,1637,111,1781,111,65359,111,8500,111,119848,111,119900,111,119952,111,120056,111,120108,111,120160,111,120212,111,120264,111,120316,111,120368,111,120420,111,120472,111,7439,111,7441,111,43837,111,959,111,120528,111,120586,111,120644,111,120702,111,120760,111,963,111,120532,111,120590,111,120648,111,120706,111,120764,111,11423,111,4351,111,1413,111,1505,111,1607,111,126500,111,126564,111,126596,111,65259,111,65260,111,65258,111,65257,111,1726,111,64428,111,64429,111,64427,111,64426,111,1729,111,64424,111,64425,111,64423,111,64422,111,1749,111,3360,111,4125,111,66794,111,71880,111,71895,111,66604,111,1984,79,2534,79,2918,79,12295,79,70864,79,71904,79,118000,79,120782,79,120792,79,120802,79,120812,79,120822,79,130032,79,65327,79,117988,79,119822,79,119874,79,119926,79,119978,79,120030,79,120082,79,120134,79,120186,79,120238,79,120290,79,120342,79,120394,79,120446,79,927,79,120502,79,120560,79,120618,79,120676,79,120734,79,11422,79,1365,79,11604,79,4816,79,2848,79,66754,79,42227,79,71861,79,66194,79,66219,79,66564,79,66838,79,9076,112,65360,112,119849,112,119901,112,119953,112,120005,112,120057,112,120109,112,120161,112,120213,112,120265,112,120317,112,120369,112,120421,112,120473,112,961,112,120530,112,120544,112,120588,112,120602,112,120646,112,120660,112,120704,112,120718,112,120762,112,120776,112,11427,112,65328,80,8473,80,117989,80,119823,80,119875,80,119927,80,119979,80,120031,80,120083,80,120187,80,120239,80,120291,80,120343,80,120395,80,120447,80,929,80,120504,80,120562,80,120620,80,120678,80,120736,80,11426,80,5090,80,5229,80,42193,80,66197,80,119850,113,119902,113,119954,113,120006,113,120058,113,120110,113,120162,113,120214,113,120266,113,120318,113,120370,113,120422,113,120474,113,1307,113,1379,113,1382,113,8474,81,117990,81,119824,81,119876,81,119928,81,119980,81,120032,81,120084,81,120188,81,120240,81,120292,81,120344,81,120396,81,120448,81,11605,81,119851,114,119903,114,119955,114,120007,114,120059,114,120111,114,120163,114,120215,114,120267,114,120319,114,120371,114,120423,114,120475,114,43847,114,43848,114,7462,114,11397,114,43905,114,119318,82,8475,82,8476,82,8477,82,117991,82,119825,82,119877,82,119929,82,120033,82,120189,82,120241,82,120293,82,120345,82,120397,82,120449,82,422,82,5025,82,5074,82,66740,82,5511,82,42211,82,94005,82,65363,115,119852,115,119904,115,119956,115,120008,115,120060,115,120112,115,120164,115,120216,115,120268,115,120320,115,120372,115,120424,115,120476,115,42801,115,445,115,1109,115,43946,115,71873,115,66632,115,65331,83,117992,83,119826,83,119878,83,119930,83,119982,83,120034,83,120086,83,120138,83,120190,83,120242,83,120294,83,120346,83,120398,83,120450,83,1029,83,1359,83,5077,83,5082,83,42210,83,94010,83,66198,83,66592,83,119853,116,119905,116,119957,116,120009,116,120061,116,120113,116,120165,116,120217,116,120269,116,120321,116,120373,116,120425,116,120477,116,8868,84,10201,84,128872,84,65332,84,117993,84,119827,84,119879,84,119931,84,119983,84,120035,84,120087,84,120139,84,120191,84,120243,84,120295,84,120347,84,120399,84,120451,84,932,84,120507,84,120565,84,120623,84,120681,84,120739,84,11430,84,5026,84,42196,84,93962,84,71868,84,66199,84,66225,84,66325,84,119854,117,119906,117,119958,117,120010,117,120062,117,120114,117,120166,117,120218,117,120270,117,120322,117,120374,117,120426,117,120478,117,42911,117,7452,117,43854,117,43858,117,651,117,965,117,120534,117,120592,117,120650,117,120708,117,120766,117,1405,117,66806,117,71896,117,8746,85,8899,85,117994,85,119828,85,119880,85,119932,85,119984,85,120036,85,120088,85,120140,85,120192,85,120244,85,120296,85,120348,85,120400,85,120452,85,1357,85,4608,85,66766,85,5196,85,42228,85,94018,85,71864,85,8744,118,8897,118,65366,118,8564,118,119855,118,119907,118,119959,118,120011,118,120063,118,120115,118,120167,118,120219,118,120271,118,120323,118,120375,118,120427,118,120479,118,7456,118,957,118,120526,118,120584,118,120642,118,120700,118,120758,118,1141,118,1496,118,71430,118,43945,118,71872,118,119309,86,1639,86,1783,86,8548,86,117995,86,119829,86,119881,86,119933,86,119985,86,120037,86,120089,86,120141,86,120193,86,120245,86,120297,86,120349,86,120401,86,120453,86,1140,86,11576,86,5081,86,5167,86,42719,86,42214,86,93960,86,71840,86,66845,86,623,119,119856,119,119908,119,119960,119,120012,119,120064,119,120116,119,120168,119,120220,119,120272,119,120324,119,120376,119,120428,119,120480,119,7457,119,1121,119,1309,119,1377,119,71434,119,71438,119,71439,119,43907,119,71910,87,71919,87,117996,87,119830,87,119882,87,119934,87,119986,87,120038,87,120090,87,120142,87,120194,87,120246,87,120298,87,120350,87,120402,87,120454,87,1308,87,5043,87,5076,87,42218,87,5742,120,10539,120,10540,120,10799,120,65368,120,8569,120,119857,120,119909,120,119961,120,120013,120,120065,120,120117,120,120169,120,120221,120,120273,120,120325,120,120377,120,120429,120,120481,120,5441,120,5501,120,5741,88,9587,88,66338,88,71916,88,65336,88,8553,88,117997,88,119831,88,119883,88,119935,88,119987,88,120039,88,120091,88,120143,88,120195,88,120247,88,120299,88,120351,88,120403,88,120455,88,42931,88,935,88,120510,88,120568,88,120626,88,120684,88,120742,88,11436,88,11613,88,5815,88,42219,88,66192,88,66228,88,66327,88,66855,88,611,121,7564,121,65369,121,119858,121,119910,121,119962,121,120014,121,120066,121,120118,121,120170,121,120222,121,120274,121,120326,121,120378,121,120430,121,120482,121,655,121,7935,121,43866,121,947,121,8509,121,120516,121,120574,121,120632,121,120690,121,120748,121,1199,121,4327,121,71900,121,65337,89,117998,89,119832,89,119884,89,119936,89,119988,89,120040,89,120092,89,120144,89,120196,89,120248,89,120300,89,120352,89,120404,89,120456,89,933,89,978,89,120508,89,120566,89,120624,89,120682,89,120740,89,11432,89,1198,89,5033,89,5053,89,42220,89,94019,89,71844,89,66226,89,119859,122,119911,122,119963,122,120015,122,120067,122,120119,122,120171,122,120223,122,120275,122,120327,122,120379,122,120431,122,120483,122,7458,122,43923,122,71876,122,71909,90,66293,90,65338,90,8484,90,8488,90,117999,90,119833,90,119885,90,119937,90,119989,90,120041,90,120197,90,120249,90,120301,90,120353,90,120405,90,120457,90,918,90,120493,90,120551,90,120609,90,120667,90,120725,90,5059,90,42204,90,71849,90,65282,34,65283,35,65284,36,65285,37,65286,38,65290,42,65291,43,65294,46,65295,47,65296,48,65298,50,65299,51,65300,52,65301,53,65302,54,65303,55,65304,56,65305,57,65308,60,65309,61,65310,62,65312,64,65316,68,65318,70,65319,71,65324,76,65329,81,65330,82,65333,85,65334,86,65335,87,65343,95,65346,98,65348,100,65350,102,65355,107,65357,109,65358,110,65361,113,65362,114,65364,116,65365,117,65367,119,65370,122,65371,123,65373,125,119846,109],\"_default\":[160,32,8211,45,65374,126,8218,44,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"cs\":[65374,126,8218,44,65306,58,65281,33,8216,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"de\":[65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"es\":[8211,45,65374,126,8218,44,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"fr\":[65374,126,8218,44,65306,58,65281,33,8216,96,8245,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"it\":[160,32,8211,45,65374,126,8218,44,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"ja\":[8211,45,8218,44,65281,33,8216,96,8245,96,180,96,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65292,44,65297,49,65307,59],\"ko\":[8211,45,65374,126,8218,44,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"pl\":[65374,126,65306,58,65281,33,8216,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"pt-BR\":[65374,126,8218,44,65306,58,65281,33,8216,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"qps-ploc\":[160,32,8211,45,65374,126,8218,44,65306,58,65281,33,8216,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"ru\":[65374,126,8218,44,65306,58,65281,33,8216,96,8245,96,180,96,12494,47,305,105,921,73,1009,112,215,120,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"tr\":[160,32,8211,45,65374,126,8218,44,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41,65292,44,65297,49,65307,59,65311,63],\"zh-hans\":[160,32,65374,126,8218,44,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65297,49],\"zh-hant\":[8211,45,65374,126,8218,44,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89]}'

1246 );

1247 > }); strings.ts

1248 >

1249 > private static readonly cache = new LRUCachedFunction<string, AmbiguousCharacters>((localesStr) => {

1250 const locales = localesStr.split(',');

1251

1304

1305 return new AmbiguousCharacters(map);

1306 > }); strings.ts

1307 >

1308 > public static getInstance(locales: Iterable<string>): AmbiguousCharacters {

1309 return AmbiguousCharacters.cache.get(Array.from(locales).join(','));

1310 }

1311 > strings.ts

1312 > private static _locales = new Lazy<string[]>(() =>

1313 Object.keys(AmbiguousCharacters.ambiguousCharacterData.value).filter(

1314 (k) => !k.startsWith('_')

1315 )

1316 > ); strings.ts

1317 > public static getLocales(): string[] {

1318 return AmbiguousCharacters._locales.value;

1319 }

1320 > strings.ts

1321 > private constructor(

1322 private readonly confusableDictionary: Map<number, number>

1323 ) { }

1324 > strings.ts

1325 > public isAmbiguous(codePoint: number): boolean {

1326 return this.confusableDictionary.has(codePoint);

1327 }

1328 > strings.ts

1329 > public containsAmbiguousCharacter(str: string): boolean {

1330 for (let i = 0; i < str.length; i++) {

1331 const codePoint = str.codePointAt(i);

1336 return false;

1337 }

1338 > strings.ts

1339 > /**

1340 > * Returns the non basic ASCII code point that the given code point can be confused,

1341 > * or undefined if such code point does note exist.

1342 > */

1343 > public getPrimaryConfusable(codePoint: number): number | undefined {

1344 return this.confusableDictionary.get(codePoint);

1345 }

1346 > strings.ts

1347 > public getConfusableCodePoints(): ReadonlySet<number> {

1348 return new Set(this.confusableDictionary.keys());

1349 }

1350 > } strings.ts

1351 >

1352 > export class InvisibleCharacters {

1353 > private static getRawData(): Record<string | '_common', number[]> {

1354 // Generated using https://github.com/hediet/vscode-unicode-data

1355 return JSON.parse('{\"_common\":[11,12,13,127,847,1564,4447,4448,6068,6069,6155,6156,6157,6158,7355,7356,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8204,8205,8206,8207,8234,8235,8236,8237,8238,8239,8287,8288,8289,8290,8291,8292,8293,8294,8295,8296,8297,8298,8299,8300,8301,8302,8303,10240,12644,65024,65025,65026,65027,65028,65029,65030,65031,65032,65033,65034,65035,65036,65037,65038,65039,65279,65440,65520,65521,65522,65523,65524,65525,65526,65527,65528,65532,78844,119155,119156,119157,119158,119159,119160,119161,119162,917504,917505,917506,917507,917508,917509,917510,917511,917512,917513,917514,917515,917516,917517,917518,917519,917520,917521,917522,917523,917524,917525,917526,917527,917528,917529,917530,917531,917532,917533,917534,917535,917536,917537,917538,917539,917540,917541,917542,917543,917544,917545,917546,917547,917548,917549,917550,917551,917552,917553,917554,917555,917556,917557,917558,917559,917560,917561,917562,917563,917564,917565,917566,917567,917568,917569,917570,917571,917572,917573,917574,917575,917576,917577,917578,917579,917580,917581,917582,917583,917584,917585,917586,917587,917588,917589,917590,917591,917592,917593,917594,917595,917596,917597,917598,917599,917600,917601,917602,917603,917604,917605,917606,917607,917608,917609,917610,917611,917612,917613,917614,917615,917616,917617,917618,917619,917620,917621,917622,917623,917624,917625,917626,917627,917628,917629,917630,917631,917760,917761,917762,917763,917764,917765,917766,917767,917768,917769,917770,917771,917772,917773,917774,917775,917776,917777,917778,917779,917780,917781,917782,917783,917784,917785,917786,917787,917788,917789,917790,917791,917792,917793,917794,917795,917796,917797,917798,917799,917800,917801,917802,917803,917804,917805,917806,917807,917808,917809,917810,917811,917812,917813,917814,917815,917816,917817,917818,917819,917820,917821,917822,917823,917824,917825,917826,917827,917828,917829,917830,917831,917832,917833,917834,917835,917836,917837,917838,917839,917840,917841,917842,917843,917844,917845,917846,917847,917848,917849,917850,917851,917852,917853,917854,917855,917856,917857,917858,917859,917860,917861,917862,917863,917864,917865,917866,917867,917868,917869,917870,917871,917872,917873,917874,917875,917876,917877,917878,917879,917880,917881,917882,917883,917884,917885,917886,917887,917888,917889,917890,917891,917892,917893,917894,917895,917896,917897,917898,917899,917900,917901,917902,917903,917904,917905,917906,917907,917908,917909,917910,917911,917912,917913,917914,917915,917916,917917,917918,917919,917920,917921,917922,917923,917924,917925,917926,917927,917928,917929,917930,917931,917932,917933,917934,917935,917936,917937,917938,917939,917940,917941,917942,917943,917944,917945,917946,917947,917948,917949,917950,917951,917952,917953,917954,917955,917956,917957,917958,917959,917960,917961,917962,917963,917964,917965,917966,917967,917968,917969,917970,917971,917972,917973,917974,917975,917976,917977,917978,917979,917980,917981,917982,917983,917984,917985,917986,917987,917988,917989,917990,917991,917992,917993,917994,917995,917996,917997,917998,917999],\"cs\":[173,8203,12288],\"de\":[173,8203,12288],\"es\":[8203,12288],\"fr\":[173,8203,12288],\"it\":[160,173,12288],\"ja\":[173],\"ko\":[173,12288],\"pl\":[173,8203,12288],\"pt-BR\":[173,8203,12288],\"qps-ploc\":[160,173,8203,12288],\"ru\":[173,12288],\"tr\":[160,173,8203,12288],\"zh-hans\":[160,173,8203,12288],\"zh-hant\":[173,12288]}');

1356 }

1357 > strings.ts

1358 > private static _data: Set<number> | undefined = undefined;

1359 >

1360 > private static getData() {

1361 if (!this._data) {

1362 this._data = new Set([...Object.values(InvisibleCharacters.getRawData())].flat());

1364 return this._data;

1365 }

1366 > strings.ts

1367 > public static isInvisibleCharacter(codePoint: number): boolean {

1368 return InvisibleCharacters.getData().has(codePoint);

1369 }

1370 > strings.ts

1371 > public static containsInvisibleCharacter(str: string): boolean {

1372 for (let i = 0; i < str.length; i++) {

1373 const codePoint = str.codePointAt(i);

1378 return false;

1379 }

1380 > strings.ts

1381 > public static get codePoints(): ReadonlySet<number> {

1382 return InvisibleCharacters.getData();

1383 }

1384 > } strings.ts

1385 >

1386 > export const Ellipsis = '\u2026';

1387 >

1388 > /**

1389 > * Convert a Unicode string to a string in which each 16-bit unit occupies only one byte

1390 > *

1391 > * From https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/btoa

1392 > */

1393 function toBinary(str: string): string {

1394 const codeUnits = new Uint16Array(str.length);

1403 return binary;

1404 }

1405 > strings.ts

1406 > /**

1407 > * Version of the global `btoa` function that handles multi-byte characters instead

1408 > * of throwing an exception.

1409 > */

1410 >

1411 > export function multibyteAwareBtoa(str: string): string {

1412 return btoa(toBinary(str));

1413 }

src/vs/platform/storage/common/storage.ts 451 covered LOC · 41 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- storage.ts

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 { Promises, RunOnceScheduler, runWhenGlobalIdle } from '../../../base/common/async.js';

7 > import { Emitter, Event, PauseableEmitter } from '../../../base/common/event.js';

8 > import { Disposable, DisposableStore, dispose, MutableDisposable } from '../../../base/common/lifecycle.js';

9 > import { mark } from '../../../base/common/performance.js';

10 > import { isUndefinedOrNull } from '../../../base/common/types.js';

11 > import { InMemoryStorageDatabase, IStorage, IStorageChangeEvent, Storage, StorageHint, StorageValue } from '../../../base/parts/storage/common/storage.js';

12 > import { createDecorator } from '../../instantiation/common/instantiation.js';

13 > import { isUserDataProfile, IUserDataProfile } from '../../userDataProfile/common/userDataProfile.js';

14 > import { IAnyWorkspaceIdentifier } from '../../workspace/common/workspace.js';

15 >

16 > export const IS_NEW_KEY = '__$__isNewStorageMarker';

17 > export const TARGET_KEY = '__$__targetStorageMarker';

18 >

19 > export const IStorageService = createDecorator<IStorageService>('storageService');

20 >

21 > export enum WillSaveStateReason {

22 >

23 > /**

24 > * No specific reason to save state.

25 > */

26 > NONE,

27 >

28 > /**

29 > * A hint that the workbench is about to shutdown.

30 > */

31 > SHUTDOWN

32 > }

33 >

34 > export interface IWillSaveStateEvent {

35 > readonly reason: WillSaveStateReason;

36 > }

37 >

38 > export interface IStorageEntry {

39 > readonly key: string;

40 > readonly value: StorageValue;

41 > readonly scope: StorageScope;

42 > readonly target: StorageTarget;

43 > }

44 >

45 > export interface IWorkspaceStorageValueChangeEvent extends IStorageValueChangeEvent {

46 > readonly scope: StorageScope.WORKSPACE;

47 > }

48 >

49 > export interface IProfileStorageValueChangeEvent extends IStorageValueChangeEvent {

50 > readonly scope: StorageScope.PROFILE;

51 > }

52 >

53 > export interface IApplicationStorageValueChangeEvent extends IStorageValueChangeEvent {

54 > readonly scope: StorageScope.APPLICATION;

55 > }

56 >

57 > export interface IApplicationSharedStorageValueChangeEvent extends IStorageValueChangeEvent {

58 > readonly scope: StorageScope.APPLICATION_SHARED;

59 > }

60 >

61 > export interface IStorageService {

62 >

63 > readonly _serviceBrand: undefined;

64 >

65 > /**

66 > * Emitted whenever data is updated or deleted on the given

67 > * scope and optional key.

68 > *

69 > * @param scope the `StorageScope` to listen to changes

70 > * @param key the optional key to filter for or all keys of

71 > * the scope if `undefined`

72 > */

73 > onDidChangeValue(scope: StorageScope.WORKSPACE, key: string | undefined, disposable: DisposableStore): Event<IWorkspaceStorageValueChangeEvent>;

74 > onDidChangeValue(scope: StorageScope.PROFILE, key: string | undefined, disposable: DisposableStore): Event<IProfileStorageValueChangeEvent>;

75 > onDidChangeValue(scope: StorageScope.APPLICATION, key: string | undefined, disposable: DisposableStore): Event<IApplicationStorageValueChangeEvent>;

76 > onDidChangeValue(scope: StorageScope.APPLICATION_SHARED, key: string | undefined, disposable: DisposableStore): Event<IApplicationSharedStorageValueChangeEvent>;

77 > onDidChangeValue(scope: StorageScope, key: string | undefined, disposable: DisposableStore): Event<IStorageValueChangeEvent>;

78 >

79 > /**

80 > * Emitted whenever target of a storage entry changes.

81 > */

82 > readonly onDidChangeTarget: Event<IStorageTargetChangeEvent>;

83 >

84 > /**

85 > * Emitted when the storage is about to persist. This is the right time

86 > * to persist data to ensure it is stored before the application shuts

87 > * down.

88 > *

89 > * The will save state event allows to optionally ask for the reason of

90 > * saving the state, e.g. to find out if the state is saved due to a

91 > * shutdown.

92 > *

93 > * Note: this event may be fired many times, not only on shutdown to prevent

94 > * loss of state in situations where the shutdown is not sufficient to

95 > * persist the data properly.

96 > */

97 > readonly onWillSaveState: Event<IWillSaveStateEvent>;

98 >

99 > /**

100 > * Retrieve an element stored with the given key from storage. Use

101 > * the provided `defaultValue` if the element is `null` or `undefined`.

102 > *

103 > * @param scope allows to define the scope of the storage operation

104 > * to either the current workspace only, all workspaces or all profiles.

105 > */

106 > get(key: string, scope: StorageScope, fallbackValue: string): string;

107 > get(key: string, scope: StorageScope, fallbackValue?: string): string | undefined;

108 >

109 > /**

110 > * Retrieve an element stored with the given key from storage. Use

111 > * the provided `defaultValue` if the element is `null` or `undefined`.

112 > * The element will be converted to a `boolean`.

113 > *

114 > * @param scope allows to define the scope of the storage operation

115 > * to either the current workspace only, all workspaces or all profiles.

116 > */

117 > getBoolean(key: string, scope: StorageScope, fallbackValue: boolean): boolean;

118 > getBoolean(key: string, scope: StorageScope, fallbackValue?: boolean): boolean | undefined;

119 >

120 > /**

121 > * Retrieve an element stored with the given key from storage. Use

122 > * the provided `defaultValue` if the element is `null` or `undefined`.

123 > * The element will be converted to a `number` using `parseInt` with a

124 > * base of `10`.

125 > *

126 > * @param scope allows to define the scope of the storage operation

127 > * to either the current workspace only, all workspaces or all profiles.

128 > */

129 > getNumber(key: string, scope: StorageScope, fallbackValue: number): number;

130 > getNumber(key: string, scope: StorageScope, fallbackValue?: number): number | undefined;

131 >

132 > /**

133 > * Retrieve an element stored with the given key from storage. Use

134 > * the provided `defaultValue` if the element is `null` or `undefined`.

135 > * The element will be converted to a `object` using `JSON.parse`.

136 > *

137 > * @param scope allows to define the scope of the storage operation

138 > * to either the current workspace only, all workspaces or all profiles.

139 > */

140 > getObject<T extends object>(key: string, scope: StorageScope, fallbackValue: T): T;

141 > getObject<T extends object>(key: string, scope: StorageScope, fallbackValue?: T): T | undefined;

142 >

143 > /**

144 > * Store a value under the given key to storage. The value will be

145 > * converted to a `string`. Storing either `undefined` or `null` will

146 > * remove the entry under the key.

147 > *

148 > * @param scope allows to define the scope of the storage operation

149 > * to either the current workspace only, all workspaces or all profiles.

150 > *

151 > * @param target allows to define the target of the storage operation

152 > * to either the current machine or user.

153 > */

154 > store(key: string, value: StorageValue, scope: StorageScope, target: StorageTarget): void;

155 >

156 > /**

157 > * Allows to store multiple values in a bulk operation. Events will only

158 > * be emitted when all values have been stored.

159 > *

160 > * @param external a hint to indicate the source of the operation is external,

161 > * such as settings sync or profile changes.

162 > */

163 > storeAll(entries: Array<IStorageEntry>, external: boolean): void;

164 >

165 > /**

166 > * Delete an element stored under the provided key from storage.

167 > *

168 > * The scope argument allows to define the scope of the storage

169 > * operation to either the current workspace only, all workspaces

170 > * or all profiles.

171 > */

172 > remove(key: string, scope: StorageScope): void;

173 >

174 > /**

175 > * Returns all the keys used in the storage for the provided `scope`

176 > * and `target`.

177 > *

178 > * Note: this will NOT return all keys stored in the storage layer.

179 > * Some keys may not have an associated `StorageTarget` and thus

180 > * will be excluded from the results.

181 > *

182 > * @param scope allows to define the scope for the keys

183 > * to either the current workspace only, all workspaces or all profiles.

184 > *

185 > * @param target allows to define the target for the keys

186 > * to either the current machine or user.

187 > */

188 > keys(scope: StorageScope, target: StorageTarget): string[];

189 >

190 > /**

191 > * Log the contents of the storage to the console.

192 > */

193 > log(): void;

194 >

195 > /**

196 > * Returns true if the storage service handles the provided scope.

197 > */

198 > hasScope(scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean;

199 >

200 > /**

201 > * Switch storage to another workspace or profile. Optionally preserve the

202 > * current data to the new storage.

203 > */

204 > switch(to: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void>;

205 >

206 > /**

207 > * Whether the storage for the given scope was created during this session or

208 > * existed before.

209 > */

210 > isNew(scope: StorageScope): boolean;

211 >

212 > /**

213 > * Attempts to reduce the DB size via optimization commands if supported.

214 > */

215 > optimize(scope: StorageScope): Promise<void>;

216 >

217 > /**

218 > * Allows to flush state, e.g. in cases where a shutdown is

219 > * imminent. This will send out the `onWillSaveState` to ask

220 > * everyone for latest state.

221 > *

222 > * @returns a `Promise` that can be awaited on when all updates

223 > * to the underlying storage have been flushed.

224 > */

225 > flush(reason?: WillSaveStateReason): Promise<void>;

226 > }

227 >

228 > export const enum StorageScope {

229 >

230 > /**

231 > * The stored data will be scoped to all workspaces across all profiles

232 > * and shared across VS Code and Sessions app.

233 > */

234 > APPLICATION_SHARED = -2,

235 >

236 > /**

237 > * The stored data will be scoped to all workspaces across all profiles.

238 > */

239 > APPLICATION = -1,

240 >

241 > /**

242 > * The stored data will be scoped to all workspaces of the same profile.

243 > */

244 > PROFILE = 0,

245 >

246 > /**

247 > * The stored data will be scoped to the current workspace.

248 > */

249 > WORKSPACE = 1

250 > }

251 >

252 > export const enum StorageTarget {

253 >

254 > /**

255 > * The stored data is user specific and applies across machines.

256 > */

257 > USER,

258 >

259 > /**

260 > * The stored data is machine specific.

261 > */

262 > MACHINE

263 > }

264 >

265 > export interface IStorageValueChangeEvent {

266 >

267 > /**

268 > * The scope for the storage entry that changed

269 > * or was removed.

270 > */

271 > readonly scope: StorageScope;

272 >

273 > /**

274 > * The `key` of the storage entry that was changed

275 > * or was removed.

276 > */

277 > readonly key: string;

278 >

279 > /**

280 > * The `target` can be `undefined` if a key is being

281 > * removed.

282 > */

283 > readonly target: StorageTarget | undefined;

284 >

285 > /**

286 > * A hint how the storage change event was triggered. If

287 > * `true`, the storage change was triggered by an external

288 > * source, such as:

289 > * - another process (for example another window)

290 > * - operations such as settings sync or profiles change

291 > */

292 > readonly external?: boolean;

293 > }

294 >

295 > export interface IStorageTargetChangeEvent {

296 >

297 > /**

298 > * The scope for the target that changed. Listeners

299 > * should use `keys(scope, target)` to get an updated

300 > * list of keys for the given `scope` and `target`.

301 > */

302 > readonly scope: StorageScope;

303 > }

304 >

305 > interface IKeyTargets {

306 > [key: string]: StorageTarget;

307 > }

308 >

309 > export interface IStorageServiceOptions {

310 > readonly flushInterval: number;

311 > }

312 >

313 > export function loadKeyTargets(storage: IStorage): IKeyTargets {

314 const keysRaw = storage.get(TARGET_KEY);

315 if (keysRaw) {

323 return Object.create(null);

324 }

325 > storage.ts

326 > export abstract class AbstractStorageService extends Disposable implements IStorageService {

327 >

328 > declare readonly _serviceBrand: undefined;

329 >

330 > private static DEFAULT_FLUSH_INTERVAL = 60 * 1000; // every minute

331 >

332 > private readonly _onDidChangeValue = this._register(new PauseableEmitter<IStorageValueChangeEvent>());

333 >

334 > private readonly _onDidChangeTarget = this._register(new PauseableEmitter<IStorageTargetChangeEvent>());

335 > readonly onDidChangeTarget = this._onDidChangeTarget.event;

336 >

337 > private readonly _onWillSaveState = this._register(new Emitter<IWillSaveStateEvent>());

338 > readonly onWillSaveState = this._onWillSaveState.event;

339 >

340 > private initializationPromise: Promise<void> | undefined;

341 >

342 > private readonly flushWhenIdleScheduler: RunOnceScheduler;

343 > private readonly runFlushWhenIdle = this._register(new MutableDisposable());

344 >

345 > constructor(options: IStorageServiceOptions = { flushInterval: AbstractStorageService.DEFAULT_FLUSH_INTERVAL }) {

346 super();

347

348 this.flushWhenIdleScheduler = this._register(new RunOnceScheduler(() => this.doFlushWhenIdle(), options.flushInterval));

349 }

350 > storage.ts

351 > onDidChangeValue(scope: StorageScope.WORKSPACE, key: string | undefined, disposable: DisposableStore): Event<IWorkspaceStorageValueChangeEvent>;

352 > onDidChangeValue(scope: StorageScope.PROFILE, key: string | undefined, disposable: DisposableStore): Event<IProfileStorageValueChangeEvent>;

353 > onDidChangeValue(scope: StorageScope.APPLICATION, key: string | undefined, disposable: DisposableStore): Event<IApplicationStorageValueChangeEvent>;

354 > onDidChangeValue(scope: StorageScope.APPLICATION_SHARED, key: string | undefined, disposable: DisposableStore): Event<IApplicationSharedStorageValueChangeEvent>;

355 > onDidChangeValue(scope: StorageScope, key: string | undefined, disposable: DisposableStore): Event<IStorageValueChangeEvent> {

356 return Event.filter(this._onDidChangeValue.event, e => e.scope === scope && (key === undefined || e.key === key), disposable);

357 }

358 > storage.ts

359 > private doFlushWhenIdle(): void {

360 this.runFlushWhenIdle.value = runWhenGlobalIdle(() => {

361 if (this.shouldFlushWhenIdle()) {

367 });

368 }

369 > storage.ts

370 > protected shouldFlushWhenIdle(): boolean {

371 return true;

372 }

373 > storage.ts

374 > protected stopFlushWhenIdle(): void {

375 dispose([this.runFlushWhenIdle, this.flushWhenIdleScheduler]);

376 }

377 > storage.ts

378 > initialize(): Promise<void> {

379 if (!this.initializationPromise) {

380 this.initializationPromise = (async () => {

402 return this.initializationPromise;

403 }

404 > storage.ts

405 > protected emitDidChangeValue(scope: StorageScope, event: IStorageChangeEvent): void {

406 const { key, external } = event;

407

434 }

435 }

436 > storage.ts

437 > protected emitWillSaveState(reason: WillSaveStateReason): void {

438 this._onWillSaveState.fire({ reason });

439 }

440 > storage.ts

441 > get(key: string, scope: StorageScope, fallbackValue: string): string;

442 > get(key: string, scope: StorageScope): string | undefined;

443 > get(key: string, scope: StorageScope, fallbackValue?: string): string | undefined {

444 return this.getStorage(scope)?.get(key, fallbackValue);

445 }

446 > storage.ts

447 > getBoolean(key: string, scope: StorageScope, fallbackValue: boolean): boolean;

448 > getBoolean(key: string, scope: StorageScope): boolean | undefined;

449 > getBoolean(key: string, scope: StorageScope, fallbackValue?: boolean): boolean | undefined {

450 return this.getStorage(scope)?.getBoolean(key, fallbackValue);

451 }

452 > storage.ts

453 > getNumber(key: string, scope: StorageScope, fallbackValue: number): number;

454 > getNumber(key: string, scope: StorageScope): number | undefined;

455 > getNumber(key: string, scope: StorageScope, fallbackValue?: number): number | undefined {

456 return this.getStorage(scope)?.getNumber(key, fallbackValue);

457 }

458 > storage.ts

459 > getObject(key: string, scope: StorageScope, fallbackValue: object): object;

460 > getObject(key: string, scope: StorageScope): object | undefined;

461 > getObject(key: string, scope: StorageScope, fallbackValue?: object): object | undefined {

462 return this.getStorage(scope)?.getObject(key, fallbackValue);

463 }

464 > storage.ts

465 > storeAll(entries: Array<IStorageEntry>, external: boolean): void {

466 this.withPausedEmitters(() => {

467 for (const entry of entries) {

470 });

471 }

472 > storage.ts

473 > store(key: string, value: StorageValue, scope: StorageScope, target: StorageTarget, external = false): void {

474

475 // We remove the key for undefined/null values

489 });

490 }

491 > storage.ts

492 > remove(key: string, scope: StorageScope, external = false): void {

493

494 // Update our datastructures but send events only after

502 });

503 }

504 > storage.ts

505 > private withPausedEmitters(fn: Function): void {

506

507 // Pause emitters

518 }

519 }

520 > storage.ts

521 > keys(scope: StorageScope, target: StorageTarget): string[] {

522 const keys: string[] = [];

523

532 return keys;

533 }

534 > storage.ts

535 > private updateKeyTarget(key: string, scope: StorageScope, target: StorageTarget | undefined, external = false): void {

536

537 // Add

552 }

553 }

554 > storage.ts

555 > private _workspaceKeyTargets: IKeyTargets | undefined = undefined;

556 > private get workspaceKeyTargets(): IKeyTargets {

557 if (!this._workspaceKeyTargets) {

558 this._workspaceKeyTargets = this.loadKeyTargets(StorageScope.WORKSPACE);

561 return this._workspaceKeyTargets;

562 }

563 > storage.ts

564 > private _profileKeyTargets: IKeyTargets | undefined = undefined;

565 > private get profileKeyTargets(): IKeyTargets {

566 if (!this._profileKeyTargets) {

567 this._profileKeyTargets = this.loadKeyTargets(StorageScope.PROFILE);

570 return this._profileKeyTargets;

571 }

572 > storage.ts

573 > private _applicationKeyTargets: IKeyTargets | undefined = undefined;

574 > private get applicationKeyTargets(): IKeyTargets {

575 if (!this._applicationKeyTargets) {

576 this._applicationKeyTargets = this.loadKeyTargets(StorageScope.APPLICATION);

579 return this._applicationKeyTargets;

580 }

581 > storage.ts

582 > private _applicationSharedKeyTargets: IKeyTargets | undefined = undefined;

583 > private get applicationSharedKeyTargets(): IKeyTargets {

584 if (!this._applicationSharedKeyTargets) {

585 this._applicationSharedKeyTargets = this.loadKeyTargets(StorageScope.APPLICATION_SHARED);

588 return this._applicationSharedKeyTargets;

589 }

590 > storage.ts

591 > private getKeyTargets(scope: StorageScope): IKeyTargets {

592 switch (scope) {

593 case StorageScope.APPLICATION_SHARED:

601 }

602 }

603 > storage.ts

604 > private loadKeyTargets(scope: StorageScope): { [key: string]: StorageTarget } {

605 const storage = this.getStorage(scope);

606

607 return storage ? loadKeyTargets(storage) : Object.create(null);

608 }

609 > storage.ts

610 > isNew(scope: StorageScope): boolean {

611 return this.getBoolean(IS_NEW_KEY, scope) === true;

612 }

613 > storage.ts

614 > async flush(reason = WillSaveStateReason.NONE): Promise<void> {

615

616 // Signal event to collect changes

646 }

647 }

648 > storage.ts

649 > async log(): Promise<void> {

650 const applicationItems = this.getStorage(StorageScope.APPLICATION)?.items ?? new Map<string, string>();

651 const applicationSharedItems = this.getStorage(StorageScope.APPLICATION_SHARED)?.items ?? new Map<string, string>();

664 );

665 }

666 > storage.ts

667 > async optimize(scope: StorageScope): Promise<void> {

668

669 // Await pending data to be flushed to the DB

673 return this.getStorage(scope)?.optimize();

674 }

675 > storage.ts

676 > async switch(to: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void> {

677

678 // Signal as event so that clients can store data before we switch

685 return this.switchToWorkspace(to, preserveData);

686 }

687 > storage.ts

688 > protected canSwitchProfile(from: IUserDataProfile, to: IUserDataProfile): boolean {

689 if (from.id === to.id) {

690 return false; // both profiles are same

697 return true;

698 }

699 > storage.ts

700 > protected switchData(oldStorage: Map<string, string>, newStorage: IStorage, scope: StorageScope): void {

701 this.withPausedEmitters(() => {

702 // Signal storage keys that have changed

718 });

719 }

720 > storage.ts

721 > // --- abstract

722 >

723 > abstract hasScope(scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean;

724 >

725 > protected abstract doInitialize(): Promise<void>;

726 >

727 > protected abstract getStorage(scope: StorageScope): IStorage | undefined;

728 >

729 > protected abstract getLogDetails(scope: StorageScope): string | undefined;

730 >

731 > protected abstract switchToProfile(toProfile: IUserDataProfile, preserveData: boolean): Promise<void>;

732 > protected abstract switchToWorkspace(toWorkspace: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void>;

733 > }

734 >

735 > export function isProfileUsingDefaultStorage(profile: IUserDataProfile): boolean {

736 return profile.isDefault || !!profile.useDefaultFlags?.globalState;

737 }

738 > storage.ts

739 > export class InMemoryStorageService extends AbstractStorageService {

740 >

741 > private readonly applicationStorage = this._register(new Storage(new InMemoryStorageDatabase(), { hint: StorageHint.STORAGE_IN_MEMORY }));

742 > private readonly applicationSharedStorage = this._register(new Storage(new InMemoryStorageDatabase(), { hint: StorageHint.STORAGE_IN_MEMORY }));

743 > private readonly profileStorage = this._register(new Storage(new InMemoryStorageDatabase(), { hint: StorageHint.STORAGE_IN_MEMORY }));

744 > private readonly workspaceStorage = this._register(new Storage(new InMemoryStorageDatabase(), { hint: StorageHint.STORAGE_IN_MEMORY }));

745 >

746 > constructor() {

747 super();

748

752 this._register(this.applicationSharedStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.APPLICATION_SHARED, e)));

753 }

754 > storage.ts

755 > protected getStorage(scope: StorageScope): IStorage {

756 switch (scope) {

757 case StorageScope.APPLICATION_SHARED:

765 }

766 }

767 > storage.ts

768 > protected getLogDetails(scope: StorageScope): string | undefined {

769 switch (scope) {

770 case StorageScope.APPLICATION_SHARED:

778 }

779 }

780 > storage.ts

781 > protected async doInitialize(): Promise<void> { }

782 >

783 > protected async switchToProfile(): Promise<void> {

784 // no-op when in-memory

785 }

786 > storage.ts

787 > protected async switchToWorkspace(): Promise<void> {

788 // no-op when in-memory

789 }

790 > storage.ts

791 > protected override shouldFlushWhenIdle(): boolean {

792 return false;

793 }

794 > storage.ts

795 > hasScope(scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean {

796 return false;

797 }

798 > } storage.ts

799 >

800 export async function logStorage(application: Map<string, string>, applicationShared: Map<string, string>, profile: Map<string, string>, workspace: Map<string, string>, applicationPath: string, applicationSharedPath: string, profilePath: string, workspacePath: string): Promise<void> {

801 const safeParse = (value: string) => {

src/vs/base/common/charCode.ts 450 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- charCode.ts

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 > // Names from https://blog.codinghorror.com/ascii-pronunciation-rules-for-programmers/

7 >

8 > /**

9 > * An inlined enum containing useful character codes (to be used with String.charCodeAt).

10 > * Please leave the const keyword such that it gets inlined when compiled to JavaScript!

11 > */

12 > export const enum CharCode {

13 > Null = 0,

14 > /**

15 > * The `\b` character.

16 > */

17 > Backspace = 8,

18 > /**

19 > * The `\t` character.

20 > */

21 > Tab = 9,

22 > /**

23 > * The `\n` character.

24 > */

25 > LineFeed = 10,

26 > /**

27 > * The `\r` character.

28 > */

29 > CarriageReturn = 13,

30 > Space = 32,

31 > /**

32 > * The `!` character.

33 > */

34 > ExclamationMark = 33,

35 > /**

36 > * The `"` character.

37 > */

38 > DoubleQuote = 34,

39 > /**

40 > * The `#` character.

41 > */

42 > Hash = 35,

43 > /**

44 > * The `$` character.

45 > */

46 > DollarSign = 36,

47 > /**

48 > * The `%` character.

49 > */

50 > PercentSign = 37,

51 > /**

52 > * The `&` character.

53 > */

54 > Ampersand = 38,

55 > /**

56 > * The `'` character.

57 > */

58 > SingleQuote = 39,

59 > /**

60 > * The `(` character.

61 > */

62 > OpenParen = 40,

63 > /**

64 > * The `)` character.

65 > */

66 > CloseParen = 41,

67 > /**

68 > * The `*` character.

69 > */

70 > Asterisk = 42,

71 > /**

72 > * The `+` character.

73 > */

74 > Plus = 43,

75 > /**

76 > * The `,` character.

77 > */

78 > Comma = 44,

79 > /**

80 > * The `-` character.

81 > */

82 > Dash = 45,

83 > /**

84 > * The `.` character.

85 > */

86 > Period = 46,

87 > /**

88 > * The `/` character.

89 > */

90 > Slash = 47,

91 >

92 > Digit0 = 48,

93 > Digit1 = 49,

94 > Digit2 = 50,

95 > Digit3 = 51,

96 > Digit4 = 52,

97 > Digit5 = 53,

98 > Digit6 = 54,

99 > Digit7 = 55,

100 > Digit8 = 56,

101 > Digit9 = 57,

102 >

103 > /**

104 > * The `:` character.

105 > */

106 > Colon = 58,

107 > /**

108 > * The `;` character.

109 > */

110 > Semicolon = 59,

111 > /**

112 > * The `<` character.

113 > */

114 > LessThan = 60,

115 > /**

116 > * The `=` character.

117 > */

118 > Equals = 61,

119 > /**

120 > * The `>` character.

121 > */

122 > GreaterThan = 62,

123 > /**

124 > * The `?` character.

125 > */

126 > QuestionMark = 63,

127 > /**

128 > * The `@` character.

129 > */

130 > AtSign = 64,

131 >

132 > A = 65,

133 > B = 66,

134 > C = 67,

135 > D = 68,

136 > E = 69,

137 > F = 70,

138 > G = 71,

139 > H = 72,

140 > I = 73,

141 > J = 74,

142 > K = 75,

143 > L = 76,

144 > M = 77,

145 > N = 78,

146 > O = 79,

147 > P = 80,

148 > Q = 81,

149 > R = 82,

150 > S = 83,

151 > T = 84,

152 > U = 85,

153 > V = 86,

154 > W = 87,

155 > X = 88,

156 > Y = 89,

157 > Z = 90,

158 >

159 > /**

160 > * The `[` character.

161 > */

162 > OpenSquareBracket = 91,

163 > /**

164 > * The `\` character.

165 > */

166 > Backslash = 92,

167 > /**

168 > * The `]` character.

169 > */

170 > CloseSquareBracket = 93,

171 > /**

172 > * The `^` character.

173 > */

174 > Caret = 94,

175 > /**

176 > * The `_` character.

177 > */

178 > Underline = 95,

179 > /**

180 > * The ``(`)`` character.

181 > */

182 > BackTick = 96,

183 >

184 > a = 97,

185 > b = 98,

186 > c = 99,

187 > d = 100,

188 > e = 101,

189 > f = 102,

190 > g = 103,

191 > h = 104,

192 > i = 105,

193 > j = 106,

194 > k = 107,

195 > l = 108,

196 > m = 109,

197 > n = 110,

198 > o = 111,

199 > p = 112,

200 > q = 113,

201 > r = 114,

202 > s = 115,

203 > t = 116,

204 > u = 117,

205 > v = 118,

206 > w = 119,

207 > x = 120,

208 > y = 121,

209 > z = 122,

210 >

211 > /**

212 > * The `{` character.

213 > */

214 > OpenCurlyBrace = 123,

215 > /**

216 > * The `|` character.

217 > */

218 > Pipe = 124,

219 > /**

220 > * The `}` character.

221 > */

222 > CloseCurlyBrace = 125,

223 > /**

224 > * The `~` character.

225 > */

226 > Tilde = 126,

227 >

228 > /**

229 > * The   (no-break space) character.

230 > * Unicode Character 'NO-BREAK SPACE' (U+00A0)

231 > */

232 > NoBreakSpace = 160,

233 >

234 > U_Combining_Grave_Accent = 0x0300, // U+0300 Combining Grave Accent

235 > U_Combining_Acute_Accent = 0x0301, // U+0301 Combining Acute Accent

236 > U_Combining_Circumflex_Accent = 0x0302, // U+0302 Combining Circumflex Accent

237 > U_Combining_Tilde = 0x0303, // U+0303 Combining Tilde

238 > U_Combining_Macron = 0x0304, // U+0304 Combining Macron

239 > U_Combining_Overline = 0x0305, // U+0305 Combining Overline

240 > U_Combining_Breve = 0x0306, // U+0306 Combining Breve

241 > U_Combining_Dot_Above = 0x0307, // U+0307 Combining Dot Above

242 > U_Combining_Diaeresis = 0x0308, // U+0308 Combining Diaeresis

243 > U_Combining_Hook_Above = 0x0309, // U+0309 Combining Hook Above

244 > U_Combining_Ring_Above = 0x030A, // U+030A Combining Ring Above

245 > U_Combining_Double_Acute_Accent = 0x030B, // U+030B Combining Double Acute Accent

246 > U_Combining_Caron = 0x030C, // U+030C Combining Caron

247 > U_Combining_Vertical_Line_Above = 0x030D, // U+030D Combining Vertical Line Above

248 > U_Combining_Double_Vertical_Line_Above = 0x030E, // U+030E Combining Double Vertical Line Above

249 > U_Combining_Double_Grave_Accent = 0x030F, // U+030F Combining Double Grave Accent

250 > U_Combining_Candrabindu = 0x0310, // U+0310 Combining Candrabindu

251 > U_Combining_Inverted_Breve = 0x0311, // U+0311 Combining Inverted Breve

252 > U_Combining_Turned_Comma_Above = 0x0312, // U+0312 Combining Turned Comma Above

253 > U_Combining_Comma_Above = 0x0313, // U+0313 Combining Comma Above

254 > U_Combining_Reversed_Comma_Above = 0x0314, // U+0314 Combining Reversed Comma Above

255 > U_Combining_Comma_Above_Right = 0x0315, // U+0315 Combining Comma Above Right

256 > U_Combining_Grave_Accent_Below = 0x0316, // U+0316 Combining Grave Accent Below

257 > U_Combining_Acute_Accent_Below = 0x0317, // U+0317 Combining Acute Accent Below

258 > U_Combining_Left_Tack_Below = 0x0318, // U+0318 Combining Left Tack Below

259 > U_Combining_Right_Tack_Below = 0x0319, // U+0319 Combining Right Tack Below

260 > U_Combining_Left_Angle_Above = 0x031A, // U+031A Combining Left Angle Above

261 > U_Combining_Horn = 0x031B, // U+031B Combining Horn

262 > U_Combining_Left_Half_Ring_Below = 0x031C, // U+031C Combining Left Half Ring Below

263 > U_Combining_Up_Tack_Below = 0x031D, // U+031D Combining Up Tack Below

264 > U_Combining_Down_Tack_Below = 0x031E, // U+031E Combining Down Tack Below

265 > U_Combining_Plus_Sign_Below = 0x031F, // U+031F Combining Plus Sign Below

266 > U_Combining_Minus_Sign_Below = 0x0320, // U+0320 Combining Minus Sign Below

267 > U_Combining_Palatalized_Hook_Below = 0x0321, // U+0321 Combining Palatalized Hook Below

268 > U_Combining_Retroflex_Hook_Below = 0x0322, // U+0322 Combining Retroflex Hook Below

269 > U_Combining_Dot_Below = 0x0323, // U+0323 Combining Dot Below

270 > U_Combining_Diaeresis_Below = 0x0324, // U+0324 Combining Diaeresis Below

271 > U_Combining_Ring_Below = 0x0325, // U+0325 Combining Ring Below

272 > U_Combining_Comma_Below = 0x0326, // U+0326 Combining Comma Below

273 > U_Combining_Cedilla = 0x0327, // U+0327 Combining Cedilla

274 > U_Combining_Ogonek = 0x0328, // U+0328 Combining Ogonek

275 > U_Combining_Vertical_Line_Below = 0x0329, // U+0329 Combining Vertical Line Below

276 > U_Combining_Bridge_Below = 0x032A, // U+032A Combining Bridge Below

277 > U_Combining_Inverted_Double_Arch_Below = 0x032B, // U+032B Combining Inverted Double Arch Below

278 > U_Combining_Caron_Below = 0x032C, // U+032C Combining Caron Below

279 > U_Combining_Circumflex_Accent_Below = 0x032D, // U+032D Combining Circumflex Accent Below

280 > U_Combining_Breve_Below = 0x032E, // U+032E Combining Breve Below

281 > U_Combining_Inverted_Breve_Below = 0x032F, // U+032F Combining Inverted Breve Below

282 > U_Combining_Tilde_Below = 0x0330, // U+0330 Combining Tilde Below

283 > U_Combining_Macron_Below = 0x0331, // U+0331 Combining Macron Below

284 > U_Combining_Low_Line = 0x0332, // U+0332 Combining Low Line

285 > U_Combining_Double_Low_Line = 0x0333, // U+0333 Combining Double Low Line

286 > U_Combining_Tilde_Overlay = 0x0334, // U+0334 Combining Tilde Overlay

287 > U_Combining_Short_Stroke_Overlay = 0x0335, // U+0335 Combining Short Stroke Overlay

288 > U_Combining_Long_Stroke_Overlay = 0x0336, // U+0336 Combining Long Stroke Overlay

289 > U_Combining_Short_Solidus_Overlay = 0x0337, // U+0337 Combining Short Solidus Overlay

290 > U_Combining_Long_Solidus_Overlay = 0x0338, // U+0338 Combining Long Solidus Overlay

291 > U_Combining_Right_Half_Ring_Below = 0x0339, // U+0339 Combining Right Half Ring Below

292 > U_Combining_Inverted_Bridge_Below = 0x033A, // U+033A Combining Inverted Bridge Below

293 > U_Combining_Square_Below = 0x033B, // U+033B Combining Square Below

294 > U_Combining_Seagull_Below = 0x033C, // U+033C Combining Seagull Below

295 > U_Combining_X_Above = 0x033D, // U+033D Combining X Above

296 > U_Combining_Vertical_Tilde = 0x033E, // U+033E Combining Vertical Tilde

297 > U_Combining_Double_Overline = 0x033F, // U+033F Combining Double Overline

298 > U_Combining_Grave_Tone_Mark = 0x0340, // U+0340 Combining Grave Tone Mark

299 > U_Combining_Acute_Tone_Mark = 0x0341, // U+0341 Combining Acute Tone Mark

300 > U_Combining_Greek_Perispomeni = 0x0342, // U+0342 Combining Greek Perispomeni

301 > U_Combining_Greek_Koronis = 0x0343, // U+0343 Combining Greek Koronis

302 > U_Combining_Greek_Dialytika_Tonos = 0x0344, // U+0344 Combining Greek Dialytika Tonos

303 > U_Combining_Greek_Ypogegrammeni = 0x0345, // U+0345 Combining Greek Ypogegrammeni

304 > U_Combining_Bridge_Above = 0x0346, // U+0346 Combining Bridge Above

305 > U_Combining_Equals_Sign_Below = 0x0347, // U+0347 Combining Equals Sign Below

306 > U_Combining_Double_Vertical_Line_Below = 0x0348, // U+0348 Combining Double Vertical Line Below

307 > U_Combining_Left_Angle_Below = 0x0349, // U+0349 Combining Left Angle Below

308 > U_Combining_Not_Tilde_Above = 0x034A, // U+034A Combining Not Tilde Above

309 > U_Combining_Homothetic_Above = 0x034B, // U+034B Combining Homothetic Above

310 > U_Combining_Almost_Equal_To_Above = 0x034C, // U+034C Combining Almost Equal To Above

311 > U_Combining_Left_Right_Arrow_Below = 0x034D, // U+034D Combining Left Right Arrow Below

312 > U_Combining_Upwards_Arrow_Below = 0x034E, // U+034E Combining Upwards Arrow Below

313 > U_Combining_Grapheme_Joiner = 0x034F, // U+034F Combining Grapheme Joiner

314 > U_Combining_Right_Arrowhead_Above = 0x0350, // U+0350 Combining Right Arrowhead Above

315 > U_Combining_Left_Half_Ring_Above = 0x0351, // U+0351 Combining Left Half Ring Above

316 > U_Combining_Fermata = 0x0352, // U+0352 Combining Fermata

317 > U_Combining_X_Below = 0x0353, // U+0353 Combining X Below

318 > U_Combining_Left_Arrowhead_Below = 0x0354, // U+0354 Combining Left Arrowhead Below

319 > U_Combining_Right_Arrowhead_Below = 0x0355, // U+0355 Combining Right Arrowhead Below

320 > U_Combining_Right_Arrowhead_And_Up_Arrowhead_Below = 0x0356, // U+0356 Combining Right Arrowhead And Up Arrowhead Below

321 > U_Combining_Right_Half_Ring_Above = 0x0357, // U+0357 Combining Right Half Ring Above

322 > U_Combining_Dot_Above_Right = 0x0358, // U+0358 Combining Dot Above Right

323 > U_Combining_Asterisk_Below = 0x0359, // U+0359 Combining Asterisk Below

324 > U_Combining_Double_Ring_Below = 0x035A, // U+035A Combining Double Ring Below

325 > U_Combining_Zigzag_Above = 0x035B, // U+035B Combining Zigzag Above

326 > U_Combining_Double_Breve_Below = 0x035C, // U+035C Combining Double Breve Below

327 > U_Combining_Double_Breve = 0x035D, // U+035D Combining Double Breve

328 > U_Combining_Double_Macron = 0x035E, // U+035E Combining Double Macron

329 > U_Combining_Double_Macron_Below = 0x035F, // U+035F Combining Double Macron Below

330 > U_Combining_Double_Tilde = 0x0360, // U+0360 Combining Double Tilde

331 > U_Combining_Double_Inverted_Breve = 0x0361, // U+0361 Combining Double Inverted Breve

332 > U_Combining_Double_Rightwards_Arrow_Below = 0x0362, // U+0362 Combining Double Rightwards Arrow Below

333 > U_Combining_Latin_Small_Letter_A = 0x0363, // U+0363 Combining Latin Small Letter A

334 > U_Combining_Latin_Small_Letter_E = 0x0364, // U+0364 Combining Latin Small Letter E

335 > U_Combining_Latin_Small_Letter_I = 0x0365, // U+0365 Combining Latin Small Letter I

336 > U_Combining_Latin_Small_Letter_O = 0x0366, // U+0366 Combining Latin Small Letter O

337 > U_Combining_Latin_Small_Letter_U = 0x0367, // U+0367 Combining Latin Small Letter U

338 > U_Combining_Latin_Small_Letter_C = 0x0368, // U+0368 Combining Latin Small Letter C

339 > U_Combining_Latin_Small_Letter_D = 0x0369, // U+0369 Combining Latin Small Letter D

340 > U_Combining_Latin_Small_Letter_H = 0x036A, // U+036A Combining Latin Small Letter H

341 > U_Combining_Latin_Small_Letter_M = 0x036B, // U+036B Combining Latin Small Letter M

342 > U_Combining_Latin_Small_Letter_R = 0x036C, // U+036C Combining Latin Small Letter R

343 > U_Combining_Latin_Small_Letter_T = 0x036D, // U+036D Combining Latin Small Letter T

344 > U_Combining_Latin_Small_Letter_V = 0x036E, // U+036E Combining Latin Small Letter V

345 > U_Combining_Latin_Small_Letter_X = 0x036F, // U+036F Combining Latin Small Letter X

346 >

347 > /**

348 > * Unicode Character 'LINE SEPARATOR' (U+2028)

349 > * http://www.fileformat.info/info/unicode/char/2028/index.htm

350 > */

351 > LINE_SEPARATOR = 0x2028,

352 > /**

353 > * Unicode Character 'PARAGRAPH SEPARATOR' (U+2029)

354 > * http://www.fileformat.info/info/unicode/char/2029/index.htm

355 > */

356 > PARAGRAPH_SEPARATOR = 0x2029,

357 > /**

358 > * Unicode Character 'NEXT LINE' (U+0085)

359 > * http://www.fileformat.info/info/unicode/char/0085/index.htm

360 > */

361 > NEXT_LINE = 0x0085,

362 >

363 > // http://www.fileformat.info/info/unicode/category/Sk/list.htm

364 > U_CIRCUMFLEX = 0x005E, // U+005E CIRCUMFLEX

365 > U_GRAVE_ACCENT = 0x0060, // U+0060 GRAVE ACCENT

366 > U_DIAERESIS = 0x00A8, // U+00A8 DIAERESIS

367 > U_MACRON = 0x00AF, // U+00AF MACRON

368 > U_ACUTE_ACCENT = 0x00B4, // U+00B4 ACUTE ACCENT

369 > U_CEDILLA = 0x00B8, // U+00B8 CEDILLA

370 > U_MODIFIER_LETTER_LEFT_ARROWHEAD = 0x02C2, // U+02C2 MODIFIER LETTER LEFT ARROWHEAD

371 > U_MODIFIER_LETTER_RIGHT_ARROWHEAD = 0x02C3, // U+02C3 MODIFIER LETTER RIGHT ARROWHEAD

372 > U_MODIFIER_LETTER_UP_ARROWHEAD = 0x02C4, // U+02C4 MODIFIER LETTER UP ARROWHEAD

373 > U_MODIFIER_LETTER_DOWN_ARROWHEAD = 0x02C5, // U+02C5 MODIFIER LETTER DOWN ARROWHEAD

374 > U_MODIFIER_LETTER_CENTRED_RIGHT_HALF_RING = 0x02D2, // U+02D2 MODIFIER LETTER CENTRED RIGHT HALF RING

375 > U_MODIFIER_LETTER_CENTRED_LEFT_HALF_RING = 0x02D3, // U+02D3 MODIFIER LETTER CENTRED LEFT HALF RING

376 > U_MODIFIER_LETTER_UP_TACK = 0x02D4, // U+02D4 MODIFIER LETTER UP TACK

377 > U_MODIFIER_LETTER_DOWN_TACK = 0x02D5, // U+02D5 MODIFIER LETTER DOWN TACK

378 > U_MODIFIER_LETTER_PLUS_SIGN = 0x02D6, // U+02D6 MODIFIER LETTER PLUS SIGN

379 > U_MODIFIER_LETTER_MINUS_SIGN = 0x02D7, // U+02D7 MODIFIER LETTER MINUS SIGN

380 > U_BREVE = 0x02D8, // U+02D8 BREVE

381 > U_DOT_ABOVE = 0x02D9, // U+02D9 DOT ABOVE

382 > U_RING_ABOVE = 0x02DA, // U+02DA RING ABOVE

383 > U_OGONEK = 0x02DB, // U+02DB OGONEK

384 > U_SMALL_TILDE = 0x02DC, // U+02DC SMALL TILDE

385 > U_DOUBLE_ACUTE_ACCENT = 0x02DD, // U+02DD DOUBLE ACUTE ACCENT

386 > U_MODIFIER_LETTER_RHOTIC_HOOK = 0x02DE, // U+02DE MODIFIER LETTER RHOTIC HOOK

387 > U_MODIFIER_LETTER_CROSS_ACCENT = 0x02DF, // U+02DF MODIFIER LETTER CROSS ACCENT

388 > U_MODIFIER_LETTER_EXTRA_HIGH_TONE_BAR = 0x02E5, // U+02E5 MODIFIER LETTER EXTRA-HIGH TONE BAR

389 > U_MODIFIER_LETTER_HIGH_TONE_BAR = 0x02E6, // U+02E6 MODIFIER LETTER HIGH TONE BAR

390 > U_MODIFIER_LETTER_MID_TONE_BAR = 0x02E7, // U+02E7 MODIFIER LETTER MID TONE BAR

391 > U_MODIFIER_LETTER_LOW_TONE_BAR = 0x02E8, // U+02E8 MODIFIER LETTER LOW TONE BAR

392 > U_MODIFIER_LETTER_EXTRA_LOW_TONE_BAR = 0x02E9, // U+02E9 MODIFIER LETTER EXTRA-LOW TONE BAR

393 > U_MODIFIER_LETTER_YIN_DEPARTING_TONE_MARK = 0x02EA, // U+02EA MODIFIER LETTER YIN DEPARTING TONE MARK

394 > U_MODIFIER_LETTER_YANG_DEPARTING_TONE_MARK = 0x02EB, // U+02EB MODIFIER LETTER YANG DEPARTING TONE MARK

395 > U_MODIFIER_LETTER_UNASPIRATED = 0x02ED, // U+02ED MODIFIER LETTER UNASPIRATED

396 > U_MODIFIER_LETTER_LOW_DOWN_ARROWHEAD = 0x02EF, // U+02EF MODIFIER LETTER LOW DOWN ARROWHEAD

397 > U_MODIFIER_LETTER_LOW_UP_ARROWHEAD = 0x02F0, // U+02F0 MODIFIER LETTER LOW UP ARROWHEAD

398 > U_MODIFIER_LETTER_LOW_LEFT_ARROWHEAD = 0x02F1, // U+02F1 MODIFIER LETTER LOW LEFT ARROWHEAD

399 > U_MODIFIER_LETTER_LOW_RIGHT_ARROWHEAD = 0x02F2, // U+02F2 MODIFIER LETTER LOW RIGHT ARROWHEAD

400 > U_MODIFIER_LETTER_LOW_RING = 0x02F3, // U+02F3 MODIFIER LETTER LOW RING

401 > U_MODIFIER_LETTER_MIDDLE_GRAVE_ACCENT = 0x02F4, // U+02F4 MODIFIER LETTER MIDDLE GRAVE ACCENT

402 > U_MODIFIER_LETTER_MIDDLE_DOUBLE_GRAVE_ACCENT = 0x02F5, // U+02F5 MODIFIER LETTER MIDDLE DOUBLE GRAVE ACCENT

403 > U_MODIFIER_LETTER_MIDDLE_DOUBLE_ACUTE_ACCENT = 0x02F6, // U+02F6 MODIFIER LETTER MIDDLE DOUBLE ACUTE ACCENT

404 > U_MODIFIER_LETTER_LOW_TILDE = 0x02F7, // U+02F7 MODIFIER LETTER LOW TILDE

405 > U_MODIFIER_LETTER_RAISED_COLON = 0x02F8, // U+02F8 MODIFIER LETTER RAISED COLON

406 > U_MODIFIER_LETTER_BEGIN_HIGH_TONE = 0x02F9, // U+02F9 MODIFIER LETTER BEGIN HIGH TONE

407 > U_MODIFIER_LETTER_END_HIGH_TONE = 0x02FA, // U+02FA MODIFIER LETTER END HIGH TONE

408 > U_MODIFIER_LETTER_BEGIN_LOW_TONE = 0x02FB, // U+02FB MODIFIER LETTER BEGIN LOW TONE

409 > U_MODIFIER_LETTER_END_LOW_TONE = 0x02FC, // U+02FC MODIFIER LETTER END LOW TONE

410 > U_MODIFIER_LETTER_SHELF = 0x02FD, // U+02FD MODIFIER LETTER SHELF

411 > U_MODIFIER_LETTER_OPEN_SHELF = 0x02FE, // U+02FE MODIFIER LETTER OPEN SHELF

412 > U_MODIFIER_LETTER_LOW_LEFT_ARROW = 0x02FF, // U+02FF MODIFIER LETTER LOW LEFT ARROW

413 > U_GREEK_LOWER_NUMERAL_SIGN = 0x0375, // U+0375 GREEK LOWER NUMERAL SIGN

414 > U_GREEK_TONOS = 0x0384, // U+0384 GREEK TONOS

415 > U_GREEK_DIALYTIKA_TONOS = 0x0385, // U+0385 GREEK DIALYTIKA TONOS

416 > U_GREEK_KORONIS = 0x1FBD, // U+1FBD GREEK KORONIS

417 > U_GREEK_PSILI = 0x1FBF, // U+1FBF GREEK PSILI

418 > U_GREEK_PERISPOMENI = 0x1FC0, // U+1FC0 GREEK PERISPOMENI

419 > U_GREEK_DIALYTIKA_AND_PERISPOMENI = 0x1FC1, // U+1FC1 GREEK DIALYTIKA AND PERISPOMENI

420 > U_GREEK_PSILI_AND_VARIA = 0x1FCD, // U+1FCD GREEK PSILI AND VARIA

421 > U_GREEK_PSILI_AND_OXIA = 0x1FCE, // U+1FCE GREEK PSILI AND OXIA

422 > U_GREEK_PSILI_AND_PERISPOMENI = 0x1FCF, // U+1FCF GREEK PSILI AND PERISPOMENI

423 > U_GREEK_DASIA_AND_VARIA = 0x1FDD, // U+1FDD GREEK DASIA AND VARIA

424 > U_GREEK_DASIA_AND_OXIA = 0x1FDE, // U+1FDE GREEK DASIA AND OXIA

425 > U_GREEK_DASIA_AND_PERISPOMENI = 0x1FDF, // U+1FDF GREEK DASIA AND PERISPOMENI

426 > U_GREEK_DIALYTIKA_AND_VARIA = 0x1FED, // U+1FED GREEK DIALYTIKA AND VARIA

427 > U_GREEK_DIALYTIKA_AND_OXIA = 0x1FEE, // U+1FEE GREEK DIALYTIKA AND OXIA

428 > U_GREEK_VARIA = 0x1FEF, // U+1FEF GREEK VARIA

429 > U_GREEK_OXIA = 0x1FFD, // U+1FFD GREEK OXIA

430 > U_GREEK_DASIA = 0x1FFE, // U+1FFE GREEK DASIA

431 >

432 > U_IDEOGRAPHIC_FULL_STOP = 0x3002, // U+3002 IDEOGRAPHIC FULL STOP

433 > U_LEFT_CORNER_BRACKET = 0x300C, // U+300C LEFT CORNER BRACKET

434 > U_RIGHT_CORNER_BRACKET = 0x300D, // U+300D RIGHT CORNER BRACKET

435 > U_LEFT_BLACK_LENTICULAR_BRACKET = 0x3010, // U+3010 LEFT BLACK LENTICULAR BRACKET

436 > U_RIGHT_BLACK_LENTICULAR_BRACKET = 0x3011, // U+3011 RIGHT BLACK LENTICULAR BRACKET

437 >

438 >

439 > U_OVERLINE = 0x203E, // Unicode Character 'OVERLINE'

440 >

441 > /**

442 > * UTF-8 BOM

443 > * Unicode Character 'ZERO WIDTH NO-BREAK SPACE' (U+FEFF)

444 > * http://www.fileformat.info/info/unicode/char/feff/index.htm

445 > */

446 > UTF8_BOM = 65279,

447 >

448 > U_FULLWIDTH_SEMICOLON = 0xFF1B, // U+FF1B FULLWIDTH SEMICOLON

449 > U_FULLWIDTH_COMMA = 0xFF0C, // U+FF0C FULLWIDTH COMMA

450 > }

src/vs/platform/log/common/log.ts 447 covered LOC · 73 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- log.ts

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 * as nls from '../../../nls.js';

7 > import { toErrorMessage } from '../../../base/common/errorMessage.js';

8 > import { Emitter, Event } from '../../../base/common/event.js';

9 > import { hash } from '../../../base/common/hash.js';

10 > import { Disposable, IDisposable, toDisposable } from '../../../base/common/lifecycle.js';

11 > import { ResourceMap } from '../../../base/common/map.js';

12 > import { isWindows } from '../../../base/common/platform.js';

13 > import { joinPath } from '../../../base/common/resources.js';

14 > import { Mutable, isNumber, isString } from '../../../base/common/types.js';

15 > import { URI } from '../../../base/common/uri.js';

16 > import { ILocalizedString } from '../../action/common/action.js';

17 > import { RawContextKey } from '../../contextkey/common/contextkey.js';

18 > import { IEnvironmentService } from '../../environment/common/environment.js';

19 > import { createDecorator } from '../../instantiation/common/instantiation.js';

20 >

21 > export const ILogService = createDecorator<ILogService>('logService');

22 > export const ILoggerService = createDecorator<ILoggerService>('loggerService');

23 >

24 function now(): string {

25 return new Date().toISOString();

26 }

27 > log.ts

28 > export function isLogLevel(thing: unknown): thing is LogLevel {

29 return isNumber(thing);

30 }

31 > log.ts

32 > export enum LogLevel {

33 > Off,

34 > Trace,

35 > Debug,

36 > Info,

37 > Warning,

38 > Error

39 > }

40 >

41 > export const DEFAULT_LOG_LEVEL: LogLevel = LogLevel.Info;

42 >

43 > export interface ILogger extends IDisposable {

44 > readonly onDidChangeLogLevel: Event<LogLevel>;

45 > getLevel(): LogLevel;

46 > setLevel(level: LogLevel): void;

47 >

48 > trace(message: string, ...args: unknown[]): void;

49 > debug(message: string, ...args: unknown[]): void;

50 > info(message: string, ...args: unknown[]): void;

51 > warn(message: string, ...args: unknown[]): void;

52 > error(message: string | Error, ...args: unknown[]): void;

53 >

54 > /**

55 > * An operation to flush the contents. Can be synchronous.

56 > */

57 > flush(): void;

58 > }

59 >

60 > export function canLog(loggerLevel: LogLevel, messageLevel: LogLevel): boolean {

61 return loggerLevel !== LogLevel.Off && loggerLevel <= messageLevel;

62 }

63 > log.ts

64 > export function log(logger: ILogger, level: LogLevel, message: string): void {

65 switch (level) {

66 case LogLevel.Trace: logger.trace(message); break;

73 }

74 }

75 > log.ts

76 > type ConsoleMethod = 'debug' | 'error' | 'info' | 'log' | 'warn';

77 > type ConsoleMethodFn = (...args: unknown[]) => void;

78 >

79 > /**

80 > * Flag to enable forwarding of console.* calls to the log service in development.

81 > * This is intended for the use of agents to quickly instrument the code with console.logs

82 > * which will end up in the log service's file outputs.

83 > */

84 > export const isDevConsoleLogForwardingEnabled = false

85 > // || Boolean("true") // done "weirdly" so that a lint warning prevents you from pushing this

86 > ;

87 >

88 > let isConsoleForwarding = false;

89 > let isLogServiceConsoleEcho = false;

90 >

91 function getConsoleMethod(method: ConsoleMethod): ConsoleMethodFn {

92 switch (method) {

98 }

99 }

100 > log.ts

101 function setConsoleMethod(method: ConsoleMethod, fn: ConsoleMethodFn): void {

102 switch (method) {

108 }

109 }

110 > log.ts

111 function logToConsole(method: ConsoleMethod, ...args: unknown[]): void {

112 if (isConsoleForwarding) {

120 }

121 }

122 > log.ts

123 > export function registerDevConsoleLogForwarder(logService: ILogService): IDisposable {

124 const originalConsoleMethods: Record<ConsoleMethod, ConsoleMethodFn> = {

125 debug: console.debug,

177 });

178 }

179 > log.ts

180 > export function format(args: any, verbose: boolean = false): string {

181 let result = '';

182

199 return result;

200 }

201 > log.ts

202 > export type LoggerGroup = {

203 > readonly id: string;

204 > readonly name: string;

205 > };

206 >

207 > export interface ILogService extends ILogger {

208 > readonly _serviceBrand: undefined;

209 > }

210 >

211 > export interface ILoggerOptions {

212 >

213 > /**

214 > * Id of the logger.

215 > */

216 > id?: string;

217 >

218 > /**

219 > * Name of the logger.

220 > */

221 > name?: string;

222 >

223 > /**

224 > * Do not create rotating files if max size exceeds.

225 > */

226 > donotRotate?: boolean;

227 >

228 > /**

229 > * Do not use formatters.

230 > */

231 > donotUseFormatters?: boolean;

232 >

233 > /**

234 > * When to log. Set to `always` to log always.

235 > */

236 > logLevel?: 'always' | LogLevel;

237 >

238 > /**

239 > * Whether the log should be hidden from the user.

240 > */

241 > hidden?: boolean;

242 >

243 > /**

244 > * Condition which must be true to show this logger

245 > */

246 > when?: string;

247 >

248 > /**

249 > * Id of the extension that created this logger.

250 > */

251 > extensionId?: string;

252 >

253 > /**

254 > * Group of the logger.

255 > */

256 > group?: LoggerGroup;

257 > }

258 >

259 > export interface ILoggerResource {

260 > readonly resource: URI;

261 > readonly id: string;

262 > readonly name?: string;

263 > readonly logLevel?: LogLevel;

264 > readonly hidden?: boolean;

265 > readonly when?: string;

266 > readonly extensionId?: string;

267 > readonly group?: LoggerGroup;

268 > }

269 >

270 > export type DidChangeLoggersEvent = {

271 > readonly added: Iterable<ILoggerResource>;

272 > readonly removed: Iterable<ILoggerResource>;

273 > };

274 >

275 > export interface ILoggerService {

276 >

277 > readonly _serviceBrand: undefined;

278 >

279 > /**

280 > * Creates a logger for the given resource, or gets one if it already exists.

281 > *

282 > * This will also register the logger with the logger service.

283 > */

284 > createLogger(resource: URI, options?: ILoggerOptions): ILogger;

285 >

286 > /**

287 > * Creates a logger with the given id in the logs folder, or gets one if it already exists.

288 > *

289 > * This will also register the logger with the logger service.

290 > */

291 > createLogger(id: string, options?: Omit<ILoggerOptions, 'id'>): ILogger;

292 >

293 > /**

294 > * Gets an existing logger, if any.

295 > */

296 > getLogger(resourceOrId: URI | string): ILogger | undefined;

297 >

298 > /**

299 > * An event which fires when the log level of a logger has changed

300 > */

301 > readonly onDidChangeLogLevel: Event<LogLevel | [URI, LogLevel]>;

302 >

303 > /**

304 > * Set default log level.

305 > */

306 > setLogLevel(level: LogLevel): void;

307 >

308 > /**

309 > * Set log level for a logger.

310 > */

311 > setLogLevel(resource: URI, level: LogLevel): void;

312 >

313 > /**

314 > * Get log level for a logger or the default log level.

315 > */

316 > getLogLevel(resource?: URI): LogLevel;

317 >

318 > /**

319 > * An event which fires when the visibility of a logger has changed

320 > */

321 > readonly onDidChangeVisibility: Event<[URI, boolean]>;

322 >

323 > /**

324 > * Set the visibility of a logger.

325 > */

326 > setVisibility(resourceOrId: URI | string, visible: boolean): void;

327 >

328 > /**

329 > * An event which fires when the logger resources are changed

330 > */

331 > readonly onDidChangeLoggers: Event<DidChangeLoggersEvent>;

332 >

333 > /**

334 > * Register a logger with the logger service.

335 > *

336 > * Note that this will not create a logger, but only register it.

337 > *

338 > * Use `createLogger` to create a logger and register it.

339 > *

340 > * Use it when you want to register a logger that is not created by the logger service.

341 > */

342 > registerLogger(resource: ILoggerResource): void;

343 >

344 > /**

345 > * Deregister the logger for the given resource.

346 > */

347 > deregisterLogger(idOrResource: URI | string): void;

348 >

349 > /**

350 > * Get all registered loggers

351 > */

352 > getRegisteredLoggers(): Iterable<ILoggerResource>;

353 >

354 > /**

355 > * Get the registered logger for the given resource.

356 > */

357 > getRegisteredLogger(resource: URI): ILoggerResource | undefined;

358 > }

359 >

360 > export abstract class AbstractLogger extends Disposable implements ILogger {

361

362 private level: LogLevel = DEFAULT_LOG_LEVEL;

363 private readonly _onDidChangeLogLevel: Emitter<LogLevel> = this._register(new Emitter<LogLevel>());

364 > get onDidChangeLogLevel(): Event<LogLevel> { return this._onDidChangeLogLevel.event; } log.ts

365 >

366 > setLevel(level: LogLevel): void {

367 if (this.level !== level) {

368 this.level = level;

370 }

371 }

372 > log.ts

373 > getLevel(): LogLevel {

374 return this.level;

375 }

376 > log.ts

377 > protected checkLogLevel(level: LogLevel): boolean {

378 return canLog(this.level, level);

379 }

380 > log.ts

381 > protected canLog(level: LogLevel): boolean {

382 if (this._store.isDisposed) {

383 return false;

385 return this.checkLogLevel(level);

386 }

387 > log.ts

388 > abstract trace(message: string, ...args: unknown[]): void;

389 > abstract debug(message: string, ...args: unknown[]): void;

390 > abstract info(message: string, ...args: unknown[]): void;

391 > abstract warn(message: string, ...args: unknown[]): void;

392 > abstract error(message: string | Error, ...args: unknown[]): void;

393 > abstract flush(): void;

394 > }

395 >

396 > export abstract class AbstractMessageLogger extends AbstractLogger implements ILogger {

397 >

398 > constructor(private readonly logAlways?: boolean) {

399 super();

400 }

401 > log.ts

402 > protected override checkLogLevel(level: LogLevel): boolean {

403 return this.logAlways || super.checkLogLevel(level);

404 }

405 > log.ts

406 > trace(message: string, ...args: unknown[]): void {

407 if (this.canLog(LogLevel.Trace)) {

408 this.log(LogLevel.Trace, format([message, ...args], true));

409 }

410 }

411 > log.ts

412 > debug(message: string, ...args: unknown[]): void {

413 if (this.canLog(LogLevel.Debug)) {

414 this.log(LogLevel.Debug, format([message, ...args]));

415 }

416 }

417 > log.ts

418 > info(message: string, ...args: unknown[]): void {

419 if (this.canLog(LogLevel.Info)) {

420 this.log(LogLevel.Info, format([message, ...args]));

421 }

422 }

423 > log.ts

424 > warn(message: string, ...args: unknown[]): void {

425 if (this.canLog(LogLevel.Warning)) {

426 this.log(LogLevel.Warning, format([message, ...args]));

427 }

428 }

429 > log.ts

430 > error(message: string | Error, ...args: unknown[]): void {

431 if (this.canLog(LogLevel.Error)) {

432 if (message instanceof Error) {

439 }

440 }

441 > log.ts

442 > flush(): void { }

443 >

444 > protected abstract log(level: LogLevel, message: string): void;

445 > }

446 >

447 >

448 > export class ConsoleMainLogger extends AbstractLogger implements ILogger {

449 >

450 > private useColors: boolean;

451 >

452 > constructor(logLevel: LogLevel = DEFAULT_LOG_LEVEL) {

453 super();

454 this.setLevel(logLevel);

455 this.useColors = !isWindows;

456 }

457 > log.ts

458 > trace(message: string, ...args: unknown[]): void {

459 if (this.canLog(LogLevel.Trace)) {

460 if (this.useColors) {

465 }

466 }

467 > log.ts

468 > debug(message: string, ...args: unknown[]): void {

469 if (this.canLog(LogLevel.Debug)) {

470 if (this.useColors) {

475 }

476 }

477 > log.ts

478 > info(message: string, ...args: unknown[]): void {

479 if (this.canLog(LogLevel.Info)) {

480 if (this.useColors) {

485 }

486 }

487 > log.ts

488 > warn(message: string | Error, ...args: unknown[]): void {

489 if (this.canLog(LogLevel.Warning)) {

490 if (this.useColors) {

495 }

496 }

497 > log.ts

498 > error(message: string, ...args: unknown[]): void {

499 if (this.canLog(LogLevel.Error)) {

500 if (this.useColors) {

505 }

506 }

507 > log.ts

508 > flush(): void {

509 // noop

510 }

511 > log.ts

512 > }

513 >

514 > export class ConsoleLogger extends AbstractLogger implements ILogger {

515 >

516 > constructor(logLevel: LogLevel = DEFAULT_LOG_LEVEL, private readonly useColors: boolean = true) {

517 super();

518 this.setLevel(logLevel);

519 }

520 > log.ts

521 > trace(message: string, ...args: unknown[]): void {

522 if (this.canLog(LogLevel.Trace)) {

523 if (this.useColors) {

528 }

529 }

530 > log.ts

531 > debug(message: string, ...args: unknown[]): void {

532 if (this.canLog(LogLevel.Debug)) {

533 if (this.useColors) {

538 }

539 }

540 > log.ts

541 > info(message: string, ...args: unknown[]): void {

542 if (this.canLog(LogLevel.Info)) {

543 if (this.useColors) {

548 }

549 }

550 > log.ts

551 > warn(message: string | Error, ...args: unknown[]): void {

552 if (this.canLog(LogLevel.Warning)) {

553 if (this.useColors) {

558 }

559 }

560 > log.ts

561 > error(message: string, ...args: unknown[]): void {

562 if (this.canLog(LogLevel.Error)) {

563 if (this.useColors) {

568 }

569 }

570 > log.ts

571 >

572 > flush(): void {

573 // noop

574 }

575 > } log.ts

576 >

577 > export class AdapterLogger extends AbstractLogger implements ILogger {

578 >

579 > constructor(private readonly adapter: { log: (logLevel: LogLevel, args: any[]) => void }, logLevel: LogLevel = DEFAULT_LOG_LEVEL) {

580 super();

581 this.setLevel(logLevel);

582 }

583 > log.ts

584 > trace(message: string, ...args: unknown[]): void {

585 if (this.canLog(LogLevel.Trace)) {

586 this.adapter.log(LogLevel.Trace, [this.extractMessage(message), ...args]);

587 }

588 }

589 > log.ts

590 > debug(message: string, ...args: unknown[]): void {

591 if (this.canLog(LogLevel.Debug)) {

592 this.adapter.log(LogLevel.Debug, [this.extractMessage(message), ...args]);

593 }

594 }

595 > log.ts

596 > info(message: string, ...args: unknown[]): void {

597 if (this.canLog(LogLevel.Info)) {

598 this.adapter.log(LogLevel.Info, [this.extractMessage(message), ...args]);

599 }

600 }

601 > log.ts

602 > warn(message: string | Error, ...args: unknown[]): void {

603 if (this.canLog(LogLevel.Warning)) {

604 this.adapter.log(LogLevel.Warning, [this.extractMessage(message), ...args]);

605 }

606 }

607 > log.ts

608 > error(message: string | Error, ...args: unknown[]): void {

609 if (this.canLog(LogLevel.Error)) {

610 this.adapter.log(LogLevel.Error, [this.extractMessage(message), ...args]);

611 }

612 }

613 > log.ts

614 > private extractMessage(msg: string | Error): string {

615 if (typeof msg === 'string') {

616 return msg;

619 return toErrorMessage(msg, this.canLog(LogLevel.Trace));

620 }

621 > log.ts

622 > flush(): void {

623 // noop

624 }

625 > } log.ts

626 >

627 > export class MultiplexLogger extends AbstractLogger implements ILogger {

628 >

629 > constructor(private readonly loggers: ReadonlyArray<ILogger>) {

630 super();

631 if (loggers.length) {

633 }

634 }

635 > log.ts

636 > override setLevel(level: LogLevel): void {

637 for (const logger of this.loggers) {

638 logger.setLevel(level);

640 super.setLevel(level);

641 }

642 > log.ts

643 > trace(message: string, ...args: unknown[]): void {

644 for (const logger of this.loggers) {

645 logger.trace(message, ...args);

646 }

647 }

648 > log.ts

649 > debug(message: string, ...args: unknown[]): void {

650 for (const logger of this.loggers) {

651 logger.debug(message, ...args);

652 }

653 }

654 > log.ts

655 > info(message: string, ...args: unknown[]): void {

656 for (const logger of this.loggers) {

657 logger.info(message, ...args);

658 }

659 }

660 > log.ts

661 > warn(message: string, ...args: unknown[]): void {

662 for (const logger of this.loggers) {

663 logger.warn(message, ...args);

664 }

665 }

666 > log.ts

667 > error(message: string | Error, ...args: unknown[]): void {

668 for (const logger of this.loggers) {

669 logger.error(message, ...args);

670 }

671 }

672 > log.ts

673 > flush(): void {

674 for (const logger of this.loggers) {

675 logger.flush();

676 }

677 }

678 > log.ts

679 > override dispose(): void {

680 for (const logger of this.loggers) {

681 logger.dispose();

683 super.dispose();

684 }

685 > } log.ts

686 >

687 > type LoggerEntry = { logger: ILogger | undefined; info: Mutable<ILoggerResource> };

688 >

689 > export abstract class AbstractLoggerService extends Disposable implements ILoggerService {

690 >

691 > declare readonly _serviceBrand: undefined;

692 >

693 > private readonly _loggers = new ResourceMap<LoggerEntry>();

694 >

695 > private _onDidChangeLoggers = this._register(new Emitter<{ added: ILoggerResource[]; removed: ILoggerResource[] }>);

696 > readonly onDidChangeLoggers = this._onDidChangeLoggers.event;

697 >

698 > private _onDidChangeLogLevel = this._register(new Emitter<LogLevel | [URI, LogLevel]>);

699 > readonly onDidChangeLogLevel = this._onDidChangeLogLevel.event;

700 >

701 > private _onDidChangeVisibility = this._register(new Emitter<[URI, boolean]>);

702 > readonly onDidChangeVisibility = this._onDidChangeVisibility.event;

703 >

704 > constructor(

705 protected logLevel: LogLevel,

706 private readonly logsHome: URI,

714 }

715 }

716 > log.ts

717 > private getLoggerEntry(resourceOrId: URI | string): LoggerEntry | undefined {

718 if (isString(resourceOrId)) {

719 return [...this._loggers.values()].find(logger => logger.info.id === resourceOrId);

721 return this._loggers.get(resourceOrId);

722 }

723 > log.ts

724 > getLogger(resourceOrId: URI | string): ILogger | undefined {

725 return this.getLoggerEntry(resourceOrId)?.logger;

726 }

727 > log.ts

728 > createLogger(idOrResource: URI | string, options?: ILoggerOptions): ILogger {

729 const resource = this.toResource(idOrResource);

730 const id = isString(idOrResource) ? idOrResource : (options?.id ?? hash(resource.toString()).toString(16));

752 return logger;

753 }

754 > log.ts

755 > protected toResource(idOrResource: string | URI): URI {

756 return isString(idOrResource) ? joinPath(this.logsHome, `${idOrResource.replace(/[\\/:\*\?"<>\|]/g, '')}.log`) : idOrResource;

757 }

758 > log.ts

759 > setLogLevel(logLevel: LogLevel): void;

760 > setLogLevel(resource: URI, logLevel: LogLevel): void;

761 > setLogLevel(arg1: any, arg2?: any): void {

762 if (URI.isUri(arg1)) {

763 const resource = arg1;

780 }

781 }

782 > log.ts

783 > setVisibility(resourceOrId: URI | string, visibility: boolean): void {

784 const logger = this.getLoggerEntry(resourceOrId);

785 if (logger && visibility !== !logger.info.hidden) {

789 }

790 }

791 > log.ts

792 > getLogLevel(resource?: URI): LogLevel {

793 let logLevel;

794 if (resource) {

797 return logLevel ?? this.logLevel;

798 }

799 > log.ts

800 > registerLogger(resource: ILoggerResource): void {

801 const existing = this._loggers.get(resource.resource);

802 if (existing) {

809 }

810 }

811 > log.ts

812 > deregisterLogger(idOrResource: URI | string): void {

813 const resource = this.toResource(idOrResource);

814 const existing = this._loggers.get(resource);

821 }

822 }

823 > log.ts

824 > *getRegisteredLoggers(): Iterable<ILoggerResource> {

825 for (const entry of this._loggers.values()) {

826 yield entry.info;

827 }

828 }

829 > log.ts

830 > getRegisteredLogger(resource: URI): ILoggerResource | undefined {

831 return this._loggers.get(resource)?.info;

832 }

833 > log.ts

834 > override dispose(): void {

835 this._loggers.forEach(logger => logger.logger?.dispose());

836 this._loggers.clear();

837 super.dispose();

838 }

839 > log.ts

840 > protected abstract doCreateLogger(resource: URI, logLevel: LogLevel, options?: ILoggerOptions): ILogger;

841 > }

842 >

843 > export class NullLogger implements ILogger {

844 > readonly onDidChangeLogLevel: Event<LogLevel> = new Emitter<LogLevel>().event; log.ts

845 > setLevel(level: LogLevel): void { } log.ts

846 > getLevel(): LogLevel { return LogLevel.Info; }

847 > trace(message: string, ...args: unknown[]): void { }

848 > debug(message: string, ...args: unknown[]): void { }

849 > info(message: string, ...args: unknown[]): void { }

850 > warn(message: string, ...args: unknown[]): void { }

851 > error(message: string | Error, ...args: unknown[]): void { }

852 > critical(message: string | Error, ...args: unknown[]): void { }

853 > dispose(): void { }

854 > flush(): void { }

855 > }

856 >

857 > export class NullLogService extends NullLogger implements ILogService {

858 > declare readonly _serviceBrand: undefined;

859 > }

860 >

861 > export class NullLoggerService extends AbstractLoggerService {

862 > constructor() {

863 super(LogLevel.Off, URI.parse('log:///log'));

864 }

865 > protected override doCreateLogger(resource: URI, logLevel: LogLevel, options?: ILoggerOptions): ILogger { log.ts

866 return new NullLogger();

867 }

868 > } log.ts

869 >

870 > export function getLogLevel(environmentService: IEnvironmentService): LogLevel {

871 if (environmentService.verbose) {

872 return LogLevel.Trace;

880 return DEFAULT_LOG_LEVEL;

881 }

882 > log.ts

883 > export function LogLevelToString(logLevel: LogLevel): string {

884 > switch (logLevel) {

885 > case LogLevel.Trace: return 'trace';

886 > case LogLevel.Debug: return 'debug';

887 > case LogLevel.Info: return 'info';

888 > case LogLevel.Warning: return 'warn';

889 > case LogLevel.Error: return 'error';

890 > case LogLevel.Off: return 'off';

891 > }

892 > }

893 >

894 > export function LogLevelToLocalizedString(logLevel: LogLevel): ILocalizedString {

895 switch (logLevel) {

896 case LogLevel.Trace: return { original: 'Trace', value: nls.localize('trace', "Trace") };

902 }

903 }

904 > log.ts

905 > export function parseLogLevel(logLevel: string): LogLevel | undefined {

906 switch (logLevel) {

907 case 'trace':

922 return undefined;

923 }

924 > log.ts

925 > // Contexts

926 > export const CONTEXT_LOG_LEVEL = new RawContextKey<string>('logLevel', LogLevelToString(LogLevel.Info));

src/vs/base/common/arrays.ts 404 covered LOC · 72 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- arrays.ts

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 { findFirstIdxMonotonousOrArrLen } from './arraysFind.js';

7 > import { CancellationToken } from './cancellation.js';

8 > import { CancellationError } from './errors.js';

9 > import { ISplice } from './sequence.js';

10 >

11 > /**

12 > * Returns the last entry and the initial N-1 entries of the array, as a tuple of [rest, last].

13 > *

14 > * The array must have at least one element.

15 > *

16 > * @param arr The input array

17 > * @returns A tuple of [rest, last] where rest is all but the last element and last is the last element

18 > * @throws Error if the array is empty

19 > */

20 > export function tail<T>(arr: T[]): [T[], T] {

21 if (arr.length === 0) {

22 throw new Error('Invalid tail call');

25 return [arr.slice(0, arr.length - 1), arr[arr.length - 1]];

26 }

27 > arrays.ts

28 > export function equals<T>(one: ReadonlyArray<T> | undefined, other: ReadonlyArray<T> | undefined, itemEquals: (a: T, b: T) => boolean = (a, b) => a === b): boolean {

29 if (one === other) {

30 return true;

47 return true;

48 }

49 > arrays.ts

50 > /**

51 > * Remove the element at `index` by replacing it with the last element. This is faster than `splice`

52 > * but changes the order of the array

53 > */

54 > export function removeFastWithoutKeepingOrder<T>(array: T[], index: number) {

55 const last = array.length - 1;

56 if (index < last) {

59 array.pop();

60 }

61 > arrays.ts

62 > /**

63 > * Performs a binary search algorithm over a sorted array.

64 > *

65 > * @param array The array being searched.

66 > * @param key The value we search for.

67 > * @param comparator A function that takes two array elements and returns zero

68 > * if they are equal, a negative number if the first element precedes the

69 > * second one in the sorting order, or a positive number if the second element

70 > * precedes the first one.

71 > * @return See {@link binarySearch2}

72 > */

73 > export function binarySearch<T>(array: ReadonlyArray<T>, key: T, comparator: (op1: T, op2: T) => number): number {

74 return binarySearch2(array.length, i => comparator(array[i], key));

75 }

76 > arrays.ts

77 > /**

78 > * Performs a binary search algorithm over a sorted collection. Useful for cases

79 > * when we need to perform a binary search over something that isn't actually an

80 > * array, and converting data to an array would defeat the use of binary search

81 > * in the first place.

82 > *

83 > * @param length The collection length.

84 > * @param compareToKey A function that takes an index of an element in the

85 > * collection and returns zero if the value at this index is equal to the

86 > * search key, a negative number if the value precedes the search key in the

87 > * sorting order, or a positive number if the search key precedes the value.

88 > * @return A non-negative index of an element, if found. If not found, the

89 > * result is -(n+1) (or ~n, using bitwise notation), where n is the index

90 > * where the key should be inserted to maintain the sorting order.

91 > */

92 > export function binarySearch2(length: number, compareToKey: (index: number) => number): number {

93 let low = 0,

94 high = length - 1;

107 return -(low + 1);

108 }

109 > arrays.ts

110 > type Compare<T> = (a: T, b: T) => number;

111 >

112 > /**

113 > * Finds the nth smallest element in the array using quickselect algorithm.

114 > * The data does not need to be sorted.

115 > *

116 > * @param nth The zero-based index of the element to find (0 = smallest, 1 = second smallest, etc.)

117 > * @param data The unsorted array

118 > * @param compare A comparator function that defines the sort order

119 > * @returns The nth smallest element

120 > * @throws TypeError if nth is >= data.length

121 > */

122 > export function quickSelect<T>(nth: number, data: T[], compare: Compare<T>): T {

123

124 nth = nth | 0;

152 }

153 }

154 > arrays.ts

155 > export function groupBy<T>(data: ReadonlyArray<T>, compare: (a: T, b: T) => number): T[][] {

156 const result: T[][] = [];

157 let currentGroup: T[] | undefined = undefined;

166 return result;

167 }

168 > arrays.ts

169 > /**

170 > * Splits the given items into a list of (non-empty) groups.

171 > * `shouldBeGrouped` is used to decide if two consecutive items should be in the same group.

172 > * The order of the items is preserved.

173 > */

174 > export function* groupAdjacentBy<T>(items: Iterable<T>, shouldBeGrouped: (item1: T, item2: T) => boolean): Iterable<T[]> {

175 let currentGroup: T[] | undefined;

176 let last: T | undefined;

190 }

191 }

192 > arrays.ts

193 > export function forEachAdjacent<T>(arr: T[], f: (item1: T | undefined, item2: T | undefined) => void): void {

194 for (let i = 0; i <= arr.length; i++) {

195 f(i === 0 ? undefined : arr[i - 1], i === arr.length ? undefined : arr[i]);

196 }

197 }

198 > arrays.ts

199 > export function forEachWithNeighbors<T>(arr: T[], f: (before: T | undefined, element: T, after: T | undefined) => void): void {

200 for (let i = 0; i < arr.length; i++) {

201 f(i === 0 ? undefined : arr[i - 1], arr[i], i + 1 === arr.length ? undefined : arr[i + 1]);

202 }

203 }

204 > arrays.ts

205 > export function concatArrays<T extends any[]>(...arrays: T): T[number][number][] {

206 return [].concat(...arrays);

207 }

208 > arrays.ts

209 > interface IMutableSplice<T> extends ISplice<T> {

210 > readonly toInsert: T[];

211 > deleteCount: number;

212 > }

213 >

214 > /**

215 > * Diffs two *sorted* arrays and computes the splices which apply the diff.

216 > */

217 > export function sortedDiff<T>(before: ReadonlyArray<T>, after: ReadonlyArray<T>, compare: (a: T, b: T) => number): ISplice<T>[] {

218 const result: IMutableSplice<T>[] = [];

219

266 return result;

267 }

268 > arrays.ts

269 > /**

270 > * Takes two *sorted* arrays and computes their delta (removed, added elements).

271 > * Finishes in `Math.min(before.length, after.length)` steps.

272 > */

273 > export function delta<T>(before: ReadonlyArray<T>, after: ReadonlyArray<T>, compare: (a: T, b: T) => number): { removed: T[]; added: T[] } {

274 const splices = sortedDiff(before, after, compare);

275 const removed: T[] = [];

283 return { removed, added };

284 }

285 > arrays.ts

286 > /**

287 > * Returns the top N elements from the array.

288 > *

289 > * Faster than sorting the entire array when the array is a lot larger than N.

290 > *

291 > * @param array The unsorted array.

292 > * @param compare A sort function for the elements.

293 > * @param n The number of elements to return.

294 > * @return The first n elements from array when sorted with compare.

295 > */

296 > export function top<T>(array: ReadonlyArray<T>, compare: (a: T, b: T) => number, n: number): T[] {

297 if (n === 0) {

298 return [];

302 return result;

303 }

304 > arrays.ts

305 > /**

306 > * Asynchronous variant of `top()` allowing for splitting up work in batches between which the event loop can run.

307 > *

308 > * Returns the top N elements from the array.

309 > *

310 > * Faster than sorting the entire array when the array is a lot larger than N.

311 > *

312 > * @param array The unsorted array.

313 > * @param compare A sort function for the elements.

314 > * @param n The number of elements to return.

315 > * @param batch The number of elements to examine before yielding to the event loop.

316 > * @return The first n elements from array when sorted with compare.

317 > */

318 > export function topAsync<T>(array: T[], compare: (a: T, b: T) => number, n: number, batch: number, token?: CancellationToken): Promise<T[]> {

319 if (n === 0) {

320 return Promise.resolve([]);

339 });

340 }

341 > arrays.ts

342 function topStep<T>(array: ReadonlyArray<T>, compare: (a: T, b: T) => number, result: T[], i: number, m: number): void {

343 for (const n = result.length; i < m; i++) {

350 }

351 }

352 > arrays.ts

353 > /**

354 > * @returns New array with all falsy values removed. The original array IS NOT modified.

355 > */

356 > export function coalesce<T>(array: ReadonlyArray<T | undefined | null>): T[] {

357 return array.filter((e): e is T => !!e);

358 }

359 > arrays.ts

360 > /**

361 > * Remove all falsy values from `array`. The original array IS modified.

362 > */

363 > export function coalesceInPlace<T>(array: Array<T | undefined | null>): asserts array is Array<T> {

364 let to = 0;

365 for (let i = 0; i < array.length; i++) {

371 array.length = to;

372 }

373 > arrays.ts

374 > /**

375 > * @deprecated Use `Array.copyWithin` instead

376 > */

377 > export function move(array: unknown[], from: number, to: number): void {

378 array.splice(to, 0, array.splice(from, 1)[0]);

379 }

380 > arrays.ts

381 > /**

382 > * @returns false if the provided object is an array and not empty.

383 > */

384 > export function isFalsyOrEmpty(obj: unknown): boolean {

385 return !Array.isArray(obj) || obj.length === 0;

386 }

387 > arrays.ts

388 > /**

389 > * @returns True if the provided object is an array and has at least one element.

390 > */

391 > export function isNonEmptyArray<T>(obj: T[] | undefined | null): obj is T[];

392 > export function isNonEmptyArray<T>(obj: readonly T[] | undefined | null): obj is readonly T[];

393 > export function isNonEmptyArray<T>(obj: T[] | readonly T[] | undefined | null): obj is T[] | readonly T[] {

394 return Array.isArray(obj) && obj.length > 0;

395 }

396 > arrays.ts

397 > /**

398 > * Removes duplicates from the given array. The optional keyFn allows to specify

399 > * how elements are checked for equality by returning an alternate value for each.

400 > */

401 > export function distinct<T>(array: ReadonlyArray<T>, keyFn: (value: T) => unknown = value => value): T[] {

402 const seen = new Set<any>();

403

411 });

412 }

413 > arrays.ts

414 > export function uniqueFilter<T, R>(keyFn: (t: T) => R): (t: T) => boolean {

415 const seen = new Set<R>();

416

426 };

427 }

428 > arrays.ts

429 > export function commonPrefixLength<T>(one: ReadonlyArray<T>, other: ReadonlyArray<T>, equals: (a: T, b: T) => boolean = (a, b) => a === b): number {

430 let result = 0;

431

436 return result;

437 }

438 > arrays.ts

439 > export function range(to: number): number[];

440 > export function range(from: number, to: number): number[];

441 > export function range(arg: number, to?: number): number[] {

442 let from = typeof to === 'number' ? arg : 0;

443

463 return result;

464 }

465 > arrays.ts

466 > export function index<T>(array: ReadonlyArray<T>, indexer: (t: T) => string): { [key: string]: T };

467 > export function index<T, R>(array: ReadonlyArray<T>, indexer: (t: T) => string, mapper: (t: T) => R): { [key: string]: R };

468 > export function index<T, R>(array: ReadonlyArray<T>, indexer: (t: T) => string, mapper?: (t: T) => R): { [key: string]: R } {

469 return array.reduce((r, t) => {

470 r[indexer(t)] = mapper ? mapper(t) : t;

472 }, Object.create(null));

473 }

474 > arrays.ts

475 > /**

476 > * Inserts an element into an array. Returns a function which, when

477 > * called, will remove that element from the array.

478 > *

479 > * @deprecated In almost all cases, use a `Set<T>` instead.

480 > */

481 > export function insert<T>(array: T[], element: T): () => void {

482 array.push(element);

483

484 return () => remove(array, element);

485 }

486 > arrays.ts

487 > /**

488 > * Removes an element from an array if it can be found.

489 > *

490 > * @deprecated In almost all cases, use a `Set<T>` instead.

491 > */

492 > export function remove<T>(array: T[], element: T): T | undefined {

493 const index = array.indexOf(element);

494 if (index > -1) {

500 return undefined;

501 }

502 > arrays.ts

503 > /**

504 > * Insert `insertArr` inside `target` at `insertIndex`.

505 > * Please don't touch unless you understand https://jsperf.com/inserting-an-array-within-an-array

506 > */

507 > export function arrayInsert<T>(target: T[], insertIndex: number, insertArr: T[]): T[] {

508 const before = target.slice(0, insertIndex);

509 const after = target.slice(insertIndex);

510 return before.concat(insertArr, after);

511 }

512 > arrays.ts

513 > /**

514 > * Uses Fisher-Yates shuffle to shuffle the given array

515 > */

516 > export function shuffle<T>(array: T[], _seed?: number): void {

517 let rand: () => number;

518

536 }

537 }

538 > arrays.ts

539 > /**

540 > * Pushes an element to the start of the array, if found.

541 > */

542 > export function pushToStart<T>(arr: T[], value: T): void {

543 const index = arr.indexOf(value);

544

548 }

549 }

550 > arrays.ts

551 > /**

552 > * Pushes an element to the end of the array, if found.

553 > */

554 > export function pushToEnd<T>(arr: T[], value: T): void {

555 const index = arr.indexOf(value);

556

560 }

561 }

562 > arrays.ts

563 > export function pushMany<T>(arr: T[], items: ReadonlyArray<T>): void {

564 for (const item of items) {

565 arr.push(item);

566 }

567 }

568 > arrays.ts

569 > export function mapArrayOrNot<T, U>(items: T | T[], fn: (_: T) => U): U | U[] {

570 return Array.isArray(items) ?

571 items.map(fn) :

572 fn(items);

573 }

574 > arrays.ts

575 > export function mapFilter<T, U>(array: ReadonlyArray<T>, fn: (t: T) => U | undefined): U[] {

576 const result: U[] = [];

577 for (const item of array) {

583 return result;

584 }

585 > arrays.ts

586 > export function withoutDuplicates<T>(array: ReadonlyArray<T>): T[] {

587 const s = new Set(array);

588 return Array.from(s);

589 }

590 > arrays.ts

591 > export function asArray<T>(x: T | T[]): T[];

592 > export function asArray<T>(x: T | readonly T[]): readonly T[];

593 > export function asArray<T>(x: T | T[]): T[] {

594 return Array.isArray(x) ? x : [x];

595 }

596 > arrays.ts

597 > export function getRandomElement<T>(arr: T[]): T | undefined {

598 return arr[Math.floor(Math.random() * arr.length)];

599 }

600 > arrays.ts

601 > /**

602 > * Insert the new items in the array.

603 > * @param array The original array.

604 > * @param start The zero-based location in the array from which to start inserting elements.

605 > * @param newItems The items to be inserted

606 > */

607 > export function insertInto<T>(array: T[], start: number, newItems: T[]): void {

608 const startIdx = getActualStartIndex(array, start);

609 const originalLength = array.length;

619 }

620 }

621 > arrays.ts

622 > /**

623 > * Removes elements from an array and inserts new elements in their place, returning the deleted elements. Alternative to the native Array.splice method, it

624 > * can only support limited number of items due to the maximum call stack size limit.

625 > * @param array The original array.

626 > * @param start The zero-based location in the array from which to start removing elements.

627 > * @param deleteCount The number of elements to remove.

628 > * @returns An array containing the elements that were deleted.

629 > */

630 > export function splice<T>(array: T[], start: number, deleteCount: number, newItems: T[]): T[] {

631 const index = getActualStartIndex(array, start);

632 let result = array.splice(index, deleteCount);

638 return result;

639 }

640 > arrays.ts

641 > /**

642 > * Determine the actual start index (same logic as the native splice() or slice())

643 > * If greater than the length of the array, start will be set to the length of the array. In this case, no element will be deleted but the method will behave as an adding function, adding as many element as item[n*] provided.

644 > * If negative, it will begin that many elements from the end of the array. (In this case, the origin -1, meaning -n is the index of the nth last element, and is therefore equivalent to the index of array.length - n.) If array.length + start is less than 0, it will begin from index 0.

645 > * @param array The target array.

646 > * @param start The operation index.

647 > */

648 function getActualStartIndex<T>(array: T[], start: number): number {

649 return start < 0 ? Math.max(start + array.length, 0) : Math.min(start, array.length);

650 }

651 > arrays.ts

652 >

653 >

654 > /**

655 > * When comparing two values,

656 > * a negative number indicates that the first value is less than the second,

657 > * a positive number indicates that the first value is greater than the second,

658 > * and zero indicates that neither is the case.

659 > */

660 > export type CompareResult = number;

661 >

662 > export namespace CompareResult {

663 > export function isLessThan(result: CompareResult): boolean {

664 return result < 0;

665 }

666 > arrays.ts

667 > export function isLessThanOrEqual(result: CompareResult): boolean {

668 return result <= 0;

669 }

670 > arrays.ts

671 > export function isGreaterThan(result: CompareResult): boolean {

672 return result > 0;

673 }

674 > arrays.ts

675 > export function isNeitherLessOrGreaterThan(result: CompareResult): boolean {

676 return result === 0;

677 }

678 > arrays.ts

679 > export const greaterThan = 1;

680 > export const lessThan = -1;

681 > export const neitherLessOrGreaterThan = 0;

682 > }

683 >

684 > /**

685 > * A comparator `c` defines a total order `<=` on `T` as following:

686 > * `c(a, b) <= 0` iff `a` <= `b`.

687 > * We also have `c(a, b) == 0` iff `c(b, a) == 0`.

688 > */

689 > export type Comparator<T> = (a: T, b: T) => CompareResult;

690 >

691 > export function compareBy<TItem, TCompareBy>(selector: (item: TItem) => TCompareBy, comparator: Comparator<TCompareBy>): Comparator<TItem> {

692 return (a, b) => comparator(selector(a), selector(b));

693 }

694 > arrays.ts

695 > export function tieBreakComparators<TItem>(...comparators: Comparator<TItem>[]): Comparator<TItem> {

696 return (item1, item2) => {

697 for (const comparator of comparators) {

704 };

705 }

706 > arrays.ts

707 > /**

708 > * The natural order on numbers.

709 > */

710 > export const numberComparator: Comparator<number> = (a, b) => a - b;

711 >

712 > export const booleanComparator: Comparator<boolean> = (a, b) => numberComparator(a ? 1 : 0, b ? 1 : 0);

713 >

714 > export function reverseOrder<TItem>(comparator: Comparator<TItem>): Comparator<TItem> {

715 return (a, b) => -comparator(a, b);

716 }

717 > arrays.ts

718 > /**

719 > * Returns a new comparator that treats `undefined` as the smallest value.

720 > * All other values are compared using the given comparator.

721 > */

722 > export function compareUndefinedSmallest<T>(comparator: Comparator<T>): Comparator<T | undefined> {

723 return (a, b) => {

724 if (a === undefined) {

731 };

732 }

733 > arrays.ts

734 > export class ArrayQueue<T> {

735 > private readonly items: readonly T[];

736 > private firstIdx = 0;

737 > private lastIdx: number;

738 >

739 > /**

740 > * Constructs a queue that is backed by the given array. Runtime is O(1).

741 > */

742 > constructor(items: readonly T[]) {

743 this.items = items;

744 this.lastIdx = this.items.length - 1;

745 }

746 > arrays.ts

747 > get length(): number {

748 return this.lastIdx - this.firstIdx + 1;

749 }

750 > arrays.ts

751 > /**

752 > * Consumes elements from the beginning of the queue as long as the predicate returns true.

753 > * If no elements were consumed, `null` is returned. Has a runtime of O(result.length).

754 > */

755 > takeWhile(predicate: (value: T) => boolean): T[] | null {

756 // P(k) := k <= this.lastIdx && predicate(this.items[k])

757 // Find s := min { k | k >= this.firstIdx && !P(k) } and return this.data[this.firstIdx...s)

765 return result;

766 }

767 > arrays.ts

768 > /**

769 > * Consumes elements from the end of the queue as long as the predicate returns true.

770 > * If no elements were consumed, `null` is returned.

771 > * The result has the same order as the underlying array!

772 > */

773 > takeFromEndWhile(predicate: (value: T) => boolean): T[] | null {

774 // P(k) := this.firstIdx >= k && predicate(this.items[k])

775 // Find s := max { k | k <= this.lastIdx && !P(k) } and return this.data(s...this.lastIdx]

783 return result;

784 }

785 > arrays.ts

786 > peek(): T | undefined {

787 if (this.length === 0) {

788 return undefined;

790 return this.items[this.firstIdx];

791 }

792 > arrays.ts

793 > peekLast(): T | undefined {

794 if (this.length === 0) {

795 return undefined;

797 return this.items[this.lastIdx];

798 }

799 > arrays.ts

800 > dequeue(): T | undefined {

801 const result = this.items[this.firstIdx];

802 this.firstIdx++;

803 return result;

804 }

805 > arrays.ts

806 > removeLast(): T | undefined {

807 const result = this.items[this.lastIdx];

808 this.lastIdx--;

809 return result;

810 }

811 > arrays.ts

812 > takeCount(count: number): T[] {

813 const result = this.items.slice(this.firstIdx, this.firstIdx + count);

814 this.firstIdx += count;

815 return result;

816 }

817 > } arrays.ts

818 >

819 > /**

820 > * This class is faster than an iterator and array for lazy computed data.

821 > */

822 > export class CallbackIterable<T> {

823 > public static readonly empty = new CallbackIterable<never>(_callback => { });

824 >

825 > constructor(

826 > /**

827 > * Calls the callback for every item.

828 > * Stops when the callback returns false.

829 > */

830 > public readonly iterate: (callback: (item: T) => boolean) => void

831 > ) {

832 > }

833 >

834 > forEach(handler: (item: T) => void) {

835 this.iterate(item => { handler(item); return true; });

836 }

837 > arrays.ts

838 > toArray(): T[] {

839 const result: T[] = [];

840 this.iterate(item => { result.push(item); return true; });

841 return result;

842 }

843 > arrays.ts

844 > filter(predicate: (item: T) => boolean): CallbackIterable<T> {

845 return new CallbackIterable(cb => this.iterate(item => predicate(item) ? cb(item) : true));

846 }

847 > arrays.ts

848 > map<TResult>(mapFn: (item: T) => TResult): CallbackIterable<TResult> {

849 return new CallbackIterable<TResult>(cb => this.iterate(item => cb(mapFn(item))));

850 }

851 > arrays.ts

852 > some(predicate: (item: T) => boolean): boolean {

853 let result = false;

854 this.iterate(item => { result = predicate(item); return !result; });

855 return result;

856 }

857 > arrays.ts

858 > findFirst(predicate: (item: T) => boolean): T | undefined {

859 let result: T | undefined;

860 this.iterate(item => {

867 return result;

868 }

869 > arrays.ts

870 > findLast(predicate: (item: T) => boolean): T | undefined {

871 let result: T | undefined;

872 this.iterate(item => {

878 return result;

879 }

880 > arrays.ts

881 > findLastMaxBy(comparator: Comparator<T>): T | undefined {

882 let result: T | undefined;

883 let first = true;

891 return result;

892 }

893 > } arrays.ts

894 >

895 > /**

896 > * Represents a re-arrangement of items in an array.

897 > */

898 > export class Permutation {

899 > constructor(private readonly _indexMap: readonly number[]) { }

900 >

901 > /**

902 > * Returns a permutation that sorts the given array according to the given compare function.

903 > */

904 > public static createSortPermutation<T>(arr: readonly T[], compareFn: (a: T, b: T) => number): Permutation {

905 const sortIndices = Array.from(arr.keys()).sort((index1, index2) => compareFn(arr[index1], arr[index2]));

906 return new Permutation(sortIndices);

907 }

908 > arrays.ts

909 > /**

910 > * Returns a new array with the elements of the given array re-arranged according to this permutation.

911 > */

912 > apply<T>(arr: readonly T[]): T[] {

913 return arr.map((_, index) => arr[this._indexMap[index]]);

914 }

915 > arrays.ts

916 > /**

917 > * Returns a new permutation that undoes the re-arrangement of this permutation.

918 > */

919 > inverse(): Permutation {

920 const inverseIndexMap = this._indexMap.slice();

921 for (let i = 0; i < this._indexMap.length; i++) {

924 return new Permutation(inverseIndexMap);

925 }

926 > } arrays.ts

927 >

928 > /**

929 > * Asynchronous variant of `Array.find()`, returning the first element in

930 > * the array for which the predicate returns true.

931 > *

932 > * This implementation does not bail early and waits for all promises to

933 > * resolve before returning.

934 > */

935 export async function findAsync<T>(array: readonly T[], predicate: (element: T, index: number) => Promise<boolean>): Promise<T | undefined> {

936 const results = await Promise.all(array.map(

940 return results.find(r => r.ok)?.element;

941 }

942 > arrays.ts

943 > export function sum(array: readonly number[]): number {

944 return array.reduce((acc, value) => acc + value, 0);

945 }

946 > arrays.ts

947 > export function sumBy<T>(array: readonly T[], selector: (value: T) => number): number {

948 return array.reduce((acc, value) => acc + selector(value), 0);

949 }

src/vs/base/common/uri.ts 347 covered LOC · 42 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- uri.ts

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 { CharCode } from './charCode.js';

7 > import { MarshalledId } from './marshallingIds.js';

8 > import * as paths from './path.js';

9 > import { isWindows } from './platform.js';

10 >

11 > const _schemePattern = /^\w[\w\d+.-]*$/;

12 > const _singleSlashStart = /^\//;

13 > const _doubleSlashStart = /^\/\//;

14 >

15 > function _validateUri(ret: URI, _strict?: boolean): void { uri.ts

16 >

17 > // scheme, must be set

18 > if (!ret.scheme && _strict) {

19 throw new Error(`[UriError]: Scheme is missing: {scheme: "", authority: "${ret.authority}", path: "${ret.path}", query: "${ret.query}", fragment: "${ret.fragment}"}`);

20 }

21 > uri.ts

22 > // scheme, https://tools.ietf.org/html/rfc3986#section-3.1

23 > // ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

24 > if (ret.scheme && !_schemePattern.test(ret.scheme)) { uri.ts

25 const matches = [...ret.scheme.matchAll(/[^\w\d+.-]/gu)];

26 const detail = matches.length > 0

29 throw new Error(`[UriError]: Scheme contains illegal characters.${detail} (len:${ret.scheme.length})`);

30 }

31 > uri.ts

32 > // path, http://tools.ietf.org/html/rfc3986#section-3.3

33 > // If a URI contains an authority component, then the path component

34 > // must either be empty or begin with a slash ("/") character. If a URI

35 > // does not contain an authority component, then the path cannot begin

36 > // with two slash characters ("//").

37 > if (ret.path) {

38 if (ret.authority) {

39 if (!_singleSlashStart.test(ret.path)) {

46 }

47 }

48 > } uri.ts

49 > uri.ts

50 > // for a while we allowed uris *without* schemes and this is the migration

51 > // for them, e.g. an uri without scheme and without strict-mode warns and falls

52 > // back to the file-scheme. that should cause the least carnage and still be a

53 > // clear warning

54 > function _schemeFix(scheme: string, _strict: boolean): string { uri.ts

55 > if (!scheme && !_strict) {

56 return 'file';

57 }

58 > return scheme; uri.ts

59 > }

60 > uri.ts

61 > // implements a bit of https://tools.ietf.org/html/rfc3986#section-5

62 > function _referenceResolution(scheme: string, path: string): string { uri.ts

63 >

64 > // the slash-character is our 'default base' as we don't

65 > // support constructing URIs relative to other URIs. This

66 > // also means that we alter and potentially break paths.

67 > // see https://tools.ietf.org/html/rfc3986#section-5.1.4

68 > switch (scheme) {

69 > case 'https':

70 > case 'http':

71 > case 'file':

72 if (!path) {

73 path = _slash;

76 }

77 break;

78 > } uri.ts

79 > return path;

80 > }

81 > uri.ts

82 > const _empty = '';

83 > const _slash = '/';

84 > const _regexp = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;

85 >

86 > /**

87 > * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.

88 > * This class is a simple parser which creates the basic component parts

89 > * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation

90 > * and encoding.

91 > *

92 > * ```txt

93 > * foo://example.com:8042/over/there?name=ferret#nose

94 > * \_/ \______________/\_________/ \_________/ \__/

95 > * | | | | |

96 > * scheme authority path query fragment

97 > * | _____________________|__

98 > * / \ / \

99 > * urn:example:animal:ferret:nose

100 > * ```

101 > */

102 > export class URI implements UriComponents {

103 >

104 > static isUri(thing: unknown): thing is URI {

105 if (thing instanceof URI) {

106 return true;

118 && typeof (<URI>thing).toString === 'function';

119 }

120 > uri.ts

121 > /**

122 > * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.

123 > * The part before the first colon.

124 > */

125 > readonly scheme: string;

126 >

127 > /**

128 > * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'.

129 > * The part between the first double slashes and the next slash.

130 > */

131 > readonly authority: string;

132 >

133 > /**

134 > * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.

135 > */

136 > readonly path: string;

137 >

138 > /**

139 > * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.

140 > */

141 > readonly query: string;

142 >

143 > /**

144 > * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.

145 > */

146 > readonly fragment: string;

147 >

148 > /**

149 > * @internal

150 > */

151 > protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);

152 >

153 > /**

154 > * @internal

155 > */

156 > protected constructor(components: UriComponents);

157 >

158 > /**

159 > * @internal

160 > */

161 > protected constructor(schemeOrData: string | UriComponents, authority?: string, path?: string, query?: string, fragment?: string, _strict: boolean = false) {

162 > uri.ts

163 > if (typeof schemeOrData === 'object') {

164 this.scheme = schemeOrData.scheme || _empty;

165 this.authority = schemeOrData.authority || _empty;

170 // that creates uri components.

171 // _validateUri(this);

172 > } else { uri.ts

173 > this.scheme = _schemeFix(schemeOrData, _strict);

174 > this.authority = authority || _empty;

175 > this.path = _referenceResolution(this.scheme, path || _empty);

176 > this.query = query || _empty;

177 > this.fragment = fragment || _empty;

178 >

179 > _validateUri(this, _strict);

180 > }

181 > }

182 > uri.ts

183 > // ---- filesystem path -----------------------

184 >

185 > /**

186 > * Returns a string representing the corresponding file system path of this URI.

187 > * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the

188 > * platform specific path separator.

189 > *

190 > * * Will *not* validate the path for invalid characters and semantics.

191 > * * Will *not* look at the scheme of this URI.

192 > * * The result shall *not* be used for display purposes but for accessing a file on disk.

193 > *

194 > *

195 > * The *difference* to `URI#path` is the use of the platform specific separator and the handling

196 > * of UNC paths. See the below sample of a file-uri with an authority (UNC path).

197 > *

198 > * ```ts

199 > const u = URI.parse('file://server/c$/folder/file.txt')

200 > u.authority === 'server'

201 > u.path === '/shares/c$/file.txt'

202 > u.fsPath === '\\server\c$\folder\file.txt'

203 > ```

204 > *

205 > * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,

206 > * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working

207 > * with URIs that represent files on disk (`file` scheme).

208 > */

209 > get fsPath(): string {

210 // if (this.scheme !== 'file') {

211 // console.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);

213 return uriToFsPath(this, false);

214 }

215 > uri.ts

216 > // ---- modify to new -------------------------

217 >

218 > with(change: { scheme?: string; authority?: string | null; path?: string | null; query?: string | null; fragment?: string | null }): URI {

219

220 if (!change) {

260 return new Uri(scheme, authority, path, query, fragment);

261 }

262 > uri.ts

263 > // ---- parse & validate ------------------------

264 >

265 > /**

266 > * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,

267 > * `file:///usr/home`, or `scheme:with/path`.

268 > *

269 > * @param value A string which represents an URI (see `URI#toString`).

270 > */

271 > static parse(value: string, _strict: boolean = false): URI {

272 > const match = _regexp.exec(value); uri.ts

273 > if (!match) {

274 return new Uri(_empty, _empty, _empty, _empty, _empty);

275 }

276 > return new Uri( uri.ts

277 > match[2] || _empty,

278 > percentDecode(match[4] || _empty),

279 > percentDecode(match[5] || _empty),

280 > percentDecode(match[7] || _empty),

281 > percentDecode(match[9] || _empty),

282 > _strict

283 > );

284 > }

285 > uri.ts

286 > /**

287 > * Creates a new URI from a file system path, e.g. `c:\my\files`,

288 > * `/usr/home`, or `\\server\share\some\path`.

289 > *

290 > * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument

291 > * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**

292 > * `URI.parse('file://' + path)` because the path might contain characters that are

293 > * interpreted (# and ?). See the following sample:

294 > * ```ts

295 > const good = URI.file('/coding/c#/project1');

296 > good.scheme === 'file';

297 > good.path === '/coding/c#/project1';

298 > good.fragment === '';

299 > const bad = URI.parse('file://' + '/coding/c#/project1');

300 > bad.scheme === 'file';

301 > bad.path === '/coding/c'; // path is now broken

302 > bad.fragment === '/project1';

303 > ```

304 > *

305 > * @param path A file system path (see `URI#fsPath`)

306 > */

307 > static file(path: string): URI {

308

309 let authority = _empty;

331 return new Uri('file', authority, path, _empty, _empty);

332 }

333 > uri.ts

334 > /**

335 > * Creates new URI from uri components.

336 > *

337 > * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs

338 > * validation and should be used for untrusted uri components retrieved from storage,

339 > * user input, command arguments etc

340 > */

341 > static from(components: UriComponents, strict?: boolean): URI {

342 const result = new Uri(

343 components.scheme,

350 return result;

351 }

352 > uri.ts

353 > /**

354 > * Join a URI path with path fragments and normalizes the resulting path.

355 > *

356 > * @param uri The input URI.

357 > * @param pathFragment The path fragment to add to the URI path.

358 > * @returns The resulting URI.

359 > */

360 > static joinPath(uri: URI, ...pathFragment: string[]): URI {

361 if (!uri.path) {

362 throw new Error(`[UriError]: cannot call joinPath on URI without path: ${uri.toString()}`);

370 return uri.with({ path: newPath });

371 }

372 > uri.ts

373 > // ---- printing/externalize ---------------------------

374 >

375 > /**

376 > * Creates a string representation for this URI. It's guaranteed that calling

377 > * `URI.parse` with the result of this function creates an URI which is equal

378 > * to this URI.

379 > *

380 > * * The result shall *not* be used for display purposes but for externalization or transport.

381 > * * The result will be encoded using the percentage encoding and encoding happens mostly

382 > * ignore the scheme-specific encoding rules.

383 > *

384 > * @param skipEncoding Do not encode the result, default is `false`

385 > */

386 > toString(skipEncoding: boolean = false): string {

387 return _asFormatted(this, skipEncoding);

388 }

389 > uri.ts

390 > toJSON(): UriComponents {

391 return this;

392 }

393 > uri.ts

394 > /**

395 > * A helper function to revive URIs.

396 > *

397 > * **Note** that this function should only be used when receiving URI#toJSON generated data

398 > * and that it doesn't do any validation. Use {@link URI.from} when received "untrusted"

399 > * uri components such as command arguments or data from storage.

400 > *

401 > * @param data The URI components or URI to revive.

402 > * @returns The revived URI or undefined or null.

403 > */

404 > static revive(data: UriComponents | URI): URI;

405 > static revive(data: UriComponents | URI | undefined): URI | undefined;

406 > static revive(data: UriComponents | URI | null): URI | null;

407 > static revive(data: UriComponents | URI | undefined | null): URI | undefined | null;

408 > static revive(data: UriComponents | URI | undefined | null): URI | undefined | null {

409 if (!data) {

410 return data;

418 }

419 }

420 > uri.ts

421 > [Symbol.for('debug.description')]() {

422 return `URI(${this.toString()})`;

423 }

424 > } uri.ts

425 >

426 > export interface UriComponents {

427 > scheme: string;

428 > authority?: string;

429 > path?: string;

430 > query?: string;

431 > fragment?: string;

432 > }

433 >

434 > export function isUriComponents(thing: unknown): thing is UriComponents {

435 if (!thing || typeof thing !== 'object') {

436 return false;

442 && (typeof (<UriComponents>thing).fragment === 'string' || typeof (<UriComponents>thing).fragment === 'undefined');

443 }

444 > uri.ts

445 > interface UriState extends UriComponents {

446 > $mid: MarshalledId.Uri;

447 > external?: string;

448 > fsPath?: string;

449 > _sep?: 1;

450 > }

451 >

452 > const _pathSepMarker = isWindows ? 1 : undefined;

453 >

454 > // This class exists so that URI is compatible with vscode.Uri (API).

455 > class Uri extends URI { uri.ts

456 >

457 > _formatted: string | null = null;

458 > _fsPath: string | null = null;

459 > uri.ts

460 > override get fsPath(): string {

461 if (!this._fsPath) {

462 this._fsPath = uriToFsPath(this, false);

464 return this._fsPath;

465 }

466 > uri.ts

467 > override toString(skipEncoding: boolean = false): string {

468 if (!skipEncoding) {

469 if (!this._formatted) {

476 }

477 }

478 > uri.ts

479 > override toJSON(): UriComponents {

480 // eslint-disable-next-line local/code-no-dangerous-type-assertions

481 const res = <UriState>{

512 return res;

513 }

514 > } uri.ts

515 >

516 > // reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2

517 > const encodeTable: { [ch: number]: string } = {

518 > [CharCode.Colon]: '%3A', // gen-delims

519 > [CharCode.Slash]: '%2F',

520 > [CharCode.QuestionMark]: '%3F',

521 > [CharCode.Hash]: '%23',

522 > [CharCode.OpenSquareBracket]: '%5B',

523 > [CharCode.CloseSquareBracket]: '%5D',

524 > [CharCode.AtSign]: '%40',

525 >

526 > [CharCode.ExclamationMark]: '%21', // sub-delims

527 > [CharCode.DollarSign]: '%24',

528 > [CharCode.Ampersand]: '%26',

529 > [CharCode.SingleQuote]: '%27',

530 > [CharCode.OpenParen]: '%28',

531 > [CharCode.CloseParen]: '%29',

532 > [CharCode.Asterisk]: '%2A',

533 > [CharCode.Plus]: '%2B',

534 > [CharCode.Comma]: '%2C',

535 > [CharCode.Semicolon]: '%3B',

536 > [CharCode.Equals]: '%3D',

537 >

538 > [CharCode.Space]: '%20',

539 > };

540 >

541 function encodeURIComponentFast(uriComponent: string, isPath: boolean, isAuthority: boolean): string {

542 let res: string | undefined = undefined;

602 return res !== undefined ? res : uriComponent;

603 }

604 > uri.ts

605 function encodeURIComponentMinimal(path: string): string {

606 let res: string | undefined = undefined;

620 return res !== undefined ? res : path;

621 }

622 > uri.ts

623 > /**

624 > * Compute `fsPath` for the given uri

625 > */

626 > export function uriToFsPath(uri: URI, keepDriveLetterCasing: boolean): string {

627

628 let value: string;

650 return value;

651 }

652 > uri.ts

653 > /**

654 > * Create the external version of a uri

655 > */

656 function _asFormatted(uri: URI, skipEncoding: boolean): string {

657

723 return res;

724 }

725 > uri.ts

726 > // --- decode

727 >

728 function decodeURIComponentGraceful(str: string): string {

729 try {

737 }

738 }

739 > uri.ts

740 > const _rEncodedAsHex = /(%[0-9A-Za-z][0-9A-Za-z])+/g;

741 >

742 > function percentDecode(str: string): string { uri.ts

743 > if (!str.match(_rEncodedAsHex)) {

744 > return str;

745 > }

746 return str.replace(_rEncodedAsHex, (match) => decodeURIComponentGraceful(match));

747 }

748 > uri.ts

749 > /**

750 > * Mapped-type that replaces all occurrences of URI with UriComponents

751 > */

752 > export type UriDto<T> = { [K in keyof T]: T[K] extends URI

753 > ? UriComponents

754 > : UriDto<T[K]> };

src/vs/base/common/naturalLanguage/korean.ts 329 covered LOC · 5 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- korean.ts

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 > // allow-any-unicode-comment-file

7 >

8 > /**

9 > * Gets alternative Korean characters for the character code. This will return the ascii

10 > * character code(s) that a Hangul character may have been input with using a qwerty layout.

11 > *

12 > * This only aims to cover modern (not archaic) Hangul syllables.

13 > *

14 > * @param code The character code to get alternate characters for

15 > */

16 > export function getKoreanAltChars(code: number): ArrayLike<number> | undefined {

17 const result = disassembleKorean(code);

18 if (result && result.length > 0) {

21 return undefined;

22 }

23 > korean.ts

24 > let codeBufferLength = 0;

25 > const codeBuffer = new Uint32Array(10);

26 function disassembleKorean(code: number): Uint32Array | undefined {

27 codeBufferLength = 0;

91 return undefined;

92 }

93 > korean.ts

94 function getCodesFromArray(code: number, array: ArrayLike<number>, arrayStartIndex: number): void {

95 // Verify the code is within the array's range

98 }

99 }

100 > korean.ts

101 function addCodesToBuffer(codes: number): void {

102 // NUL is ignored, this is used for archaic characters to avoid using a Map

114 }

115 }

116 > korean.ts

117 > const enum HangulRangeStartCode {

118 > InitialConsonant = 0x1100,

119 > Vowel = 0x1161,

120 > FinalConsonant = 0x11A8,

121 > CompatibilityJamo = 0x3131,

122 > }

123 >

124 > const enum AsciiCode {

125 > NUL = 0,

126 > A = 65,

127 > B = 66,

128 > C = 67,

129 > D = 68,

130 > E = 69,

131 > F = 70,

132 > G = 71,

133 > H = 72,

134 > I = 73,

135 > J = 74,

136 > K = 75,

137 > L = 76,

138 > M = 77,

139 > N = 78,

140 > O = 79,

141 > P = 80,

142 > Q = 81,

143 > R = 82,

144 > S = 83,

145 > T = 84,

146 > U = 85,

147 > V = 86,

148 > W = 87,

149 > X = 88,

150 > Y = 89,

151 > Z = 90,

152 > a = 97,

153 > b = 98,

154 > c = 99,

155 > d = 100,

156 > e = 101,

157 > f = 102,

158 > g = 103,

159 > h = 104,

160 > i = 105,

161 > j = 106,

162 > k = 107,

163 > l = 108,

164 > m = 109,

165 > n = 110,

166 > o = 111,

167 > p = 112,

168 > q = 113,

169 > r = 114,

170 > s = 115,

171 > t = 116,

172 > u = 117,

173 > v = 118,

174 > w = 119,

175 > x = 120,

176 > y = 121,

177 > z = 122,

178 > }

179 >

180 > /**

181 > * Numbers that represent multiple ascii codes. These are precomputed at compile time to reduce

182 > * bundle and runtime overhead.

183 > */

184 > const enum AsciiCodeCombo {

185 > fa = AsciiCode.a << 8 | AsciiCode.f,

186 > fg = AsciiCode.g << 8 | AsciiCode.f,

187 > fq = AsciiCode.q << 8 | AsciiCode.f,

188 > fr = AsciiCode.r << 8 | AsciiCode.f,

189 > ft = AsciiCode.t << 8 | AsciiCode.f,

190 > fv = AsciiCode.v << 8 | AsciiCode.f,

191 > fx = AsciiCode.x << 8 | AsciiCode.f,

192 > hk = AsciiCode.k << 8 | AsciiCode.h,

193 > hl = AsciiCode.l << 8 | AsciiCode.h,

194 > ho = AsciiCode.o << 8 | AsciiCode.h,

195 > ml = AsciiCode.l << 8 | AsciiCode.m,

196 > nj = AsciiCode.j << 8 | AsciiCode.n,

197 > nl = AsciiCode.l << 8 | AsciiCode.n,

198 > np = AsciiCode.p << 8 | AsciiCode.n,

199 > qt = AsciiCode.t << 8 | AsciiCode.q,

200 > rt = AsciiCode.t << 8 | AsciiCode.r,

201 > sg = AsciiCode.g << 8 | AsciiCode.s,

202 > sw = AsciiCode.w << 8 | AsciiCode.s,

203 > }

204 >

205 > /**

206 > * Hangul Jamo - Modern consonants #1

207 > *

208 > * Range U+1100..U+1112

209 > *

210 > * | | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |

211 > * |--------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|

212 > * | U+110x | ᄀ | ᄁ | ᄂ | ᄃ | ᄄ | ᄅ | ᄆ | ᄇ | ᄈ | ᄉ | ᄊ | ᄋ | ᄌ | ᄍ | ᄎ | ᄏ |

213 > * | U+111x | ᄐ | ᄑ | ᄒ |

214 > */

215 > const modernConsonants = new Uint8Array([

216 > AsciiCode.r, // ㄱ

217 > AsciiCode.R, // ㄲ

218 > AsciiCode.s, // ㄴ

219 > AsciiCode.e, // ㄷ

220 > AsciiCode.E, // ㄸ

221 > AsciiCode.f, // ㄹ

222 > AsciiCode.a, // ㅁ

223 > AsciiCode.q, // ㅂ

224 > AsciiCode.Q, // ㅃ

225 > AsciiCode.t, // ㅅ

226 > AsciiCode.T, // ㅆ

227 > AsciiCode.d, // ㅇ

228 > AsciiCode.w, // ㅈ

229 > AsciiCode.W, // ㅉ

230 > AsciiCode.c, // ㅊ

231 > AsciiCode.z, // ㅋ

232 > AsciiCode.x, // ㅌ

233 > AsciiCode.v, // ㅍ

234 > AsciiCode.g, // ㅎ

235 > ]);

236 >

237 > /**

238 > * Hangul Jamo - Modern Vowels

239 > *

240 > * Range U+1161..U+1175

241 > *

242 > * | | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |

243 > * |--------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|

244 > * | U+116x | | ᅡ | ᅢ | ᅣ | ᅤ | ᅥ | ᅦ | ᅧ | ᅨ | ᅩ | ᅪ | ᅫ | ᅬ | ᅭ | ᅮ | ᅯ |

245 > * | U+117x | ᅰ | ᅱ | ᅲ | ᅳ | ᅴ | ᅵ |

246 > */

247 > const modernVowels = new Uint16Array([

248 > AsciiCode.k, // -> ㅏ

249 > AsciiCode.o, // -> ㅐ

250 > AsciiCode.i, // -> ㅑ

251 > AsciiCode.O, // -> ㅒ

252 > AsciiCode.j, // -> ㅓ

253 > AsciiCode.p, // -> ㅔ

254 > AsciiCode.u, // -> ㅕ

255 > AsciiCode.P, // -> ㅖ

256 > AsciiCode.h, // -> ㅗ

257 > AsciiCodeCombo.hk, // -> ㅘ

258 > AsciiCodeCombo.ho, // -> ㅙ

259 > AsciiCodeCombo.hl, // -> ㅚ

260 > AsciiCode.y, // -> ㅛ

261 > AsciiCode.n, // -> ㅜ

262 > AsciiCodeCombo.nj, // -> ㅝ

263 > AsciiCodeCombo.np, // -> ㅞ

264 > AsciiCodeCombo.nl, // -> ㅟ

265 > AsciiCode.b, // -> ㅠ

266 > AsciiCode.m, // -> ㅡ

267 > AsciiCodeCombo.ml, // -> ㅢ

268 > AsciiCode.l, // -> ㅣ

269 > ]);

270 >

271 > /**

272 > * Hangul Jamo - Modern Consonants #2

273 > *

274 > * Range U+11A8..U+11C2

275 > *

276 > * | | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |

277 > * |--------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|

278 > * | U+11Ax | | | | | | | | | ᆨ | ᆩ | ᆪ | ᆫ | ᆬ | ᆭ | ᆮ | ᆯ |

279 > * | U+11Bx | ᆰ | ᆱ | ᆲ | ᆳ | ᆴ | ᆵ | ᆶ | ᆷ | ᆸ | ᆹ | ᆺ | ᆻ | ᆼ | ᆽ | ᆾ | ᆿ |

280 > * | U+11Cx | ᇀ | ᇁ | ᇂ |

281 > */

282 > const modernFinalConsonants = new Uint16Array([

283 > AsciiCode.r, // ㄱ

284 > AsciiCode.R, // ㄲ

285 > AsciiCodeCombo.rt, // ㄳ

286 > AsciiCode.s, // ㄴ

287 > AsciiCodeCombo.sw, // ㄵ

288 > AsciiCodeCombo.sg, // ㄶ

289 > AsciiCode.e, // ㄷ

290 > AsciiCode.f, // ㄹ

291 > AsciiCodeCombo.fr, // ㄺ

292 > AsciiCodeCombo.fa, // ㄻ

293 > AsciiCodeCombo.fq, // ㄼ

294 > AsciiCodeCombo.ft, // ㄽ

295 > AsciiCodeCombo.fx, // ㄾ

296 > AsciiCodeCombo.fv, // ㄿ

297 > AsciiCodeCombo.fg, // ㅀ

298 > AsciiCode.a, // ㅁ

299 > AsciiCode.q, // ㅂ

300 > AsciiCodeCombo.qt, // ㅄ

301 > AsciiCode.t, // ㅅ

302 > AsciiCode.T, // ㅆ

303 > AsciiCode.d, // ㅇ

304 > AsciiCode.w, // ㅈ

305 > AsciiCode.c, // ㅊ

306 > AsciiCode.z, // ㅋ

307 > AsciiCode.x, // ㅌ

308 > AsciiCode.v, // ㅍ

309 > AsciiCode.g, // ㅎ

310 > ]);

311 >

312 > /**

313 > * Hangul Compatibility Jamo

314 > *

315 > * Range U+3131..U+318F

316 > *

317 > * This includes range includes archaic jamo which we don't consider, these are

318 > * given the NUL character code in order to be ignored.

319 > *

320 > * | | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |

321 > * |--------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|

322 > * | U+313x | | ㄱ | ㄲ | ㄳ | ㄴ | ㄵ | ㄶ | ㄷ | ㄸ | ㄹ | ㄺ | ㄻ | ㄼ | ㄽ | ㄾ | ㄿ |

323 > * | U+314x | ㅀ | ㅁ | ㅂ | ㅃ | ㅄ | ㅅ | ㅆ | ㅇ | ㅈ | ㅉ | ㅊ | ㅋ | ㅌ | ㅍ | ㅎ | ㅏ |

324 > * | U+315x | ㅐ | ㅑ | ㅒ | ㅓ | ㅔ | ㅕ | ㅖ | ㅗ | ㅘ | ㅙ | ㅚ | ㅛ | ㅜ | ㅝ | ㅞ | ㅟ |

325 > * | U+316x | ㅠ | ㅡ | ㅢ | ㅣ | HF | ㅥ | ㅦ | ㅧ | ㅨ | ㅩ | ㅪ | ㅫ | ㅬ | ㅭ | ㅮ | ㅯ |

326 > * | U+317x | ㅰ | ㅱ | ㅲ | ㅳ | ㅴ | ㅵ | ㅶ | ㅷ | ㅸ | ㅹ | ㅺ | ㅻ | ㅼ | ㅽ | ㅾ | ㅿ |

327 > * | U+318x | ㆀ | ㆁ | ㆂ | ㆃ | ㆄ | ㆅ | ㆆ | ㆇ | ㆈ | ㆉ | ㆊ | ㆋ | ㆌ | ㆍ | ㆎ |

328 > */

329 > const compatibilityJamo = new Uint16Array([

330 > AsciiCode.r, // ㄱ

331 > AsciiCode.R, // ㄲ

332 > AsciiCodeCombo.rt, // ㄳ

333 > AsciiCode.s, // ㄴ

334 > AsciiCodeCombo.sw, // ㄵ

335 > AsciiCodeCombo.sg, // ㄶ

336 > AsciiCode.e, // ㄷ

337 > AsciiCode.E, // ㄸ

338 > AsciiCode.f, // ㄹ

339 > AsciiCodeCombo.fr, // ㄺ

340 > AsciiCodeCombo.fa, // ㄻ

341 > AsciiCodeCombo.fq, // ㄼ

342 > AsciiCodeCombo.ft, // ㄽ

343 > AsciiCodeCombo.fx, // ㄾ

344 > AsciiCodeCombo.fv, // ㄿ

345 > AsciiCodeCombo.fg, // ㅀ

346 > AsciiCode.a, // ㅁ

347 > AsciiCode.q, // ㅂ

348 > AsciiCode.Q, // ㅃ

349 > AsciiCodeCombo.qt, // ㅄ

350 > AsciiCode.t, // ㅅ

351 > AsciiCode.T, // ㅆ

352 > AsciiCode.d, // ㅇ

353 > AsciiCode.w, // ㅈ

354 > AsciiCode.W, // ㅉ

355 > AsciiCode.c, // ㅊ

356 > AsciiCode.z, // ㅋ

357 > AsciiCode.x, // ㅌ

358 > AsciiCode.v, // ㅍ

359 > AsciiCode.g, // ㅎ

360 > AsciiCode.k, // ㅏ

361 > AsciiCode.o, // ㅐ

362 > AsciiCode.i, // ㅑ

363 > AsciiCode.O, // ㅒ

364 > AsciiCode.j, // ㅓ

365 > AsciiCode.p, // ㅔ

366 > AsciiCode.u, // ㅕ

367 > AsciiCode.P, // ㅖ

368 > AsciiCode.h, // ㅗ

369 > AsciiCodeCombo.hk, // ㅘ

370 > AsciiCodeCombo.ho, // ㅙ

371 > AsciiCodeCombo.hl, // ㅚ

372 > AsciiCode.y, // ㅛ

373 > AsciiCode.n, // ㅜ

374 > AsciiCodeCombo.nj, // ㅝ

375 > AsciiCodeCombo.np, // ㅞ

376 > AsciiCodeCombo.nl, // ㅟ

377 > AsciiCode.b, // ㅠ

378 > AsciiCode.m, // ㅡ

379 > AsciiCodeCombo.ml, // ㅢ

380 > AsciiCode.l, // ㅣ

381 > // HF: Hangul Filler (everything after this is archaic)

382 > // ㅥ

383 > // ㅦ

384 > // ㅧ

385 > // ㅨ

386 > // ㅩ

387 > // ㅪ

388 > // ㅫ

389 > // ㅬ

390 > // ㅮ

391 > // ㅯ

392 > // ㅰ

393 > // ㅱ

394 > // ㅲ

395 > // ㅳ

396 > // ㅴ

397 > // ㅵ

398 > // ㅶ

399 > // ㅷ

400 > // ㅸ

401 > // ㅹ

402 > // ㅺ

403 > // ㅻ

404 > // ㅼ

405 > // ㅽ

406 > // ㅾ

407 > // ㅿ

408 > // ㆀ

409 > // ㆁ

410 > // ㆂ

411 > // ㆃ

412 > // ㆄ

413 > // ㆅ

414 > // ㆆ

415 > // ㆇ

416 > // ㆈ

417 > // ㆉ

418 > // ㆊ

419 > // ㆋ

420 > // ㆌ

421 > // ㆍ

422 > // ㆎ

423 > ]);

src/vs/base/common/map.ts 325 covered LOC · 100 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- map.ts

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 { URI } from './uri.js';

7 >

8 > export function getOrSet<K, V>(map: Map<K, V>, key: K, value: V): V {

9 let result = map.get(key);

10 if (result === undefined) {

15 return result;

16 }

17 > map.ts

18 > export function mapToString<K, V>(map: Map<K, V>): string {

19 const entries: string[] = [];

20 map.forEach((value, key) => {

24 return `Map(${map.size}) {${entries.join(', ')}}`;

25 }

26 > map.ts

27 > export function setToString<K>(set: Set<K>): string {

28 const entries: K[] = [];

29 set.forEach(value => {

33 return `Set(${set.size}) {${entries.join(', ')}}`;

34 }

35 > map.ts

36 > interface ResourceMapKeyFn {

37 > (resource: URI): string;

38 > }

39 >

40 > class ResourceMapEntry<T> {

41 > constructor(readonly uri: URI, readonly value: T) { }

42 > }

43 >

44 function isEntries<T>(arg: ResourceMap<T> | ResourceMapKeyFn | readonly (readonly [URI, T])[] | undefined): arg is readonly (readonly [URI, T])[] {

45 return Array.isArray(arg);

46 }

47 > map.ts

48 > export class ResourceMap<T> implements Map<URI, T> {

49 >

50 > private static readonly defaultToKey = (resource: URI) => resource.toString();

51 >

52 > readonly [Symbol.toStringTag] = 'ResourceMap';

53 >

54 > private readonly map: Map<string, ResourceMapEntry<T>>;

55 > private readonly toKey: ResourceMapKeyFn;

56 >

57 > /**

58 > *

59 > * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util

60 > */

61 > constructor(toKey?: ResourceMapKeyFn);

62 >

63 > /**

64 > *

65 > * @param other Another resource which this maps is created from

66 > * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util

67 > */

68 > constructor(other?: ResourceMap<T>, toKey?: ResourceMapKeyFn);

69 >

70 > /**

71 > *

72 > * @param other Another resource which this maps is created from

73 > * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util

74 > */

75 > constructor(entries?: readonly (readonly [URI, T])[], toKey?: ResourceMapKeyFn);

76 >

77 > constructor(arg?: ResourceMap<T> | ResourceMapKeyFn | readonly (readonly [URI, T])[], toKey?: ResourceMapKeyFn) {

78 if (arg instanceof ResourceMap) {

79 this.map = new Map(arg.map);

91 }

92 }

93 > map.ts

94 > set(resource: URI, value: T): this {

95 this.map.set(this.toKey(resource), new ResourceMapEntry(resource, value));

96 return this;

97 }

98 > map.ts

99 > get(resource: URI): T | undefined {

100 return this.map.get(this.toKey(resource))?.value;

101 }

102 > map.ts

103 > has(resource: URI): boolean {

104 return this.map.has(this.toKey(resource));

105 }

106 > map.ts

107 > get size(): number {

108 return this.map.size;

109 }

110 > map.ts

111 > clear(): void {

112 this.map.clear();

113 }

114 > map.ts

115 > delete(resource: URI): boolean {

116 return this.map.delete(this.toKey(resource));

117 }

118 > map.ts

119 > forEach(clb: (value: T, key: URI, map: Map<URI, T>) => void, thisArg?: object): void {

120 if (typeof thisArg !== 'undefined') {

121 clb = clb.bind(thisArg);

125 }

126 }

127 > map.ts

128 > *values(): MapIterator<T> {

129 for (const entry of this.map.values()) {

130 yield entry.value;

131 }

132 }

133 > map.ts

134 > *keys(): MapIterator<URI> {

135 for (const entry of this.map.values()) {

136 yield entry.uri;

137 }

138 }

139 > map.ts

140 > *entries(): MapIterator<[URI, T]> {

141 for (const entry of this.map.values()) {

142 yield [entry.uri, entry.value];

143 }

144 }

145 > map.ts

146 > *[Symbol.iterator](): MapIterator<[URI, T]> {

147 for (const [, entry] of this.map) {

148 yield [entry.uri, entry.value];

149 }

150 }

151 > } map.ts

152 >

153 > export class ResourceSet implements Set<URI> {

154 >

155 > readonly [Symbol.toStringTag]: string = 'ResourceSet';

156 >

157 > private readonly _map: ResourceMap<URI>;

158 >

159 > constructor(toKey?: ResourceMapKeyFn);

160 > constructor(entries: readonly URI[], toKey?: ResourceMapKeyFn);

161 > constructor(entriesOrKey?: readonly URI[] | ResourceMapKeyFn, toKey?: ResourceMapKeyFn) {

162 if (!entriesOrKey || typeof entriesOrKey === 'function') {

163 this._map = new ResourceMap(entriesOrKey);

167 }

168 }

169 > map.ts

170 >

171 > get size(): number {

172 return this._map.size;

173 }

174 > map.ts

175 > add(value: URI): this {

176 this._map.set(value, value);

177 return this;

178 }

179 > map.ts

180 > clear(): void {

181 this._map.clear();

182 }

183 > map.ts

184 > delete(value: URI): boolean {

185 return this._map.delete(value);

186 }

187 > map.ts

188 > forEach(callbackfn: (value: URI, value2: URI, set: Set<URI>) => void, thisArg?: unknown): void {

189 this._map.forEach((_value, key) => callbackfn.call(thisArg, key, key, this));

190 }

191 > map.ts

192 > has(value: URI): boolean {

193 return this._map.has(value);

194 }

195 > map.ts

196 > entries(): SetIterator<[URI, URI]> {

197 return this._map.entries() as unknown as SetIterator<[URI, URI]>;

198 }

199 > map.ts

200 > keys(): SetIterator<URI> {

201 return this._map.keys() as unknown as SetIterator<URI>;

202 }

203 > map.ts

204 > values(): SetIterator<URI> {

205 return this._map.keys() as unknown as SetIterator<URI>;

206 }

207 > map.ts

208 > [Symbol.iterator](): SetIterator<URI> {

209 return this.keys();

210 }

211 > } map.ts

212 >

213 >

214 > interface Item<K, V> {

215 > previous: Item<K, V> | undefined;

216 > next: Item<K, V> | undefined;

217 > key: K;

218 > value: V;

219 > }

220 >

221 > export const enum Touch {

222 > None = 0,

223 > AsOld = 1,

224 > AsNew = 2

225 > }

226 >

227 > export class LinkedMap<K, V> implements Map<K, V> {

228 >

229 > readonly [Symbol.toStringTag] = 'LinkedMap';

230 >

231 > private _map: Map<K, Item<K, V>>;

232 > private _head: Item<K, V> | undefined;

233 > private _tail: Item<K, V> | undefined;

234 > private _size: number;

235 >

236 > private _state: number;

237 >

238 > constructor() {

239 > this._map = new Map<K, Item<K, V>>(); map.ts

240 > this._head = undefined;

241 > this._tail = undefined;

242 > this._size = 0;

243 > this._state = 0;

244 > }

245 > map.ts

246 > clear(): void {

247 this._map.clear();

248 this._head = undefined;

251 this._state++;

252 }

253 > map.ts

254 > isEmpty(): boolean {

255 return !this._head && !this._tail;

256 }

257 > map.ts

258 > get size(): number {

259 return this._size;

260 }

261 > map.ts

262 > get first(): V | undefined {

263 return this._head?.value;

264 }

265 > map.ts

266 > get last(): V | undefined {

267 return this._tail?.value;

268 }

269 > map.ts

270 > has(key: K): boolean {

271 return this._map.has(key);

272 }

273 > map.ts

274 > get(key: K, touch: Touch = Touch.None): V | undefined {

275 const item = this._map.get(key);

276 if (!item) {

282 return item.value;

283 }

284 > map.ts

285 > set(key: K, value: V, touch: Touch = Touch.None): this {

286 let item = this._map.get(key);

287 if (item) {

311 return this;

312 }

313 > map.ts

314 > delete(key: K): boolean {

315 return !!this.remove(key);

316 }

317 > map.ts

318 > remove(key: K): V | undefined {

319 const item = this._map.get(key);

320 if (!item) {

326 return item.value;

327 }

328 > map.ts

329 > shift(): V | undefined {

330 if (!this._head && !this._tail) {

331 return undefined;

340 return item.value;

341 }

342 > map.ts

343 > forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: unknown): void {

344 const state = this._state;

345 let current = this._head;

356 }

357 }

358 > map.ts

359 > keys(): MapIterator<K> {

360 const map = this;

361 const state = this._state;

381 return iterator;

382 }

383 > map.ts

384 > values(): MapIterator<V> {

385 const map = this;

386 const state = this._state;

406 return iterator;

407 }

408 > map.ts

409 > entries(): MapIterator<[K, V]> {

410 const map = this;

411 const state = this._state;

431 return iterator;

432 }

433 > map.ts

434 > [Symbol.iterator](): MapIterator<[K, V]> {

435 return this.entries();

436 }

437 > map.ts

438 > protected trimOld(newSize: number) {

439 if (newSize >= this.size) {

440 return;

458 this._state++;

459 }

460 > map.ts

461 > protected trimNew(newSize: number) {

462 if (newSize >= this.size) {

463 return;

481 this._state++;

482 }

483 > map.ts

484 > private addItemFirst(item: Item<K, V>): void {

485 // First time Insert

486 if (!this._head && !this._tail) {

495 this._state++;

496 }

497 > map.ts

498 > private addItemLast(item: Item<K, V>): void {

499 // First time Insert

500 if (!this._head && !this._tail) {

509 this._state++;

510 }

511 > map.ts

512 > private removeItem(item: Item<K, V>): void {

513 if (item === this._head && item === this._tail) {

514 this._head = undefined;

546 this._state++;

547 }

548 > map.ts

549 > private touch(item: Item<K, V>, touch: Touch): void {

550 if (!this._head || !this._tail) {

551 throw new Error('Invalid list');

608 }

609 }

610 > map.ts

611 > toJSON(): [K, V][] {

612 const data: [K, V][] = [];

613

618 return data;

619 }

620 > map.ts

621 > fromJSON(data: [K, V][]): void {

622 this.clear();

623

626 }

627 }

628 > } map.ts

629 >

630 > abstract class Cache<K, V> extends LinkedMap<K, V> {

631 >

632 > protected _limit: number;

633 > protected _ratio: number;

634 >

635 > constructor(limit: number, ratio: number = 1) {

636 > super(); map.ts

637 > this._limit = limit;

638 > this._ratio = Math.min(Math.max(0, ratio), 1);

639 > }

640 > map.ts

641 > get limit(): number {

642 return this._limit;

643 }

644 > map.ts

645 > set limit(limit: number) {

646 this._limit = limit;

647 this.checkTrim();

648 }

649 > map.ts

650 > get ratio(): number {

651 return this._ratio;

652 }

653 > map.ts

654 > set ratio(ratio: number) {

655 this._ratio = Math.min(Math.max(0, ratio), 1);

656 this.checkTrim();

657 }

658 > map.ts

659 > override get(key: K, touch: Touch = Touch.AsNew): V | undefined {

660 return super.get(key, touch);

661 }

662 > map.ts

663 > peek(key: K): V | undefined {

664 return super.get(key, Touch.None);

665 }

666 > map.ts

667 > override set(key: K, value: V): this {

668 super.set(key, value, Touch.AsNew);

669 return this;

670 }

671 > map.ts

672 > protected checkTrim() {

673 if (this.size > this._limit) {

674 this.trim(Math.round(this._limit * this._ratio));

675 }

676 }

677 > map.ts

678 > protected abstract trim(newSize: number): void;

679 > }

680 >

681 > export class LRUCache<K, V> extends Cache<K, V> {

682 >

683 > constructor(limit: number, ratio: number = 1) {

684 > super(limit, ratio); map.ts

685 > }

686 > map.ts

687 > protected override trim(newSize: number) {

688 this.trimOld(newSize);

689 }

690 > map.ts

691 > override set(key: K, value: V): this {

692 super.set(key, value);

693 this.checkTrim();

694 return this;

695 }

696 > } map.ts

697 >

698 > export class MRUCache<K, V> extends Cache<K, V> {

699 >

700 > constructor(limit: number, ratio: number = 1) {

701 super(limit, ratio);

702 }

703 > map.ts

704 > protected override trim(newSize: number) {

705 this.trimNew(newSize);

706 }

707 > map.ts

708 > override set(key: K, value: V): this {

709 if (this._limit <= this.size && !this.has(key)) {

710 this.trim(Math.round(this._limit * this._ratio) - 1);

714 return this;

715 }

716 > } map.ts

717 >

718 > export class CounterSet<T> {

719

720 private map = new Map<T, number>();

721 > map.ts

722 > add(value: T): CounterSet<T> {

723 this.map.set(value, (this.map.get(value) || 0) + 1);

724 return this;

725 }

726 > map.ts

727 > delete(value: T): boolean {

728 let counter = this.map.get(value) || 0;

729

742 return true;

743 }

744 > map.ts

745 > has(value: T): boolean {

746 return this.map.has(value);

747 }

748 > } map.ts

749 >

750 > /**

751 > * A map that allows access both by keys and values.

752 > * **NOTE**: values need to be unique.

753 > */

754 > export class BidirectionalMap<K, V> {

755 >

756 > private readonly _m1 = new Map<K, V>();

757 > private readonly _m2 = new Map<V, K>();

758 >

759 > constructor(entries?: readonly (readonly [K, V])[]) {

760 if (entries) {

761 for (const [key, value] of entries) {

764 }

765 }

766 > map.ts

767 > clear(): void {

768 this._m1.clear();

769 this._m2.clear();

770 }

771 > map.ts

772 > set(key: K, value: V): void {

773 this._m1.set(key, value);

774 this._m2.set(value, key);

775 }

776 > map.ts

777 > get(key: K): V | undefined {

778 return this._m1.get(key);

779 }

780 > map.ts

781 > getKey(value: V): K | undefined {

782 return this._m2.get(value);

783 }

784 > map.ts

785 > delete(key: K): boolean {

786 const value = this._m1.get(key);

787 if (value === undefined) {

792 return true;

793 }

794 > map.ts

795 > forEach(callbackfn: (value: V, key: K, map: BidirectionalMap<K, V>) => void, thisArg?: unknown): void {

796 this._m1.forEach((value, key) => {

797 callbackfn.call(thisArg, value, key, this);

798 });

799 }

800 > map.ts

801 > keys(): IterableIterator<K> {

802 return this._m1.keys();

803 }

804 > map.ts

805 > values(): IterableIterator<V> {

806 return this._m1.values();

807 }

808 > } map.ts

809 >

810 > export class SetMap<K, V> {

811

812 private map = new Map<K, Set<V>>();

813 > map.ts

814 > add(key: K, value: V): void {

815 let values = this.map.get(key);

816

822 values.add(value);

823 }

824 > map.ts

825 > delete(key: K, value: V): void {

826 const values = this.map.get(key);

827

836 }

837 }

838 > map.ts

839 > forEach(key: K, fn: (value: V) => void): void {

840 const values = this.map.get(key);

841

846 values.forEach(fn);

847 }

848 > map.ts

849 > get(key: K): ReadonlySet<V> {

850 const values = this.map.get(key);

851 if (!values) {

854 return values;

855 }

856 > } map.ts

857 >

858 > export function mapsStrictEqualIgnoreOrder(a: Map<unknown, unknown>, b: Map<unknown, unknown>): boolean {

859 if (a === b) {

860 return true;

879 return true;

880 }

881 > map.ts

882 > /**

883 > * A map that is addressable with an arbitrary number of keys. This is useful in high performance

884 > * scenarios where creating a composite key whenever the data is accessed is too expensive. For

885 > * example for a very hot function, constructing a string like `first-second-third` for every call

886 > * will cause a significant hit to performance.

887 > */

888 > export class NKeyMap<TValue, TKeys extends (string | boolean | number)[]> {

889 private _data: Map<any, any> = new Map();

890 > map.ts

891 > /**

892 > * Sets a value on the map. Note that unlike a standard `Map`, the first argument is the value.

893 > * This is because the spread operator is used for the keys and must be last..

894 > * @param value The value to set.

895 > * @param keys The keys for the value.

896 > */

897 > public set(value: TValue, ...keys: [...TKeys]): void {

898 let currentMap = this._data;

899 for (let i = 0; i < keys.length - 1; i++) {

907 currentMap.set(keys[keys.length - 1], value);

908 }

909 > map.ts

910 > public get(...keys: [...TKeys]): TValue | undefined {

911 let currentMap = this._data;

912 for (let i = 0; i < keys.length - 1; i++) {

919 return currentMap.get(keys[keys.length - 1]);

920 }

921 > map.ts

922 > public delete(...keys: [...TKeys]): boolean {

923 const maps: Map<any, any>[] = [this._data];

924 let currentMap = this._data;

939 return deleted;

940 }

941 > map.ts

942 > public deleteAll(...keys: Partial<TKeys>): boolean {

943 if (keys.length === 0) {

944 const hadData = this._data.size > 0;

964 return deleted;

965 }

966 > map.ts

967 > public clear(): void {

968 this._data.clear();

969 }

970 > map.ts

971 > public *getAll(...keys: Partial<TKeys>): IterableIterator<TValue> {

972 let currentMap = this._data;

973 for (const key of keys) {

980 yield* this._values(currentMap);

981 }

982 > map.ts

983 > public *values(): IterableIterator<TValue> {

984 yield* this._values(this._data);

985 }

986 > map.ts

987 > private *_values(map: Map<any, any>): IterableIterator<TValue> {

988 for (const value of map.values()) {

989 if (value instanceof Map) {

994 }

995 }

996 > map.ts

997 > /**

998 > * Get a textual representation of the map for debugging purposes.

999 > */

1000 > public toString(): string {

1001 const printMap = (map: Map<any, any>, depth: number): string => {

1002 let result = '';

1014 return printMap(this._data, 0);

1015 }

1016 > } map.ts

src/vs/base/common/stream.ts 325 covered LOC · 29 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- stream.ts

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 { CancellationToken } from './cancellation.js';

7 > import { onUnexpectedError } from './errors.js';

8 > import { DisposableStore, toDisposable } from './lifecycle.js';

9 >

10 > /**

11 > * The payload that flows in readable stream events.

12 > */

13 > export type ReadableStreamEventPayload<T> = T | Error | 'end';

14 >

15 > export interface ReadableStreamEvents<T> {

16 >

17 > /**

18 > * The 'data' event is emitted whenever the stream is

19 > * relinquishing ownership of a chunk of data to a consumer.

20 > *

21 > * NOTE: PLEASE UNDERSTAND THAT ADDING A DATA LISTENER CAN

22 > * TURN THE STREAM INTO FLOWING MODE. IT IS THEREFOR THE

23 > * LAST LISTENER THAT SHOULD BE ADDED AND NOT THE FIRST

24 > *

25 > * Use `listenStream` as a helper method to listen to

26 > * stream events in the right order.

27 > */

28 > on(event: 'data', callback: (data: T) => void): void;

29 >

30 > /**

31 > * Emitted when any error occurs.

32 > */

33 > on(event: 'error', callback: (err: Error) => void): void;

34 >

35 > /**

36 > * The 'end' event is emitted when there is no more data

37 > * to be consumed from the stream. The 'end' event will

38 > * not be emitted unless the data is completely consumed.

39 > */

40 > on(event: 'end', callback: () => void): void;

41 > }

42 >

43 > /**

44 > * A interface that emulates the API shape of a node.js readable

45 > * stream for use in native and web environments.

46 > */

47 > export interface ReadableStream<T> extends ReadableStreamEvents<T> {

48 >

49 > /**

50 > * Stops emitting any events until resume() is called.

51 > */

52 > pause(): void;

53 >

54 > /**

55 > * Starts emitting events again after pause() was called.

56 > */

57 > resume(): void;

58 >

59 > /**

60 > * Destroys the stream and stops emitting any event.

61 > */

62 > destroy(): void;

63 >

64 > /**

65 > * Allows to remove a listener that was previously added.

66 > */

67 > removeListener(event: string, callback: Function): void;

68 > }

69 >

70 > /**

71 > * A interface that emulates the API shape of a node.js readable

72 > * for use in native and web environments.

73 > */

74 > export interface Readable<T> {

75 >

76 > /**

77 > * Read data from the underlying source. Will return

78 > * null to indicate that no more data can be read.

79 > */

80 > read(): T | null;

81 > }

82 >

83 > export function isReadable<T>(obj: unknown): obj is Readable<T> {

84 const candidate = obj as Readable<T> | undefined;

85 if (!candidate) {

89 return typeof candidate.read === 'function';

90 }

91 > stream.ts

92 > /**

93 > * A interface that emulates the API shape of a node.js writeable

94 > * stream for use in native and web environments.

95 > */

96 > export interface WriteableStream<T> extends ReadableStream<T> {

97 >

98 > /**

99 > * Writing data to the stream will trigger the on('data')

100 > * event listener if the stream is flowing and buffer the

101 > * data otherwise until the stream is flowing.

102 > *

103 > * If a `highWaterMark` is configured and writing to the

104 > * stream reaches this mark, a promise will be returned

105 > * that should be awaited on before writing more data.

106 > * Otherwise there is a risk of buffering a large number

107 > * of data chunks without consumer.

108 > */

109 > write(data: T): void | Promise<void>;

110 >

111 > /**

112 > * Signals an error to the consumer of the stream via the

113 > * on('error') handler if the stream is flowing.

114 > *

115 > * NOTE: call `end` to signal that the stream has ended,

116 > * this DOES NOT happen automatically from `error`.

117 > */

118 > error(error: Error): void;

119 >

120 > /**

121 > * Signals the end of the stream to the consumer. If the

122 > * result is provided, will trigger the on('data') event

123 > * listener if the stream is flowing and buffer the data

124 > * otherwise until the stream is flowing.

125 > */

126 > end(result?: T): void;

127 > }

128 >

129 > /**

130 > * A stream that has a buffer already read. Returns the original stream

131 > * that was read as well as the chunks that got read.

132 > *

133 > * The `ended` flag indicates if the stream has been fully consumed.

134 > */

135 > export interface ReadableBufferedStream<T> {

136 >

137 > /**

138 > * The original stream that is being read.

139 > */

140 > stream: ReadableStream<T>;

141 >

142 > /**

143 > * An array of chunks already read from this stream.

144 > */

145 > buffer: T[];

146 >

147 > /**

148 > * Signals if the stream has ended or not. If not, consumers

149 > * should continue to read from the stream until consumed.

150 > */

151 > ended: boolean;

152 > }

153 >

154 > export function isReadableStream<T>(obj: unknown): obj is ReadableStream<T> {

155 const candidate = obj as ReadableStream<T> | undefined;

156 if (!candidate) {

160 return [candidate.on, candidate.pause, candidate.resume, candidate.destroy].every(fn => typeof fn === 'function');

161 }

162 > stream.ts

163 > export function isReadableBufferedStream<T>(obj: unknown): obj is ReadableBufferedStream<T> {

164 const candidate = obj as ReadableBufferedStream<T> | undefined;

165 if (!candidate) {

169 return isReadableStream(candidate.stream) && Array.isArray(candidate.buffer) && typeof candidate.ended === 'boolean';

170 }

171 > stream.ts

172 > export interface IReducer<T, R = T> {

173 > (data: T[]): R;

174 > }

175 >

176 > export interface IDataTransformer<Original, Transformed> {

177 > (data: Original): Transformed;

178 > }

179 >

180 > export interface IErrorTransformer {

181 > (error: Error): Error;

182 > }

183 >

184 > export interface ITransformer<Original, Transformed> {

185 > data: IDataTransformer<Original, Transformed>;

186 > error?: IErrorTransformer;

187 > }

188 >

189 > export function newWriteableStream<T>(reducer: IReducer<T> | null, options?: WriteableStreamOptions): WriteableStream<T> {

190 return new WriteableStreamImpl<T>(reducer, options);

191 }

192 > stream.ts

193 > export interface WriteableStreamOptions {

194 >

195 > /**

196 > * The number of objects to buffer before WriteableStream#write()

197 > * signals back that the buffer is full. Can be used to reduce

198 > * the memory pressure when the stream is not flowing.

199 > */

200 > highWaterMark?: number;

201 > }

202 >

203 > class WriteableStreamImpl<T> implements WriteableStream<T> {

204 >

205 > private readonly state = {

206 > flowing: false,

207 > ended: false,

208 > destroyed: false

209 > };

210 >

211 > private readonly buffer = {

212 > data: [] as T[],

213 > error: [] as Error[]

214 > };

215 >

216 > private readonly listeners = {

217 > data: [] as { (data: T): void }[],

218 > error: [] as { (error: Error): void }[],

219 > end: [] as { (): void }[]

220 > };

221 >

222 > private readonly pendingWritePromises: Function[] = [];

223 >

224 > /**

225 > * @param reducer a function that reduces the buffered data into a single object;

226 > * because some objects can be complex and non-reducible, we also

227 > * allow passing the explicit `null` value to skip the reduce step

228 > * @param options stream options

229 > */

230 > constructor(private reducer: IReducer<T> | null, private options?: WriteableStreamOptions) { }

231 >

232 > pause(): void {

233 if (this.state.destroyed) {

234 return;

237 this.state.flowing = false;

238 }

239 > stream.ts

240 > resume(): void {

241 if (this.state.destroyed) {

242 return;

252 }

253 }

254 > stream.ts

255 > write(data: T): void | Promise<void> {

256 if (this.state.destroyed) {

257 return;

273 }

274 }

275 > stream.ts

276 > error(error: Error): void {

277 if (this.state.destroyed) {

278 return;

289 }

290 }

291 > stream.ts

292 > end(result?: T): void {

293 if (this.state.destroyed) {

294 return;

312 }

313 }

314 > stream.ts

315 > private emitData(data: T): void {

316 this.listeners.data.slice(0).forEach(listener => listener(data)); // slice to avoid listener mutation from delivering event

317 }

318 > stream.ts

319 > private emitError(error: Error): void {

320 if (this.listeners.error.length === 0) {

321 onUnexpectedError(error); // nobody listened to this error so we log it as unexpected

324 }

325 }

326 > stream.ts

327 > private emitEnd(): void {

328 this.listeners.end.slice(0).forEach(listener => listener()); // slice to avoid listener mutation from delivering event

329 }

330 > stream.ts

331 > on(event: 'data', callback: (data: T) => void): void;

332 > on(event: 'error', callback: (err: Error) => void): void;

333 > on(event: 'end', callback: () => void): void;

334 > on(event: 'data' | 'error' | 'end', callback: ((data: T) => void) | ((err: Error) => void) | (() => void)): void {

335 if (this.state.destroyed) {

336 return;

372 }

373 }

374 > stream.ts

375 > removeListener(event: string, callback: Function): void {

376 if (this.state.destroyed) {

377 return;

401 }

402 }

403 > stream.ts

404 > private flowData(): void {

405 // if buffer is empty, nothing to do

406 if (this.buffer.data.length === 0) {

428 pendingWritePromises.forEach(pendingWritePromise => pendingWritePromise());

429 }

430 > stream.ts

431 > private flowErrors(): void {

432 if (this.listeners.error.length > 0) {

433 for (const error of this.buffer.error) {

438 }

439 }

440 > stream.ts

441 > private flowEnd(): boolean {

442 if (this.state.ended) {

443 this.emitEnd();

448 return false;

449 }

450 > stream.ts

451 > destroy(): void {

452 if (!this.state.destroyed) {

453 this.state.destroyed = true;

464 }

465 }

466 > } stream.ts

467 >

468 > /**

469 > * Helper to fully read a T readable into a T.

470 > */

471 > export function consumeReadable<T>(readable: Readable<T>, reducer: IReducer<T>): T {

472 const chunks: T[] = [];

473

479 return reducer(chunks);

480 }

481 > stream.ts

482 > /**

483 > * Helper to read a T readable up to a maximum of chunks. If the limit is

484 > * reached, will return a readable instead to ensure all data can still

485 > * be read.

486 > */

487 > export function peekReadable<T>(readable: Readable<T>, reducer: IReducer<T>, maxChunks: number): T | Readable<T> {

488 const chunks: T[] = [];

489

527 };

528 }

529 > stream.ts

530 > /**

531 > * Helper to fully read a T stream into a T or consuming

532 > * a stream fully, awaiting all the events without caring

533 > * about the data.

534 > */

535 > export function consumeStream<T, R = T>(stream: ReadableStreamEvents<T>, reducer: IReducer<T, R>): Promise<R>;

536 > export function consumeStream(stream: ReadableStreamEvents<unknown>): Promise<undefined>;

537 > export function consumeStream<T, R = T>(stream: ReadableStreamEvents<T>, reducer?: IReducer<T, R>): Promise<R | undefined> {

538 return new Promise((resolve, reject) => {

539 const chunks: T[] = [];

562 });

563 }

564 > stream.ts

565 > export interface IStreamListener<T> {

566 >

567 > /**

568 > * The 'data' event is emitted whenever the stream is

569 > * relinquishing ownership of a chunk of data to a consumer.

570 > */

571 > onData(data: T): void;

572 >

573 > /**

574 > * Emitted when any error occurs.

575 > */

576 > onError(err: Error): void;

577 >

578 > /**

579 > * The 'end' event is emitted when there is no more data

580 > * to be consumed from the stream. The 'end' event will

581 > * not be emitted unless the data is completely consumed.

582 > */

583 > onEnd(): void;

584 > }

585 >

586 > /**

587 > * Helper to listen to all events of a T stream in proper order.

588 > */

589 > export function listenStream<T>(stream: ReadableStreamEvents<T>, listener: IStreamListener<T>, token?: CancellationToken): void {

590

591 stream.on('error', error => {

610 });

611 }

612 > stream.ts

613 > /**

614 > * Helper to peek up to `maxChunks` into a stream. The return type signals if

615 > * the stream has ended or not. If not, caller needs to add a `data` listener

616 > * to continue reading.

617 > */

618 > export function peekStream<T>(stream: ReadableStream<T>, maxChunks: number): Promise<ReadableBufferedStream<T>> {

619 return new Promise((resolve, reject) => {

620 const streamListeners = new DisposableStore();

666 });

667 }

668 > stream.ts

669 > /**

670 > * Helper to create a readable stream from an existing T.

671 > */

672 > export function toStream<T>(t: T, reducer: IReducer<T>): ReadableStream<T> {

673 const stream = newWriteableStream<T>(reducer);

674

677 return stream;

678 }

679 > stream.ts

680 > /**

681 > * Helper to create an empty stream

682 > */

683 > export function emptyStream(): ReadableStream<never> {

684 const stream = newWriteableStream<never>(() => { throw new Error('not supported'); });

685 stream.end();

687 return stream;

688 }

689 > stream.ts

690 > /**

691 > * Helper to convert a T into a Readable<T>.

692 > */

693 > export function toReadable<T>(t: T): Readable<T> {

694 let consumed = false;

695

706 };

707 }

708 > stream.ts

709 > /**

710 > * Helper to transform a readable stream into another stream.

711 > */

712 > export function transform<Original, Transformed>(stream: ReadableStreamEvents<Original>, transformer: ITransformer<Original, Transformed>, reducer: IReducer<Transformed>): ReadableStream<Transformed> {

713 const target = newWriteableStream<Transformed>(reducer);

714

721 return target;

722 }

723 > stream.ts

724 > /**

725 > * Helper to take an existing readable that will

726 > * have a prefix injected to the beginning.

727 > */

728 > export function prefixedReadable<T>(prefix: T, readable: Readable<T>, reducer: IReducer<T>): Readable<T> {

729 let prefixHandled = false;

730

751 };

752 }

753 > stream.ts

754 > /**

755 > * Helper to take an existing stream that will

756 > * have a prefix injected to the beginning.

757 > */

758 > export function prefixedStream<T>(prefix: T, stream: ReadableStream<T>, reducer: IReducer<T>): ReadableStream<T> {

759 let prefixHandled = false;

760

src/vs/platform/workspace/common/workspace.ts 322 covered LOC · 27 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- workspace.ts

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 { basename, extname } from '../../../base/common/path.js';

9 > import { TernarySearchTree } from '../../../base/common/ternarySearchTree.js';

10 > import { extname as resourceExtname, basenameOrAuthority, joinPath, extUriBiasedIgnorePathCase } from '../../../base/common/resources.js';

11 > import { URI, UriComponents } from '../../../base/common/uri.js';

12 > import { createDecorator } from '../../instantiation/common/instantiation.js';

13 > import { IEnvironmentService } from '../../environment/common/environment.js';

14 > import { Schemas } from '../../../base/common/network.js';

15 >

16 > export const IWorkspaceContextService = createDecorator<IWorkspaceContextService>('contextService');

17 >

18 > export interface IWorkspaceContextService {

19 >

20 > readonly _serviceBrand: undefined;

21 >

22 > /**

23 > * An event which fires on workbench state changes.

24 > */

25 > readonly onDidChangeWorkbenchState: Event<WorkbenchState>;

26 >

27 > /**

28 > * An event which fires on workspace name changes.

29 > */

30 > readonly onDidChangeWorkspaceName: Event<void>;

31 >

32 > /**

33 > * An event which fires before workspace folders change.

34 > */

35 > readonly onWillChangeWorkspaceFolders: Event<IWorkspaceFoldersWillChangeEvent>;

36 >

37 > /**

38 > * An event which fires on workspace folders change.

39 > */

40 > readonly onDidChangeWorkspaceFolders: Event<IWorkspaceFoldersChangeEvent>;

41 >

42 > /**

43 > * Provides access to the complete workspace object.

44 > */

45 > getCompleteWorkspace(): Promise<IWorkspace>;

46 >

47 > /**

48 > * Provides access to the workspace object the window is running with.

49 > * Use `getCompleteWorkspace` to get complete workspace object.

50 > */

51 > getWorkspace(): IWorkspace;

52 >

53 > /**

54 > * Return the state of the workbench.

55 > *

56 > * WorkbenchState.EMPTY - if the workbench was opened with empty window or file

57 > * WorkbenchState.FOLDER - if the workbench was opened with a folder

58 > * WorkbenchState.WORKSPACE - if the workbench was opened with a workspace

59 > */

60 > getWorkbenchState(): WorkbenchState;

61 >

62 > /**

63 > * Returns the folder for the given resource from the workspace.

64 > * Can be null if there is no workspace or the resource is not inside the workspace.

65 > */

66 > getWorkspaceFolder(resource: URI): IWorkspaceFolder | null;

67 >

68 > /**

69 > * Return `true` if the current workspace has the given identifier or root URI otherwise `false`.

70 > */

71 > isCurrentWorkspace(workspaceIdOrFolder: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | URI): boolean;

72 >

73 > /**

74 > * Returns if the provided resource is inside the workspace or not.

75 > */

76 > isInsideWorkspace(resource: URI): boolean;

77 >

78 > /**

79 > * Return `true` if the current workspace has data (e.g. folders or a workspace configuration) that can be sent to the extension host, otherwise `false`.

80 > */

81 > hasWorkspaceData(): boolean;

82 > }

83 >

84 > export interface IResolvedWorkspace extends IWorkspaceIdentifier, IBaseWorkspace {

85 > readonly folders: IWorkspaceFolder[];

86 > }

87 >

88 > export interface IBaseWorkspace {

89 >

90 > /**

91 > * If present, marks the window that opens the workspace

92 > * as a remote window with the given authority.

93 > */

94 > readonly remoteAuthority?: string;

95 >

96 > /**

97 > * Transient workspaces are meant to go away after being used

98 > * once, e.g. a window reload of a transient workspace will

99 > * open an empty window.

100 > *

101 > * See: https://github.com/microsoft/vscode/issues/119695

102 > */

103 > readonly transient?: boolean;

104 > }

105 >

106 > export interface IBaseWorkspaceIdentifier {

107 >

108 > /**

109 > * Every workspace (multi-root, single folder or empty)

110 > * has a unique identifier. It is not possible to open

111 > * a workspace with the same `id` in multiple windows

112 > */

113 > readonly id: string;

114 > }

115 >

116 > /**

117 > * A single folder workspace identifier is a path to a folder + id.

118 > */

119 > export interface ISingleFolderWorkspaceIdentifier extends IBaseWorkspaceIdentifier {

120 >

121 > /**

122 > * Folder path as `URI`.

123 > */

124 > readonly uri: URI;

125 > }

126 >

127 > /**

128 > * A multi-root workspace identifier is a path to a workspace file + id.

129 > */

130 > export interface IWorkspaceIdentifier extends IBaseWorkspaceIdentifier {

131 >

132 > /**

133 > * Workspace config file path as `URI`.

134 > */

135 > configPath: URI;

136 > }

137 >

138 > export interface IEmptyWorkspaceIdentifier extends IBaseWorkspaceIdentifier { }

139 >

140 > export type IAnyWorkspaceIdentifier = IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | IEmptyWorkspaceIdentifier;

141 >

142 > export function isSingleFolderWorkspaceIdentifier(obj: unknown): obj is ISingleFolderWorkspaceIdentifier {

143 const singleFolderIdentifier = obj as ISingleFolderWorkspaceIdentifier | undefined;

144

145 return typeof singleFolderIdentifier?.id === 'string' && URI.isUri(singleFolderIdentifier.uri);

146 }

147 > workspace.ts

148 > export function isEmptyWorkspaceIdentifier(obj: unknown): obj is IEmptyWorkspaceIdentifier {

149 const emptyWorkspaceIdentifier = obj as IEmptyWorkspaceIdentifier | undefined;

150 return typeof emptyWorkspaceIdentifier?.id === 'string'

152 && !isWorkspaceIdentifier(obj);

153 }

154 > workspace.ts

155 > export const EXTENSION_DEVELOPMENT_EMPTY_WINDOW_WORKSPACE: IEmptyWorkspaceIdentifier = { id: 'ext-dev' };

156 > export const UNKNOWN_EMPTY_WINDOW_WORKSPACE: IEmptyWorkspaceIdentifier = { id: 'empty-window' };

157 >

158 > export function toWorkspaceIdentifier(workspace: IWorkspace): IAnyWorkspaceIdentifier;

159 > export function toWorkspaceIdentifier(backupPath: string | undefined, isExtensionDevelopment: boolean): IEmptyWorkspaceIdentifier;

160 > export function toWorkspaceIdentifier(arg0: IWorkspace | string | undefined, isExtensionDevelopment?: boolean): IAnyWorkspaceIdentifier {

161

162 // Empty workspace

202 };

203 }

204 > workspace.ts

205 > export function isWorkspaceIdentifier(obj: unknown): obj is IWorkspaceIdentifier {

206 const workspaceIdentifier = obj as IWorkspaceIdentifier | undefined;

207

208 return typeof workspaceIdentifier?.id === 'string' && URI.isUri(workspaceIdentifier.configPath);

209 }

210 > workspace.ts

211 > export interface ISerializedSingleFolderWorkspaceIdentifier extends IBaseWorkspaceIdentifier {

212 > readonly uri: UriComponents;

213 > }

214 >

215 > export interface ISerializedWorkspaceIdentifier extends IBaseWorkspaceIdentifier {

216 > readonly configPath: UriComponents;

217 > }

218 >

219 > export function reviveIdentifier(identifier: undefined): undefined;

220 > export function reviveIdentifier(identifier: ISerializedWorkspaceIdentifier): IWorkspaceIdentifier;

221 > export function reviveIdentifier(identifier: ISerializedSingleFolderWorkspaceIdentifier): ISingleFolderWorkspaceIdentifier;

222 > export function reviveIdentifier(identifier: IEmptyWorkspaceIdentifier): IEmptyWorkspaceIdentifier;

223 > export function reviveIdentifier(identifier: ISerializedWorkspaceIdentifier | ISerializedSingleFolderWorkspaceIdentifier | IEmptyWorkspaceIdentifier | undefined): IAnyWorkspaceIdentifier | undefined;

224 > export function reviveIdentifier(identifier: ISerializedWorkspaceIdentifier | ISerializedSingleFolderWorkspaceIdentifier | IEmptyWorkspaceIdentifier | undefined): IAnyWorkspaceIdentifier | undefined {

225

226 // Single Folder

243 return undefined;

244 }

245 > workspace.ts

246 > export const enum WorkbenchState {

247 > EMPTY = 1,

248 > FOLDER,

249 > WORKSPACE

250 > }

251 >

252 > export interface IWorkspaceFoldersWillChangeEvent {

253 >

254 > readonly changes: IWorkspaceFoldersChangeEvent;

255 > readonly fromCache: boolean;

256 >

257 > join(promise: Promise<void>): void;

258 > }

259 >

260 > export interface IWorkspaceFoldersChangeEvent {

261 > added: IWorkspaceFolder[];

262 > removed: IWorkspaceFolder[];

263 > changed: IWorkspaceFolder[];

264 > }

265 >

266 > export interface IWorkspace {

267 >

268 > /**

269 > * the unique identifier of the workspace.

270 > */

271 > readonly id: string;

272 >

273 > /**

274 > * Folders in the workspace.

275 > */

276 > readonly folders: IWorkspaceFolder[];

277 >

278 > /**

279 > * Transient workspaces are meant to go away after being used

280 > * once, e.g. a window reload of a transient workspace will

281 > * open an empty window.

282 > */

283 > readonly transient?: boolean;

284 >

285 > /**

286 > * the location of the workspace configuration

287 > */

288 > readonly configuration?: URI | null;

289 >

290 > /**

291 > * Optional display name for the workspace.

292 > */

293 > readonly name?: string;

294 >

295 > }

296 >

297 > export function isWorkspace(thing: unknown): thing is IWorkspace {

298 const candidate = thing as IWorkspace | undefined;

299

302 && Array.isArray(candidate.folders));

303 }

304 > workspace.ts

305 > export interface IWorkspaceFolderData {

306 >

307 > /**

308 > * The associated URI for this workspace folder.

309 > */

310 > readonly uri: URI;

311 >

312 > /**

313 > * The name of this workspace folder. Defaults to

314 > * the basename of its [uri-path](#Uri.path)

315 > */

316 > readonly name: string;

317 >

318 > /**

319 > * The ordinal number of this workspace folder.

320 > */

321 > readonly index: number;

322 > }

323 >

324 > export interface IWorkspaceFolder extends IWorkspaceFolderData {

325 >

326 > /**

327 > * Given workspace folder relative path, returns the resource with the absolute path.

328 > */

329 > toResource: (relativePath: string) => URI;

330 > }

331 >

332 > export function isWorkspaceFolder(thing: unknown): thing is IWorkspaceFolder {

333 const candidate = thing as IWorkspaceFolder;

334

338 && typeof candidate.toResource === 'function');

339 }

340 > workspace.ts

341 > export class Workspace implements IWorkspace {

342 >

343 > private foldersMap: TernarySearchTree<URI, WorkspaceFolder>;

344 >

345 > private _folders!: WorkspaceFolder[];

346 > get folders(): WorkspaceFolder[] { return this._folders; }

347 > set folders(folders: WorkspaceFolder[]) {

348 this._folders = folders;

349 this.updateFoldersMap();

350 }

351 > workspace.ts

352 > constructor(

353 private _id: string,

354 folders: WorkspaceFolder[],

361 this.folders = folders;

362 }

363 > workspace.ts

364 > update(workspace: Workspace) {

365 this._id = workspace.id;

366 this._configuration = workspace.configuration;

370 this.folders = workspace.folders;

371 }

372 > workspace.ts

373 > get id(): string {

374 return this._id;

375 }

376 > workspace.ts

377 > get transient(): boolean {

378 return this._transient;

379 }

380 > workspace.ts

381 > get configuration(): URI | null {

382 return this._configuration;

383 }

384 > workspace.ts

385 > set configuration(configuration: URI | null) {

386 this._configuration = configuration;

387 }

388 > workspace.ts

389 > get name(): string | undefined {

390 return this._workspaceName;

391 }

392 > workspace.ts

393 > getFolder(resource: URI): IWorkspaceFolder | null {

394 if (!resource) {

395 return null;

398 return this.foldersMap.findSubstr(resource) || null;

399 }

400 > workspace.ts

401 > private updateFoldersMap(): void {

402 this.foldersMap = TernarySearchTree.forUris<WorkspaceFolder>(this.ignorePathCasing, () => true);

403 for (const folder of this.folders) {

405 }

406 }

407 > workspace.ts

408 > toJSON(): IWorkspace {

409 return { id: this.id, folders: this.folders, transient: this.transient, configuration: this.configuration, name: this.name };

410 }

411 > } workspace.ts

412 >

413 > export interface IRawFileWorkspaceFolder {

414 > readonly path: string;

415 > name?: string;

416 > }

417 >

418 > export interface IRawUriWorkspaceFolder {

419 > readonly uri: string;

420 > name?: string;

421 > }

422 >

423 > export class WorkspaceFolder implements IWorkspaceFolder {

424 >

425 > readonly uri: URI;

426 > readonly name: string;

427 > readonly index: number;

428 >

429 > constructor(

430 data: IWorkspaceFolderData,

431 /**

442 this.name = data.name;

443 }

444 > workspace.ts

445 > toResource(relativePath: string): URI {

446 return joinPath(this.uri, relativePath);

447 }

448 > workspace.ts

449 > toJSON(): IWorkspaceFolderData {

450 return { uri: this.uri, name: this.name, index: this.index };

451 }

452 > } workspace.ts

453 >

454 > export function toWorkspaceFolder(resource: URI): WorkspaceFolder {

455 return new WorkspaceFolder({ uri: resource, index: 0, name: basenameOrAuthority(resource) }, { uri: resource.toString() });

456 }

457 > workspace.ts

458 > export const WORKSPACE_EXTENSION = 'code-workspace';

459 > export const WORKSPACE_SUFFIX = `.${WORKSPACE_EXTENSION}`;

460 > export const WORKSPACE_FILTER = [{ name: localize('codeWorkspace', "Code Workspace"), extensions: [WORKSPACE_EXTENSION] }];

461 > export const UNTITLED_WORKSPACE_NAME = 'workspace.json';

462 >

463 > export function isUntitledWorkspace(path: URI, environmentService: IEnvironmentService): boolean {

464 return extUriBiasedIgnorePathCase.isEqualOrParent(path, environmentService.untitledWorkspacesHome);

465 }

466 > workspace.ts

467 > export function isTemporaryWorkspace(workspace: IWorkspace): boolean;

468 > export function isTemporaryWorkspace(path: URI): boolean;

469 > export function isTemporaryWorkspace(arg1: IWorkspace | URI): boolean {

470 let path: URI | null | undefined;

471 if (URI.isUri(arg1)) {

477 return path?.scheme === Schemas.tmp;

478 }

479 > workspace.ts

480 > export const STANDALONE_EDITOR_WORKSPACE_ID = '4064f6ec-cb38-4ad0-af64-ee6467e63c82';

481 > export function isStandaloneEditorWorkspace(workspace: IWorkspace): boolean {

482 return workspace.id === STANDALONE_EDITOR_WORKSPACE_ID;

483 }

484 > workspace.ts

485 > export function isSavedWorkspace(path: URI, environmentService: IEnvironmentService): boolean {

486 return !isUntitledWorkspace(path, environmentService) && !isTemporaryWorkspace(path);

487 }

488 > workspace.ts

489 > export function hasWorkspaceFileExtension(path: string | URI) {

490 const ext = (typeof path === 'string') ? extname(path) : resourceExtname(path);

491

src/vs/workbench/contrib/chat/common/constants.ts 306 covered LOC · 18 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- constants.ts

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 { Schemas } from '../../../../base/common/network.js';

7 > import { IChatSessionsService, isAgentHostTarget, localChatSessionType, SessionType } from './chatSessionsService.js';

8 > import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';

9 > import { IStorageService } from '../../../../platform/storage/common/storage.js';

10 > import { IWorkspace } from '../../../../platform/workspace/common/workspace.js';

11 > import { isVirtualWorkspace } from '../../../../platform/workspace/common/virtualWorkspace.js';

12 > import { ServicesAccessor } from '../../../../platform/instantiation/common/instantiation.js';

13 > import { ContextKeyExpr, RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';

14 > import { ChatEntitlementContextKeys } from '../../../services/chat/common/chatEntitlementService.js';

15 > import { IsAuxiliaryWindowContext, IsSessionsWindowContext } from '../../../common/contextkeys.js';

16 > import { URI } from '../../../../base/common/uri.js';

17 > import { generateUuid } from '../../../../base/common/uuid.js';

18 > import { LocalChatSessionUri } from './model/chatUri.js';

19 > import { clearUserSelectedSessionType, getRememberedSessionType, hasPreferredCopilotHarness, storeUserSelectedSessionType } from './chatSessionTypePreference.js';

20 >

21 > export const enum BYOKUtilityModelDefault {

22 > None = 'none',

23 > MainAgent = 'mainAgent',

24 > Copilot = 'copilot',

25 > }

26 >

27 > export enum ChatConfiguration {

28 > AIDisabled = 'chat.disableAIFeatures',

29 > PluginsEnabled = 'chat.plugins.enabled',

30 > PluginLocations = 'chat.pluginLocations',

31 > PluginMarketplaces = 'chat.plugins.marketplaces',

32 > ExtraMarketplaces = 'chat.plugins.extraMarketplaces',

33 > StrictMarketplaces = 'chat.plugins.strictMarketplaces',

34 > EnabledPlugins = 'chat.plugins.enabledPlugins',

35 > AgentEnabled = 'chat.agent.enabled',

36 > PlanAgentDefaultModel = 'chat.planAgent.defaultModel',

37 > ExploreAgentDefaultModel = 'chat.exploreAgent.defaultModel',

38 > UtilityModel = 'chat.utilityModel',

39 > UtilitySmallModel = 'chat.utilitySmallModel',

40 > BYOKUtilityModelDefault = 'chat.byokUtilityModelDefault',

41 > RequestQueueingDefaultAction = 'chat.requestQueuing.defaultAction',

42 > AgentStatusEnabled = 'chat.agentsControl.enabled',

43 > EditorAssociations = 'chat.editorAssociations',

44 > UnifiedAgentsBar = 'chat.unifiedAgentsBar.enabled',

45 > AgentSessionProjectionEnabled = 'chat.agentSessionProjection.enabled',

46 > ExtensionToolsEnabled = 'chat.extensionTools.enabled',

47 > RepoInfoEnabled = 'chat.repoInfo.enabled',

48 > EditRequests = 'chat.editRequests',

49 > InlineReferencesStyle = 'chat.inlineReferences.style',

50 > AutoReply = 'chat.autoReply',

51 > GlobalAutoApprove = 'chat.tools.global.autoApprove',

52 > AutoApproveEdits = 'chat.tools.edits.autoApprove',

53 > AutoApprovedUrls = 'chat.tools.urls.autoApprove',

54 > EligibleForAutoApproval = 'chat.tools.eligibleForAutoApproval',

55 > EnableMath = 'chat.math.enabled',

56 > CheckpointsEnabled = 'chat.checkpoints.enabled',

57 > ThinkingStyle = 'chat.agent.thinkingStyle',

58 > ThinkingGenerateTitles = 'chat.agent.thinking.generateTitles',

59 > TerminalToolsInThinking = 'chat.agent.thinking.terminalTools',

60 > SimpleTerminalCollapsible = 'chat.tools.terminal.simpleCollapsible',

61 > CompressOutputEnabled = 'chat.tools.compressOutput.enabled',

62 > ThinkingPhrases = 'chat.agent.thinking.phrases',

63 > AutoExpandToolFailures = 'chat.tools.autoExpandFailures',

64 > TodosShowWidget = 'chat.tools.todos.showWidget',

65 > NotifyWindowOnConfirmation = 'chat.notifyWindowOnConfirmation',

66 > NotifyWindowOnResponseReceived = 'chat.notifyWindowOnResponseReceived',

67 > ChatViewSessionsEnabled = 'chat.viewSessions.enabled',

68 > SessionSyncEnabled = 'chat.sessionSync.enabled',

69 > SessionSyncExcludeRepositories = 'chat.sessionSync.excludeRepositories',

70 > ChatViewSessionsGrouping = 'chat.viewSessions.grouping',

71 > ChatViewSessionsOrientation = 'chat.viewSessions.orientation',

72 > ChatViewProgressBadgeEnabled = 'chat.viewProgressBadge.enabled',

73 > ChatContextUsageEnabled = 'chat.contextUsage.enabled',

74 > Verbose = 'chat.verbose',

75 > ProgressBorder = 'chat.progressBorder.enabled',

76 > SubagentToolCustomAgents = 'chat.customAgentInSubagent.enabled',

77 > SubagentsAllowInvocationsFromSubagents = 'chat.subagents.allowInvocationsFromSubagents',

78 > ShowCodeBlockProgressAnimation = 'chat.agent.codeBlockProgress',

79 > RestoreLastPanelSession = 'chat.restoreLastPanelSession',

80 > ExitAfterDelegation = 'chat.exitAfterDelegation',

81 > ExplainChangesEnabled = 'chat.editing.explainChanges.enabled',

82 > RevealNextChangeOnResolve = 'chat.editing.revealNextChangeOnResolve',

83 > OpenChangedFileInDiffEditor = 'chat.editing.openChangedFileInDiffEditor',

84 > GrowthNotificationEnabled = 'chat.growthNotification.enabled',

85 > TitleBarSignInEnabled = 'chat.titleBar.signIn.enabled',

86 > TitleBarOpenInAgentsWindowEnabled = 'chat.titleBar.openInAgentsWindow.enabled',

87 >

88 > ChatCustomizationsStructuredPreviewEnabled = 'chat.customizations.structuredPreview.enabled',

89 > ChatCustomizationsPromptMigrationEnabled = 'chat.customizations.promptMigration.enabled',

90 > AutopilotAdvancedEnabled = 'chat.autopilot.advanced.enabled',

91 > PlanReviewInlineEditorEnabled = 'chat.planReview.inlineEditor.enabled',

92 > DefaultPermissionLevel = 'chat.permissions.default',

93 > AssistedPermissionsEnabled = 'chat.assistedPermissions.enabled',

94 > PermissionsSandboxToggleEnabled = 'chat.experimental.permissionsSandboxToggle.enabled',

95 > DefaultConfiguration = 'chat.defaultConfiguration',

96 > DefaultModel = 'chat.defaultModel',

97 > ImageCarouselEnabled = 'imageCarousel.chat.enabled',

98 > ArtifactsEnabled = 'chat.artifacts.enabled',

99 > ArtifactsRulesByMimeType = 'chat.artifacts.rules.byMimeType',

100 > ArtifactsRulesByFilePath = 'chat.artifacts.rules.byFilePath',

101 > ArtifactsRulesByMemoryFilePath = 'chat.artifacts.rules.byMemoryFilePath',

102 > ToolConfirmationCarousel = 'chat.tools.confirmationCarousel.enabled',

103 > ToolRiskAssessmentEnabled = 'chat.tools.riskAssessment.enabled',

104 > ToolRiskAssessmentModel = 'chat.tools.riskAssessment.model',

105 > DefaultNewSessionMode = 'chat.newSession.defaultMode',

106 > CopilotCliHideExtensionHostAgents = 'chat.agents.copilotCli.hideExtensionHost',

107 > EditorPreferCopilotHarness = 'chat.editor.preferCopilotHarness',

108 > DefaultToCopilotHarness = 'chat.defaultToCopilotHarness',

109 > EditorLocalAgentEnabled = 'chat.editor.localAgent.enabled',

110 > CopilotCliHideExtensionHostEditor = 'chat.editor.copilotCli.hideExtensionHost',

111 > AgentsHandoffTipMode = 'chat.agentsHandoffTip.mode',

112 > TurnStatusPills = 'chat.turnStatusPills',

113 >

114 > IncrementalRendering = 'chat.experimental.incrementalRendering.enabled',

115 > IncrementalRenderingStyle = 'chat.experimental.incrementalRendering.animationStyle',

116 > IncrementalRenderingBuffering = 'chat.experimental.incrementalRendering.buffering',

117 >

118 > CollectInstructionsInExtension = 'chat.experimental.collectInstructionsInExtension',

119 > ImplicitContextActiveEditor = 'chat.implicitContext.includeActiveEditor',

120 > }

121 >

122 > /**

123 > * The "kind" of agents for custom agents.

124 > */

125 > export enum ChatModeKind {

126 > Ask = 'ask',

127 > Edit = 'edit',

128 > Agent = 'agent'

129 > }

130 >

131 > /**

132 > * The permission level controlling tool auto-approval behavior.

133 > */

134 > export enum ChatPermissionLevel {

135 > /** Use existing auto-approve settings */

136 > Default = 'default',

137 > /** Delegate approval decisions to a model */

138 > Assisted = 'assisted',

139 > /** Auto-approve all tool calls, auto-retry on error */

140 > AutoApprove = 'autoApprove',

141 > /** Everything AutoApprove does plus an internal stop hook that continues until the task is done */

142 > Autopilot = 'autopilot'

143 > }

144 >

145 > const chatPermissionLevels = new Set<string>(Object.values(ChatPermissionLevel));

146 >

147 > export function isChatPermissionLevel(level: unknown | undefined): level is ChatPermissionLevel {

148 return chatPermissionLevels.has(level as string);

149 }

150 > constants.ts

151 > /**

152 > * Shape of the {@link ChatConfiguration.DefaultConfiguration}

153 > * object setting. Controls the starting `mode` and `approvals` for new agent-host

154 > * sessions (such as Copilot CLI). All properties are optional — a missing property

155 > * falls back to the per-axis default.

156 > */

157 > export type AgentSessionMode = 'interactive' | 'plan' | 'autopilot';

158 >

159 > /** Approval values exposed by the `chat.defaultConfiguration` setting. */

160 > export enum ChatDefaultPermissionLevel {

161 > Default = 'default',

162 > Assisted = 'assisted',

163 > AllowAll = 'allowAll',

164 > }

165 >

166 > export interface IChatDefaultConfiguration {

167 > /** Starting agent mode: `interactive` / `plan` / `autopilot`. */

168 > readonly mode?: AgentSessionMode;

169 > /** Starting approval level: `default` / `assisted` / `allowAll`. */

170 > readonly approvals?: ChatDefaultPermissionLevel;

171 > }

172 >

173 > /** Maps a default-configuration value to the internal Agent Host permission level. */

174 > export function getChatPermissionLevelFromDefaultConfiguration(value: unknown): ChatPermissionLevel | undefined {

175 switch (value) {

176 case ChatDefaultPermissionLevel.Default:

185 }

186 }

187 > constants.ts

188 > /**

189 > * Returns true if the permission level enables auto-approval of all tool calls.

190 > * Both {@link ChatPermissionLevel.AutoApprove} and {@link ChatPermissionLevel.Autopilot} enable auto-approval.

191 > */

192 > export function isAutoApproveLevel(level: ChatPermissionLevel | undefined): boolean {

193 return level === ChatPermissionLevel.AutoApprove || level === ChatPermissionLevel.Autopilot;

194 }

195 > constants.ts

196 > /**

197 > * True for {@link ChatPermissionLevel.Autopilot} only. Unlike {@link isAutoApproveLevel}, this

198 > * excludes {@link ChatPermissionLevel.AutoApprove}, so it can gate Autopilot-only behavior such as

199 > * risk-based skipping of tool calls.

200 > */

201 > export function isAutopilotLevel(level: ChatPermissionLevel | undefined): boolean {

202 return level === ChatPermissionLevel.Autopilot;

203 }

204 > constants.ts

205 > // Thinking display modes for pinned content

206 > export enum ThinkingDisplayMode {

207 > Collapsed = 'collapsed',

208 > CollapsedPreview = 'collapsedPreview',

209 > FixedScrolling = 'fixedScrolling',

210 > }

211 >

212 > export enum CollapsedToolsDisplayMode {

213 > Off = 'off',

214 > WithThinking = 'withThinking',

215 > Always = 'always',

216 > }

217 >

218 > export enum ChatNotificationMode {

219 > Off = 'off',

220 > WindowNotFocused = 'windowNotFocused',

221 > Always = 'always',

222 > }

223 >

224 > export type RawChatParticipantLocation = 'panel' | 'terminal' | 'notebook' | 'editing-session';

225 >

226 > export enum ChatAgentLocation {

227 > /**

228 > * This is chat, whether it's in the sidebar, a chat editor, or quick chat.

229 > * Leaving the values alone as they are in stored data so we don't have to normalize them.

230 > */

231 > Chat = 'panel',

232 > Terminal = 'terminal',

233 > Notebook = 'notebook',

234 > /**

235 > * EditorInline means inline chat in a text editor.

236 > */

237 > EditorInline = 'editor',

238 > }

239 >

240 > export namespace ChatAgentLocation {

241 > export function fromRaw(value: RawChatParticipantLocation | string): ChatAgentLocation {

242 switch (value) {

243 case 'panel': return ChatAgentLocation.Chat;

248 return ChatAgentLocation.Chat;

249 }

250 > } constants.ts

251 >

252 > /**

253 > * List of file schemes that are always unsupported for use in chat

254 > */

255 > const chatAlwaysUnsupportedFileSchemes = new Set([

256 > Schemas.vscodeChatEditor,

257 > Schemas.walkThrough,

258 > Schemas.vscodeLocalChatSession,

259 > Schemas.vscodeSettings,

260 > Schemas.webviewPanel,

261 > Schemas.vscodeUserData,

262 > Schemas.extension,

263 > 'ccreq',

264 > 'openai-codex', // Codex session custom editor scheme

265 > ]);

266 >

267 > export function isSupportedChatFileScheme(accessor: ServicesAccessor, scheme: string): boolean {

268 const chatService = accessor.get(IChatSessionsService);

269

281 return true;

282 }

283 > constants.ts

284 > /**

285 > * Returns the effective default session type for a new chat in the VS Code

286 > * editor window.

287 > *

288 > * Virtual workspaces always default to {@link localChatSessionType}. Otherwise,

289 > * when the agent host is enabled and `chat.defaultToCopilotHarness` is opted in,

290 > * Agent Host Copilot CLI is the default. It falls back to the local harness

291 > * when enabled, or to the first visible non-local provider.

292 > */

293 > export function getComputedDefaultSessionType(

294 configurationService: IConfigurationService,

295 chatSessionsService: Pick<IChatSessionsService, 'getChatSessionContribution' | 'getAllChatSessionContributions'>,

311 return getVisibleNonLocalEditorChatSessionTypes(configurationService, chatSessionsService, workspace)[0] ?? localChatSessionType;

312 }

313 > constants.ts

314 > export function getComputedDefaultSessionResource(

315 configurationService: IConfigurationService,

316 chatSessionsService: Pick<IChatSessionsService, 'getChatSessionContribution' | 'getAllChatSessionContributions'>,

323 : URI.from({ scheme: defaultType, path: `/untitled-${generateUuid()}` });

324 }

325 > constants.ts

326 > export function isRememberedSessionTypeUsable(

327 sessionType: string,

328 configurationService: IConfigurationService,

338 return !!chatSessionsService.getChatSessionContribution(sessionType);

339 }

340 > constants.ts

341 > export interface IDefaultNewChatSessionTypeOptions {

342 > readonly explicitOverride?: string;

343 > readonly currentSessionType?: string;

344 > }

345 >

346 > export interface IResolvedNewChatSessionType {

347 > /** The session type to open for the new chat. */

348 > readonly sessionType: string;

349 > /**

350 > * True when {@link sessionType} is the one-time `chat.editor.preferCopilotHarness`

351 > * swap. The caller must persist the marker (via `markPreferredCopilotHarness`)

352 > * only once it has actually applied this session type, so the migration is not

353 > * consumed by a caller that discards the result.

354 > */

355 > readonly isPreferCopilotHarnessSwap: boolean;

356 > }

357 >

358 > export function getDefaultNewChatSessionType(

359 configurationService: IConfigurationService,

360 chatSessionsService: Pick<IChatSessionsService, 'getChatSessionContribution' | 'getAllChatSessionContributions'>,

379 return getComputedDefaultSessionType(configurationService, chatSessionsService, workspace, agentHostEnabled);

380 }

381 > constants.ts

382 > export function resolveDefaultNewChatSessionType(

383 configurationService: IConfigurationService,

384 chatSessionsService: Pick<IChatSessionsService, 'getChatSessionContribution' | 'getAllChatSessionContributions'>,

413 return { sessionType: getDefaultNewChatSessionType(configurationService, chatSessionsService, storageService, workspace, agentHostEnabled, options), isPreferCopilotHarnessSwap: false };

414 }

415 > constants.ts

416 function getUsableRememberedSessionType(

417 storageService: IStorageService,

423 return remembered && isRememberedSessionTypeUsable(remembered, configurationService, chatSessionsService, workspace) ? remembered : undefined;

424 }

425 > constants.ts

426 > export function getDefaultNewChatSessionResource(

427 configurationService: IConfigurationService,

428 chatSessionsService: Pick<IChatSessionsService, 'getChatSessionContribution' | 'getAllChatSessionContributions'>,

437 : URI.from({ scheme: defaultType, path: `/untitled-${generateUuid()}` });

438 }

439 > constants.ts

440 > export function recordUserSelectedSessionType(

441 storageService: IStorageService,

442 configurationService: IConfigurationService,

452 }

453 }

454 > constants.ts

455 > export function isEditorLocalAgentEnabled(configurationService: IConfigurationService, workspace: IWorkspace): boolean {

456 return isVirtualWorkspace(workspace) || (configurationService.getValue<boolean>(ChatConfiguration.EditorLocalAgentEnabled) ?? true);

457 }

458 > constants.ts

459 > export function isVisibleEditorChatSessionType(

460 sessionType: string,

461 configurationService: IConfigurationService,

473 return !!chatSessionsService.getChatSessionContribution(sessionType);

474 }

475 > constants.ts

476 function getVisibleNonLocalEditorChatSessionTypes(

477 configurationService: IConfigurationService,

487 return Array.from(sessionTypes);

488 }

489 > constants.ts

490 > export const MANAGE_CHAT_COMMAND_ID = 'workbench.action.chat.manage';

491 > export const CHAT_OPEN_AGENT_HOST_CHAT_COMMAND_ID = 'workbench.action.chat.openAgentHostChat';

492 >

493 > export const OPEN_WORKSPACE_IN_AGENTS_WINDOW_COMMAND_ID = 'workbench.action.openWorkspaceInAgentsWindow';

494 > export const OPEN_AGENTS_WINDOW_COMMAND_ID = 'workbench.action.openAgentsWindow';

495 > export const OPEN_AGENTS_WINDOW_PRECONDITION = ContextKeyExpr.and(

496 > ChatEntitlementContextKeys.Setup.hidden.negate(),

497 > ChatEntitlementContextKeys.Setup.disabledInWorkspace.negate(),

498 > IsSessionsWindowContext.negate(),

499 > ContextKeyExpr.has(`config.${ChatConfiguration.AgentEnabled}`),

500 > IsAuxiliaryWindowContext.negate()

501 > );

502 >

503 > export const ChatEditorTitleMaxLength = 30;

504 >

505 > export const CHAT_TERMINAL_OUTPUT_MAX_PREVIEW_LINES = 1000;

506 > export const CONTEXT_MODELS_EDITOR = new RawContextKey<boolean>('inModelsEditor', false);

507 > export const CONTEXT_MODELS_SEARCH_FOCUS = new RawContextKey<boolean>('inModelsSearch', false);

src/vs/base/common/types.ts 299 covered LOC · 31 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- types.ts

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 { assert } from './assert.js';

7 >

8 > /**

9 > * @returns whether the provided parameter is a JavaScript String or not.

10 > */

11 > export function isString(str: unknown): str is string {

12 > return (typeof str === 'string'); types.ts

13 > }

14 > types.ts

15 > /**

16 > * @returns whether the provided parameter is a JavaScript Array and each element in the array is a string.

17 > */

18 > export function isStringArray(value: unknown): value is string[] {

19 return isArrayOf(value, isString);

20 }

21 > types.ts

22 > /**

23 > * @returns whether the provided parameter is a JavaScript Array and each element in the array satisfies the provided type guard.

24 > */

25 > export function isArrayOf<T>(value: unknown, check: (item: unknown) => item is T): value is T[] {

26 return Array.isArray(value) && value.every(check);

27 }

28 > types.ts

29 > /**

30 > * @returns whether the provided parameter is of type `object` but **not**

31 > * `null`, an `array`, a `regexp`, nor a `date`.

32 > */

33 > export function isObject(obj: unknown): obj is Object {

34 > // The method can't do a type cast since there are type (like strings) which types.ts

35 > // are subclasses of any put not positvely matched by the function. Hence type

36 > // narrowing results in wrong results.

37 > return typeof obj === 'object'

38 > && obj !== null types.ts

39 > && !Array.isArray(obj)

40 > && !(obj instanceof RegExp) types.ts

41 > && !(obj instanceof Date);

42 > } types.ts

43 > types.ts

44 > /**

45 > * @returns whether the provided parameter is of type `Buffer` or Uint8Array dervived type

46 > */

47 > export function isTypedArray(obj: unknown): obj is Object {

48 const TypedArray = Object.getPrototypeOf(Uint8Array);

49 return typeof obj === 'object'

50 && obj instanceof TypedArray;

51 }

52 > types.ts

53 > /**

54 > * In **contrast** to just checking `typeof` this will return `false` for `NaN`.

55 > * @returns whether the provided parameter is a JavaScript Number or not.

56 > */

57 > export function isNumber(obj: unknown): obj is number {

58 return (typeof obj === 'number' && !isNaN(obj));

59 }

60 > types.ts

61 > /**

62 > * @returns whether the provided parameter is an Iterable, casting to the given generic

63 > */

64 > export function isIterable<T>(obj: unknown): obj is Iterable<T> {

65 // eslint-disable-next-line local/code-no-any-casts

66 return !!obj && typeof (obj as any)[Symbol.iterator] === 'function';

67 }

68 > types.ts

69 > /**

70 > * @returns whether the provided parameter is an Iterable, casting to the given generic

71 > */

72 > export function isAsyncIterable<T>(obj: unknown): obj is AsyncIterable<T> {

73 // eslint-disable-next-line local/code-no-any-casts

74 return !!obj && typeof (obj as any)[Symbol.asyncIterator] === 'function';

75 }

76 > types.ts

77 > /**

78 > * @returns whether the provided parameter is a JavaScript Boolean or not.

79 > */

80 > export function isBoolean(obj: unknown): obj is boolean {

81 return (obj === true || obj === false);

82 }

83 > types.ts

84 > /**

85 > * @returns whether the provided parameter is undefined.

86 > */

87 > export function isUndefined(obj: unknown): obj is undefined {

88 > return (typeof obj === 'undefined'); types.ts

89 > }

90 > types.ts

91 > /**

92 > * @returns whether the provided parameter is defined.

93 > */

94 > export function isDefined<T>(arg: T | null | undefined): arg is T {

95 return !isUndefinedOrNull(arg);

96 }

97 > types.ts

98 > /**

99 > * @returns whether the provided parameter is undefined or null.

100 > */

101 > export function isUndefinedOrNull(obj: unknown): obj is undefined | null {

102 > return (isUndefined(obj) || obj === null); types.ts

103 > }

104 > types.ts

105 >

106 > export function assertType(condition: unknown, type?: string): asserts condition {

107 if (!condition) {

108 throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type');

109 }

110 }

111 > types.ts

112 > /**

113 > * Asserts that the argument passed in is neither undefined nor null.

114 > *

115 > * @see {@link assertDefined} for a similar utility that leverages TS assertion functions to narrow down the type of `arg` to be non-nullable.

116 > */

117 > export function assertReturnsDefined<T>(arg: T | null | undefined): NonNullable<T> {

118 assert(

119 arg !== null && arg !== undefined,

123 return arg;

124 }

125 > types.ts

126 > /**

127 > * Asserts that a provided `value` is `defined` - not `null` or `undefined`,

128 > * throwing an error with the provided error or error message, while also

129 > * narrowing down the type of the `value` to be `NonNullable` using TS

130 > * assertion functions.

131 > *

132 > * @throws if the provided `value` is `null` or `undefined`.

133 > *

134 > * ## Examples

135 > *

136 > * ```typescript

137 > * // an assert with an error message

138 > * assertDefined('some value', 'String constant is not defined o_O.');

139 > *

140 > * // `throws!` the provided error

141 > * assertDefined(null, new Error('Should throw this error.'));

142 > *

143 > * // narrows down the type of `someValue` to be non-nullable

144 > * const someValue: string | undefined | null = blackbox();

145 > * assertDefined(someValue, 'Some value must be defined.');

146 > * console.log(someValue.length); // now type of `someValue` is `string`

147 > * ```

148 > *

149 > * @see {@link assertReturnsDefined} for a similar utility but without assertion.

150 > * @see {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions typescript-3-7.html#assertion-functions}

151 > */

152 > export function assertDefined<T>(value: T, error: string | NonNullable<Error>): asserts value is NonNullable<T> {

153 if (value === null || value === undefined) {

154 const errorToThrow = typeof error === 'string' ? new Error(error) : error;

157 }

158 }

159 > types.ts

160 > /**

161 > * Asserts that each argument passed in is neither undefined nor null.

162 > */

163 > export function assertReturnsAllDefined<T1, T2>(t1: T1 | null | undefined, t2: T2 | null | undefined): [T1, T2];

164 > export function assertReturnsAllDefined<T1, T2, T3>(t1: T1 | null | undefined, t2: T2 | null | undefined, t3: T3 | null | undefined): [T1, T2, T3];

165 > export function assertReturnsAllDefined<T1, T2, T3, T4>(t1: T1 | null | undefined, t2: T2 | null | undefined, t3: T3 | null | undefined, t4: T4 | null | undefined): [T1, T2, T3, T4];

166 > export function assertReturnsAllDefined(...args: (unknown | null | undefined)[]): unknown[] {

167 const result = [];

168

179 return result;

180 }

181 > types.ts

182 > /**

183 > * Checks if the provided value is one of the vales in the provided list.

184 > *

185 > * ## Examples

186 > *

187 > * ```typescript

188 > * // note! item type is a `subset of string`

189 > * type TItem = ':' | '.' | '/';

190 > *

191 > * // note! item is type of `string` here

192 > * const item: string = ':';

193 > * // list of the items to check against

194 > * const list: TItem[] = [':', '.'];

195 > *

196 > * // ok

197 > * assert(

198 > * isOneOf(item, list),

199 > * 'Must succeed.',

200 > * );

201 > *

202 > * // `item` is of `TItem` type now

203 > * ```

204 > */

205 > export const isOneOf = <TType, TSubtype extends TType>(

206 value: TType,

207 validValues: readonly TSubtype[],

211 return validValues.includes(<TSubtype>value);

212 };

213 > types.ts

214 > /**

215 > * Compile-time type check of a variable.

216 > */

217 > export function typeCheck<T = never>(_thing: NoInfer<T>): void { }

218 >

219 > const hasOwnProperty = Object.prototype.hasOwnProperty;

220 >

221 > /**

222 > * @returns whether the provided parameter is an empty JavaScript Object or not.

223 > */

224 > export function isEmptyObject(obj: unknown): obj is object {

225 if (!isObject(obj)) {

226 return false;

235 return true;

236 }

237 > types.ts

238 > /**

239 > * @returns whether the provided parameter is a JavaScript Function or not.

240 > */

241 > export function isFunction(obj: unknown): obj is Function {

242 return (typeof obj === 'function');

243 }

244 > types.ts

245 > /**

246 > * @returns whether the provided parameters is are JavaScript Function or not.

247 > */

248 > export function areFunctions(...objects: unknown[]): boolean {

249 return objects.length > 0 && objects.every(isFunction);

250 }

251 > types.ts

252 > export type TypeConstraint = string | Function;

253 >

254 > export function validateConstraints(args: unknown[], constraints: Array<TypeConstraint | undefined>): void {

255 const len = Math.min(args.length, constraints.length);

256 for (let i = 0; i < len; i++) {

258 }

259 }

260 > types.ts

261 > export function validateConstraint(arg: unknown, constraint: TypeConstraint | undefined): void {

262

263 if (isString(constraint)) {

283 }

284 }

285 > types.ts

286 > /**

287 > * Helper type assertion that safely upcasts a type to a supertype.

288 > *

289 > * This can be used to make sure the argument correctly conforms to the subtype while still being able to pass it

290 > * to contexts that expects the supertype.

291 > */

292 > export function upcast<Base, Sub extends Base = Base>(x: Sub): Base {

293 return x;

294 }

295 > types.ts

296 > type AddFirstParameterToFunction<T, TargetFunctionsReturnType, FirstParameter> = T extends (...args: any[]) => TargetFunctionsReturnType ?

297 > // Function: add param to function

298 > (firstArg: FirstParameter, ...args: Parameters<T>) => ReturnType<T> :

299 >

300 > // Else: just leave as is

301 > T;

302 >

303 > /**

304 > * Allows to add a first parameter to functions of a type.

305 > */

306 > export type AddFirstParameterToFunctions<Target, TargetFunctionsReturnType, FirstParameter> = {

307 > // For every property

308 > [K in keyof Target]: AddFirstParameterToFunction<Target[K], TargetFunctionsReturnType, FirstParameter>;

309 > };

310 >

311 > /**

312 > * Given an object with all optional properties, requires at least one to be defined.

313 > * i.e. AtLeastOne<MyObject>;

314 > */

315 > export type AtLeastOne<T, U = { [K in keyof T]: Pick<T, K> }> = Partial<T> & U[keyof U];

316 >

317 > /**

318 > * Only picks the non-optional properties of a type.

319 > */

320 > export type OmitOptional<T> = { [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K] };

321 >

322 > /**

323 > * A type that removed readonly-less from all properties of `T`

324 > */

325 > export type Mutable<T> = {

326 > -readonly [P in keyof T]: T[P]

327 > };

328 >

329 > /**

330 > * A type that adds readonly to all properties of T, recursively.

331 > */

332 > export type DeepImmutable<T> = T extends (infer U)[]

333 > ? ReadonlyArray<DeepImmutable<U>>

334 > : T extends ReadonlyArray<infer U>

335 > ? ReadonlyArray<DeepImmutable<U>>

336 > : T extends Map<infer K, infer V>

337 > ? ReadonlyMap<K, DeepImmutable<V>>

338 > : T extends Set<infer U>

339 > ? ReadonlySet<DeepImmutable<U>>

340 > : T extends object

341 > ? {

342 > readonly [K in keyof T]: DeepImmutable<T[K]>;

343 > }

344 > : T;

345 >

346 > /**

347 > * A single object or an array of the objects.

348 > */

349 > export type SingleOrMany<T> = T | T[];

350 >

351 > /**

352 > * Given a `type X = { foo?: string }` checking that an object `satisfies X`

353 > * will ensure each property was explicitly defined, ensuring no properties

354 > * are omitted or forgotten.

355 > */

356 > export type WithDefinedProps<T> = { [K in keyof Required<T>]: T[K] };

357 >

358 >

359 > /**

360 > * A type that recursively makes all properties of `T` required

361 > */

362 > export type DeepRequiredNonNullable<T> = {

363 > [P in keyof T]-?: T[P] extends object ? DeepRequiredNonNullable<T[P]> : Required<NonNullable<T[P]>>;

364 > };

365 >

366 >

367 > /**

368 > * Represents a type that is a partial version of a given type `T`, where all properties are optional and can be deeply nested.

369 > */

370 > export type DeepPartial<T> = {

371 > [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : Partial<T[P]>;

372 > };

373 >

374 > /**

375 > * Represents a type that is a partial version of a given type `T`, except a subset.

376 > */

377 > export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;

378 >

379 >

380 > type KeysOfUnionType<T> = T extends T ? keyof T : never;

381 > type FilterType<T, TTest> = T extends TTest ? T : never;

382 > type MakeOptionalAndTrue<T extends object> = { [K in keyof T]?: true };

383 >

384 > /**

385 > * Type guard that checks if an object has specific keys and narrows the type accordingly.

386 > *

387 > * @param x - The object to check

388 > * @param key - An object with boolean values indicating which keys to check for

389 > * @returns true if all specified keys exist in the object, false otherwise

390 > *

391 > * @example

392 > * ```typescript

393 > * type A = { a: string };

394 > * type B = { b: number };

395 > * const obj: A | B = getObject();

396 > *

397 > * if (hasKey(obj, { a: true })) {

398 > * // obj is now narrowed to type A

399 > * console.log(obj.a);

400 > * }

401 > * ```

402 > */

403 > export function hasKey<T extends object, TKeys extends MakeOptionalAndTrue<T>>(x: T, key: TKeys): x is FilterType<T, { [K in KeysOfUnionType<T> & keyof TKeys]: unknown }> {

404 for (const k in key) {

405 if (!(k in x)) {

src/vs/base/common/network.ts 292 covered LOC · 20 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- network.ts

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 * as errors from './errors.js';

7 > import * as platform from './platform.js';

8 > import { equalsIgnoreCase, startsWithIgnoreCase } from './strings.js';

9 > import { URI } from './uri.js';

10 > import * as paths from './path.js';

11 >

12 > export namespace Schemas {

13 >

14 > /**

15 > * A schema that is used for models that exist in memory

16 > * only and that have no correspondence on a server or such.

17 > */

18 > export const inMemory = 'inmemory';

19 >

20 > /**

21 > * A schema that is used for setting files

22 > */

23 > export const vscode = 'vscode';

24 >

25 > /**

26 > * A schema that is used for internal private files

27 > */

28 > export const internal = 'private';

29 >

30 > /**

31 > * A walk-through document.

32 > */

33 > export const walkThrough = 'walkThrough';

34 >

35 > /**

36 > * An embedded code snippet.

37 > */

38 > export const walkThroughSnippet = 'walkThroughSnippet';

39 >

40 > export const http = 'http';

41 >

42 > export const https = 'https';

43 >

44 > export const file = 'file';

45 >

46 > export const mailto = 'mailto';

47 >

48 > export const untitled = 'untitled';

49 >

50 > export const data = 'data';

51 >

52 > export const command = 'command';

53 >

54 > export const vscodeRemote = 'vscode-remote';

55 >

56 > export const vscodeRemoteResource = 'vscode-remote-resource';

57 >

58 > export const vscodeManagedRemoteResource = 'vscode-managed-remote-resource';

59 >

60 > export const vscodeUserData = 'vscode-userdata';

61 >

62 > export const vscodeCustomEditor = 'vscode-custom-editor';

63 >

64 > export const vscodeNotebookCell = 'vscode-notebook-cell';

65 > export const vscodeNotebookCellMetadata = 'vscode-notebook-cell-metadata';

66 > export const vscodeNotebookCellMetadataDiff = 'vscode-notebook-cell-metadata-diff';

67 > export const vscodeNotebookCellOutput = 'vscode-notebook-cell-output';

68 > export const vscodeNotebookCellOutputDiff = 'vscode-notebook-cell-output-diff';

69 > export const vscodeNotebookMetadata = 'vscode-notebook-metadata';

70 > export const vscodeInteractiveInput = 'vscode-interactive-input';

71 >

72 > export const vscodeSettings = 'vscode-settings';

73 >

74 > export const vscodeWorkspaceTrust = 'vscode-workspace-trust';

75 >

76 > export const vscodeTerminal = 'vscode-terminal';

77 >

78 > /** Scheme used for the image carousel editor. */

79 > export const vscodeImageCarousel = 'vscode-image-carousel';

80 >

81 > /** Scheme used for code blocks in chat. */

82 > export const vscodeChatCodeBlock = 'vscode-chat-code-block';

83 >

84 > /** Scheme used for LHS of code compare (aka diff) blocks in chat. */

85 > export const vscodeChatCodeCompareBlock = 'vscode-chat-code-compare-block';

86 >

87 > /** Scheme used for the chat input editor. */

88 > export const vscodeChatEditor = 'vscode-chat-editor';

89 >

90 > /** Scheme used for the chat input part */

91 > export const vscodeChatInput = 'chatSessionInput';

92 >

93 > /** Scheme used for local chat session content */

94 > export const vscodeLocalChatSession = 'vscode-chat-session';

95 >

96 > /**

97 > * Scheme used internally for webviews that aren't linked to a resource (i.e. not custom editors)

98 > */

99 > export const webviewPanel = 'webview-panel';

100 >

101 > /**

102 > * Scheme used for loading the wrapper html and script in webviews.

103 > */

104 > export const vscodeWebview = 'vscode-webview';

105 >

106 > /**

107 > * Scheme used for integrated browser tabs using WebContentsView.

108 > */

109 > export const vscodeBrowser = 'vscode-browser';

110 >

111 > /**

112 > * Scheme used for extension pages

113 > */

114 > export const extension = 'extension';

115 >

116 > /**

117 > * Scheme used as a replacement of `file` scheme to load

118 > * files with our custom protocol handler (desktop only).

119 > */

120 > export const vscodeFileResource = 'vscode-file';

121 >

122 > /**

123 > * Scheme used for temporary resources

124 > */

125 > export const tmp = 'tmp';

126 >

127 > /**

128 > * Scheme used vs live share

129 > */

130 > export const vsls = 'vsls';

131 >

132 > /**

133 > * Scheme used for the Source Control commit input's text document

134 > */

135 > export const vscodeSourceControl = 'vscode-scm';

136 >

137 > /**

138 > * Scheme used for input box for creating comments.

139 > */

140 > export const commentsInput = 'comment';

141 >

142 > /**

143 > * Scheme used for special rendering of settings in the release notes

144 > */

145 > export const codeSetting = 'code-setting';

146 >

147 > /**

148 > * Scheme used for output panel resources

149 > */

150 > export const outputChannel = 'output';

151 >

152 > /**

153 > * Scheme used for the accessible view

154 > */

155 > export const accessibleView = 'accessible-view';

156 >

157 > /**

158 > * Used for snapshots of chat edits

159 > */

160 > export const chatEditingSnapshotScheme = 'chat-editing-snapshot-text-model';

161 > export const chatEditingModel = 'chat-editing-text-model';

162 >

163 > /**

164 > * Used for rendering multidiffs in copilot agent sessions

165 > */

166 > export const copilotPr = 'copilot-pr';

167 > }

168 >

169 > export function matchesScheme(target: URI | string, scheme: string): boolean {

170 if (URI.isUri(target)) {

171 return equalsIgnoreCase(target.scheme, scheme);

174 }

175 }

176 > network.ts

177 > export function matchesSomeScheme(target: URI | string, ...schemes: string[]): boolean {

178 return schemes.some(scheme => matchesScheme(target, scheme));

179 }

180 > network.ts

181 > export const connectionTokenCookieName = 'vscode-tkn';

182 > export const connectionTokenQueryName = 'tkn';

183 >

184 > class RemoteAuthoritiesImpl {

185 > private readonly _hosts: { [authority: string]: string | undefined } = Object.create(null);

186 > private readonly _ports: { [authority: string]: number | undefined } = Object.create(null);

187 > private readonly _connectionTokens: { [authority: string]: string | undefined } = Object.create(null);

188 > private _preferredWebSchema: 'http' | 'https' = 'http';

189 > private _delegate: ((uri: URI) => URI) | null = null;

190 > private _serverRootPath: string = '/';

191 >

192 > setPreferredWebSchema(schema: 'http' | 'https') {

193 this._preferredWebSchema = schema;

194 }

195 > network.ts

196 > setDelegate(delegate: (uri: URI) => URI): void {

197 this._delegate = delegate;

198 }

199 > network.ts

200 > setServerRootPath(product: { quality?: string; commit?: string }, serverBasePath: string | undefined): void {

201 this._serverRootPath = paths.posix.join(serverBasePath ?? '/', getServerProductSegment(product));

202 }

203 > network.ts

204 > getServerRootPath(): string {

205 return this._serverRootPath;

206 }

207 > network.ts

208 > private get _remoteResourcesPath(): string {

209 return paths.posix.join(this._serverRootPath, Schemas.vscodeRemoteResource);

210 }

211 > network.ts

212 > set(authority: string, host: string, port: number): void {

213 this._hosts[authority] = host;

214 this._ports[authority] = port;

215 }

216 > network.ts

217 > setConnectionToken(authority: string, connectionToken: string): void {

218 this._connectionTokens[authority] = connectionToken;

219 }

220 > network.ts

221 > getPreferredWebSchema(): 'http' | 'https' {

222 return this._preferredWebSchema;

223 }

224 > network.ts

225 > rewrite(uri: URI): URI {

226 if (this._delegate) {

227 try {

250 });

251 }

252 > } network.ts

253 >

254 > export const RemoteAuthorities = new RemoteAuthoritiesImpl();

255 >

256 > export function getServerProductSegment(product: { quality?: string; commit?: string }) {

257 return `${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`;

258 }

259 > network.ts

260 > /**

261 > * A string pointing to a path inside the app. It should not begin with ./ or ../

262 > */

263 > export type AppResourcePath = (

264 > `a${string}` | `b${string}` | `c${string}` | `d${string}` | `e${string}` | `f${string}`

265 > | `g${string}` | `h${string}` | `i${string}` | `j${string}` | `k${string}` | `l${string}`

266 > | `m${string}` | `n${string}` | `o${string}` | `p${string}` | `q${string}` | `r${string}`

267 > | `s${string}` | `t${string}` | `u${string}` | `v${string}` | `w${string}` | `x${string}`

268 > | `y${string}` | `z${string}`

269 > );

270 >

271 > export const builtinExtensionsPath: AppResourcePath = 'vs/../../extensions';

272 > export const nodeModulesPath: AppResourcePath = 'vs/../../node_modules';

273 > export const nodeModulesAsarPath: AppResourcePath = 'vs/../../node_modules.asar';

274 > export const nodeModulesAsarUnpackedPath: AppResourcePath = 'vs/../../node_modules.asar.unpacked';

275 >

276 > export const VSCODE_AUTHORITY = 'vscode-app';

277 >

278 > class FileAccessImpl {

279 >

280 > private static readonly FALLBACK_AUTHORITY = VSCODE_AUTHORITY;

281 >

282 > /**

283 > * Returns a URI to use in contexts where the browser is responsible

284 > * for loading (e.g. fetch()) or when used within the DOM.

285 > *

286 > * **Note:** use `dom.ts#asCSSUrl` whenever the URL is to be used in CSS context.

287 > */

288 > asBrowserUri(resourcePath: AppResourcePath | ''): URI {

289 const uri = this.toUri(resourcePath);

290 return this.uriToBrowserUri(uri);

291 }

292 > network.ts

293 > /**

294 > * Returns a URI to use in contexts where the browser is responsible

295 > * for loading (e.g. fetch()) or when used within the DOM.

296 > *

297 > * **Note:** use `dom.ts#asCSSUrl` whenever the URL is to be used in CSS context.

298 > */

299 > uriToBrowserUri(uri: URI): URI {

300 // Handle remote URIs via `RemoteAuthorities`

301 if (uri.scheme === Schemas.vscodeRemote) {

328 return uri;

329 }

330 > network.ts

331 > /**

332 > * Returns the `file` URI to use in contexts where node.js

333 > * is responsible for loading.

334 > */

335 > asFileUri(resourcePath: AppResourcePath | ''): URI {

336 const uri = this.toUri(resourcePath);

337 return this.uriToFileUri(uri);

338 }

339 > network.ts

340 > /**

341 > * Returns the `file` URI to use in contexts where node.js

342 > * is responsible for loading.

343 > */

344 > uriToFileUri(uri: URI): URI {

345 // Only convert the URI if it is `vscode-file:` scheme

346 if (uri.scheme === Schemas.vscodeFileResource) {

358 return uri;

359 }

360 > network.ts

361 > private toUri(uriOrModule: URI | string): URI {

362 if (URI.isUri(uriOrModule)) {

363 return uriOrModule;

379 throw new Error('Cannot determine URI for module id!');

380 }

381 > } network.ts

382 >

383 > export const FileAccess = new FileAccessImpl();

384 >

385 > export const CacheControlheaders: Record<string, string> = Object.freeze({

386 > 'Cache-Control': 'no-cache, no-store'

387 > });

388 >

389 > export const DocumentPolicyheaders: Record<string, string> = Object.freeze({

390 > 'Document-Policy': 'include-js-call-stacks-in-crash-reports'

391 > });

392 >

393 > export namespace COI {

394 >

395 > const coiHeaders = new Map<'3' | '2' | '1' | string, Record<string, string>>([

396 > ['1', { 'Cross-Origin-Opener-Policy': 'same-origin' }],

397 > ['2', { 'Cross-Origin-Embedder-Policy': 'require-corp' }],

398 > ['3', { 'Cross-Origin-Opener-Policy': 'same-origin', 'Cross-Origin-Embedder-Policy': 'require-corp' }],

399 > ]);

400 >

401 > export const CoopAndCoep = Object.freeze(coiHeaders.get('3'));

402 >

403 > const coiSearchParamName = 'vscode-coi';

404 >

405 > /**

406 > * Extract desired headers from `vscode-coi` invocation

407 > */

408 > export function getHeadersFromQuery(url: string | URI | URL): Record<string, string> | undefined {

409 let params: URLSearchParams | undefined;

410 if (typeof url === 'string') {

421 return coiHeaders.get(value);

422 }

423 > network.ts

424 > /**

425 > * Add the `vscode-coi` query attribute based on wanting `COOP` and `COEP`. Will be a noop when `crossOriginIsolated`

426 > * isn't enabled the current context

427 > */

428 > export function addSearchParam(urlOrSearch: URLSearchParams | Record<string, string>, coop: boolean, coep: boolean): void {

429 if (!(globalThis as typeof globalThis & { crossOriginIsolated?: boolean }).crossOriginIsolated) {

430 // depends on the current context being COI

438 }

439 }

440 > } network.ts

src/vs/workbench/services/lifecycle/common/lifecycle.ts 292 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- lifecycle.ts

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 { CancellationToken } from '../../../../base/common/cancellation.js';

7 > import { Event } from '../../../../base/common/event.js';

8 > import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';

9 >

10 > export const ILifecycleService = createDecorator<ILifecycleService>('lifecycleService');

11 >

12 > /**

13 > * An event that is send out when the window is about to close. Clients have a chance to veto

14 > * the closing by either calling veto with a boolean "true" directly or with a promise that

15 > * resolves to a boolean. Returning a promise is useful in cases of long running operations

16 > * on shutdown.

17 > *

18 > * Note: It is absolutely important to avoid long running promises if possible. Please try hard

19 > * to return a boolean directly. Returning a promise has quite an impact on the shutdown sequence!

20 > */

21 > export interface BeforeShutdownEvent {

22 >

23 > /**

24 > * The reason why the application will be shutting down.

25 > */

26 > readonly reason: ShutdownReason;

27 >

28 > /**

29 > * Allows to veto the shutdown. The veto can be a long running operation but it

30 > * will block the application from closing.

31 > *

32 > * @param id to identify the veto operation in case it takes very long or never

33 > * completes.

34 > */

35 > veto(value: boolean | Promise<boolean>, id: string): void;

36 > }

37 >

38 > export interface InternalBeforeShutdownEvent extends BeforeShutdownEvent {

39 >

40 > /**

41 > * Allows to set a veto operation to run after all other

42 > * vetos have been handled from the `BeforeShutdownEvent`

43 > *

44 > * This method is hidden from the API because it is intended

45 > * to be only used once internally.

46 > */

47 > finalVeto(vetoFn: () => boolean | Promise<boolean>, id: string): void;

48 > }

49 >

50 > /**

51 > * An event that signals an error happened during `onBeforeShutdown` veto handling.

52 > * In this case the shutdown operation will not proceed because this is an unexpected

53 > * condition that is treated like a veto.

54 > */

55 > export interface BeforeShutdownErrorEvent {

56 >

57 > /**

58 > * The reason why the application is shutting down.

59 > */

60 > readonly reason: ShutdownReason;

61 >

62 > /**

63 > * The error that happened during shutdown handling.

64 > */

65 > readonly error: Error;

66 > }

67 >

68 > export enum WillShutdownJoinerOrder {

69 >

70 > /**

71 > * Joiners to run before the `Last` joiners. This is the default order and best for

72 > * most cases. You can be sure that services are still functional at this point.

73 > */

74 > Default = 1,

75 >

76 > /**

77 > * The joiners to run last. This should ONLY be used in rare cases when you have no

78 > * dependencies to workbench services or state. The workbench may be in a state where

79 > * resources can no longer be accessed or changed.

80 > */

81 > Last

82 > }

83 >

84 > export interface IWillShutdownEventJoiner {

85 > readonly id: string;

86 > readonly label: string;

87 > readonly order?: WillShutdownJoinerOrder;

88 > }

89 >

90 > export interface IWillShutdownEventDefaultJoiner extends IWillShutdownEventJoiner {

91 > readonly order?: WillShutdownJoinerOrder.Default;

92 > }

93 >

94 > export interface IWillShutdownEventLastJoiner extends IWillShutdownEventJoiner {

95 > readonly order: WillShutdownJoinerOrder.Last;

96 > }

97 >

98 > /**

99 > * An event that is send out when the window closes. Clients have a chance to join the closing

100 > * by providing a promise from the join method. Returning a promise is useful in cases of long

101 > * running operations on shutdown.

102 > *

103 > * Note: It is absolutely important to avoid long running promises if possible. Please try hard

104 > * to return a boolean directly. Returning a promise has quite an impact on the shutdown sequence!

105 > */

106 > export interface WillShutdownEvent {

107 >

108 > /**

109 > * The reason why the application is shutting down.

110 > */

111 > readonly reason: ShutdownReason;

112 >

113 > /**

114 > * A token that will signal cancellation when the

115 > * shutdown was forced by the user.

116 > */

117 > readonly token: CancellationToken;

118 >

119 > /**

120 > * Allows to join the shutdown. The promise can be a long running operation but it

121 > * will block the application from closing.

122 > *

123 > * @param promise the promise to join the shutdown event.

124 > * @param joiner to identify the join operation in case it takes very long or never

125 > * completes.

126 > */

127 > join(promise: Promise<void>, joiner: IWillShutdownEventDefaultJoiner): void;

128 >

129 > /**

130 > * Allows to join the shutdown at the end. The promise can be a long running operation but it

131 > * will block the application from closing.

132 > *

133 > * @param promiseFn the promise to join the shutdown event.

134 > * @param joiner to identify the join operation in case it takes very long or never

135 > * completes.

136 > */

137 > join(promiseFn: (() => Promise<void>), joiner: IWillShutdownEventLastJoiner): void;

138 >

139 > /**

140 > * Allows to access the joiners that have not finished joining this event.

141 > */

142 > joiners(): IWillShutdownEventJoiner[];

143 >

144 > /**

145 > * Allows to enforce the shutdown, even when there are

146 > * pending `join` operations to complete.

147 > */

148 > force(): void;

149 > }

150 >

151 > export const enum ShutdownReason {

152 >

153 > /**

154 > * The window is closed.

155 > */

156 > CLOSE = 1,

157 >

158 > /**

159 > * The window closes because the application quits.

160 > */

161 > QUIT,

162 >

163 > /**

164 > * The window is reloaded.

165 > */

166 > RELOAD,

167 >

168 > /**

169 > * The window is loaded into a different workspace context.

170 > */

171 > LOAD

172 > }

173 >

174 > export const enum StartupKind {

175 > NewWindow = 1,

176 > ReloadedWindow = 3,

177 > ReopenedWindow = 4

178 > }

179 >

180 > export function StartupKindToString(startupKind: StartupKind): string {

181 switch (startupKind) {

182 case StartupKind.NewWindow: return 'NewWindow';

185 }

186 }

187 > lifecycle.ts

188 > export const enum LifecyclePhase {

189 >

190 > /**

191 > * The first phase signals that we are about to startup getting ready.

192 > *

193 > * Note: doing work in this phase blocks an editor from showing to

194 > * the user, so please rather consider to use `Restored` phase.

195 > */

196 > Starting = 1,

197 >

198 > /**

199 > * Services are ready and the window is about to restore its UI state.

200 > *

201 > * Note: doing work in this phase blocks an editor from showing to

202 > * the user, so please rather consider to use `Restored` phase.

203 > */

204 > Ready = 2,

205 >

206 > /**

207 > * Views, panels and editors have restored. Editors are given a bit of

208 > * time to restore their contents.

209 > */

210 > Restored = 3,

211 >

212 > /**

213 > * The last phase after views, panels and editors have restored and

214 > * some time has passed (2-5 seconds).

215 > */

216 > Eventually = 4

217 > }

218 >

219 > export function LifecyclePhaseToString(phase: LifecyclePhase): string {

220 switch (phase) {

221 case LifecyclePhase.Starting: return 'Starting';

225 }

226 }

227 > lifecycle.ts

228 > /**

229 > * A lifecycle service informs about lifecycle events of the

230 > * application, such as shutdown.

231 > */

232 > export interface ILifecycleService {

233 >

234 > readonly _serviceBrand: undefined;

235 >

236 > /**

237 > * Value indicates how this window got loaded.

238 > */

239 > readonly startupKind: StartupKind;

240 >

241 > /**

242 > * A flag indicating in what phase of the lifecycle we currently are.

243 > */

244 > phase: LifecyclePhase;

245 >

246 > /**

247 > * Fired before shutdown happens. Allows listeners to veto against the

248 > * shutdown to prevent it from happening.

249 > *

250 > * The event carries a shutdown reason that indicates how the shutdown was triggered.

251 > */

252 > readonly onBeforeShutdown: Event<BeforeShutdownEvent>;

253 >

254 > /**

255 > * Fired when the shutdown was prevented by a component giving veto.

256 > */

257 > readonly onShutdownVeto: Event<void>;

258 >

259 > /**

260 > * Fired when an error happened during `onBeforeShutdown` veto handling.

261 > * In this case the shutdown operation will not proceed because this is

262 > * an unexpected condition that is treated like a veto.

263 > *

264 > * The event carries a shutdown reason that indicates how the shutdown was triggered.

265 > */

266 > readonly onBeforeShutdownError: Event<BeforeShutdownErrorEvent>;

267 >

268 > /**

269 > * Fired when no client is preventing the shutdown from happening (from `onBeforeShutdown`).

270 > *

271 > * This event can be joined with a long running operation via `WillShutdownEvent#join()` to

272 > * handle long running shutdown operations.

273 > *

274 > * The event carries a shutdown reason that indicates how the shutdown was triggered.

275 > */

276 > readonly onWillShutdown: Event<WillShutdownEvent>;

277 >

278 > /**

279 > * A flag indicating that we are about to shutdown without further veto.

280 > */

281 > readonly willShutdown: boolean;

282 >

283 > /**

284 > * Fired when the shutdown is about to happen after long running shutdown operations

285 > * have finished (from `onWillShutdown`).

286 > *

287 > * This event should be used to dispose resources.

288 > */

289 > readonly onDidShutdown: Event<void>;

290 >

291 > /**

292 > * Returns a promise that resolves when a certain lifecycle phase

293 > * has started.

294 > */

295 > when(phase: LifecyclePhase): Promise<void>;

296 >

297 > /**

298 > * Triggers a shutdown of the workbench. Depending on native or web, this can have

299 > * different implementations and behaviour.

300 > *

301 > * **Note:** this should normally not be called. See related methods in `IHostService`

302 > * and `INativeHostService` to close a window or quit the application.

303 > */

304 > shutdown(): Promise<void>;

305 > }

src/vs/platform/request/common/request.ts 277 covered LOC · 15 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- request.ts

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 { streamToBuffer } from '../../../base/common/buffer.js';

7 > import { CancellationToken } from '../../../base/common/cancellation.js';

8 > import { getErrorMessage } from '../../../base/common/errors.js';

9 > import { Emitter, Event } from '../../../base/common/event.js';

10 > import { Disposable } from '../../../base/common/lifecycle.js';

11 > import { IHeaders, IRequestContext, IRequestOptions } from '../../../base/parts/request/common/request.js';

12 > import { localize } from '../../../nls.js';

13 > import { ConfigurationScope, Extensions, IConfigurationNode, IConfigurationRegistry } from '../../configuration/common/configurationRegistry.js';

14 > import { createDecorator } from '../../instantiation/common/instantiation.js';

15 > import { ILogService } from '../../log/common/log.js';

16 > import { Registry } from '../../registry/common/platform.js';

17 >

18 > export const IRequestService = createDecorator<IRequestService>('requestService');

19 >

20 > /**

21 > * Use as the {@link IRequestOptions.callSite} value to prevent

22 > * request telemetry from being emitted. This is needed for

23 > * callers such as the telemetry sender to avoid cyclical calls.

24 > */

25 > export const NO_FETCH_TELEMETRY = 'NO_FETCH_TELEMETRY';

26 >

27 > export interface IRequestCompleteEvent {

28 > readonly callSite: string;

29 > readonly latency: number;

30 > readonly statusCode: number | undefined;

31 > }

32 >

33 > export interface AuthInfo {

34 > isProxy: boolean;

35 > scheme: string;

36 > host: string;

37 > port: number;

38 > realm: string;

39 > attempt: number;

40 > }

41 >

42 > export interface Credentials {

43 > username: string;

44 > password: string;

45 > }

46 >

47 > export interface IRequestService {

48 > readonly _serviceBrand: undefined;

49 >

50 > /**

51 > * Fires when a request completes (successfully or with an error response).

52 > */

53 > readonly onDidCompleteRequest: Event<IRequestCompleteEvent>;

54 >

55 > request(options: IRequestOptions, token: CancellationToken): Promise<IRequestContext>;

56 >

57 > resolveProxy(url: string): Promise<string | undefined>;

58 > lookupAuthorization(authInfo: AuthInfo): Promise<Credentials | undefined>;

59 > lookupKerberosAuthorization(url: string): Promise<string | undefined>;

60 > loadCertificates(): Promise<string[]>;

61 > }

62 >

63 > class LoggableHeaders {

64 >

65 > private headers: IHeaders | undefined;

66 >

67 > constructor(private readonly original: IHeaders) { }

68 >

69 > toJSON(): any {

70 if (!this.headers) {

71 const headers = Object.create(null);

81 return this.headers;

82 }

83 > request.ts

84 > }

85 >

86 > export abstract class AbstractRequestService extends Disposable implements IRequestService {

87 >

88 > declare readonly _serviceBrand: undefined;

89 >

90 > private counter = 0;

91 >

92 > private readonly _onDidCompleteRequest = this._register(new Emitter<IRequestCompleteEvent>());

93 > readonly onDidCompleteRequest = this._onDidCompleteRequest.event;

94 >

95 > constructor(protected readonly logService: ILogService) {

96 super();

97 }

98 > request.ts

99 > protected async logAndRequest(options: IRequestOptions, request: () => Promise<IRequestContext>): Promise<IRequestContext> {

100 const prefix = `#${++this.counter}: ${options.url}`;

101 this.logService.trace(`${prefix} - begin`, options.type, new LoggableHeaders(options.headers ?? {}));

115 }

116 }

117 > request.ts

118 > abstract request(options: IRequestOptions, token: CancellationToken): Promise<IRequestContext>;

119 > abstract resolveProxy(url: string): Promise<string | undefined>;

120 > abstract lookupAuthorization(authInfo: AuthInfo): Promise<Credentials | undefined>;

121 > abstract lookupKerberosAuthorization(url: string): Promise<string | undefined>;

122 > abstract loadCertificates(): Promise<string[]>;

123 > }

124 >

125 > export function isSuccess(context: IRequestContext): boolean {

126 return (context.res.statusCode && context.res.statusCode >= 200 && context.res.statusCode < 300) || context.res.statusCode === 1223;

127 }

128 > request.ts

129 > export function isClientError(context: IRequestContext): boolean {

130 return !!context.res.statusCode && context.res.statusCode >= 400 && context.res.statusCode < 500;

131 }

132 > request.ts

133 > export function isServerError(context: IRequestContext): boolean {

134 return !!context.res.statusCode && context.res.statusCode >= 500 && context.res.statusCode < 600;

135 }

136 > request.ts

137 > /**

138 > * Reads a header value from an {@link IHeaders} map, tolerating array-shaped

139 > * values and case-insensitive lookups.

140 > */

141 > export function readHeader(headers: IHeaders | undefined, name: string): string | undefined {

142 if (!headers) {

143 return undefined;

149 return value;

150 }

151 > request.ts

152 > /**

153 > * Parses the `Retry-After` header as a number of seconds. Returns `undefined`

154 > * if absent or not a finite positive number. The HTTP-date form is not parsed.

155 > */

156 > export function retryAfterFromHeaders(headers: IHeaders | undefined): number | undefined {

157 const value = readHeader(headers, 'retry-after');

158 if (!value) {

162 return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;

163 }

164 > request.ts

165 > export function hasNoContent(context: IRequestContext): boolean {

166 return context.res.statusCode === 204;

167 }

168 > request.ts

169 export async function asText(context: IRequestContext): Promise<string | null> {

170 if (hasNoContent(context)) {

174 return buffer.toString();

175 }

176 > request.ts

177 export async function asTextOrError(context: IRequestContext): Promise<string | null> {

178 if (!isSuccess(context)) {

181 return asText(context);

182 }

183 > request.ts

184 export async function asJson<T = {}>(context: IRequestContext): Promise<T | null> {

185 if (!isSuccess(context)) {

198 }

199 }

200 > request.ts

201 > export function updateProxyConfigurationsScope(useHostProxy: boolean, useHostProxyDefault: boolean): void {

202 registerProxyConfigurations(useHostProxy, useHostProxyDefault);

203 }

204 > request.ts

205 > export const USER_LOCAL_AND_REMOTE_SETTINGS = [

206 > 'http.proxy',

207 > 'http.proxyStrictSSL',

208 > 'http.proxyKerberosServicePrincipal',

209 > 'http.noProxy',

210 > 'http.proxyAuthorization',

211 > 'http.proxySupport',

212 > 'http.systemCertificates',

213 > 'http.systemCertificatesNode',

214 > 'http.experimental.systemCertificatesV2',

215 > 'http.fetchAdditionalSupport',

216 > 'http.experimental.networkInterfaceCheckInterval',

217 > ];

218 >

219 > export const systemCertificatesNodeDefault = false;

220 >

221 > let proxyConfiguration: IConfigurationNode[] = [];

222 > let previousUseHostProxy: boolean | undefined = undefined;

223 > let previousUseHostProxyDefault: boolean | undefined = undefined;

224 > function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault = true): void {

225 > if (previousUseHostProxy === useHostProxy && previousUseHostProxyDefault === useHostProxyDefault) {

226 return;

227 }

228 > request.ts

229 > previousUseHostProxy = useHostProxy;

230 > previousUseHostProxyDefault = useHostProxyDefault;

231 >

232 > const configurationRegistry = Registry.as<IConfigurationRegistry>(Extensions.Configuration);

233 > const oldProxyConfiguration = proxyConfiguration;

234 > proxyConfiguration = [

235 > {

236 > id: 'http',

237 > order: 15,

238 > title: localize('httpConfigurationTitle', "HTTP"),

239 > type: 'object',

240 > scope: ConfigurationScope.MACHINE,

241 > properties: {

242 > 'http.useLocalProxyConfiguration': {

243 > type: 'boolean',

244 > default: useHostProxyDefault,

245 > markdownDescription: localize('useLocalProxy', "Controls whether in the remote extension host the local proxy configuration should be used. This setting only applies as a remote setting during [remote development](https://aka.ms/vscode-remote)."),

246 > restricted: true

247 > },

248 > }

249 > },

250 > {

251 > id: 'http',

252 > order: 15,

253 > title: localize('httpConfigurationTitle', "HTTP"),

254 > type: 'object',

255 > scope: ConfigurationScope.APPLICATION,

256 > properties: {

257 > 'http.electronFetch': {

258 > type: 'boolean',

259 > default: false,

260 > description: localize('electronFetch', "Controls whether use of Electron's fetch implementation instead of Node.js' should be enabled. All local extensions will get Electron's fetch implementation for the global fetch API."),

261 > restricted: true

262 > },

263 > }

264 > },

265 > {

266 > id: 'http',

267 > order: 15,

268 > title: localize('httpConfigurationTitle', "HTTP"),

269 > type: 'object',

270 > scope: useHostProxy ? ConfigurationScope.APPLICATION : ConfigurationScope.MACHINE,

271 > properties: {

272 > 'http.proxy': {

273 > type: 'string',

274 > pattern: '^(https?|socks|socks4a?|socks5h?)://([^:]*(:[^@]*)?@)?([^:]+|\\[[:0-9a-fA-F]+\\])(:\\d+)?/?$|^$',

275 > markdownDescription: localize('proxy', "The proxy setting to use. If not set, will be inherited from the `http_proxy` and `https_proxy` environment variables. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

276 > restricted: true

277 > },

278 > 'http.proxyStrictSSL': {

279 > type: 'boolean',

280 > default: true,

281 > markdownDescription: localize('strictSSL', "Controls whether the proxy server certificate should be verified against the list of supplied CAs. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

282 > restricted: true

283 > },

284 > 'http.proxyKerberosServicePrincipal': {

285 > type: 'string',

286 > markdownDescription: localize('proxyKerberosServicePrincipal', "Overrides the principal service name for Kerberos authentication with the HTTP proxy. A default based on the proxy hostname is used when this is not set. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

287 > restricted: true

288 > },

289 > 'http.noProxy': {

290 > type: 'array',

291 > items: { type: 'string' },

292 > markdownDescription: localize('noProxy', "Specifies domain names for which proxy settings should be ignored for HTTP/HTTPS requests. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

293 > restricted: true

294 > },

295 > 'http.proxyAuthorization': {

296 > type: ['null', 'string'],

297 > default: null,

298 > markdownDescription: localize('proxyAuthorization', "The value to send as the `Proxy-Authorization` header for every network request. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

299 > restricted: true

300 > },

301 > 'http.proxySupport': {

302 > type: 'string',

303 > enum: ['off', 'on', 'fallback', 'override'],

304 > enumDescriptions: [

305 > localize('proxySupportOff', "Disable proxy support for extensions."),

306 > localize('proxySupportOn', "Enable proxy support for extensions."),

307 > localize('proxySupportFallback', "Enable proxy support for extensions, fall back to request options, when no proxy found."),

308 > localize('proxySupportOverride', "Enable proxy support for extensions, override request options."),

309 > ],

310 > default: 'override',

311 > markdownDescription: localize('proxySupport', "Use the proxy support for extensions. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

312 > restricted: true

313 > },

314 > 'http.systemCertificates': {

315 > type: 'boolean',

316 > default: true,

317 > markdownDescription: localize('systemCertificates', "Controls whether CA certificates should be loaded from the OS. On Windows and macOS, a reload of the window is required after turning this off. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

318 > restricted: true

319 > },

320 > 'http.systemCertificatesNode': {

321 > type: 'boolean',

322 > tags: ['experimental'],

323 > default: systemCertificatesNodeDefault,

324 > markdownDescription: localize('systemCertificatesNode', "Controls whether system certificates should be loaded using Node.js built-in support. Reload the window after changing this setting. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

325 > restricted: true,

326 > experiment: {

327 > mode: 'auto'

328 > }

329 > },

330 > 'http.experimental.systemCertificatesV2': {

331 > type: 'boolean',

332 > tags: ['experimental'],

333 > default: false,

334 > markdownDescription: localize('systemCertificatesV2', "Controls whether experimental loading of CA certificates from the OS should be enabled. This uses a more general approach than the default implementation. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

335 > restricted: true

336 > },

337 > 'http.fetchAdditionalSupport': {

338 > type: 'boolean',

339 > default: true,

340 > markdownDescription: localize('fetchAdditionalSupport', "Controls whether Node.js' fetch implementation should be extended with additional support. Currently proxy support ({1}) and system certificates ({2}) are added when the corresponding settings are enabled. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`', '`#http.proxySupport#`', '`#http.systemCertificates#`'),

341 > restricted: true

342 > },

343 > 'http.webSocketAdditionalSupport': {

344 > type: 'boolean',

345 > default: true,

346 > markdownDescription: localize('webSocketAdditionalSupport', "Controls whether the built-in WebSocket implementation should be extended with additional support. Currently proxy support ({1}) and system certificates ({2}) are added when the corresponding settings are enabled. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`', '`#http.proxySupport#`', '`#http.systemCertificates#`'),

347 > restricted: true

348 > },

349 > 'http.experimental.networkInterfaceCheckInterval': {

350 > type: 'number',

351 > default: 300,

352 > minimum: -1,

353 > tags: ['experimental'],

354 > markdownDescription: localize('networkInterfaceCheckInterval', "Controls the interval in seconds for checking network interface changes to invalidate the proxy cache. Set to -1 to disable. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.", '`#http.useLocalProxyConfiguration#`'),

355 > restricted: true,

356 > experiment: {

357 > mode: 'auto'

358 > }

359 > }

360 > }

361 > }

362 > ];

363 > configurationRegistry.updateConfigurations({ add: proxyConfiguration, remove: oldProxyConfiguration });

364 > }

365 >

366 > registerProxyConfigurations();

src/vs/workbench/contrib/chat/common/tools/builtinTools/askQuestionsTool.ts 258 covered LOC · 21 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- askQuestionsTool.ts

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 { CancellationToken } from '../../../../../../base/common/cancellation.js';

7 > import { CancellationError } from '../../../../../../base/common/errors.js';

8 > import { MarkdownString } from '../../../../../../base/common/htmlContent.js';

9 > import { IJSONSchema, IJSONSchemaMap } from '../../../../../../base/common/jsonSchema.js';

10 > import { Disposable } from '../../../../../../base/common/lifecycle.js';

11 > import { hasKey } from '../../../../../../base/common/types.js';

12 > import { generateUuid } from '../../../../../../base/common/uuid.js';

13 > import { localize } from '../../../../../../nls.js';

14 > import { IChatQuestion, IChatQuestionAnswers, IChatQuestionAnswerValue, IChatMultiSelectAnswer, IChatService, IChatSingleSelectAnswer, IChatToolInvocation } from '../../chatService/chatService.js';

15 > import { ChatQuestionCarouselData } from '../../model/chatProgressTypes/chatQuestionCarouselData.js';

16 > import { IChatRequestModel } from '../../model/chatModel.js';

17 > import { ChatConfiguration, ChatPermissionLevel } from '../../constants.js';

18 > import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';

19 > import { StopWatch } from '../../../../../../base/common/stopwatch.js';

20 > import { ILogService } from '../../../../../../platform/log/common/log.js';

21 > import { ITelemetryService } from '../../../../../../platform/telemetry/common/telemetry.js';

22 > import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolDataSource, ToolProgress } from '../languageModelToolsService.js';

23 > import { ThemeIcon } from '../../../../../../base/common/themables.js';

24 > import { Codicon } from '../../../../../../base/common/codicons.js';

25 > import { raceCancellation } from '../../../../../../base/common/async.js';

26 > import { URI } from '../../../../../../base/common/uri.js';

27 > import { TerminalToolId } from '../terminalToolIds.js';

28 >

29 > /**

30 > * Response returned to the model when the user is not available (autopilot mode).

31 > */

32 > export const AUTOPILOT_ASK_USER_RESPONSE =

33 > 'The user is not available to respond and will review your work later. Work autonomously and make good decisions.';

34 >

35 > // Use a distinct id to avoid clashing with extension-provided tools

36 > export const AskQuestionsToolId = 'vscode_askQuestions';

37 >

38 > // Soft limits are used in the schema to guide the model

39 > // Hard limits are more lenient and used to truncate if the model overshoots

40 > //

41 > // Example text at each limit:

42 > // - header soft (50 chars): "Which database engine do you want to use for this?"

43 > // - header hard (75 chars): "Which database engine and connection pooling strategy do you want to use here?"

44 > // - question soft (200 chars): "What testing framework would you like to use for this project? Consider factors like your team's familiarity, community support, and integration with your existing CI/CD pipeline when making a choice."

45 > const SoftLimits = {

46 > header: 50,

47 > question: 200

48 > } as const;

49 >

50 > const HardLimits = {

51 > header: 75,

52 > } as const;

53 >

54 function truncateToLimit(value: string | undefined, limit: number): string | undefined {

55 if (value === undefined) {

61 return value;

62 }

63 > askQuestionsTool.ts

64 > export interface IQuestionOption {

65 > readonly label: string;

66 > readonly description?: string;

67 > readonly recommended?: boolean;

68 > }

69 >

70 > export interface IQuestion {

71 > readonly header: string;

72 > readonly question: string;

73 > readonly message?: string;

74 > readonly multiSelect?: boolean;

75 > readonly options?: IQuestionOption[];

76 > readonly allowFreeformInput?: boolean;

77 > }

78 >

79 > export interface IAskQuestionsParams {

80 > readonly questions: IQuestion[];

81 > }

82 >

83 > export interface IQuestionAnswer {

84 > readonly selected: string[];

85 > readonly freeText: string | null;

86 > readonly skipped: boolean;

87 > }

88 >

89 > export interface IAnswerResult {

90 > readonly answers: Record<string, IQuestionAnswer>;

91 > }

92 >

93 > export function createAskQuestionsToolData(): IToolData {

94 > const questionSchema: IJSONSchema & { properties: IJSONSchemaMap } = {

95 > type: 'object',

96 > properties: {

97 > header: {

98 > type: 'string',

99 > description: `Short identifier for the question. Must be unique so answers can be mapped back to the question. Maximum ${SoftLimits.header} characters.`,

100 > maxLength: SoftLimits.header

101 > },

102 > question: {

103 > type: 'string',

104 > description: `The question text to display to the user. Keep it concise, ideally one sentence. Maximum ${SoftLimits.question} characters.`,

105 > maxLength: SoftLimits.question

106 > },

107 > multiSelect: {

108 > type: 'boolean',

109 > description: 'Allow selecting multiple options when options are provided.'

110 > },

111 > allowFreeformInput: {

112 > type: 'boolean',

113 > description: 'Allow freeform text answers in addition to option selection. Defaults to true; set to false to restrict to predefined options only.'

114 > },

115 > message: {

116 > type: 'string',

117 > description: 'Optional markdown message to display below the question text, providing additional context or details.'

118 > },

119 > options: {

120 > type: 'array',

121 > description: 'Optional list of selectable answers. If omitted, the question is free text.',

122 > items: {

123 > type: 'object',

124 > properties: {

125 > label: {

126 > type: 'string',

127 > description: 'Display label and value for the option.'

128 > },

129 > description: {

130 > type: 'string',

131 > description: 'Optional secondary text shown with the option.'

132 > },

133 > recommended: {

134 > type: 'boolean',

135 > description: 'Mark this option as the recommended default.'

136 > }

137 > },

138 > required: ['label']

139 > }

140 > }

141 > },

142 > required: ['header', 'question']

143 > };

144 >

145 > const inputSchema: IJSONSchema & { properties: IJSONSchemaMap } = {

146 > type: 'object',

147 > properties: {

148 > questions: {

149 > type: 'array',

150 > description: 'List of questions to ask the user. Order is preserved.',

151 > items: questionSchema,

152 > minItems: 1

153 > }

154 > },

155 > required: ['questions']

156 > };

157 >

158 > return {

159 > id: AskQuestionsToolId,

160 > toolReferenceName: 'askQuestions',

161 > legacyToolReferenceFullNames: [AskQuestionsToolId, 'vscode/askQuestions'],

162 > canBeReferencedInPrompt: false,

163 > icon: ThemeIcon.fromId(Codicon.question.id),

164 > displayName: localize('tool.askQuestions.displayName', 'Ask Clarifying Questions'),

165 > userDescription: localize('tool.askQuestions.userDescription', 'Ask structured clarifying questions using single select, multi-select, or freeform inputs to collect task requirements before proceeding.'),

166 > modelDescription: 'Use this tool to ask the user a small number of clarifying questions before proceeding. Provide the questions array with concise headers and prompts. Use options for fixed choices, set multiSelect when multiple selections are allowed. Users can always provide a freeform text answer alongside options unless you set allowFreeformInput to false.',

167 > source: ToolDataSource.Internal,

168 > inputSchema

169 > };

170 > }

171 >

172 > export const AskQuestionsToolData: IToolData = createAskQuestionsToolData();

173 >

174 > export class AskQuestionsTool extends Disposable implements IToolImpl {

175 >

176 > constructor(

177 > @IChatService private readonly chatService: IChatService,

178 > @ITelemetryService private readonly telemetryService: ITelemetryService,

179 > @ILogService private readonly logService: ILogService,

180 > @IConfigurationService private readonly configService: IConfigurationService,

181 > ) {

182 > super();

183 > }

184 >

185 > async invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult> {

186 const stopWatch = StopWatch.create(true);

187 const parameters = invocation.parameters as IAskQuestionsParams;

272 };

273 }

274 > askQuestionsTool.ts

275 > async prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined> {

276 > const parameters = context.parameters as IAskQuestionsParams; askQuestionsTool.ts

277 > const { questions } = parameters;

278 >

279 > if (!questions || questions.length === 0) {

280 throw new Error(localize('askQuestionsTool.noQuestions', 'No questions provided. The questions array must contain at least one question.'));

281 }

282 > askQuestionsTool.ts

283 > for (const question of questions) {

284 > if (question.options && question.options.length === 1 && !question.allowFreeformInput) {

285 throw new Error(localize('askQuestionsTool.invalidOptions', 'Question "{0}" must have at least two options, or set allowFreeformInput when providing a single option, or omit options for free text input.', question.header));

286 }

287 > } askQuestionsTool.ts

288 > askQuestionsTool.ts

289 > const questionCount = questions.length;

290 > const headers = questions.map(q => q.header).join(', ');

291 > const message = questionCount === 1

292 > ? localize('askQuestionsTool.invocation.single', 'Asking a question ({0})', headers)

293 : localize('askQuestionsTool.invocation.multiple', 'Asking {0} questions ({1})', questionCount, headers);

294 > const pastMessage = questionCount === 1 askQuestionsTool.ts

295 > ? localize('askQuestionsTool.invocation.single.past', 'Asked a question ({0})', headers) askQuestionsTool.ts

296 : localize('askQuestionsTool.invocation.multiple.past', 'Asked {0} questions ({1})', questionCount, headers);

297 > askQuestionsTool.ts

298 > return {

299 > invocationMessage: new MarkdownString(message),

300 > pastTenseMessage: new MarkdownString(pastMessage)

301 > };

302 > }

303 > askQuestionsTool.ts

304 > private getRequest(chatSessionResource: URI | undefined, chatRequestId: string | undefined): { request: IChatRequestModel | undefined; sessionResource: URI | undefined } {

305 if (!chatSessionResource) {

306 return { request: undefined, sessionResource: undefined };

326 return { request, sessionResource: chatSessionResource };

327 }

328 > askQuestionsTool.ts

329 > /**

330 > * Resolves the terminal execution ID for the request.

331 > * Prefer structured metadata and fall back to legacy message parsing for

332 > * old sessions that may not carry the metadata yet.

333 > * As a final fallback, search completed runInTerminal tool invocations in

334 > * the response for the terminal ID, but only when the tool output indicates

335 > * the terminal is still running and waiting for input (foreground/timeout

336 > * path where the model calls ask_questions from the same turn as

337 > * runInTerminal).

338 > */

339 > private extractTerminalId(request: IChatRequestModel): string | undefined {

340 if (request.terminalExecutionId) {

341 return request.terminalExecutionId;

375 return undefined;

376 }

377 > askQuestionsTool.ts

378 > private toQuestionCarousel(questions: IQuestion[], resolveId?: string): { carousel: ChatQuestionCarouselData; idToHeaderMap: Map<string, string> } {

379 const idToHeaderMap = new Map<string, string>();

380 const carouselResolveId = resolveId ?? generateUuid();

385 };

386 }

387 > askQuestionsTool.ts

388 > private toChatQuestion(question: IQuestion, idToHeaderMap: Map<string, string>, resolveId: string, index: number): IChatQuestion {

389 let type: IChatQuestion['type'];

390 if (!question.options || question.options.length === 0) {

427 };

428 }

429 > askQuestionsTool.ts

430 > protected convertCarouselAnswers(questions: IQuestion[], carouselAnswers: IChatQuestionAnswers | undefined, idToHeaderMap: Map<string, string>): IAnswerResult {

431 const result: IAnswerResult = { answers: {} };

432

531 return result;

532 }

533 > askQuestionsTool.ts

534 > private collectMetrics(questions: IQuestion[], result: IAnswerResult): { answeredCount: number; skippedCount: number; freeTextCount: number; recommendedAvailableCount: number; recommendedSelectedCount: number } {

535 const answers = Object.values(result.answers);

536 const answeredCount = answers.filter(a => !a.skipped).length;

545 return { answeredCount, skippedCount, freeTextCount, recommendedAvailableCount, recommendedSelectedCount };

546 }

547 > askQuestionsTool.ts

548 > private createSkippedResult(questions: IQuestion[]): IToolResult {

549 const skippedAnswers: Record<string, IQuestionAnswer> = {};

550 for (const question of questions) {

555 };

556 }

557 > askQuestionsTool.ts

558 > private createAutopilotResult(questions: IQuestion[]): IToolResult {

559 const answers: Record<string, IQuestionAnswer> = {};

560 for (const question of questions) {

572 };

573 }

574 > askQuestionsTool.ts

575 > /**

576 > * Build carousel answer data keyed by carousel question IDs for rendering

577 > * the completed summary in the UI during autopilot mode.

578 > */

579 > private buildAutopilotCarouselAnswers(questions: IQuestion[], carousel: ChatQuestionCarouselData, idToHeaderMap: Map<string, string>): IChatQuestionAnswers {

580 const data: IChatQuestionAnswers = {};

581 // Build reverse map: original header -> internal carousel question ID

609 return data;

610 }

611 > askQuestionsTool.ts

612 > private sendTelemetry(requestId: string | undefined, questionCount: number, answeredCount: number, skippedCount: number, freeTextCount: number, recommendedAvailableCount: number, recommendedSelectedCount: number, duration: number): void {

613 this.telemetryService.publicLog2<AskQuestionsToolInvokedEvent, AskQuestionsToolInvokedClassification>('askQuestionsToolInvoked', {

614 requestId,

622 });

623 }

624 > } askQuestionsTool.ts

625 >

626 > type AskQuestionsToolInvokedEvent = {

627 > requestId: string | undefined;

628 > questionCount: number;

629 > answeredCount: number;

630 > skippedCount: number;

631 > freeTextCount: number;

632 > recommendedAvailableCount: number;

633 > recommendedSelectedCount: number;

634 > duration: number;

635 > };

636 >

637 > type AskQuestionsToolInvokedClassification = {

638 > requestId: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The id of the current request turn.' };

639 > questionCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The total number of questions asked' };

640 > answeredCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The number of questions that were answered' };

641 > skippedCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The number of questions that were skipped' };

642 > freeTextCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The number of questions answered with free text input' };

643 > recommendedAvailableCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The number of questions that had a recommended option' };

644 > recommendedSelectedCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The number of questions where the user selected the recommended option' };

645 > duration: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'The total time in milliseconds to complete all questions' };

646 > owner: 'digitarald';

647 > comment: 'Tracks usage of the AskQuestions tool for agent clarifications';

648 > };

src/vs/platform/userDataProfile/common/userDataProfile.ts 256 covered LOC · 28 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- userDataProfile.ts

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 { hash } from '../../../base/common/hash.js';

7 > import { Emitter, Event } from '../../../base/common/event.js';

8 > import { Disposable } from '../../../base/common/lifecycle.js';

9 > import { basename, joinPath } from '../../../base/common/resources.js';

10 > import { URI, UriDto } from '../../../base/common/uri.js';

11 > import { localize } from '../../../nls.js';

12 > import { IEnvironmentService } from '../../environment/common/environment.js';

13 > import { FileOperationResult, IFileService, toFileOperationResult } from '../../files/common/files.js';

14 > import { createDecorator } from '../../instantiation/common/instantiation.js';

15 > import { ILogService } from '../../log/common/log.js';

16 > import { IAnyWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from '../../workspace/common/workspace.js';

17 > import { IStringDictionary } from '../../../base/common/collections.js';

18 > import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.js';

19 > import { Promises } from '../../../base/common/async.js';

20 > import { generateUuid } from '../../../base/common/uuid.js';

21 > import { escapeRegExpCharacters } from '../../../base/common/strings.js';

22 > import { isString, Mutable } from '../../../base/common/types.js';

23 >

24 > export const AGENTS_WINDOW_PROFILE_ID = 'agents';

25 >

26 > const AGENTS_WINDOW_PROFILE_FLAGS: UseDefaultProfileFlags = {

27 > settings: true,

28 > keybindings: true,

29 > prompts: true,

30 > mcp: true,

31 > languageModels: true,

32 > snippets: true,

33 > tasks: true,

34 > extensions: true,

35 > };

36 >

37 > export const enum ProfileResourceType {

38 > Settings = 'settings',

39 > Keybindings = 'keybindings',

40 > Snippets = 'snippets',

41 > Prompts = 'prompts',

42 > Tasks = 'tasks',

43 > Extensions = 'extensions',

44 > GlobalState = 'globalState',

45 > Mcp = 'mcp',

46 > LanguageModels = 'languageModels',

47 > }

48 >

49 > /**

50 > * Flags to indicate whether to use the default profile or not.

51 > */

52 > export type UseDefaultProfileFlags = { [key in ProfileResourceType]?: boolean };

53 > export type ProfileResourceTypeFlags = UseDefaultProfileFlags;

54 > export type SettingValue = string | boolean | number | undefined | null | object;

55 > export type ISettingsDictionary = Record<string, SettingValue>;

56 >

57 > export interface IUserDataProfile {

58 > readonly id: string;

59 > readonly isDefault: boolean;

60 > readonly name: string;

61 > readonly icon?: string;

62 > readonly location: URI;

63 > readonly globalStorageHome: URI;

64 > readonly settingsResource: URI;

65 > readonly keybindingsResource: URI;

66 > readonly tasksResource: URI;

67 > readonly snippetsHome: URI;

68 > readonly promptsHome: URI;

69 > readonly extensionsResource: URI;

70 > readonly mcpResource: URI;

71 > readonly languageModelsResource: URI;

72 > readonly agentPluginsHome: URI;

73 > readonly cacheHome: URI;

74 > readonly useDefaultFlags?: UseDefaultProfileFlags;

75 > readonly isInternal?: boolean;

76 > readonly isTransient?: boolean;

77 > readonly isAgentsWindowProfile?: boolean;

78 > readonly workspaces?: readonly URI[];

79 > }

80 >

81 > export function isUserDataProfile(thing: unknown): thing is IUserDataProfile {

82 const candidate = thing as IUserDataProfile | undefined;

83

99 );

100 }

101 > userDataProfile.ts

102 > export interface IParsedUserDataProfileTemplate {

103 > readonly name: string;

104 > readonly icon?: string;

105 > readonly settings?: ISettingsDictionary;

106 > readonly globalState?: IStringDictionary<string>;

107 > }

108 >

109 > export interface ISystemProfileTemplate extends IParsedUserDataProfileTemplate {

110 > readonly id: string;

111 > }

112 >

113 > export type DidChangeProfilesEvent = { readonly added: readonly IUserDataProfile[]; readonly removed: readonly IUserDataProfile[]; readonly updated: readonly IUserDataProfile[]; readonly all: readonly IUserDataProfile[] };

114 >

115 > export type WillCreateProfileEvent = {

116 > profile: IUserDataProfile;

117 > join(promise: Promise<void>): void;

118 > };

119 >

120 > export type WillRemoveProfileEvent = {

121 > profile: IUserDataProfile;

122 > join(promise: Promise<void>): void;

123 > };

124 >

125 > export interface IUserDataProfileOptions {

126 > readonly icon?: string;

127 > readonly useDefaultFlags?: UseDefaultProfileFlags;

128 > readonly transient?: boolean;

129 > readonly workspaces?: readonly URI[];

130 > }

131 >

132 > export interface IUserDataProfileUpdateOptions extends Omit<IUserDataProfileOptions, 'icon'> {

133 > readonly name?: string;

134 > readonly icon?: string | null;

135 > }

136 >

137 > export const IUserDataProfilesService = createDecorator<IUserDataProfilesService>('IUserDataProfilesService');

138 > export interface IUserDataProfilesService {

139 > readonly _serviceBrand: undefined;

140 >

141 > readonly profilesHome: URI;

142 > readonly defaultProfile: IUserDataProfile;

143 >

144 > readonly onDidChangeProfiles: Event<DidChangeProfilesEvent>;

145 > readonly profiles: readonly IUserDataProfile[];

146 >

147 > readonly onDidResetWorkspaces: Event<void>;

148 >

149 > createNamedProfile(name: string, options?: IUserDataProfileOptions, workspaceIdentifier?: IAnyWorkspaceIdentifier): Promise<IUserDataProfile>;

150 > createTransientProfile(workspaceIdentifier?: IAnyWorkspaceIdentifier): Promise<IUserDataProfile>;

151 > createProfile(id: string, name: string, options?: IUserDataProfileOptions, workspaceIdentifier?: IAnyWorkspaceIdentifier): Promise<IUserDataProfile>;

152 > updateProfile(profile: IUserDataProfile, options?: IUserDataProfileUpdateOptions,): Promise<IUserDataProfile>;

153 > removeProfile(profile: IUserDataProfile): Promise<void>;

154 >

155 > setProfileForWorkspace(workspaceIdentifier: IAnyWorkspaceIdentifier, profile: IUserDataProfile): Promise<void>;

156 > resetWorkspaces(): Promise<void>;

157 >

158 > cleanUp(): Promise<void>;

159 > cleanUpTransientProfiles(): Promise<void>;

160 > }

161 >

162 > export function reviveProfile(profile: UriDto<IUserDataProfile>, scheme: string): IUserDataProfile {

163 return {

164 id: profile.id,

185 };

186 }

187 > userDataProfile.ts

188 > export function toUserDataProfile(id: string, name: string, location: URI, profilesCacheHome: URI, options?: IUserDataProfileOptions, defaultProfile?: IUserDataProfile): IUserDataProfile {

189 const isAgentsWindowProfile = id === AGENTS_WINDOW_PROFILE_ID;

190 return {

212 };

213 }

214 > userDataProfile.ts

215 > export type UserDataProfilesObject = {

216 > profiles: IUserDataProfile[];

217 > emptyWindows: Map<string, IUserDataProfile>;

218 > };

219 >

220 > export type StoredUserDataProfile = {

221 > name: string;

222 > location: URI;

223 > icon?: string;

224 > useDefaultFlags?: UseDefaultProfileFlags;

225 > };

226 >

227 > export type StoredProfileAssociations = {

228 > workspaces?: IStringDictionary<string>;

229 > emptyWindows?: IStringDictionary<string>;

230 > };

231 >

232 > const SYSTEM_PROFILES_HOME = 'builtin';

233 >

234 > export class UserDataProfilesService extends Disposable implements IUserDataProfilesService {

235 >

236 > readonly _serviceBrand: undefined;

237 >

238 > protected static readonly PROFILES_KEY = 'userDataProfiles';

239 > protected static readonly PROFILE_ASSOCIATIONS_KEY = 'profileAssociations';

240 >

241 > readonly profilesHome: URI;

242 > private readonly profilesCacheHome: URI;

243 >

244 > get defaultProfile(): IUserDataProfile { return this.profiles[0]; }

245 > get profiles(): IUserDataProfile[] { return [...this.profilesObject.profiles, ...this.transientProfilesObject.profiles]; }

246 >

247 > protected readonly _onDidChangeProfiles = this._register(new Emitter<DidChangeProfilesEvent>());

248 > readonly onDidChangeProfiles = this._onDidChangeProfiles.event;

249 >

250 > protected readonly _onWillCreateProfile = this._register(new Emitter<WillCreateProfileEvent>());

251 > readonly onWillCreateProfile = this._onWillCreateProfile.event;

252 >

253 > protected readonly _onWillRemoveProfile = this._register(new Emitter<WillRemoveProfileEvent>());

254 > readonly onWillRemoveProfile = this._onWillRemoveProfile.event;

255 >

256 > private readonly _onDidResetWorkspaces = this._register(new Emitter<void>());

257 > readonly onDidResetWorkspaces = this._onDidResetWorkspaces.event;

258 >

259 > private profileCreationPromises = new Map<string, Promise<IUserDataProfile>>();

260 >

261 > protected readonly transientProfilesObject: UserDataProfilesObject = {

262 > profiles: [],

263 > emptyWindows: new Map()

264 > };

265 >

266 > constructor(

267 @IEnvironmentService protected environmentService: IEnvironmentService,

268 @IFileService protected fileService: IFileService,

274 this.profilesCacheHome = joinPath(this.environmentService.cacheHome, 'CachedProfilesData');

275 }

276 > userDataProfile.ts

277 > init(): void {

278 this._profilesObject = undefined;

279 }

280 > userDataProfile.ts

281 > protected _profilesObject: UserDataProfilesObject | undefined;

282 > protected get profilesObject(): UserDataProfilesObject {

283 if (!this._profilesObject) {

284 const defaultProfile = this.createDefaultProfile();

336 return this._profilesObject;

337 }

338 > userDataProfile.ts

339 > private isInvalidProfile(storedProfile: StoredUserDataProfile): boolean {

340 if (!storedProfile.name) {

341 return true;

349 return false;

350 }

351 > userDataProfile.ts

352 > protected createDefaultProfile() {

353 const defaultProfile = toUserDataProfile('__default__profile__', localize('defaultProfile', "Default"), this.environmentService.userRoamingDataHome, this.profilesCacheHome);

354 return { ...defaultProfile, extensionsResource: this.getDefaultProfileExtensionsLocation() ?? defaultProfile.extensionsResource, isDefault: true };

355 }

356 > userDataProfile.ts

357 > async createTransientProfile(workspaceIdentifier?: IAnyWorkspaceIdentifier): Promise<IUserDataProfile> {

358 const namePrefix = `Temp`;

359 const nameRegEx = new RegExp(`${escapeRegExpCharacters(namePrefix)}\\s(\\d+)`);

367 return this.createProfile(hash(generateUuid()).toString(16), name, { transient: true }, workspaceIdentifier);

368 }

369 > userDataProfile.ts

370 > async createNamedProfile(name: string, options?: IUserDataProfileOptions, workspaceIdentifier?: IAnyWorkspaceIdentifier): Promise<IUserDataProfile> {

371 return this.createProfile(hash(generateUuid()).toString(16), name, options, workspaceIdentifier);

372 }

373 > userDataProfile.ts

374 > async createProfile(id: string, name: string, options?: IUserDataProfileOptions, workspaceIdentifier?: IAnyWorkspaceIdentifier): Promise<IUserDataProfile> {

375 const profile = await this.doCreateProfile(id, name, options, workspaceIdentifier);

376

377 return profile;

378 }

379 > userDataProfile.ts

380 > private async doCreateProfile(id: string, name: string, options?: IUserDataProfileOptions, workspaceIdentifier?: IAnyWorkspaceIdentifier): Promise<IUserDataProfile> {

381 if (!isString(name) || !name) {

382 throw new Error('Name of the profile is mandatory and must be of type `string`');

428 return profileCreationPromise;

429 }

430 > userDataProfile.ts

431 > async updateProfile(profile: IUserDataProfile, options: IUserDataProfileUpdateOptions): Promise<IUserDataProfile> {

432 if (profile.isAgentsWindowProfile) {

433 throw new Error('Cannot update agents window profile');

481 return updatedProfile;

482 }

483 > userDataProfile.ts

484 > async removeProfile(profileToRemove: IUserDataProfile): Promise<void> {

485 if (profileToRemove.isDefault) {

486 throw new Error('Cannot remove default profile');

515 }

516 }

517 > userDataProfile.ts

518 > async setProfileForWorkspace(workspaceIdentifier: IAnyWorkspaceIdentifier, profileToSet: IUserDataProfile): Promise<void> {

519 const profile = this.profiles.find(p => p.id === profileToSet.id);

520 if (!profile) {

534 }

535 }

536 > userDataProfile.ts

537 > unsetWorkspace(workspaceIdentifier: IAnyWorkspaceIdentifier, transient: boolean = false): void {

538 const workspace = this.getWorkspace(workspaceIdentifier);

539 if (URI.isUri(workspace)) {

547 }

548 }

549 > userDataProfile.ts

550 > async resetWorkspaces(): Promise<void> {

551 this.transientProfilesObject.emptyWindows.clear();

552 this.profilesObject.emptyWindows.clear();

557 this._onDidResetWorkspaces.fire();

558 }

559 > userDataProfile.ts

560 > async cleanUp(): Promise<void> {

561 try {

562 if (await this.fileService.exists(this.profilesHome)) {

587 }

588 }

589 > userDataProfile.ts

590 > async cleanUpTransientProfiles(): Promise<void> {

591 const unAssociatedTransientProfiles = this.transientProfilesObject.profiles.filter(p => !this.isProfileAssociatedToWorkspace(p));

592 await Promise.allSettled(unAssociatedTransientProfiles.map(p => this.removeProfile(p)));

593 }

594 > userDataProfile.ts

595 > getProfileForWorkspace(workspaceIdentifier: IAnyWorkspaceIdentifier): IUserDataProfile | undefined {

596 const workspace = this.getWorkspace(workspaceIdentifier);

597

604 : (this.profilesObject.emptyWindows.get(workspace) ?? this.transientProfilesObject.emptyWindows.get(workspace));

605 }

606 > userDataProfile.ts

607 > protected getWorkspace(workspaceIdentifier: IAnyWorkspaceIdentifier): URI | string {

608 if (isSingleFolderWorkspaceIdentifier(workspaceIdentifier)) {

609 return workspaceIdentifier.uri;

614 return workspaceIdentifier.id;

615 }

616 > userDataProfile.ts

617 > private isProfileAssociatedToWorkspace(profile: IUserDataProfile): boolean {

618 if (profile.workspaces?.length) {

619 return true;

627 return false;

628 }

629 > userDataProfile.ts

630 > private updateProfiles(added: IUserDataProfile[], removed: IUserDataProfile[], updated: IUserDataProfile[], donotTrigger: boolean = false): void {

631 const allProfiles: Mutable<IUserDataProfile>[] = [...this.profiles, ...added];

632

679 }

680 }

681 > userDataProfile.ts

682 > protected triggerProfilesChanges(added: IUserDataProfile[], removed: IUserDataProfile[], updated: IUserDataProfile[]) {

683 this._onDidChangeProfiles.fire({ added, removed, updated, all: this.profiles });

684 }

685 > userDataProfile.ts

686 > private updateEmptyWindowAssociation(windowId: string, newProfile: IUserDataProfile | undefined, transient: boolean): void {

687 // Force transient if the new profile to associate is transient

688 transient = newProfile?.isTransient ? true : transient;

706 }

707 }

708 > userDataProfile.ts

709 > private updateStoredProfiles(profiles: IUserDataProfile[]): void {

710 const storedProfiles: StoredUserDataProfile[] = [];

711 const workspaces: IStringDictionary<string> = {};

739 this._profilesObject = undefined;

740 }

741 > userDataProfile.ts

742 > protected getStoredProfiles(): StoredUserDataProfile[] { return []; }

743 > protected saveStoredProfiles(storedProfiles: StoredUserDataProfile[]): void { throw new Error('not implemented'); }

744 >

745 > protected getStoredProfileAssociations(): StoredProfileAssociations { return {}; }

746 > protected saveStoredProfileAssociations(storedProfileAssociations: StoredProfileAssociations): void { throw new Error('not implemented'); }

747 > protected getDefaultProfileExtensionsLocation(): URI | undefined { return undefined; }

748 > }

749 >

750 > export class InMemoryUserDataProfilesService extends UserDataProfilesService {

751 private storedProfiles: StoredUserDataProfile[] = [];

752 protected override getStoredProfiles(): StoredUserDataProfile[] { return this.storedProfiles; }

754

755 private storedProfileAssociations: StoredProfileAssociations = {};

756 > protected override getStoredProfileAssociations(): StoredProfileAssociations { return this.storedProfileAssociations; } userDataProfile.ts

757 > protected override saveStoredProfileAssociations(storedProfileAssociations: StoredProfileAssociations): void { this.storedProfileAssociations = storedProfileAssociations; }

758 > }

src/vs/base/common/resources.ts 253 covered LOC · 23 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- resources.ts

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 { CharCode } from './charCode.js';

7 > import * as extpath from './extpath.js';

8 > import { Schemas } from './network.js';

9 > import * as paths from './path.js';

10 > import { isLinux, isWindows } from './platform.js';

11 > import { compare as strCompare, equalsIgnoreCase } from './strings.js';

12 > import { URI, uriToFsPath } from './uri.js';

13 >

14 > export function originalFSPath(uri: URI): string {

15 return uriToFsPath(uri, true);

16 }

17 > resources.ts

18 > //#region IExtUri

19 >

20 > export interface IExtUri {

21 >

22 > // --- identity

23 >

24 > /**

25 > * Compares two uris.

26 > *

27 > * @param uri1 Uri

28 > * @param uri2 Uri

29 > * @param ignoreFragment Ignore the fragment (defaults to `false`)

30 > */

31 > compare(uri1: URI, uri2: URI, ignoreFragment?: boolean): number;

32 >

33 > /**

34 > * Tests whether two uris are equal

35 > *

36 > * @param uri1 Uri

37 > * @param uri2 Uri

38 > * @param ignoreFragment Ignore the fragment (defaults to `false`)

39 > */

40 > isEqual(uri1: URI | undefined, uri2: URI | undefined, ignoreFragment?: boolean): boolean;

41 >

42 > /**

43 > * Tests whether a `candidate` URI is a parent or equal of a given `base` URI.

44 > *

45 > * @param base A uri which is "longer" or at least same length as `parentCandidate`

46 > * @param parentCandidate A uri which is "shorter" or up to same length as `base`

47 > * @param ignoreFragment Ignore the fragment (defaults to `false`)

48 > */

49 > isEqualOrParent(base: URI, parentCandidate: URI, ignoreFragment?: boolean): boolean;

50 >

51 > /**

52 > * Creates a key from a resource URI to be used to resource comparison and for resource maps.

53 > * @see {@link ResourceMap}

54 > * @param uri Uri

55 > * @param ignoreFragment Ignore the fragment (defaults to `false`)

56 > */

57 > getComparisonKey(uri: URI, ignoreFragment?: boolean): string;

58 >

59 > /**

60 > * Whether the casing of the path-component of the uri should be ignored.

61 > */

62 > ignorePathCasing(uri: URI): boolean;

63 >

64 > // --- path math

65 >

66 > basenameOrAuthority(resource: URI): string;

67 >

68 > /**

69 > * Returns the basename of the path component of an uri.

70 > * @param resource

71 > */

72 > basename(resource: URI): string;

73 >

74 > /**

75 > * Returns the extension of the path component of an uri.

76 > * @param resource

77 > */

78 > extname(resource: URI): string;

79 > /**

80 > * Return a URI representing the directory of a URI path.

81 > *

82 > * @param resource The input URI.

83 > * @returns The URI representing the directory of the input URI.

84 > */

85 > dirname(resource: URI): URI;

86 > /**

87 > * Join a URI path with path fragments and normalizes the resulting path.

88 > *

89 > * @param resource The input URI.

90 > * @param pathFragment The path fragment to add to the URI path.

91 > * @returns The resulting URI.

92 > */

93 > joinPath(resource: URI, ...pathFragment: string[]): URI;

94 > /**

95 > * Normalizes the path part of a URI: Resolves `.` and `..` elements with directory names.

96 > *

97 > * @param resource The URI to normalize the path.

98 > * @returns The URI with the normalized path.

99 > */

100 > normalizePath(resource: URI): URI;

101 > /**

102 > *

103 > * @param from

104 > * @param to

105 > */

106 > relativePath(from: URI, to: URI): string | undefined;

107 > /**

108 > * Resolves an absolute or relative path against a base URI.

109 > * The path can be relative or absolute posix or a Windows path

110 > */

111 > resolvePath(base: URI, path: string): URI;

112 >

113 > // --- misc

114 >

115 > /**

116 > * Returns true if the URI path is absolute.

117 > */

118 > isAbsolutePath(resource: URI): boolean;

119 > /**

120 > * Tests whether the two authorities are the same

121 > */

122 > isEqualAuthority(a1: string, a2: string): boolean;

123 > /**

124 > * Returns true if the URI path has a trailing path separator

125 > */

126 > hasTrailingPathSeparator(resource: URI, sep?: string): boolean;

127 > /**

128 > * Removes a trailing path separator, if there's one.

129 > * Important: Doesn't remove the first slash, it would make the URI invalid

130 > */

131 > removeTrailingPathSeparator(resource: URI, sep?: string): URI;

132 > /**

133 > * Adds a trailing path separator to the URI if there isn't one already.

134 > * For example, c:\ would be unchanged, but c:\users would become c:\users\

135 > */

136 > addTrailingPathSeparator(resource: URI, sep?: string): URI;

137 > }

138 >

139 > export class ExtUri implements IExtUri {

140 >

141 > constructor(private _ignorePathCasing: (uri: URI) => boolean) { }

142 >

143 > compare(uri1: URI, uri2: URI, ignoreFragment: boolean = false): number {

144 if (uri1 === uri2) {

145 return 0;

147 return strCompare(this.getComparisonKey(uri1, ignoreFragment), this.getComparisonKey(uri2, ignoreFragment));

148 }

149 > resources.ts

150 > isEqual(uri1: URI | undefined, uri2: URI | undefined, ignoreFragment: boolean = false): boolean {

151 if (uri1 === uri2) {

152 return true;

157 return this.getComparisonKey(uri1, ignoreFragment) === this.getComparisonKey(uri2, ignoreFragment);

158 }

159 > resources.ts

160 > getComparisonKey(uri: URI, ignoreFragment: boolean = false): string {

161 return uri.with({

162 path: this._ignorePathCasing(uri) ? uri.path.toLowerCase() : undefined,

164 }).toString();

165 }

166 > resources.ts

167 > ignorePathCasing(uri: URI): boolean {

168 return this._ignorePathCasing(uri);

169 }

170 > resources.ts

171 > isEqualOrParent(base: URI, parentCandidate: URI, ignoreFragment: boolean = false): boolean {

172 if (base.scheme === parentCandidate.scheme) {

173 if (base.scheme === Schemas.file) {

180 return false;

181 }

182 > resources.ts

183 > // --- path math

184 >

185 > joinPath(resource: URI, ...pathFragment: string[]): URI {

186 return URI.joinPath(resource, ...pathFragment);

187 }

188 > resources.ts

189 > basenameOrAuthority(resource: URI): string {

190 return basename(resource) || resource.authority;

191 }

192 > resources.ts

193 > basename(resource: URI, suffix?: string): string {

194 return paths.posix.basename(resource.path, suffix);

195 }

196 > resources.ts

197 > extname(resource: URI): string {

198 return paths.posix.extname(resource.path);

199 }

200 > resources.ts

201 > dirname(resource: URI): URI {

202 if (resource.path.length === 0) {

203 return resource;

217 });

218 }

219 > resources.ts

220 > normalizePath(resource: URI): URI {

221 if (!resource.path.length) {

222 return resource;

232 });

233 }

234 > resources.ts

235 > relativePath(from: URI, to: URI): string | undefined {

236 if (from.scheme !== to.scheme || !isEqualAuthority(from.authority, to.authority)) {

237 return undefined;

257 return paths.posix.relative(fromPath, toPath);

258 }

259 > resources.ts

260 > resolvePath(base: URI, path: string): URI {

261 if (base.scheme === Schemas.file) {

262 const newURI = URI.file(paths.resolve(originalFSPath(base), path));

271 });

272 }

273 > resources.ts

274 > // --- misc

275 >

276 > isAbsolutePath(resource: URI): boolean {

277 return !!resource.path && resource.path[0] === '/';

278 }

279 > resources.ts

280 > isEqualAuthority(a1: string | undefined, a2: string | undefined) {

281 return a1 === a2 || (a1 !== undefined && a2 !== undefined && equalsIgnoreCase(a1, a2));

282 }

283 > resources.ts

284 > hasTrailingPathSeparator(resource: URI, sep: string = paths.sep): boolean {

285 if (resource.scheme === Schemas.file) {

286 const fsp = originalFSPath(resource);

291 }

292 }

293 > resources.ts

294 > removeTrailingPathSeparator(resource: URI, sep: string = paths.sep): URI {

295 // Make sure that the path isn't a drive letter. A trailing separator there is not removable.

296 if (hasTrailingPathSeparator(resource, sep)) {

299 return resource;

300 }

301 > resources.ts

302 > addTrailingPathSeparator(resource: URI, sep: string = paths.sep): URI {

303 let isRootSep: boolean = false;

304 if (resource.scheme === Schemas.file) {

315 return resource;

316 }

317 > } resources.ts

318 >

319 >

320 > /**

321 > * Unbiased utility that takes uris "as they are". This means it can be interchanged with

322 > * uri#toString() usages. The following is true

323 > * ```

324 > * assertEqual(aUri.toString() === bUri.toString(), exturi.isEqual(aUri, bUri))

325 > * ```

326 > */

327 > export const extUri = new ExtUri(() => false);

328 >

329 > /**

330 > * BIASED utility that _mostly_ ignored the case of urs paths. ONLY use this util if you

331 > * understand what you are doing.

332 > *

333 > * This utility is INCOMPATIBLE with `uri.toString()`-usages and both CANNOT be used interchanged.

334 > *

335 > * When dealing with uris from files or documents, `extUri` (the unbiased friend)is sufficient

336 > * because those uris come from a "trustworthy source". When creating unknown uris it's always

337 > * better to use `IUriIdentityService` which exposes an `IExtUri`-instance which knows when path

338 > * casing matters.

339 > */

340 > export const extUriBiasedIgnorePathCase = new ExtUri(uri => {

341 // A file scheme resource is in the same platform as code, so ignore case for non linux platforms

342 // Resource can be from another platform. Lowering the case as an hack. Should come from File system provider

343 return uri.scheme === Schemas.file ? !isLinux : true;

344 });

345 > resources.ts

346 >

347 > /**

348 > * BIASED utility that always ignores the casing of uris paths. ONLY use this util if you

349 > * understand what you are doing.

350 > *

351 > * This utility is INCOMPATIBLE with `uri.toString()`-usages and both CANNOT be used interchanged.

352 > *

353 > * When dealing with uris from files or documents, `extUri` (the unbiased friend)is sufficient

354 > * because those uris come from a "trustworthy source". When creating unknown uris it's always

355 > * better to use `IUriIdentityService` which exposes an `IExtUri`-instance which knows when path

356 > * casing matters.

357 > */

358 > export const extUriIgnorePathCase = new ExtUri(_ => true);

359 >

360 > export const isEqual = extUri.isEqual.bind(extUri);

361 > export const isEqualOrParent = extUri.isEqualOrParent.bind(extUri);

362 > export const getComparisonKey = extUri.getComparisonKey.bind(extUri);

363 > export const basenameOrAuthority = extUri.basenameOrAuthority.bind(extUri);

364 > export const basename = extUri.basename.bind(extUri);

365 > export const extname = extUri.extname.bind(extUri);

366 > export const dirname = extUri.dirname.bind(extUri);

367 > export const joinPath = extUri.joinPath.bind(extUri);

368 > export const normalizePath = extUri.normalizePath.bind(extUri);

369 > export const relativePath = extUri.relativePath.bind(extUri);

370 > export const resolvePath = extUri.resolvePath.bind(extUri);

371 > export const isAbsolutePath = extUri.isAbsolutePath.bind(extUri);

372 > export const isEqualAuthority = extUri.isEqualAuthority.bind(extUri);

373 > export const hasTrailingPathSeparator = extUri.hasTrailingPathSeparator.bind(extUri);

374 > export const removeTrailingPathSeparator = extUri.removeTrailingPathSeparator.bind(extUri);

375 > export const addTrailingPathSeparator = extUri.addTrailingPathSeparator.bind(extUri);

376 >

377 > //#endregion

378 >

379 > export function distinctParents<T>(items: T[], resourceAccessor: (item: T) => URI): T[] {

380 const distinctParents: T[] = [];

381 for (let i = 0; i < items.length; i++) {

396 return distinctParents;

397 }

398 > resources.ts

399 > /**

400 > * Data URI related helpers.

401 > */

402 > export namespace DataUri {

403 >

404 > export const META_DATA_LABEL = 'label';

405 > export const META_DATA_DESCRIPTION = 'description';

406 > export const META_DATA_SIZE = 'size';

407 > export const META_DATA_MIME = 'mime';

408 >

409 > export function parseMetaData(dataUri: URI): Map<string, string> {

410 const metadata = new Map<string, string>();

411

429 return metadata;

430 }

431 > } resources.ts

432 >

433 > export function toLocalResource(resource: URI, authority: string | undefined, localScheme: string): URI {

434 if (authority) {

435 let path = resource.path;

src/vs/workbench/common/contextkeys.ts 250 covered LOC · 10 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- contextkeys.ts

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 { DisposableStore } from '../../base/common/lifecycle.js';

7 > import { URI } from '../../base/common/uri.js';

8 > import { localize } from '../../nls.js';

9 > import { IContextKeyService, IContextKey, RawContextKey } from '../../platform/contextkey/common/contextkey.js';

10 > import { basename, dirname, extname, isEqual } from '../../base/common/resources.js';

11 > import { ILanguageService } from '../../editor/common/languages/language.js';

12 > import { IFileService } from '../../platform/files/common/files.js';

13 > import { IModelService } from '../../editor/common/services/model.js';

14 > import { Schemas } from '../../base/common/network.js';

15 > import { EditorInput } from './editor/editorInput.js';

16 > import { IEditorResolverService } from '../services/editor/common/editorResolverService.js';

17 > import { DEFAULT_EDITOR_ASSOCIATION, isDiffEditorInput } from './editor.js';

18 >

19 > //#region < --- Workbench --- >

20 >

21 > export const WorkbenchStateContext = new RawContextKey<string>('workbenchState', undefined, { type: 'string', description: localize('workbenchState', "The kind of workspace opened in the window, either 'empty' (no workspace), 'folder' (single folder) or 'workspace' (multi-root workspace)") });

22 > export const WorkspaceFolderCountContext = new RawContextKey<number>('workspaceFolderCount', 0, localize('workspaceFolderCount', "The number of root folders in the workspace"));

23 >

24 > export const OpenFolderWorkspaceSupportContext = new RawContextKey<boolean>('openFolderWorkspaceSupport', true, true);

25 > export const EnterMultiRootWorkspaceSupportContext = new RawContextKey<boolean>('enterMultiRootWorkspaceSupport', true, true);

26 > export const EmptyWorkspaceSupportContext = new RawContextKey<boolean>('emptyWorkspaceSupport', true, true);

27 >

28 > export const DirtyWorkingCopiesContext = new RawContextKey<boolean>('dirtyWorkingCopies', false, localize('dirtyWorkingCopies', "Whether there are any working copies with unsaved changes"));

29 >

30 > export const RemoteNameContext = new RawContextKey<string>('remoteName', '', localize('remoteName', "The name of the remote the window is connected to or an empty string if not connected to any remote"));

31 >

32 > export const VirtualWorkspaceContext = new RawContextKey<string>('virtualWorkspace', '', localize('virtualWorkspace', "The scheme of the current workspace is from a virtual file system or an empty string."));

33 > export const TemporaryWorkspaceContext = new RawContextKey<boolean>('temporaryWorkspace', false, localize('temporaryWorkspace', "The scheme of the current workspace is from a temporary file system."));

34 >

35 > export const IsSessionsWindowContext = new RawContextKey<boolean>('isSessionsWindow', false, localize('isSessionsWindow', "Whether the current window is a agent sessions window."));

36 >

37 > export const HasWebFileSystemAccess = new RawContextKey<boolean>('hasWebFileSystemAccess', false, true); // Support for FileSystemAccess web APIs (https://wicg.github.io/file-system-access)

38 >

39 > export const EmbedderIdentifierContext = new RawContextKey<string | undefined>('embedderIdentifier', undefined, localize('embedderIdentifier', 'The identifier of the embedder according to the product service, if one is defined'));

40 >

41 > export const InAutomationContext = new RawContextKey<boolean>('inAutomation', false, localize('inAutomation', "Whether VS Code is running under automation/smoke test"));

42 >

43 > //#endregion

44 >

45 > //#region < --- Window --- >

46 >

47 > export const IsMainWindowFullscreenContext = new RawContextKey<boolean>('isFullscreen', false, localize('isFullscreen', "Whether the main window is in fullscreen mode"));

48 > export const IsAuxiliaryWindowFocusedContext = new RawContextKey<boolean>('isAuxiliaryWindowFocusedContext', false, localize('isAuxiliaryWindowFocusedContext', "Whether an auxiliary window is focused"));

49 >

50 > export const IsWindowAlwaysOnTopContext = new RawContextKey<boolean>('isWindowAlwaysOnTop', false, localize('isWindowAlwaysOnTop', "Whether the window is always on top"));

51 >

52 > export const IsAuxiliaryWindowContext = new RawContextKey<boolean>('isAuxiliaryWindow', false, localize('isAuxiliaryWindow', "Window is an auxiliary window"));

53 >

54 >

55 > //#endregion

56 >

57 >

58 > //#region < --- Editor --- >

59 >

60 > // Editor State Context Keys

61 > export const ActiveEditorDirtyContext = new RawContextKey<boolean>('activeEditorIsDirty', false, localize('activeEditorIsDirty', "Whether the active editor has unsaved changes"));

62 > export const ActiveEditorPinnedContext = new RawContextKey<boolean>('activeEditorIsNotPreview', false, localize('activeEditorIsNotPreview', "Whether the active editor is not in preview mode"));

63 > export const ActiveEditorFirstInGroupContext = new RawContextKey<boolean>('activeEditorIsFirstInGroup', false, localize('activeEditorIsFirstInGroup', "Whether the active editor is the first one in its group"));

64 > export const ActiveEditorLastInGroupContext = new RawContextKey<boolean>('activeEditorIsLastInGroup', false, localize('activeEditorIsLastInGroup', "Whether the active editor is the last one in its group"));

65 > export const ActiveEditorStickyContext = new RawContextKey<boolean>('activeEditorIsPinned', false, localize('activeEditorIsPinned', "Whether the active editor is pinned"));

66 > export const ActiveEditorReadonlyContext = new RawContextKey<boolean>('activeEditorIsReadonly', false, localize('activeEditorIsReadonly', "Whether the active editor is read-only"));

67 > export const ActiveCompareEditorCanSwapContext = new RawContextKey<boolean>('activeCompareEditorCanSwap', false, localize('activeCompareEditorCanSwap', "Whether the active compare editor can swap sides"));

68 > export const ActiveEditorCanToggleReadonlyContext = new RawContextKey<boolean>('activeEditorCanToggleReadonly', true, localize('activeEditorCanToggleReadonly', "Whether the active editor can toggle between being read-only or writeable"));

69 > export const ActiveEditorCanRevertContext = new RawContextKey<boolean>('activeEditorCanRevert', false, localize('activeEditorCanRevert', "Whether the active editor can revert"));

70 > export const ActiveEditorCanSplitInGroupContext = new RawContextKey<boolean>('activeEditorCanSplitInGroup', true);

71 >

72 > // Editor Kind Context Keys

73 > export const ActiveEditorContext = new RawContextKey<string | null>('activeEditor', null, { type: 'string', description: localize('activeEditor', "The identifier of the active editor") });

74 > export const ActiveEditorAvailableEditorIdsContext = new RawContextKey<string>('activeEditorAvailableEditorIds', '', localize('activeEditorAvailableEditorIds', "The available editor identifiers that are usable for the active editor"));

75 > export const TextCompareEditorVisibleContext = new RawContextKey<boolean>('textCompareEditorVisible', false, localize('textCompareEditorVisible', "Whether a text compare editor is visible"));

76 > export const TextCompareEditorActiveContext = new RawContextKey<boolean>('textCompareEditorActive', false, localize('textCompareEditorActive', "Whether a text compare editor is active"));

77 > export const SideBySideEditorActiveContext = new RawContextKey<boolean>('sideBySideEditorActive', false, localize('sideBySideEditorActive', "Whether a side by side editor is active"));

78 > export const ActiveCustomEditorDiffCanToggleLayoutContext = new RawContextKey<boolean>('activeCustomEditorDiffCanToggleLayout', false, localize('activeCustomEditorDiffCanToggleLayout', "Whether the active custom editor diff can toggle between inline and side by side layout"));

79 > export const ActiveCustomEditorTextDiffContext = new RawContextKey<boolean>('activeCustomEditorTextDiff', false, localize('activeCustomEditorTextDiff', "Whether the active custom editor diff is backed by text documents"));

80 >

81 > // Editor Group Context Keys

82 > export const EditorGroupEditorsCountContext = new RawContextKey<number>('groupEditorsCount', 0, localize('groupEditorsCount', "The number of opened editor groups"));

83 > export const IsTopRightEditorGroupContext = new RawContextKey<boolean>('isTopRightEditorGroup', false, localize('isTopRightEditorGroup', "Whether the editor group is the top right editor group in the editor part"));

84 > export const ActiveEditorGroupEmptyContext = new RawContextKey<boolean>('activeEditorGroupEmpty', false, localize('activeEditorGroupEmpty', "Whether the active editor group is empty"));

85 > export const ActiveEditorGroupIndexContext = new RawContextKey<number>('activeEditorGroupIndex', 0, localize('activeEditorGroupIndex', "The index of the active editor group"));

86 > export const ActiveEditorGroupLastContext = new RawContextKey<boolean>('activeEditorGroupLast', false, localize('activeEditorGroupLast', "Whether the active editor group is the last group"));

87 > export const ActiveEditorGroupLockedContext = new RawContextKey<boolean>('activeEditorGroupLocked', false, localize('activeEditorGroupLocked', "Whether the active editor group is locked"));

88 > export const MultipleEditorGroupsContext = new RawContextKey<boolean>('multipleEditorGroups', false, localize('multipleEditorGroups', "Whether there are multiple editor groups opened"));

89 > export const SingleEditorGroupsContext = MultipleEditorGroupsContext.toNegated();

90 > export const MultipleEditorsSelectedInGroupContext = new RawContextKey<boolean>('multipleEditorsSelectedInGroup', false, localize('multipleEditorsSelectedInGroup', "Whether multiple editors have been selected in an editor group"));

91 > export const TwoEditorsSelectedInGroupContext = new RawContextKey<boolean>('twoEditorsSelectedInGroup', false, localize('twoEditorsSelectedInGroup', "Whether exactly two editors have been selected in an editor group"));

92 > export const SelectedEditorsInGroupFileOrUntitledResourceContextKey = new RawContextKey<boolean>('SelectedEditorsInGroupFileOrUntitledResourceContextKey', true, localize('SelectedEditorsInGroupFileOrUntitledResourceContextKey', "Whether all selected editors in a group have a file or untitled resource associated"));

93 >

94 > // Editor Part Context Keys

95 > export const EditorPartMultipleEditorGroupsContext = new RawContextKey<boolean>('editorPartMultipleEditorGroups', false, localize('editorPartMultipleEditorGroups', "Whether there are multiple editor groups opened in an editor part"));

96 > export const EditorPartSingleEditorGroupsContext = EditorPartMultipleEditorGroupsContext.toNegated();

97 > export const EditorPartMaximizedEditorGroupContext = new RawContextKey<boolean>('editorPartMaximizedEditorGroup', false, localize('editorPartEditorGroupMaximized', "Editor Part has a maximized group"));

98 >

99 > export const EditorPartModalContext = new RawContextKey<boolean>('editorPartModal', false, localize('editorPartModal', "Whether focus is in a modal editor part"));

100 > export const EditorPartModalVisibleContext = new RawContextKey<boolean>('editorPartModalVisible', false, localize('editorPartModalVisible', "Whether a modal editor part is visible"));

101 > export const EditorPartModalMaximizedContext = new RawContextKey<boolean>('editorPartModalMaximized', false, localize('editorPartModalMaximized', "Whether the modal editor part is maximized"));

102 > export const EditorPartModalNavigationContext = new RawContextKey<boolean>('editorPartModalNavigation', false, localize('editorPartModalNavigation', "Whether the modal editor part has navigation context"));

103 > export const EditorPartModalSidebarContext = new RawContextKey<boolean>('editorPartModalSidebar', false, localize('editorPartModalSidebar', "Whether the modal editor part has a sidebar"));

104 > export const EditorPartModalSidebarVisibleContext = new RawContextKey<boolean>('editorPartModalSidebarVisible', false, localize('editorPartModalSidebarVisible', "Whether the modal editor part sidebar is visible"));

105 >

106 > // Editor Layout Context Keys

107 > export const EditorsVisibleContext = new RawContextKey<boolean>('editorIsOpen', false, localize('editorIsOpen', "Whether an editor is open"));

108 > export const EditorAreaFocusContext = new RawContextKey<boolean>('editorAreaFocus', false, localize('editorAreaFocus', "Whether the editor area (any editor part) has keyboard focus"));

109 > export const InEditorZenModeContext = new RawContextKey<boolean>('inZenMode', false, localize('inZenMode', "Whether Zen mode is enabled"));

110 > export const IsMainEditorCenteredLayoutContext = new RawContextKey<boolean>('isCenteredLayout', false, localize('isMainEditorCenteredLayout', "Whether centered layout is enabled for the main editor"));

111 > export const SplitEditorsVertically = new RawContextKey<boolean>('splitEditorsVertically', false, localize('splitEditorsVertically', "Whether editors split vertically"));

112 > export const MainEditorAreaVisibleContext = new RawContextKey<boolean>('mainEditorAreaVisible', true, localize('mainEditorAreaVisible', "Whether the editor area in the main window is visible"));

113 > export const EditorTabsVisibleContext = new RawContextKey<boolean>('editorTabsVisible', true, localize('editorTabsVisible', "Whether editor tabs are visible"));

114 >

115 > //#endregion

116 >

117 >

118 > //#region < --- Side Bar --- >

119 >

120 > export const SideBarVisibleContext = new RawContextKey<boolean>('sideBarVisible', false, localize('sideBarVisible', "Whether the sidebar is visible"));

121 > export const SidebarFocusContext = new RawContextKey<boolean>('sideBarFocus', false, localize('sideBarFocus', "Whether the sidebar has keyboard focus"));

122 > export const ActiveViewletContext = new RawContextKey<string>('activeViewlet', '', localize('activeViewlet', "The identifier of the active viewlet"));

123 >

124 > //#endregion

125 >

126 >

127 > //#region < --- Status Bar --- >

128 >

129 > export const StatusBarFocused = new RawContextKey<boolean>('statusBarFocused', false, localize('statusBarFocused', "Whether the status bar has keyboard focus"));

130 >

131 > //#endregion

132 >

133 > //#region < --- Title Bar --- >

134 >

135 > export const TitleBarStyleContext = new RawContextKey<string>('titleBarStyle', 'custom', localize('titleBarStyle', "Style of the window title bar"));

136 > export const TitleBarVisibleContext = new RawContextKey<boolean>('titleBarVisible', false, localize('titleBarVisible', "Whether the title bar is visible"));

137 > export const IsCompactTitleBarContext = new RawContextKey<boolean>('isCompactTitleBar', false, localize('isCompactTitleBar', "Title bar is in compact mode"));

138 >

139 > //#endregion

140 >

141 >

142 > //#region < --- Banner --- >

143 >

144 > export const BannerFocused = new RawContextKey<boolean>('bannerFocused', false, localize('bannerFocused', "Whether the banner has keyboard focus"));

145 >

146 > //#endregion

147 >

148 >

149 > //#region < --- Notifications --- >

150 >

151 > export const NotificationFocusedContext = new RawContextKey<boolean>('notificationFocus', true, localize('notificationFocus', "Whether a notification has keyboard focus"));

152 > export const NotificationsCenterVisibleContext = new RawContextKey<boolean>('notificationCenterVisible', false, localize('notificationCenterVisible', "Whether the notifications center is visible"));

153 > export const NotificationsToastsVisibleContext = new RawContextKey<boolean>('notificationToastsVisible', false, localize('notificationToastsVisible', "Whether a notification toast is visible"));

154 >

155 > //#endregion

156 >

157 >

158 > //#region < --- Auxiliary Bar --- >

159 >

160 > export const ActiveAuxiliaryContext = new RawContextKey<string>('activeAuxiliary', '', localize('activeAuxiliary', "The identifier of the active auxiliary panel"));

161 > export const AuxiliaryBarFocusContext = new RawContextKey<boolean>('auxiliaryBarFocus', false, localize('auxiliaryBarFocus', "Whether the auxiliary bar has keyboard focus"));

162 > export const AuxiliaryBarVisibleContext = new RawContextKey<boolean>('auxiliaryBarVisible', false, localize('auxiliaryBarVisible', "Whether the auxiliary bar is visible"));

163 > export const SecondarySideBarVisibleContext = new RawContextKey<boolean>('secondarySideBarVisible', false, localize('secondarySideBarVisible', "Whether the layout surface representing the secondary side bar is visible"));

164 > export const AuxiliaryBarMaximizedContext = new RawContextKey<boolean>('auxiliaryBarMaximized', false, localize('auxiliaryBarMaximized', "Whether the auxiliary bar is maximized"));

165 >

166 > //#endregion

167 >

168 >

169 > //#region < --- Panel --- >

170 >

171 > export const ActivePanelContext = new RawContextKey<string>('activePanel', '', localize('activePanel', "The identifier of the active panel"));

172 > export const PanelFocusContext = new RawContextKey<boolean>('panelFocus', false, localize('panelFocus', "Whether the panel has keyboard focus"));

173 > export const PanelPositionContext = new RawContextKey<string>('panelPosition', 'bottom', localize('panelPosition', "The position of the panel, always 'bottom'"));

174 > export const PanelAlignmentContext = new RawContextKey<string>('panelAlignment', 'center', localize('panelAlignment', "The alignment of the panel, either 'center', 'left', 'right' or 'justify'"));

175 > export const PanelVisibleContext = new RawContextKey<boolean>('panelVisible', false, localize('panelVisible', "Whether the panel is visible"));

176 > export const PanelMaximizedContext = new RawContextKey<boolean>('panelMaximized', false, localize('panelMaximized', "Whether the panel is maximized"));

177 >

178 > //#endregion

179 >

180 >

181 > //#region < --- Views --- >

182 >

183 > export const FocusedViewContext = new RawContextKey<string>('focusedView', '', localize('focusedView', "The identifier of the view that has keyboard focus"));

184 > export function getVisbileViewContextKey(viewId: string): string { return `view.${viewId}.visible`; }

185 >

186 > //#endregion

187 >

188 >

189 > //#region < --- Resources --- >

190 >

191 > abstract class AbstractResourceContextKey {

192 >

193 > // NOTE: DO NOT CHANGE THE DEFAULT VALUE TO ANYTHING BUT

194 > // UNDEFINED! IT IS IMPORTANT THAT DEFAULTS ARE INHERITED

195 > // FROM THE PARENT CONTEXT AND ONLY UNDEFINED DOES THIS

196 >

197 > static readonly Scheme = new RawContextKey<string>('resourceScheme', undefined, { type: 'string', description: localize('resourceScheme', "The scheme of the resource") });

198 > static readonly Filename = new RawContextKey<string>('resourceFilename', undefined, { type: 'string', description: localize('resourceFilename', "The file name of the resource") });

199 > static readonly Dirname = new RawContextKey<string>('resourceDirname', undefined, { type: 'string', description: localize('resourceDirname', "The folder name the resource is contained in") });

200 > static readonly Path = new RawContextKey<string>('resourcePath', undefined, { type: 'string', description: localize('resourcePath', "The full path of the resource") });

201 > static readonly LangId = new RawContextKey<string>('resourceLangId', undefined, { type: 'string', description: localize('resourceLangId', "The language identifier of the resource") });

202 > static readonly Resource = new RawContextKey<string>('resource', undefined, { type: 'URI', description: localize('resource', "The full value of the resource including scheme and path") });

203 > static readonly Extension = new RawContextKey<string>('resourceExtname', undefined, { type: 'string', description: localize('resourceExtname', "The extension name of the resource") });

204 > static readonly HasResource = new RawContextKey<boolean>('resourceSet', undefined, { type: 'boolean', description: localize('resourceSet', "Whether a resource is present or not") });

205 > static readonly IsFileSystemResource = new RawContextKey<boolean>('isFileSystemResource', undefined, { type: 'boolean', description: localize('isFileSystemResource', "Whether the resource is backed by a file system provider") });

206 >

207 > protected _value: URI | undefined;

208 > protected readonly _resourceKey: IContextKey<string | null>;

209 > protected readonly _schemeKey: IContextKey<string | null>;

210 > protected readonly _filenameKey: IContextKey<string | null>;

211 > protected readonly _dirnameKey: IContextKey<string | null>;

212 > protected readonly _pathKey: IContextKey<string | null>;

213 > protected readonly _langIdKey: IContextKey<string | null>;

214 > protected readonly _extensionKey: IContextKey<string | null>;

215 > protected readonly _hasResource: IContextKey<boolean>;

216 > protected readonly _isFileSystemResource: IContextKey<boolean>;

217 >

218 > constructor(

219 @IContextKeyService protected readonly _contextKeyService: IContextKeyService,

220 @IFileService protected readonly _fileService: IFileService,

232 this._isFileSystemResource = AbstractResourceContextKey.IsFileSystemResource.bindTo(this._contextKeyService);

233 }

234 > contextkeys.ts

235 > protected _setLangId(): void {

236 const value = this.get();

237 if (!value) {

242 this._langIdKey.set(langId);

243 }

244 > contextkeys.ts

245 > set(value: URI | null | undefined) {

246 value = value ?? undefined;

247 if (isEqual(this._value, value)) {

261 });

262 }

263 > contextkeys.ts

264 > protected uriToPath(uri: URI): string {

265 if (uri.scheme === Schemas.file) {

266 return uri.fsPath;

268 return uri.path;

269 }

270 > contextkeys.ts

271 > reset(): void {

272 this._value = undefined;

273 this._contextKeyService.bufferChangeEvents(() => {

283 });

284 }

285 > contextkeys.ts

286 > get(): URI | undefined {

287 return this._value;

288 }

289 > } contextkeys.ts

290 >

291 > export class ResourceContextKey extends AbstractResourceContextKey {

292 >

293 > private readonly _disposables = new DisposableStore();

294 >

295 > constructor(

296 @IContextKeyService contextKeyService: IContextKeyService,

297 @IFileService fileService: IFileService,

315 }));

316 }

317 > contextkeys.ts

318 > dispose(): void {

319 this._disposables.dispose();

320 }

321 > } contextkeys.ts

322 >

323 > /**

324 > * This is a version of ResourceContextKey that is not disposable and has no listeners for model change events.

325 > * It will configure itself for the state/presence of a model only when created and not update.

326 > */

327 > export class StaticResourceContextKey extends AbstractResourceContextKey { }

328 >

329 >

330 > //#endregion

331 >

332 > export function applyAvailableEditorIds(contextKey: IContextKey<string>, editor: EditorInput | undefined | null, editorResolverService: IEditorResolverService): void {

333 if (!editor) {

334 contextKey.set('');

339 contextKey.set(editors.join(','));

340 }

341 > contextkeys.ts

342 function getAvailableEditorIds(editor: EditorInput, editorResolverService: IEditorResolverService): string[] {

343 // Non text editor untitled files cannot be easily serialized between

src/vs/editor/common/core/range.ts 247 covered LOC · 40 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- range.ts

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 { IPosition, Position } from './position.js';

7 >

8 > /**

9 > * A range in the editor. This interface is suitable for serialization.

10 > */

11 > export interface IRange {

12 > /**

13 > * Line number on which the range starts (starts at 1).

14 > */

15 > readonly startLineNumber: number;

16 > /**

17 > * Column on which the range starts in line `startLineNumber` (starts at 1).

18 > */

19 > readonly startColumn: number;

20 > /**

21 > * Line number on which the range ends.

22 > */

23 > readonly endLineNumber: number;

24 > /**

25 > * Column on which the range ends in line `endLineNumber`.

26 > */

27 > readonly endColumn: number;

28 > }

29 >

30 > /**

31 > * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)

32 > */

33 > export class Range {

34 >

35 > /**

36 > * Line number on which the range starts (starts at 1).

37 > */

38 > public readonly startLineNumber: number;

39 > /**

40 > * Column on which the range starts in line `startLineNumber` (starts at 1).

41 > */

42 > public readonly startColumn: number;

43 > /**

44 > * Line number on which the range ends.

45 > */

46 > public readonly endLineNumber: number;

47 > /**

48 > * Column on which the range ends in line `endLineNumber`.

49 > */

50 > public readonly endColumn: number;

51 >

52 > constructor(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number) {

53 if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {

54 this.startLineNumber = endLineNumber;

63 }

64 }

65 > range.ts

66 > /**

67 > * Test if this range is empty.

68 > */

69 > public isEmpty(): boolean {

70 return Range.isEmpty(this);

71 }

72 > range.ts

73 > /**

74 > * Test if `range` is empty.

75 > */

76 > public static isEmpty(range: IRange): boolean {

77 return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);

78 }

79 > range.ts

80 > /**

81 > * Test if position is in this range. If the position is at the edges, will return true.

82 > */

83 > public containsPosition(position: IPosition): boolean {

84 return Range.containsPosition(this, position);

85 }

86 > range.ts

87 > /**

88 > * Test if `position` is in `range`. If the position is at the edges, will return true.

89 > */

90 > public static containsPosition(range: IRange, position: IPosition): boolean {

91 if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {

92 return false;

100 return true;

101 }

102 > range.ts

103 > /**

104 > * Test if `position` is in `range`. If the position is at the edges, will return false.

105 > * @internal

106 > */

107 > public static strictContainsPosition(range: IRange, position: IPosition): boolean {

108 if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {

109 return false;

117 return true;

118 }

119 > range.ts

120 > /**

121 > * Test if range is in this range. If the range is equal to this range, will return true.

122 > */

123 > public containsRange(range: IRange): boolean {

124 return Range.containsRange(this, range);

125 }

126 > range.ts

127 > /**

128 > * Test if `otherRange` is in `range`. If the ranges are equal, will return true.

129 > */

130 > public static containsRange(range: IRange, otherRange: IRange): boolean {

131 if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {

132 return false;

143 return true;

144 }

145 > range.ts

146 > /**

147 > * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.

148 > */

149 > public strictContainsRange(range: IRange): boolean {

150 return Range.strictContainsRange(this, range);

151 }

152 > range.ts

153 > /**

154 > * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.

155 > */

156 > public static strictContainsRange(range: IRange, otherRange: IRange): boolean {

157 if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {

158 return false;

169 return true;

170 }

171 > range.ts

172 > /**

173 > * A reunion of the two ranges.

174 > * The smallest position will be used as the start point, and the largest one as the end point.

175 > */

176 > public plusRange(range: IRange): Range {

177 return Range.plusRange(this, range);

178 }

179 > range.ts

180 > /**

181 > * A reunion of the two ranges.

182 > * The smallest position will be used as the start point, and the largest one as the end point.

183 > */

184 > public static plusRange(a: IRange, b: IRange): Range {

185 let startLineNumber: number;

186 let startColumn: number;

212 return new Range(startLineNumber, startColumn, endLineNumber, endColumn);

213 }

214 > range.ts

215 > /**

216 > * A intersection of the two ranges.

217 > */

218 > public intersectRanges(range: IRange): Range | null {

219 return Range.intersectRanges(this, range);

220 }

221 > range.ts

222 > /**

223 > * A intersection of the two ranges.

224 > */

225 > public static intersectRanges(a: IRange, b: IRange): Range | null {

226 let resultStartLineNumber = a.startLineNumber;

227 let resultStartColumn = a.startColumn;

256 return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);

257 }

258 > range.ts

259 > /**

260 > * Test if this range equals other.

261 > */

262 > public equalsRange(other: IRange | null | undefined): boolean {

263 return Range.equalsRange(this, other);

264 }

265 > range.ts

266 > /**

267 > * Test if range `a` equals `b`.

268 > */

269 > public static equalsRange(a: IRange | null | undefined, b: IRange | null | undefined): boolean {

270 if (!a && !b) {

271 return true;

280 );

281 }

282 > range.ts

283 > /**

284 > * Return the end position (which will be after or equal to the start position)

285 > */

286 > public getEndPosition(): Position {

287 return Range.getEndPosition(this);

288 }

289 > range.ts

290 > /**

291 > * Return the end position (which will be after or equal to the start position)

292 > */

293 > public static getEndPosition(range: IRange): Position {

294 return new Position(range.endLineNumber, range.endColumn);

295 }

296 > range.ts

297 > /**

298 > * Return the start position (which will be before or equal to the end position)

299 > */

300 > public getStartPosition(): Position {

301 return Range.getStartPosition(this);

302 }

303 > range.ts

304 > /**

305 > * Return the start position (which will be before or equal to the end position)

306 > */

307 > public static getStartPosition(range: IRange): Position {

308 return new Position(range.startLineNumber, range.startColumn);

309 }

310 > range.ts

311 > /**

312 > * Transform to a user presentable string representation.

313 > */

314 > public toString(): string {

315 return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';

316 }

317 > range.ts

318 > /**

319 > * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.

320 > */

321 > public setEndPosition(endLineNumber: number, endColumn: number): Range {

322 return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);

323 }

324 > range.ts

325 > /**

326 > * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.

327 > */

328 > public setStartPosition(startLineNumber: number, startColumn: number): Range {

329 return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);

330 }

331 > range.ts

332 > /**

333 > * Create a new empty range using this range's start position.

334 > */

335 > public collapseToStart(): Range {

336 return Range.collapseToStart(this);

337 }

338 > range.ts

339 > /**

340 > * Create a new empty range using this range's start position.

341 > */

342 > public static collapseToStart(range: IRange): Range {

343 return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);

344 }

345 > range.ts

346 > /**

347 > * Create a new empty range using this range's end position.

348 > */

349 > public collapseToEnd(): Range {

350 return Range.collapseToEnd(this);

351 }

352 > range.ts

353 > /**

354 > * Create a new empty range using this range's end position.

355 > */

356 > public static collapseToEnd(range: IRange): Range {

357 return new Range(range.endLineNumber, range.endColumn, range.endLineNumber, range.endColumn);

358 }

359 > range.ts

360 > /**

361 > * Moves the range by the given amount of lines.

362 > */

363 > public delta(lineCount: number): Range {

364 return new Range(this.startLineNumber + lineCount, this.startColumn, this.endLineNumber + lineCount, this.endColumn);

365 }

366 > range.ts

367 > /**

368 > * Test if this range starts and ends on the same line.

369 > */

370 > public isSingleLine(): boolean {

371 return this.startLineNumber === this.endLineNumber;

372 }

373 > range.ts

374 > // ---

375 >

376 > public static fromPositions(start: IPosition, end: IPosition = start): Range {

377 return new Range(start.lineNumber, start.column, end.lineNumber, end.column);

378 }

379 > range.ts

380 > /**

381 > * Create a `Range` from an `IRange`.

382 > */

383 > public static lift(range: undefined | null): null;

384 > public static lift(range: IRange): Range;

385 > public static lift(range: IRange | undefined | null): Range | null;

386 > public static lift(range: IRange | undefined | null): Range | null {

387 if (!range) {

388 return null;

390 return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);

391 }

392 > range.ts

393 > /**

394 > * Test if `obj` is an `IRange`.

395 > */

396 > public static isIRange(obj: unknown): obj is IRange {

397 return (

398 !!obj

403 );

404 }

405 > range.ts

406 > /**

407 > * Test if the two ranges are touching in any way.

408 > */

409 > public static areIntersectingOrTouching(a: IRange, b: IRange): boolean {

410 // Check if `a` is before `b`

411 if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {

421 return true;

422 }

423 > range.ts

424 > /**

425 > * Test if the two ranges are intersecting. If the ranges are touching it returns true.

426 > */

427 > public static areIntersecting(a: IRange, b: IRange): boolean {

428 // Check if `a` is before `b`

429 if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {

439 return true;

440 }

441 > range.ts

442 > /**

443 > * Test if the two ranges are intersecting, but not touching at all.

444 > */

445 > public static areOnlyIntersecting(a: IRange, b: IRange): boolean {

446 // Check if `a` is before `b`

447 if (a.endLineNumber < (b.startLineNumber - 1) || (a.endLineNumber === b.startLineNumber && a.endColumn < (b.startColumn - 1))) {

457 return true;

458 }

459 > range.ts

460 > /**

461 > * A function that compares ranges, useful for sorting ranges

462 > * It will first compare ranges on the startPosition and then on the endPosition

463 > */

464 > public static compareRangesUsingStarts(a: IRange | null | undefined, b: IRange | null | undefined): number {

465 if (a && b) {

466 const aStartLineNumber = a.startLineNumber | 0;

490 return aExists - bExists;

491 }

492 > range.ts

493 > /**

494 > * A function that compares ranges, useful for sorting ranges

495 > * It will first compare ranges on the endPosition and then on the startPosition

496 > */

497 > public static compareRangesUsingEnds(a: IRange, b: IRange): number {

498 if (a.endLineNumber === b.endLineNumber) {

499 if (a.endColumn === b.endColumn) {

507 return a.endLineNumber - b.endLineNumber;

508 }

509 > range.ts

510 > /**

511 > * Test if the range spans multiple lines.

512 > */

513 > public static spansMultipleLines(range: IRange): boolean {

514 return range.endLineNumber > range.startLineNumber;

515 }

516 > range.ts

517 > public toJSON(): IRange {

518 return this;

519 }

520 > } range.ts

src/vs/base/common/filters.ts 212 covered LOC · 47 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- filters.ts

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 { CharCode } from './charCode.js';

7 > import { LRUCache } from './map.js';

8 > import { getKoreanAltChars } from './naturalLanguage/korean.js';

9 > import { tryNormalizeToBase } from './normalization.js';

10 > import * as strings from './strings.js';

11 >

12 > export interface IFilter {

13 > // Returns null if word doesn't match.

14 > (word: string, wordToMatchAgainst: string): IMatch[] | null;

15 > }

16 >

17 > export interface IMatch {

18 > start: number;

19 > end: number;

20 > }

21 >

22 > // Combined filters

23 >

24 > /**

25 > * @returns A filter which combines the provided set

26 > * of filters with an or. The *first* filters that

27 > * matches defined the return value of the returned

28 > * filter.

29 > */

30 > export function or(...filter: IFilter[]): IFilter {

31 > return function (word: string, wordToMatchAgainst: string): IMatch[] | null {

32 for (let i = 0, len = filter.length; i < len; i++) {

33 const match = filter[i](word, wordToMatchAgainst);

38 return null;

39 };

40 > } filters.ts

41 >

42 > // Prefix

43 >

44 > export const matchesStrictPrefix: IFilter = _matchesPrefix.bind(undefined, false);

45 > export const matchesPrefix: IFilter = _matchesPrefix.bind(undefined, true);

46 >

47 function _matchesPrefix(ignoreCase: boolean, word: string, wordToMatchAgainst: string): IMatch[] | null {

48 if (!wordToMatchAgainst || wordToMatchAgainst.length < word.length) {

63 return word.length > 0 ? [{ start: 0, end: word.length }] : [];

64 }

65 > filters.ts

66 > // Contiguous Substring

67 >

68 > export function matchesContiguousSubString(word: string, wordToMatchAgainst: string): IMatch[] | null {

69 if (word.length > wordToMatchAgainst.length) {

70 return null;

78 return [{ start: index, end: index + word.length }];

79 }

80 > filters.ts

81 > export function matchesBaseContiguousSubString(word: string, wordToMatchAgainst: string): IMatch[] | null {

82 if (word.length > wordToMatchAgainst.length) {

83 return null;

93 return [{ start: index, end: index + word.length }];

94 }

95 > filters.ts

96 > // Substring

97 >

98 > export function matchesSubString(word: string, wordToMatchAgainst: string): IMatch[] | null {

99 if (word.length > wordToMatchAgainst.length) {

100 return null;

103 return _matchesSubString(word.toLowerCase(), wordToMatchAgainst.toLowerCase(), 0, 0);

104 }

105 > filters.ts

106 function _matchesSubString(word: string, wordToMatchAgainst: string, i: number, j: number): IMatch[] | null {

107 if (i === word.length) {

121 }

122 }

123 > filters.ts

124 > // CamelCase

125 >

126 function isLower(code: number): boolean {

127 return CharCode.a <= code && code <= CharCode.z;

128 }

129 > filters.ts

130 > export function isUpper(code: number): boolean {

131 return CharCode.A <= code && code <= CharCode.Z;

132 }

133 > filters.ts

134 function isNumber(code: number): boolean {

135 return CharCode.Digit0 <= code && code <= CharCode.Digit9;

136 }

137 > filters.ts

138 function isWhitespace(code: number): boolean {

139 return (

144 );

145 }

146 > filters.ts

147 > const wordSeparators = new Set<number>();

148 > // These are chosen as natural word separators based on written text.

149 > // It is a subset of the word separators used by the monaco editor.

150 > '()[]{}<>`\'"-/;:,.?!'

151 > .split('')

152 > .forEach(s => wordSeparators.add(s.charCodeAt(0)));

153 >

154 function isWordSeparator(code: number): boolean {

155 return isWhitespace(code) || wordSeparators.has(code);

156 }

157 > filters.ts

158 function charactersMatch(codeA: number, codeB: number): boolean {

159 return (codeA === codeB) || (isWordSeparator(codeA) && isWordSeparator(codeB));

160 }

161 > filters.ts

162 > const alternateCharsCache: Map<number, ArrayLike<number> | undefined> = new Map();

163 > /**

164 > * Gets alternative codes to the character code passed in. This comes in the

165 > * form of an array of character codes, all of which must match _in order_ to

166 > * successfully match.

167 > *

168 > * @param code The character code to check.

169 > */

170 function getAlternateCodes(code: number): ArrayLike<number> | undefined {

171 if (alternateCharsCache.has(code)) {

186 return result;

187 }

188 > filters.ts

189 function isAlphanumeric(code: number): boolean {

190 return isLower(code) || isUpper(code) || isNumber(code);

191 }

192 > filters.ts

193 function join(head: IMatch, tail: IMatch[]): IMatch[] {

194 if (tail.length === 0) {

201 return tail;

202 }

203 > filters.ts

204 function nextAnchor(camelCaseWord: string, start: number): number {

205 for (let i = start; i < camelCaseWord.length; i++) {

211 return camelCaseWord.length;

212 }

213 > filters.ts

214 function _matchesCamelCase(word: string, camelCaseWord: string, i: number, j: number): IMatch[] | null {

215 if (i === word.length) {

230 }

231 }

232 > filters.ts

233 > interface ICamelCaseAnalysis {

234 > upperPercent: number;

235 > lowerPercent: number;

236 > alphaPercent: number;

237 > numericPercent: number;

238 > }

239 >

240 > // Heuristic to avoid computing camel case matcher for words that don't

241 > // look like camelCaseWords.

242 function analyzeCamelCaseWord(word: string): ICamelCaseAnalysis {

243 let upper = 0, lower = 0, alpha = 0, numeric = 0, code = 0;

259 return { upperPercent, lowerPercent, alphaPercent, numericPercent };

260 }

261 > filters.ts

262 function isUpperCaseWord(analysis: ICamelCaseAnalysis): boolean {

263 const { upperPercent, lowerPercent } = analysis;

264 return lowerPercent === 0 && upperPercent > 0.6;

265 }

266 > filters.ts

267 function isCamelCaseWord(analysis: ICamelCaseAnalysis): boolean {

268 const { upperPercent, lowerPercent, alphaPercent, numericPercent } = analysis;

269 return lowerPercent > 0.2 && upperPercent < 0.8 && alphaPercent > 0.6 && numericPercent < 0.2;

270 }

271 > filters.ts

272 > // Heuristic to avoid computing camel case matcher for words that don't

273 > // look like camel case patterns.

274 function isCamelCasePattern(word: string): boolean {

275 let upper = 0, lower = 0, code = 0, whitespace = 0;

289 }

290 }

291 > filters.ts

292 > export function matchesCamelCase(word: string, camelCaseWord: string): IMatch[] | null {

293 if (!camelCaseWord) {

294 return null;

330 return result;

331 }

332 > filters.ts

333 > // Matches beginning of words supporting non-ASCII languages

334 > // If `contiguous` is true then matches word with beginnings of the words in the target. E.g. "pul" will match "Git: Pull"

335 > // Otherwise also matches sub string of the word with beginnings of the words in the target. E.g. "gp" or "g p" will match "Git: Pull"

336 > // Useful in cases where the target is words (e.g. command labels)

337 >

338 > export function matchesWords(word: string, target: string, contiguous: boolean = false): IMatch[] | null {

339 if (!target || target.length === 0) {

340 return null;

361 return result;

362 }

363 > filters.ts

364 function cloneMatches(matches: IMatch[] | null): IMatch[] | null {

365 if (matches === null) {

372 return result;

373 }

374 > filters.ts

375 function _matchesWords(word: string, target: string, wordIndex: number, targetIndex: number, contiguous: boolean, memo: Map<number, IMatch[] | null>): IMatch[] | null {

376 if (wordIndex === word.length) {

391 return computed;

392 }

393 > filters.ts

394 function _matchesWordsCompute(word: string, target: string, wordIndex: number, targetIndex: number, contiguous: boolean, memo: Map<number, IMatch[] | null>): IMatch[] | null {

395 let targetIndexOffset = 0;

440 return join({ start: targetIndex, end: targetIndex + targetIndexOffset + 1 }, result);

441 }

442 > filters.ts

443 function nextWord(word: string, start: number): number {

444 for (let i = start; i < word.length; i++) {

450 return word.length;

451 }

452 > filters.ts

453 > // Fuzzy

454 >

455 > const fuzzyContiguousFilter = or(matchesPrefix, matchesCamelCase, matchesContiguousSubString);

456 > const fuzzySeparateFilter = or(matchesPrefix, matchesCamelCase, matchesSubString);

457 > const fuzzyRegExpCache = new LRUCache<string, RegExp>(10000); // bounded to 10000 elements

458 >

459 > export function matchesFuzzy(word: string, wordToMatchAgainst: string, enableSeparateSubstringMatching = false): IMatch[] | null {

460 if (typeof word !== 'string' || typeof wordToMatchAgainst !== 'string') {

461 return null; // return early for invalid input

478 return enableSeparateSubstringMatching ? fuzzySeparateFilter(word, wordToMatchAgainst) : fuzzyContiguousFilter(word, wordToMatchAgainst);

479 }

480 > filters.ts

481 > /**

482 > * Match pattern against word in a fuzzy way. As in IntelliSense and faster and more

483 > * powerful than `matchesFuzzy`

484 > */

485 > export function matchesFuzzy2(pattern: string, word: string): IMatch[] | null {

486 const score = fuzzyScore(pattern, pattern.toLowerCase(), 0, word, word.toLowerCase(), 0, { firstMatchCanBeWeak: true, boostFullMatch: true });

487 return score ? createMatches(score) : null;

488 }

489 > filters.ts

490 > export function anyScore(pattern: string, lowPattern: string, patternPos: number, word: string, lowWord: string, wordPos: number): FuzzyScore {

491 const max = Math.min(13, pattern.length);

492 for (; patternPos < max; patternPos++) {

498 return [0, wordPos];

499 }

500 > filters.ts

501 > //#region --- fuzzyScore ---

502 >

503 > export function createMatches(score: undefined | FuzzyScore): IMatch[] {

504 if (typeof score === 'undefined') {

505 return [];

518 return res;

519 }

520 > filters.ts

521 > const _maxLen = 128;

522 >

523 > function initTable() {

524 > const table: number[][] = [];

525 > const row: number[] = [];

526 > for (let i = 0; i <= _maxLen; i++) {

527 > row[i] = 0;

528 > }

529 > for (let i = 0; i <= _maxLen; i++) {

530 > table.push(row.slice(0));

531 > }

532 > return table;

533 > }

534 >

535 > function initArr(maxLen: number) {

536 > const row: number[] = [];

537 > for (let i = 0; i <= maxLen; i++) {

538 > row[i] = 0;

539 > }

540 > return row;

541 > }

542 >

543 > const _minWordMatchPos = initArr(2 * _maxLen); // min word position for a certain pattern position

544 > const _maxWordMatchPos = initArr(2 * _maxLen); // max word position for a certain pattern position

545 > const _diag = initTable(); // the length of a contiguous diagonal match

546 > const _table = initTable();

547 > const _arrows = <Arrow[][]>initTable();

548 > const _debug = false;

549 >

550 function printTable(table: number[][], pattern: string, patternLen: number, word: string, wordLen: number): string {

551 function pad(s: string, n: number, pad = ' ') {

567 return ret;

568 }

569 > filters.ts

570 function printTables(pattern: string, patternStart: number, word: string, wordStart: number): void {

571 pattern = pattern.substr(patternStart);

575 console.log(printTable(_diag, pattern, pattern.length, word, word.length));

576 }

577 > filters.ts

578 function isSeparatorAtPos(value: string, index: number): boolean {

579 if (index < 0 || index >= value.length) {

610 }

611 }

612 > filters.ts

613 function isWhitespaceAtPos(value: string, index: number): boolean {

614 if (index < 0 || index >= value.length) {

624 }

625 }

626 > filters.ts

627 function isUpperCaseAtPos(pos: number, word: string, wordLow: string): boolean {

628 return word[pos] !== wordLow[pos];

629 }

630 > filters.ts

631 > export function isPatternInWord(patternLow: string, patternPos: number, patternLen: number, wordLow: string, wordPos: number, wordLen: number, fillMinWordPosArr = false): boolean {

632 while (patternPos < patternLen && wordPos < wordLen) {

633 if (patternLow[patternPos] === wordLow[wordPos]) {

642 return patternPos === patternLen; // pattern must be exhausted

643 }

644 > filters.ts

645 > const enum Arrow { Diag = 1, Left = 2, LeftLeft = 3 }

646 >

647 > /**

648 > * An array representing a fuzzy match.

649 > *

650 > * 0. the score

651 > * 1. the offset at which matching started

652 > * 2. `<match_pos_N>`

653 > * 3. `<match_pos_1>`

654 > * 4. `<match_pos_0>` etc

655 > */

656 > export type FuzzyScore = [score: number, wordStart: number, ...matches: number[]];

657 >

658 > export namespace FuzzyScore {

659 > /**

660 > * No matches and value `-100`

661 > */

662 > export const Default: FuzzyScore = ([-100, 0]);

663 >

664 > export function isDefault(score?: FuzzyScore): score is [-100, 0] {

665 return !score || (score.length === 2 && score[0] === -100 && score[1] === 0);

666 }

667 > } filters.ts

668 >

669 > export abstract class FuzzyScoreOptions {

670 >

671 > static default = { boostFullMatch: true, firstMatchCanBeWeak: false };

672 >

673 > constructor(

674 readonly firstMatchCanBeWeak: boolean,

675 readonly boostFullMatch: boolean,

676 ) { }

677 > } filters.ts

678 >

679 > export interface FuzzyScorer {

680 > (pattern: string, lowPattern: string, patternPos: number, word: string, lowWord: string, wordPos: number, options?: FuzzyScoreOptions): FuzzyScore | undefined;

681 > }

682 >

683 > export function fuzzyScore(pattern: string, patternLow: string, patternStart: number, word: string, wordLow: string, wordStart: number, options: FuzzyScoreOptions = FuzzyScoreOptions.default): FuzzyScore | undefined {

684

685 const patternLen = pattern.length > _maxLen ? _maxLen : pattern.length;

832 return result;

833 }

834 > filters.ts

835 function _fillInMaxWordMatchPos(patternLen: number, wordLen: number, patternStart: number, wordStart: number, patternLow: string, wordLow: string) {

836 let patternPos = patternLen - 1;

844 }

845 }

846 > filters.ts

847 function _doScore(

848 pattern: string, patternLow: string, patternPos: number, patternStart: number,

913 return score;

914 }

915 > filters.ts

916 > //#endregion

917 >

918 >

919 > //#region --- graceful ---

920 >

921 > export function fuzzyScoreGracefulAggressive(pattern: string, lowPattern: string, patternPos: number, word: string, lowWord: string, wordPos: number, options?: FuzzyScoreOptions): FuzzyScore | undefined {

922 return fuzzyScoreWithPermutations(pattern, lowPattern, patternPos, word, lowWord, wordPos, true, options);

923 }

924 > filters.ts

925 > export function fuzzyScoreGraceful(pattern: string, lowPattern: string, patternPos: number, word: string, lowWord: string, wordPos: number, options?: FuzzyScoreOptions): FuzzyScore | undefined {

926 return fuzzyScoreWithPermutations(pattern, lowPattern, patternPos, word, lowWord, wordPos, false, options);

927 }

928 > filters.ts

929 function fuzzyScoreWithPermutations(pattern: string, lowPattern: string, patternPos: number, word: string, lowWord: string, wordPos: number, aggressive: boolean, options?: FuzzyScoreOptions): FuzzyScore | undefined {

930 let top = fuzzyScore(pattern, lowPattern, patternPos, word, lowWord, wordPos, options);

959 return top;

960 }

961 > filters.ts

962 function nextTypoPermutation(pattern: string, patternPos: number): string | undefined {

963

978 + pattern.slice(patternPos + 2);

979 }

980 > filters.ts

981 > //#endregion

src/vs/base/parts/storage/common/storage.ts 212 covered LOC · 33 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- storage.ts

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 { ThrottledDelayer } from '../../../common/async.js';

7 > import { Event, PauseableEmitter } from '../../../common/event.js';

8 > import { Disposable, IDisposable } from '../../../common/lifecycle.js';

9 > import { parse, stringify } from '../../../common/marshalling.js';

10 > import { isObject, isUndefined, isUndefinedOrNull } from '../../../common/types.js';

11 >

12 > export enum StorageHint {

13 >

14 > // A hint to the storage that the storage

15 > // does not exist on disk yet. This allows

16 > // the storage library to improve startup

17 > // time by not checking the storage for data.

18 > STORAGE_DOES_NOT_EXIST,

19 >

20 > // A hint to the storage that the storage

21 > // is backed by an in-memory storage.

22 > STORAGE_IN_MEMORY

23 > }

24 >

25 > export interface IStorageOptions {

26 > readonly hint?: StorageHint;

27 > }

28 >

29 > export interface IUpdateRequest {

30 > readonly insert?: Map<string, string>;

31 > readonly delete?: Set<string>;

32 > }

33 >

34 > export interface IStorageItemsChangeEvent {

35 > readonly changed?: Map<string, string>;

36 > readonly deleted?: Set<string>;

37 > }

38 >

39 > export function isStorageItemsChangeEvent(thing: unknown): thing is IStorageItemsChangeEvent {

40 const candidate = thing as IStorageItemsChangeEvent | undefined;

41

42 return candidate?.changed instanceof Map || candidate?.deleted instanceof Set;

43 }

44 > storage.ts

45 > export interface IStorageDatabase {

46 >

47 > readonly onDidChangeItemsExternal: Event<IStorageItemsChangeEvent>;

48 >

49 > getItems(): Promise<Map<string, string>>;

50 > updateItems(request: IUpdateRequest): Promise<void>;

51 >

52 > optimize(): Promise<void>;

53 >

54 > close(recovery?: () => Map<string, string>): Promise<void>;

55 > }

56 >

57 > export interface IStorageChangeEvent {

58 >

59 > /**

60 > * The `key` of the storage entry that was changed

61 > * or was removed.

62 > */

63 > readonly key: string;

64 >

65 > /**

66 > * A hint how the storage change event was triggered. If

67 > * `true`, the storage change was triggered by an external

68 > * source, such as:

69 > * - another process (for example another window)

70 > * - operations such as settings sync or profiles change

71 > */

72 > readonly external?: boolean;

73 > }

74 >

75 > export type StorageValue = string | boolean | number | undefined | null | object;

76 >

77 > export interface IStorage extends IDisposable {

78 >

79 > readonly onDidChangeStorage: Event<IStorageChangeEvent>;

80 >

81 > readonly items: Map<string, string>;

82 > readonly size: number;

83 >

84 > init(): Promise<void>;

85 >

86 > get(key: string, fallbackValue: string): string;

87 > get(key: string, fallbackValue?: string): string | undefined;

88 >

89 > getBoolean(key: string, fallbackValue: boolean): boolean;

90 > getBoolean(key: string, fallbackValue?: boolean): boolean | undefined;

91 >

92 > getNumber(key: string, fallbackValue: number): number;

93 > getNumber(key: string, fallbackValue?: number): number | undefined;

94 >

95 > getObject<T extends object>(key: string, fallbackValue: T): T;

96 > getObject<T extends object>(key: string, fallbackValue?: T): T | undefined;

97 >

98 > set(key: string, value: StorageValue, external?: boolean): Promise<void>;

99 > delete(key: string, external?: boolean): Promise<void>;

100 >

101 > flush(delay?: number): Promise<void>;

102 > whenFlushed(): Promise<void>;

103 >

104 > optimize(): Promise<void>;

105 >

106 > close(): Promise<void>;

107 > }

108 >

109 > export enum StorageState {

110 > None,

111 > Initialized,

112 > Closed

113 > }

114 >

115 > export class Storage extends Disposable implements IStorage {

116 >

117 > private static readonly DEFAULT_FLUSH_DELAY = 100;

118 >

119 > private readonly _onDidChangeStorage = this._register(new PauseableEmitter<IStorageChangeEvent>());

120 > readonly onDidChangeStorage = this._onDidChangeStorage.event;

121 >

122 > private state = StorageState.None;

123 >

124 > private cache = new Map<string, string>();

125 >

126 > private readonly flushDelayer = this._register(new ThrottledDelayer<void>(Storage.DEFAULT_FLUSH_DELAY));

127 >

128 > private pendingDeletes = new Set<string>();

129 > private pendingInserts = new Map<string, string>();

130 >

131 > private pendingClose: Promise<void> | undefined = undefined;

132 >

133 > private readonly whenFlushedCallbacks: Function[] = [];

134 >

135 > constructor(

136 protected readonly database: IStorageDatabase,

137 private readonly options: IStorageOptions = Object.create(null)

141 this.registerListeners();

142 }

143 > storage.ts

144 > private registerListeners(): void {

145 this._register(this.database.onDidChangeItemsExternal(e => this.onDidChangeItemsExternal(e)));

146 }

147 > storage.ts

148 > private onDidChangeItemsExternal(e: IStorageItemsChangeEvent): void {

149 this._onDidChangeStorage.pause();

150

161 }

162 }

163 > storage.ts

164 > private acceptExternal(key: string, value: string | undefined): void {

165 if (this.state === StorageState.Closed) {

166 return; // Return early if we are already closed

188 }

189 }

190 > storage.ts

191 > get items(): Map<string, string> {

192 return this.cache;

193 }

194 > storage.ts

195 > get size(): number {

196 return this.cache.size;

197 }

198 > storage.ts

199 > async init(): Promise<void> {

200 if (this.state !== StorageState.None) {

201 return; // either closed or already initialized

213 this.cache = await this.database.getItems();

214 }

215 > storage.ts

216 > get(key: string, fallbackValue: string): string;

217 > get(key: string, fallbackValue?: string): string | undefined;

218 > get(key: string, fallbackValue?: string): string | undefined {

219 const value = this.cache.get(key);

220

225 return value;

226 }

227 > storage.ts

228 > getBoolean(key: string, fallbackValue: boolean): boolean;

229 > getBoolean(key: string, fallbackValue?: boolean): boolean | undefined;

230 > getBoolean(key: string, fallbackValue?: boolean): boolean | undefined {

231 const value = this.get(key);

232

237 return value === 'true';

238 }

239 > storage.ts

240 > getNumber(key: string, fallbackValue: number): number;

241 > getNumber(key: string, fallbackValue?: number): number | undefined;

242 > getNumber(key: string, fallbackValue?: number): number | undefined {

243 const value = this.get(key);

244

249 return parseInt(value, 10);

250 }

251 > storage.ts

252 > getObject(key: string, fallbackValue: object): object;

253 > getObject(key: string, fallbackValue?: object | undefined): object | undefined;

254 > getObject(key: string, fallbackValue?: object): object | undefined {

255 const value = this.get(key);

256

261 return parse(value);

262 }

263 > storage.ts

264 > async set(key: string, value: string | boolean | number | null | undefined | object, external = false): Promise<void> {

265 if (this.state === StorageState.Closed) {

266 return; // Return early if we are already closed

292 return this.doFlush();

293 }

294 > storage.ts

295 > async delete(key: string, external = false): Promise<void> {

296 if (this.state === StorageState.Closed) {

297 return; // Return early if we are already closed

316 return this.doFlush();

317 }

318 > storage.ts

319 > async optimize(): Promise<void> {

320 if (this.state === StorageState.Closed) {

321 return; // Return early if we are already closed

328 return this.database.optimize();

329 }

330 > storage.ts

331 > async close(): Promise<void> {

332 if (!this.pendingClose) {

333 this.pendingClose = this.doClose();

336 return this.pendingClose;

337 }

338 > storage.ts

339 > private async doClose(): Promise<void> {

340

341 // Update state

356 await this.database.close(() => this.cache);

357 }

358 > storage.ts

359 > private get hasPending() {

360 return this.pendingInserts.size > 0 || this.pendingDeletes.size > 0;

361 }

362 > storage.ts

363 > private async flushPending(): Promise<void> {

364 if (!this.hasPending) {

365 return; // return early if nothing to do

383 });

384 }

385 > storage.ts

386 > async flush(delay?: number): Promise<void> {

387 if (

388 this.state === StorageState.Closed || // Return early if we are already closed

394 return this.doFlush(delay);

395 }

396 > storage.ts

397 > private async doFlush(delay?: number): Promise<void> {

398 if (this.options.hint === StorageHint.STORAGE_IN_MEMORY) {

399 return this.flushPending(); // return early if in-memory

402 return this.flushDelayer.trigger(() => this.flushPending(), delay);

403 }

404 > storage.ts

405 > async whenFlushed(): Promise<void> {

406 if (!this.hasPending) {

407 return; // return early if nothing to do

410 return new Promise(resolve => this.whenFlushedCallbacks.push(resolve));

411 }

412 > storage.ts

413 > isInMemory(): boolean {

414 return this.options.hint === StorageHint.STORAGE_IN_MEMORY;

415 }

416 > } storage.ts

417 >

418 > export class InMemoryStorageDatabase implements IStorageDatabase {

419

420 readonly onDidChangeItemsExternal = Event.None;

421

422 private readonly items = new Map<string, string>();

423 > storage.ts

424 > async getItems(): Promise<Map<string, string>> {

425 return this.items;

426 }

427 > storage.ts

428 > async updateItems(request: IUpdateRequest): Promise<void> {

429 request.insert?.forEach((value, key) => this.items.set(key, value));

430

431 request.delete?.forEach(key => this.items.delete(key));

432 }

433 > storage.ts

434 > async optimize(): Promise<void> { }

435 > async close(): Promise<void> { }

436 > }

437 >

438 >

439 > export const MIGRATED_KEY = '__$__migratedStorageMarker';

440 >

441 > export class MigratingStorage extends Storage {

442

443 private migratedKeys: Set<string> = new Set();

444 private fallbackStorage: IStorage | undefined = undefined;

445 private isFallbackStorageReadonly: boolean = false;

446 > storage.ts

447 > override async init(): Promise<void> {

448 await super.init();

449

451 this.migratedKeys = this.loadMigratedKeys();

452 }

453 > storage.ts

454 > public setFallbackStorage(storage: IStorage, isReadonly: boolean): void {

455 this.fallbackStorage = storage;

456 this.isFallbackStorageReadonly = isReadonly;

457 }

458 > storage.ts

459 > private static readonly INTERNAL_KEY_PREFIX = '__$__';

460 >

461 > override get(key: string, fallbackValue: string): string;

462 > override get(key: string, fallbackValue?: string): string | undefined;

463 > override get(key: string, fallbackValue?: string): string | undefined {

464 if (!key.startsWith(MigratingStorage.INTERNAL_KEY_PREFIX) && !this.migratedKeys.has(key) && isUndefined(super.get(key))) {

465 // Check fallback storage and auto-migrate on hit.

480 return super.get(key, fallbackValue);

481 }

482 > storage.ts

483 > private loadMigratedKeys(): Set<string> {

484 const raw = super.get(MIGRATED_KEY);

485 if (raw) {

492 return new Set();

493 }

494 > storage.ts

495 > private persistMigratedKeys(): void {

496 this.set(MIGRATED_KEY, JSON.stringify([...this.migratedKeys]));

497 }

498 > } storage.ts

499

src/vs/nls.ts 211 covered LOC · 17 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- nls.ts

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 > export function getNLSMessages(): string[] {

7 return globalThis._VSCODE_NLS_MESSAGES;

8 }

9 > nls.ts

10 > export function getNLSLanguage(): string | undefined {

11 > return globalThis._VSCODE_NLS_LANGUAGE;

12 > }

13 >

14 > declare const document: { location?: { hash?: string } } | undefined;

15 > const isPseudo = getNLSLanguage() === 'pseudo' || (typeof document !== 'undefined' && document.location && typeof document.location.hash === 'string' && document.location.hash.indexOf('pseudo=true') >= 0);

16 >

17 > export interface ILocalizeInfo {

18 > key: string;

19 > comment: string[];

20 > }

21 >

22 > export interface ILocalizedString {

23 > original: string;

24 > value: string;

25 > }

26 >

27 > function _format(message: string, args: (string | number | boolean | undefined | null)[]): string { nls.ts

28 > let result: string;

29 >

30 > if (args.length === 0) {

31 > result = message; nls.ts

32 > } else { nls.ts

33 > result = message.replace(/\{(\d+)\}/g, (match, rest) => { nls.ts

34 > const index = rest[0];

35 > const arg = args[index];

36 > let result = match;

37 > if (typeof arg === 'string') {

38 > result = arg; nls.ts

39 > } else if (typeof arg === 'number' || typeof arg === 'boolean' || arg === void 0 || arg === null) { nls.ts

40 result = String(arg);

41 }

42 > return result; nls.ts

43 > });

44 > }

45 > nls.ts

46 > if (isPseudo) {

47 // FF3B and FF3D is the Unicode zenkaku representation for [ and ]

48 result = '\uFF3B' + result.replace(/[aouei]/g, '$&$&') + '\uFF3D';

49 }

50 > nls.ts

51 > return result;

52 > }

53 > nls.ts

54 > /**

55 > * Marks a string to be localized. Returns the localized string.

56 > *

57 > * @param info The {@linkcode ILocalizeInfo} which describes the id and comments associated with the localized string.

58 > * @param message The string to localize

59 > * @param args The arguments to the string

60 > *

61 > * @note `message` can contain `{n}` notation where it is replaced by the nth value in `...args`

62 > * @example `localize({ key: 'sayHello', comment: ['Welcomes user'] }, 'hello {0}', name)`

63 > *

64 > * @returns string The localized string.

65 > */

66 > export function localize(info: ILocalizeInfo, message: string, ...args: (string | number | boolean | undefined | null)[]): string;

67 >

68 > /**

69 > * Marks a string to be localized. Returns the localized string.

70 > *

71 > * @param key The key to use for localizing the string

72 > * @param message The string to localize

73 > * @param args The arguments to the string

74 > *

75 > * @note `message` can contain `{n}` notation where it is replaced by the nth value in `...args`

76 > * @example For example, `localize('sayHello', 'hello {0}', name)`

77 > *

78 > * @returns string The localized string.

79 > */

80 > export function localize(key: string, message: string, ...args: (string | number | boolean | undefined | null)[]): string;

81 >

82 > /**

83 > * @skipMangle

84 > */

85 > export function localize(data: ILocalizeInfo | string /* | number when built */, message: string /* | null when built */, ...args: (string | number | boolean | undefined | null)[]): string {

86 > if (typeof data === 'number') { nls.ts

87 return _format(lookupMessage(data, message), args);

88 }

89 > return _format(message, args); nls.ts

90 > }

91 > nls.ts

92 > /**

93 > * Only used when built: Looks up the message in the global NLS table.

94 > * This table is being made available as a global through bootstrapping

95 > * depending on the target context.

96 > */

97 function lookupMessage(index: number, fallback: string | null): string {

98 const message = getNLSMessages()?.[index];

105 return message;

106 }

107 > nls.ts

108 > /**

109 > * Marks a string to be localized. Returns an {@linkcode ILocalizedString}

110 > * which contains the localized string and the original string.

111 > *

112 > * @param info The {@linkcode ILocalizeInfo} which describes the id and comments associated with the localized string.

113 > * @param message The string to localize

114 > * @param args The arguments to the string

115 > *

116 > * @note `message` can contain `{n}` notation where it is replaced by the nth value in `...args`

117 > * @example `localize2({ key: 'sayHello', comment: ['Welcomes user'] }, 'hello {0}', name)`

118 > *

119 > * @returns ILocalizedString which contains the localized string and the original string.

120 > */

121 > export function localize2(info: ILocalizeInfo, message: string, ...args: (string | number | boolean | undefined | null)[]): ILocalizedString;

122 >

123 > /**

124 > * Marks a string to be localized. Returns an {@linkcode ILocalizedString}

125 > * which contains the localized string and the original string.

126 > *

127 > * @param key The key to use for localizing the string

128 > * @param message The string to localize

129 > * @param args The arguments to the string

130 > *

131 > * @note `message` can contain `{n}` notation where it is replaced by the nth value in `...args`

132 > * @example `localize('sayHello', 'hello {0}', name)`

133 > *

134 > * @returns ILocalizedString which contains the localized string and the original string.

135 > */

136 > export function localize2(key: string, message: string, ...args: (string | number | boolean | undefined | null)[]): ILocalizedString;

137 >

138 > /**

139 > * @skipMangle

140 > */

141 > export function localize2(data: ILocalizeInfo | string /* | number when built */, originalMessage: string, ...args: (string | number | boolean | undefined | null)[]): ILocalizedString {

142 let message: string;

143 if (typeof data === 'number') {

154 };

155 }

156 > nls.ts

157 > export interface INLSLanguagePackConfiguration {

158 >

159 > /**

160 > * The path to the translations config file that contains pointers to

161 > * all message bundles for `main` and extensions.

162 > */

163 > readonly translationsConfigFile: string;

164 >

165 > /**

166 > * The path to the file containing the translations for this language

167 > * pack as flat string array.

168 > */

169 > readonly messagesFile: string;

170 >

171 > /**

172 > * The path to the file that can be used to signal a corrupt language

173 > * pack, for example when reading the `messagesFile` fails. This will

174 > * instruct the application to re-create the cache on next startup.

175 > */

176 > readonly corruptMarkerFile: string;

177 > }

178 >

179 > export interface INLSConfiguration {

180 >

181 > /**

182 > * Locale as defined in `argv.json` or `app.getLocale()`.

183 > */

184 > readonly userLocale: string;

185 >

186 > /**

187 > * Locale as defined by the OS (e.g. `app.getPreferredSystemLanguages()`).

188 > */

189 > readonly osLocale: string;

190 >

191 > /**

192 > * The actual language of the UI that ends up being used considering `userLocale`

193 > * and `osLocale`.

194 > */

195 > readonly resolvedLanguage: string;

196 >

197 > /**

198 > * Defined if a language pack is used that is not the

199 > * default english language pack. This requires a language

200 > * pack to be installed as extension.

201 > */

202 > readonly languagePack?: INLSLanguagePackConfiguration;

203 >

204 > /**

205 > * The path to the file containing the default english messages

206 > * as flat string array. The file is only present in built

207 > * versions of the application.

208 > */

209 > readonly defaultMessagesFile: string;

210 >

211 > /**

212 > * Below properties are deprecated and only there to continue support

213 > * for `vscode-nls` module that depends on them.

214 > * Refs https://github.com/microsoft/vscode-nls/blob/main/src/node/main.ts#L36-L46

215 > */

216 > /** @deprecated */

217 > readonly locale: string;

218 > /** @deprecated */

219 > readonly availableLanguages: Record<string, string>;

220 > /** @deprecated */

221 > readonly _languagePackSupport?: boolean;

222 > /** @deprecated */

223 > readonly _languagePackId?: string;

224 > /** @deprecated */

225 > readonly _translationsConfigFile?: string;

226 > /** @deprecated */

227 > readonly _cacheRoot?: string;

228 > /** @deprecated */

229 > readonly _resolvedLanguagePackCoreLocation?: string;

230 > /** @deprecated */

231 > readonly _corruptedFile?: string;

232 > }

233 >

234 > export interface ILanguagePack {

235 > readonly hash: string;

236 > readonly label: string | undefined;

237 > readonly extensions: {

238 > readonly extensionIdentifier: { readonly id: string; readonly uuid?: string };

239 > readonly version: string;

240 > }[];

241 > readonly translations: Record<string, string | undefined>;

242 > }

243 >

244 > export type ILanguagePacks = Record<string, ILanguagePack | undefined>;

src/vs/base/common/observableInternal/base.ts 206 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- base.ts

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 { DisposableStore, onUnexpectedError } from './commonFacade/deps.js';

7 >

8 > /**

9 > * Represents an observable value.

10 > *

11 > * @template T The type of the values the observable can hold.

12 > */

13 > // This interface exists so that, for example for string observables,

14 > // typescript renders the type as `IObservable<string>` instead of `IObservable<string, unknown>`.

15 > export interface IObservable<T> extends IObservableWithChange<T, unknown> { }

16 >

17 > /**

18 > * Represents an observable value.

19 > *

20 > * @template T The type of the values the observable can hold.

21 > * @template TChange The type used to describe value changes

22 > * (usually `void` and only used in advanced scenarios).

23 > * While observers can miss temporary values of an observable,

24 > * they will receive all change values (as long as they are subscribed)!

25 > */

26 > export interface IObservableWithChange<T, TChange = unknown> {

27 > /**

28 > * Returns the current value.

29 > *

30 > * Calls {@link IObserver.handleChange} if the observable notices that the value changed.

31 > * Must not be called from {@link IObserver.handleChange}!

32 > */

33 > get(): T;

34 >

35 > /**

36 > * Forces the observable to check for changes and report them.

37 > *

38 > * Has the same effect as calling {@link IObservable.get}, but does not force the observable

39 > * to actually construct the value, e.g. if change deltas are used.

40 > * Calls {@link IObserver.handleChange} if the observable notices that the value changed.

41 > * Must not be called from {@link IObserver.handleChange}!

42 > */

43 > reportChanges(): void;

44 >

45 > /**

46 > * Adds the observer to the set of subscribed observers.

47 > * This method is idempotent.

48 > */

49 > addObserver(observer: IObserver): void;

50 >

51 > /**

52 > * Removes the observer from the set of subscribed observers.

53 > * This method is idempotent.

54 > */

55 > removeObserver(observer: IObserver): void;

56 >

57 > // #region These members have a standard implementation and are only part of the interface for convenience.

58 >

59 > /**

60 > * Reads the current value and subscribes the reader to this observable.

61 > *

62 > * Calls {@link IReader.readObservable} if a reader is given, otherwise {@link IObservable.get}

63 > * (see {@link ConvenientObservable.read} for the implementation).

64 > */

65 > read(reader: IReader | undefined): T;

66 >

67 > /**

68 > * Makes sure this value is computed eagerly.

69 > */

70 > recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;

71 >

72 > /**

73 > * Makes sure this value is cached.

74 > */

75 > keepObserved(store: DisposableStore): IObservable<T>;

76 >

77 > /**

78 > * Creates a derived observable that depends on this observable.

79 > * Use the reader to read other observables

80 > * (see {@link ConvenientObservable.map} for the implementation).

81 > */

82 > map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;

83 > map<TNew>(owner: object, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;

84 >

85 > flatten<TNew>(this: IObservable<IObservable<TNew>>): IObservable<TNew>;

86 >

87 > /**

88 > * ONLY FOR DEBUGGING!

89 > * Logs computations of this derived.

90 > */

91 > log(): IObservableWithChange<T, TChange>;

92 >

93 > /**

94 > * A human-readable name for debugging purposes.

95 > */

96 > readonly debugName: string;

97 >

98 > /**

99 > * This property captures the type of the change object. Do not use it at runtime!

100 > */

101 > readonly TChange: TChange;

102 >

103 > // #endregion

104 > }

105 >

106 > /**

107 > * Represents an observer that can be subscribed to an observable.

108 > *

109 > * If an observer is subscribed to an observable and that observable didn't signal

110 > * a change through one of the observer methods, the observer can assume that the

111 > * observable didn't change.

112 > * If an observable reported a possible change, {@link IObservable.reportChanges} forces

113 > * the observable to report an actual change if there was one.

114 > */

115 > export interface IObserver {

116 > /**

117 > * Signals that the given observable might have changed and a transaction potentially modifying that observable started.

118 > * Before the given observable can call this method again, is must call {@link IObserver.endUpdate}.

119 > *

120 > * Implementations must not get/read the value of other observables, as they might not have received this event yet!

121 > * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.

122 > */

123 > beginUpdate<T>(observable: IObservable<T>): void;

124 >

125 > /**

126 > * Signals that the transaction that potentially modified the given observable ended.

127 > * This is a good place to react to (potential) changes.

128 > */

129 > endUpdate<T>(observable: IObservable<T>): void;

130 >

131 > /**

132 > * Signals that the given observable might have changed.

133 > * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.

134 > *

135 > * Implementations must not get/read the value of other observables, as they might not have received this event yet!

136 > * The change should be processed lazily or in {@link IObserver.endUpdate}.

137 > */

138 > handlePossibleChange<T>(observable: IObservable<T>): void;

139 >

140 > /**

141 > * Signals that the given {@link observable} changed.

142 > *

143 > * Implementations must not get/read the value of other observables, as they might not have received this event yet!

144 > * The change should be processed lazily or in {@link IObserver.endUpdate}.

145 > *

146 > * @param change Indicates how or why the value changed.

147 > */

148 > handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;

149 > }

150 >

151 > /**

152 > * A reader allows code to track what it depends on, so the caller knows when the computed value or produced side-effect is no longer valid.

153 > * Use `derived(reader => ...)` to turn code that needs a reader into an observable value.

154 > */

155 > export interface IReader {

156 > /**

157 > * Reads the value of an observable and subscribes to it.

158 > */

159 > readObservable<T>(observable: IObservableWithChange<T, any>): T;

160 > }

161 >

162 > export interface ISettable<T, TChange = void> {

163 > /**

164 > * Sets the value of the observable.

165 > * Use a transaction to batch multiple changes (with a transaction, observers only react at the end of the transaction).

166 > *

167 > * @param transaction When given, value changes are handled on demand or when the transaction ends.

168 > * @param change Describes how or why the value changed.

169 > */

170 > set(value: T, transaction: ITransaction | undefined, change: TChange): void;

171 > }

172 >

173 > export interface ITransaction {

174 > /**

175 > * Calls {@link Observer.beginUpdate} immediately

176 > * and {@link Observer.endUpdate} when the transaction ends.

177 > */

178 > updateObserver(observer: IObserver, observable: IObservableWithChange<any, any>): void;

179 > }

180 >

181 > /**

182 > * This function is used to indicate that the caller recovered from an error that indicates a bug.

183 > */

184 > export function handleBugIndicatingErrorRecovery(message: string) {

185 const err = new Error('BugIndicatingErrorRecovery: ' + message);

186 onUnexpectedError(err);

187 console.error('recovered from an error that indicates a bug', err);

188 }

189 > base.ts

190 > /**

191 > * A settable observable.

192 > */

193 > export interface ISettableObservable<T, TChange = void> extends IObservableWithChange<T, TChange>, ISettable<T, TChange> {

194 > }

195 >

196 > export interface IReaderWithStore extends IReader {

197 > /**

198 > * Items in this store get disposed just before the observable recomputes/reruns or when it becomes unobserved.

199 > */

200 > get store(): DisposableStore;

201 >

202 > /**

203 > * Items in this store get disposed just after the observable recomputes/reruns or when it becomes unobserved.

204 > * This is important if the current run needs the undisposed result from the last run.

205 > *

206 > * Warning: Items in this store might still get disposed before dependents (that read the now disposed value in the past) are recomputed with the new (undisposed) value!

207 > * A clean solution for this is ref counting.

208 > */

209 > get delayedStore(): DisposableStore;

210 > }

src/vs/base/common/observableInternal/logging/debugger/devToolsLogger.ts 204 covered LOC · 24 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- devToolsLogger.ts

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 { AutorunObserver, AutorunState } from '../../reactions/autorunImpl.js';

7 > import { TransactionImpl } from '../../transaction.js';

8 > import { IChangeInformation, IObservableLogger } from '../logging.js';

9 > import { formatValue } from '../consoleObservableLogger.js';

10 > import { ObsDebuggerApi, IObsDeclaration, ObsInstanceId, ObsStateUpdate, ITransactionState, ObserverInstanceState } from './debuggerApi.js';

11 > import { registerDebugChannel } from './debuggerRpc.js';

12 > import { deepAssign, deepAssignDeleteNulls, Throttler } from './utils.js';

13 > import { isDefined } from '../../../types.js';

14 > import { FromEventObservable } from '../../observables/observableFromEvent.js';

15 > import { BugIndicatingError, onUnexpectedError } from '../../../errors.js';

16 > import { IObservable, IObserver } from '../../base.js';

17 > import { BaseObservable } from '../../observables/baseObservable.js';

18 > import { Derived, DerivedState } from '../../observables/derivedImpl.js';

19 > import { ObservableValue } from '../../observables/observableValue.js';

20 > import { DebugLocation } from '../../debugLocation.js';

21 >

22 > interface IInstanceInfo {

23 > declarationId: number;

24 > instanceId: number;

25 > }

26 >

27 > interface IObservableInfo extends IInstanceInfo {

28 > listenerCount: number;

29 > lastValue: string | undefined;

30 > updateCount: number;

31 > changedObservables: Set<IObservable<any>>;

32 > }

33 >

34 > interface IAutorunInfo extends IInstanceInfo {

35 > updateCount: number;

36 > changedObservables: Set<IObservable<any>>;

37 > }

38 >

39 > export class DevToolsLogger implements IObservableLogger {

40 > private static _instance: DevToolsLogger | undefined = undefined;

41 > public static getInstance(): DevToolsLogger {

42 if (DevToolsLogger._instance === undefined) {

43 DevToolsLogger._instance = new DevToolsLogger();

45 return DevToolsLogger._instance;

46 }

47 > devToolsLogger.ts

48 > private _declarationId = 0;

49 > private _instanceId = 0;

50 >

51 > private readonly _declarations = new Map</* declarationId + type */string, IObsDeclaration>();

52 > private readonly _instanceInfos = new WeakMap<object, IObservableInfo | IAutorunInfo>();

53 > private readonly _aliveInstances = new Map<ObsInstanceId, IObservable<any> | AutorunObserver>();

54 > private readonly _activeTransactions = new Set<TransactionImpl>();

55 >

56 > private readonly _channel = registerDebugChannel<ObsDebuggerApi>('observableDevTools', () => {

57 > return {

58 > notifications: {

59 > setDeclarationIdFilter: declarationIds => {

60 >

61 > },

62 > logObservableValue: (observableId) => {

63 > console.log('logObservableValue', observableId);

64 > },

65 > flushUpdates: () => {

66 > this._flushUpdates();

67 > },

68 > resetUpdates: () => {

69 > this._pendingChanges = null;

70 > this._channel.api.notifications.handleChange(this._fullState, true);

71 > },

72 > },

73 > requests: {

74 > getDeclarations: () => {

75 > const result: Record<string, IObsDeclaration> = {};

76 > for (const decl of this._declarations.values()) {

77 > result[decl.id] = decl;

78 > }

79 > return { decls: result };

80 > },

81 > getSummarizedInstances: () => {

82 > return null!;

83 > },

84 > getObservableValueInfo: instanceId => {

85 > const obs = this._aliveInstances.get(instanceId) as BaseObservable<any>;

86 > return {

87 > observers: [...obs.debugGetObservers()].map(d => this._formatObserver(d)).filter(isDefined),

88 > };

89 > },

90 > getDerivedInfo: instanceId => {

91 > const d = this._aliveInstances.get(instanceId) as Derived<any>;

92 > return {

93 > dependencies: [...d.debugGetState().dependencies].map(d => this._formatObservable(d)).filter(isDefined),

94 > observers: [...d.debugGetObservers()].map(d => this._formatObserver(d)).filter(isDefined),

95 > };

96 > },

97 > getAutorunInfo: instanceId => {

98 > const obs = this._aliveInstances.get(instanceId) as AutorunObserver;

99 > return {

100 > dependencies: [...obs.debugGetState().dependencies].map(d => this._formatObservable(d)).filter(isDefined),

101 > };

102 > },

103 > getTransactionState: () => {

104 > return this.getTransactionState();

105 > },

106 > setValue: (instanceId, jsonValue) => {

107 > const obs = this._aliveInstances.get(instanceId) as BaseObservable<any>;

108 >

109 > if (obs instanceof Derived) {

110 > obs.debugSetValue(jsonValue);

111 > } else if (obs instanceof ObservableValue) {

112 > obs.debugSetValue(jsonValue);

113 > } else if (obs instanceof FromEventObservable) {

114 > obs.debugSetValue(jsonValue);

115 > } else {

116 > throw new BugIndicatingError('Observable is not supported');

117 > }

118 >

119 > const observers = [...obs.debugGetObservers()];

120 > for (const d of observers) {

121 > d.beginUpdate(obs);

122 > }

123 > for (const d of observers) {

124 > d.handleChange(obs, undefined);

125 > }

126 > for (const d of observers) {

127 > d.endUpdate(obs);

128 > }

129 > },

130 > getValue: instanceId => {

131 > const obs = this._aliveInstances.get(instanceId) as BaseObservable<any>;

132 > if (obs instanceof Derived) {

133 > return formatValue(obs.debugGetState().value, 200);

134 > } else if (obs instanceof ObservableValue) {

135 > return formatValue(obs.debugGetState().value, 200);

136 > }

137 >

138 > return undefined;

139 > },

140 > logValue: (instanceId) => {

141 > const obs = this._aliveInstances.get(instanceId);

142 > if (obs && 'get' in obs) {

143 > console.log('Logged Value:', obs.get());

144 > } else {

145 > throw new BugIndicatingError('Observable is not supported');

146 > }

147 > },

148 > rerun: (instanceId) => {

149 > const obs = this._aliveInstances.get(instanceId);

150 > if (obs instanceof Derived) {

151 > obs.debugRecompute();

152 > } else if (obs instanceof AutorunObserver) {

153 > obs.debugRerun();

154 > } else {

155 > throw new BugIndicatingError('Observable is not supported');

156 > }

157 > },

158 > }

159 > };

160 > });

161 >

162 > private getTransactionState(): ITransactionState | undefined {

163 const affected: ObserverInstanceState[] = [];

164 const txs = [...this._activeTransactions];

188 return { names: txs.map(t => t.getDebugName() ?? 'tx'), affected };

189 }

190 > devToolsLogger.ts

191 > private _getObservableInfo(observable: IObservable<any>): IObservableInfo | undefined {

192 const info = this._instanceInfos.get(observable);

193 if (!info) {

197 return info as IObservableInfo;

198 }

199 > devToolsLogger.ts

200 > private _getAutorunInfo(autorun: AutorunObserver): IAutorunInfo | undefined {

201 const info = this._instanceInfos.get(autorun);

202 if (!info) {

206 return info as IAutorunInfo;

207 }

208 > devToolsLogger.ts

209 > private _getInfo(observer: IObserver, queue: (observer: IObserver) => void): ObserverInstanceState | undefined {

210 if (observer instanceof Derived) {

211 const observersToUpdate = [...observer.debugGetObservers()];

255 return undefined;

256 }

257 > devToolsLogger.ts

258 > private _formatObservable(obs: IObservable<any>): { name: string; instanceId: ObsInstanceId } | undefined {

259 const info = this._getObservableInfo(obs);

260 if (!info) { return undefined; }

261 return { name: obs.debugName, instanceId: info.instanceId };

262 }

263 > devToolsLogger.ts

264 > private _formatObserver(obs: IObserver): { name: string; instanceId: ObsInstanceId } | undefined {

265 if (obs instanceof Derived) {

266 return { name: obs.toString(), instanceId: this._getObservableInfo(obs)?.instanceId! };

273 return undefined;

274 }

275 > devToolsLogger.ts

276 > private constructor() {

277 DebugLocation.enable();

278 }

279 > devToolsLogger.ts

280 > private _pendingChanges: ObsStateUpdate | null = null;

281 > private readonly _changeThrottler = new Throttler();

282 >

283 > private readonly _fullState = {};

284 >

285 > private _handleChange(update: ObsStateUpdate): void {

286 deepAssignDeleteNulls(this._fullState, update);

287

294 this._changeThrottler.throttle(this._flushUpdates, 10);

295 }

296 > devToolsLogger.ts

297 > private readonly _flushUpdates = () => {

298 > if (this._pendingChanges !== null) {

299 > this._channel.api.notifications.handleChange(this._pendingChanges, false);

300 > this._pendingChanges = null;

301 > }

302 > };

303 >

304 > private _getDeclarationId(type: IObsDeclaration['type'], location: DebugLocation): number {

305 if (!location) {

306 return -1;

322 return decInfo.id;

323 }

324 > devToolsLogger.ts

325 > handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void {

326 const declarationId = this._getDeclarationId('observable/value', location);

327

336 this._instanceInfos.set(observable, info);

337 }

338 > devToolsLogger.ts

339 > handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void {

340 const info = this._getObservableInfo(observable);

341 if (!info) { return; }

364 info.listenerCount = newCount;

365 }

366 > devToolsLogger.ts

367 > handleObservableUpdated(observable: IObservable<any>, changeInfo: IChangeInformation): void {

368 if (observable instanceof Derived) {

369 this._handleDerivedRecomputed(observable, changeInfo);

383 }

384 }

385 > devToolsLogger.ts

386 > handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void {

387 const declarationId = this._getDeclarationId('autorun', location);

388 const info: IAutorunInfo = {

408 }

409 }

410 > handleAutorunDisposed(autorun: AutorunObserver): void { devToolsLogger.ts

411 const info = this._getAutorunInfo(autorun);

412 if (!info) { return; }

418 this._aliveInstances.delete(info.instanceId);

419 }

420 > handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void { devToolsLogger.ts

421 const info = this._getAutorunInfo(autorun);

422 if (!info) { return; }

424 info.changedObservables.add(observable);

425 }

426 > handleAutorunStarted(autorun: AutorunObserver): void { devToolsLogger.ts

427

428 }

429 > handleAutorunFinished(autorun: AutorunObserver): void { devToolsLogger.ts

430 const info = this._getAutorunInfo(autorun);

431 if (!info) { return; }

437 });

438 }

439 > devToolsLogger.ts

440 > handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void {

441 const info = this._getObservableInfo(derived);

442 if (info) {

444 }

445 }

446 > _handleDerivedRecomputed(observable: Derived<any>, changeInfo: IChangeInformation): void { devToolsLogger.ts

447 const info = this._getObservableInfo(observable);

448 if (!info) { return; }

459 }

460 }

461 > handleDerivedCleared(observable: Derived<any>): void { devToolsLogger.ts

462 const info = this._getObservableInfo(observable);

463 if (!info) { return; }

475 }

476 }

477 > handleBeginTransaction(transaction: TransactionImpl): void { devToolsLogger.ts

478 this._activeTransactions.add(transaction);

479 }

480 > handleEndTransaction(transaction: TransactionImpl): void { devToolsLogger.ts

481 this._activeTransactions.delete(transaction);

482 }

483 > } devToolsLogger.ts

src/vs/platform/configuration/common/configuration.ts 203 covered LOC · 12 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- configuration.ts

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 { assertNever } from '../../../base/common/assert.js';

7 > import { IStringDictionary } from '../../../base/common/collections.js';

8 > import { Event } from '../../../base/common/event.js';

9 > import * as types from '../../../base/common/types.js';

10 > import { URI, UriComponents } from '../../../base/common/uri.js';

11 > import { createDecorator } from '../../instantiation/common/instantiation.js';

12 > import { IWorkspaceFolder } from '../../workspace/common/workspace.js';

13 >

14 > export const IConfigurationService = createDecorator<IConfigurationService>('configurationService');

15 >

16 > export function isConfigurationOverrides(obj: unknown): obj is IConfigurationOverrides {

17 const thing = obj as IConfigurationOverrides;

18 return thing

21 && (!thing.resource || thing.resource instanceof URI);

22 }

23 > configuration.ts

24 > export interface IConfigurationOverrides {

25 > overrideIdentifier?: string | null;

26 > resource?: URI | null;

27 > }

28 >

29 > export function isConfigurationUpdateOverrides(obj: unknown): obj is IConfigurationUpdateOverrides {

30 const thing = obj as IConfigurationUpdateOverrides | IConfigurationOverrides;

31 return thing

35 && (!thing.resource || thing.resource instanceof URI);

36 }

37 > configuration.ts

38 > export type IConfigurationUpdateOverrides = Omit<IConfigurationOverrides, 'overrideIdentifier'> & { overrideIdentifiers?: string[] | null };

39 >

40 > export const enum ConfigurationTarget {

41 > APPLICATION = 1,

42 > USER,

43 > USER_LOCAL,

44 > USER_REMOTE,

45 > WORKSPACE,

46 > WORKSPACE_FOLDER,

47 > DEFAULT,

48 > MEMORY

49 > }

50 > export function ConfigurationTargetToString(configurationTarget: ConfigurationTarget) {

51 switch (configurationTarget) {

52 case ConfigurationTarget.APPLICATION: return 'APPLICATION';

60 }

61 }

62 > configuration.ts

63 > export interface IConfigurationChange {

64 > keys: string[];

65 > overrides: [string, string[]][];

66 > }

67 >

68 > export interface IConfigurationChangeEvent {

69 >

70 > readonly source: ConfigurationTarget;

71 > readonly affectedKeys: ReadonlySet<string>;

72 > readonly change: IConfigurationChange;

73 >

74 > affectsConfiguration(configuration: string, overrides?: IConfigurationOverrides): boolean;

75 > }

76 >

77 > export interface IInspectValue<T> {

78 > readonly value?: T;

79 > readonly override?: T;

80 > readonly overrides?: { readonly identifiers: string[]; readonly value: T }[];

81 > }

82 >

83 > export interface IConfigurationValue<T> {

84 >

85 > readonly defaultValue?: T;

86 > readonly applicationValue?: T;

87 > readonly userValue?: T;

88 > readonly userLocalValue?: T;

89 > readonly userRemoteValue?: T;

90 > readonly workspaceValue?: T;

91 > readonly workspaceFolderValue?: T;

92 > readonly memoryValue?: T;

93 > readonly policyValue?: T;

94 > readonly value?: T;

95 >

96 > readonly default?: IInspectValue<T>;

97 > readonly application?: IInspectValue<T>;

98 > readonly user?: IInspectValue<T>;

99 > readonly userLocal?: IInspectValue<T>;

100 > readonly userRemote?: IInspectValue<T>;

101 > readonly workspace?: IInspectValue<T>;

102 > readonly workspaceFolder?: IInspectValue<T>;

103 > readonly memory?: IInspectValue<T>;

104 > readonly policy?: { value?: T };

105 >

106 > readonly overrideIdentifiers?: string[];

107 > }

108 >

109 > export function getConfigValueInTarget<T>(configValue: IConfigurationValue<T>, scope: ConfigurationTarget): T | undefined {

110 switch (scope) {

111 case ConfigurationTarget.APPLICATION:

129 }

130 }

131 > configuration.ts

132 > export function isConfigured<T>(configValue: IConfigurationValue<T>): configValue is IConfigurationValue<T> & { value: T } {

133 return configValue.applicationValue !== undefined ||

134 configValue.userValue !== undefined ||

138 configValue.workspaceFolderValue !== undefined;

139 }

140 > configuration.ts

141 > export interface IConfigurationUpdateOptions {

142 > /**

143 > * If `true`, do not notifies the error to user by showing the message box. Default is `false`.

144 > */

145 > donotNotifyError?: boolean;

146 > /**

147 > * How to handle dirty file when updating the configuration.

148 > */

149 > handleDirtyFile?: 'save' | 'revert';

150 > }

151 >

152 > export interface IConfigurationService {

153 > readonly _serviceBrand: undefined;

154 >

155 > readonly onDidChangeConfiguration: Event<IConfigurationChangeEvent>;

156 >

157 > getConfigurationData(): IConfigurationData | null;

158 >

159 > /**

160 > * Fetches the value of the section for the given overrides.

161 > * Value can be of native type or an object keyed off the section name.

162 > *

163 > * @param section - Section of the configuration. Can be `null` or `undefined`.

164 > * @param overrides - Overrides that has to be applied while fetching

165 > *

166 > */

167 > getValue<T>(): T;

168 > getValue<T>(section: string): T;

169 > getValue<T>(overrides: IConfigurationOverrides): T;

170 > getValue<T>(section: string, overrides: IConfigurationOverrides): T;

171 >

172 > /**

173 > * Update a configuration value.

174 > *

175 > * Use `target` to update the configuration in a specific `ConfigurationTarget`.

176 > *

177 > * Use `overrides` to update the configuration for a resource or for override identifiers or both.

178 > *

179 > * Passing a resource through overrides will update the configuration in the workspace folder containing that resource.

180 > *

181 > * *Note 1:* Updating configuration to a default value will remove the configuration from the requested target. If not target is passed, it will be removed from all writeable targets.

182 > *

183 > * *Note 2:* Use `undefined` value to remove the configuration from the given target. If not target is passed, it will be removed from all writeable targets.

184 > *

185 > * Use `donotNotifyError` and set it to `true` to surpresss errors.

186 > *

187 > * @param key setting to be updated

188 > * @param value The new value

189 > */

190 > updateValue(key: string, value: unknown): Promise<void>;

191 > updateValue(key: string, value: unknown, target: ConfigurationTarget): Promise<void>;

192 > updateValue(key: string, value: unknown, overrides: IConfigurationOverrides | IConfigurationUpdateOverrides): Promise<void>;

193 > updateValue(key: string, value: unknown, overrides: IConfigurationOverrides | IConfigurationUpdateOverrides, target: ConfigurationTarget, options?: IConfigurationUpdateOptions): Promise<void>;

194 >

195 > inspect<T>(key: string, overrides?: IConfigurationOverrides): IConfigurationValue<Readonly<T>>;

196 >

197 > reloadConfiguration(target?: ConfigurationTarget | IWorkspaceFolder): Promise<void>;

198 >

199 > keys(): {

200 > default: string[];

201 > policy: string[];

202 > user: string[];

203 > workspace: string[];

204 > workspaceFolder: string[];

205 > memory?: string[];

206 > };

207 > }

208 >

209 > export interface IConfigurationModel {

210 > contents: IStringDictionary<unknown>;

211 > keys: string[];

212 > overrides: IOverrides[];

213 > raw?: ReadonlyArray<IStringDictionary<unknown>> | IStringDictionary<unknown>;

214 > }

215 >

216 > export interface IOverrides {

217 > keys: string[];

218 > contents: IStringDictionary<unknown>;

219 > identifiers: string[];

220 > }

221 >

222 > export interface IConfigurationData {

223 > defaults: IConfigurationModel;

224 > policy: IConfigurationModel;

225 > application: IConfigurationModel;

226 > userLocal: IConfigurationModel;

227 > userRemote: IConfigurationModel;

228 > workspace: IConfigurationModel;

229 > folders: [UriComponents, IConfigurationModel][];

230 > }

231 >

232 > export interface IConfigurationCompareResult {

233 > added: string[];

234 > removed: string[];

235 > updated: string[];

236 > overrides: [string, string[]][];

237 > }

238 >

239 > export function toValuesTree(properties: IStringDictionary<unknown>, conflictReporter: (message: string) => void): IStringDictionary<unknown> {

240 const root = Object.create(null);

241

246 return root;

247 }

248 > configuration.ts

249 > export function addToValueTree(settingsTreeRoot: IStringDictionary<unknown>, key: string, value: unknown, conflictReporter: (message: string) => void): void {

250 const segments = key.split('.');

251 const last = segments.pop()!;

282 }

283 }

284 > configuration.ts

285 > export function removeFromValueTree(valueTree: IStringDictionary<unknown>, key: string): void {

286 const segments = key.split('.');

287 doRemoveFromValueTree(valueTree, segments);

288 }

289 > configuration.ts

290 function doRemoveFromValueTree(valueTree: IStringDictionary<unknown> | unknown, segments: string[]): void {

291 if (!valueTree) {

311 }

312 }

313 > configuration.ts

314 > /**

315 > * A helper function to get the configuration value with a specific settings path (e.g. config.some.setting)

316 > */

317 > export function getConfigurationValue<T>(config: IStringDictionary<unknown>, settingPath: string): T | undefined;

318 > export function getConfigurationValue<T>(config: IStringDictionary<unknown>, settingPath: string, defaultValue: T): T;

319 > export function getConfigurationValue<T>(config: IStringDictionary<unknown>, settingPath: string, defaultValue?: T): T | undefined {

320 function accessSetting(config: IStringDictionary<unknown>, path: string[]): unknown {

321 let current: unknown = config;

334 return typeof result === 'undefined' ? defaultValue : result as T;

335 }

336 > configuration.ts

337 > export function merge(base: IStringDictionary<unknown>, add: IStringDictionary<unknown>, overwrite: boolean): void {

338 Object.keys(add).forEach(key => {

339 if (key !== '__proto__') {

350 });

351 }

352 > configuration.ts

353 > export function getLanguageTagSettingPlainKey(settingKey: string) {

354 return settingKey

355 .replace(/^\[/, '')

src/vs/platform/contextkey/common/scanner.ts 203 covered LOC · 58 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- scanner.ts

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 { CharCode } from '../../../base/common/charCode.js';

7 > import { illegalState } from '../../../base/common/errors.js';

8 > import { localize } from '../../../nls.js';

9 >

10 > export const enum TokenType {

11 > LParen,

12 > RParen,

13 > Neg,

14 > Eq,

15 > NotEq,

16 > Lt,

17 > LtEq,

18 > Gt,

19 > GtEq,

20 > RegexOp,

21 > RegexStr,

22 > True,

23 > False,

24 > In,

25 > Not,

26 > And,

27 > Or,

28 > Str,

29 > QuotedStr,

30 > Error,

31 > EOF,

32 > }

33 >

34 > export type Token =

35 > | { type: TokenType.LParen; offset: number }

36 > | { type: TokenType.RParen; offset: number }

37 > | { type: TokenType.Neg; offset: number }

38 > | { type: TokenType.Eq; offset: number; isTripleEq: boolean }

39 > | { type: TokenType.NotEq; offset: number; isTripleEq: boolean }

40 > | { type: TokenType.Lt; offset: number }

41 > | { type: TokenType.LtEq; offset: number }

42 > | { type: TokenType.Gt; offset: number }

43 > | { type: TokenType.GtEq; offset: number }

44 > | { type: TokenType.RegexOp; offset: number }

45 > | { type: TokenType.RegexStr; offset: number; lexeme: string }

46 > | { type: TokenType.True; offset: number }

47 > | { type: TokenType.False; offset: number }

48 > | { type: TokenType.In; offset: number }

49 > | { type: TokenType.Not; offset: number }

50 > | { type: TokenType.And; offset: number }

51 > | { type: TokenType.Or; offset: number }

52 > | { type: TokenType.Str; offset: number; lexeme: string }

53 > | { type: TokenType.QuotedStr; offset: number; lexeme: string }

54 > | { type: TokenType.Error; offset: number; lexeme: string }

55 > | { type: TokenType.EOF; offset: number };

56 >

57 > type KeywordTokenType = TokenType.Not | TokenType.In | TokenType.False | TokenType.True;

58 > type TokenTypeWithoutLexeme =

59 > TokenType.LParen |

60 > TokenType.RParen |

61 > TokenType.Neg |

62 > TokenType.Lt |

63 > TokenType.LtEq |

64 > TokenType.Gt |

65 > TokenType.GtEq |

66 > TokenType.RegexOp |

67 > TokenType.True |

68 > TokenType.False |

69 > TokenType.In |

70 > TokenType.Not |

71 > TokenType.And |

72 > TokenType.Or |

73 > TokenType.EOF;

74 >

75 > /**

76 > * Example:

77 > * `foo == bar'` - note how single quote doesn't have a corresponding closing quote,

78 > * so it's reported as unexpected

79 > */

80 > export type LexingError = {

81 > offset: number; /** note that this doesn't take into account escape characters from the original encoding of the string, e.g., within an extension manifest file's JSON encoding */

82 > lexeme: string;

83 > additionalInfo?: string;

84 > };

85 >

86 function hintDidYouMean(...meant: string[]) {

87 switch (meant.length) {

96 }

97 }

98 > scanner.ts

99 > const hintDidYouForgetToOpenOrCloseQuote = localize('contextkey.scanner.hint.didYouForgetToOpenOrCloseQuote', "Did you forget to open or close the quote?");

100 > const hintDidYouForgetToEscapeSlash = localize('contextkey.scanner.hint.didYouForgetToEscapeSlash', "Did you forget to escape the '/' (slash) character? Put two backslashes before it to escape, e.g., '\\\\/\'.");

101 >

102 > /**

103 > * A simple scanner for context keys.

104 > *

105 > * Example:

106 > *

107 > * ```ts

108 > * const scanner = new Scanner().reset('resourceFileName =~ /docker/ && !config.docker.enabled');

109 > * const tokens = [...scanner];

110 > * if (scanner.errorTokens.length > 0) {

111 > * scanner.errorTokens.forEach(err => console.error(`Unexpected token at ${err.offset}: ${err.lexeme}\nHint: ${err.additional}`));

112 > * } else {

113 > * // process tokens

114 > * }

115 > * ```

116 > */

117 > export class Scanner {

118 >

119 > static getLexeme(token: Token): string {

120 > switch (token.type) {

121 > case TokenType.LParen:

122 > return '('; scanner.ts

123 > case TokenType.RParen: scanner.ts

124 > return ')'; scanner.ts

125 > case TokenType.Neg: scanner.ts

126 > return '!'; scanner.ts

127 > case TokenType.Eq: scanner.ts

128 > return token.isTripleEq ? '===' : '=='; scanner.ts

129 > case TokenType.NotEq: scanner.ts

130 > return token.isTripleEq ? '!==' : '!='; scanner.ts

131 > case TokenType.Lt: scanner.ts

132 > return '<'; scanner.ts

133 > case TokenType.LtEq: scanner.ts

134 > return '<='; scanner.ts

135 > case TokenType.Gt: scanner.ts

136 > return '>'; scanner.ts

137 > case TokenType.GtEq: scanner.ts

138 > return '>='; scanner.ts

139 > case TokenType.RegexOp: scanner.ts

140 > return '=~'; scanner.ts

141 > case TokenType.RegexStr: scanner.ts

142 > return token.lexeme; scanner.ts

143 > case TokenType.True: scanner.ts

144 > return 'true'; scanner.ts

145 > case TokenType.False: scanner.ts

146 > return 'false'; scanner.ts

147 > case TokenType.In: scanner.ts

148 > return 'in'; scanner.ts

149 > case TokenType.Not: scanner.ts

150 > return 'not'; scanner.ts

151 > case TokenType.And: scanner.ts

152 > return '&&'; scanner.ts

153 > case TokenType.Or: scanner.ts

154 > return '||'; scanner.ts

155 > case TokenType.Str: scanner.ts

156 > return token.lexeme; scanner.ts

157 > case TokenType.QuotedStr: scanner.ts

158 > return token.lexeme; scanner.ts

159 > case TokenType.Error: scanner.ts

160 > return token.lexeme; scanner.ts

161 > case TokenType.EOF: scanner.ts

162 > return 'EOF'; scanner.ts

163 > default: scanner.ts

164 > throw illegalState(`unhandled token type: ${JSON.stringify(token)}; have you forgotten to add a case?`); scanner.ts

165 > } scanner.ts

166 > }

167 >

168 > private static _regexFlags = new Set(['i', 'g', 's', 'm', 'y', 'u'].map(ch => ch.charCodeAt(0)));

169 >

170 > private static _keywords = new Map<string, KeywordTokenType>([

171 > ['not', TokenType.Not],

172 > ['in', TokenType.In],

173 > ['false', TokenType.False],

174 > ['true', TokenType.True],

175 > ]);

176 >

177 > private _input: string = '';

178 > private _start: number = 0;

179 > private _current: number = 0;

180 > private _tokens: Token[] = [];

181 > private _errors: LexingError[] = [];

182 >

183 > get errors(): Readonly<LexingError[]> {

184 return this._errors;

185 }

186 > scanner.ts

187 > reset(value: string) {

188 this._input = value;

189

195 return this;

196 }

197 > scanner.ts

198 > scan() {

199 while (!this._isAtEnd()) {

200

267 return Array.from(this._tokens);

268 }

269 > scanner.ts

270 > private _match(expected: number): boolean {

271 if (this._isAtEnd()) {

272 return false;

278 return true;

279 }

280 > scanner.ts

281 > private _advance(): number {

282 return this._input.charCodeAt(this._current++);

283 }

284 > scanner.ts

285 > private _peek(): number {

286 return this._isAtEnd() ? CharCode.Null : this._input.charCodeAt(this._current);

287 }

288 > scanner.ts

289 > private _addToken(type: TokenTypeWithoutLexeme) {

290 this._tokens.push({ type, offset: this._start });

291 }

292 > scanner.ts

293 > private _error(additional?: string) {

294 const offset = this._start;

295 const lexeme = this._input.substring(this._start, this._current);

298 this._tokens.push(errToken);

299 }

300 > scanner.ts

301 > // u - unicode, y - sticky // TODO@ulugbekna: we accept double quotes as part of the string rather than as a delimiter (to preserve old parser's behavior)

302 > private stringRe = /[a-zA-Z0-9_<>\-\./\\:\*\?\+\[\]\^,#@;"%\$\p{L}-]+/uy;

303 > private _string() {

304 this.stringRe.lastIndex = this._start;

305 const match = this.stringRe.exec(this._input);

315 }

316 }

317 > scanner.ts

318 > // captures the lexeme without the leading and trailing '

319 > private _quotedString() {

320 while (this._peek() !== CharCode.SingleQuote && !this._isAtEnd()) { // TODO@ulugbekna: add support for escaping ' ?

321 this._advance();

332 this._tokens.push({ type: TokenType.QuotedStr, lexeme: this._input.substring(this._start + 1, this._current - 1), offset: this._start + 1 });

333 }

334 > scanner.ts

335 > /*

336 > * Lexing a regex expression: /.../[igsmyu]*

337 > * Based on https://github.com/microsoft/TypeScript/blob/9247ef115e617805983740ba795d7a8164babf89/src/compiler/scanner.ts#L2129-L2181

338 > *

339 > * Note that we want slashes within a regex to be escaped, e.g., /file:\\/\\/\\// should match `file:///`

340 > */

341 > private _regex() {

342 let p = this._current;

343

378 this._tokens.push({ type: TokenType.RegexStr, lexeme, offset: this._start });

379 }

380 > scanner.ts

381 > private _isAtEnd() {

382 return this._current >= this._input.length;

383 }

384 > } scanner.ts

src/vs/base/common/ternarySearchTree.ts 200 covered LOC · 63 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- ternarySearchTree.ts

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 { shuffle } from './arrays.js';

7 > import { assert } from './assert.js';

8 > import { CharCode } from './charCode.js';

9 > import { compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase } from './strings.js';

10 > import { URI } from './uri.js';

11 >

12 > export interface IKeyIterator<K> {

13 > reset(key: K): this;

14 > next(): this;

15 >

16 > hasNext(): boolean;

17 > cmp(a: string): number;

18 > value(): string;

19 > }

20 >

21 > export class StringIterator implements IKeyIterator<string> {

22

23 private _value: string = '';

24 private _pos: number = 0;

25 > ternarySearchTree.ts

26 > reset(key: string): this {

27 this._value = key;

28 this._pos = 0;

29 return this;

30 }

31 > ternarySearchTree.ts

32 > next(): this {

33 this._pos += 1;

34 return this;

35 }

36 > ternarySearchTree.ts

37 > hasNext(): boolean {

38 return this._pos < this._value.length - 1;

39 }

40 > ternarySearchTree.ts

41 > cmp(a: string): number {

42 const aCode = a.charCodeAt(0);

43 const thisCode = this._value.charCodeAt(this._pos);

44 return aCode - thisCode;

45 }

46 > ternarySearchTree.ts

47 > value(): string {

48 return this._value[this._pos];

49 }

50 > } ternarySearchTree.ts

51 >

52 > export class ConfigKeysIterator implements IKeyIterator<string> {

53 >

54 > private _value!: string;

55 > private _from!: number;

56 > private _to!: number;

57 >

58 > constructor(

59 private readonly _caseSensitive: boolean = true

60 ) { }

61 > ternarySearchTree.ts

62 > reset(key: string): this {

63 this._value = key;

64 this._from = 0;

66 return this.next();

67 }

68 > ternarySearchTree.ts

69 > hasNext(): boolean {

70 return this._to < this._value.length;

71 }

72 > ternarySearchTree.ts

73 > next(): this {

74 // this._data = key.split(/[\\/]/).filter(s => !!s);

75 this._from = this._to;

89 return this;

90 }

91 > ternarySearchTree.ts

92 > cmp(a: string): number {

93 return this._caseSensitive

94 ? compareSubstring(a, this._value, 0, a.length, this._from, this._to)

95 : compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);

96 }

97 > ternarySearchTree.ts

98 > value(): string {

99 return this._value.substring(this._from, this._to);

100 }

101 > } ternarySearchTree.ts

102 >

103 > export class PathIterator implements IKeyIterator<string> {

104 >

105 > private _value!: string;

106 > private _valueLen!: number;

107 > private _from!: number;

108 > private _to!: number;

109 >

110 > constructor(

111 > private readonly _splitOnBackslash: boolean = true, ternarySearchTree.ts

112 > private readonly _caseSensitive: boolean = true

113 > ) { }

114 > ternarySearchTree.ts

115 > reset(key: string): this {

116 this._from = 0;

117 this._to = 0;

127 return this.next();

128 }

129 > ternarySearchTree.ts

130 > hasNext(): boolean {

131 return this._to < this._valueLen;

132 }

133 > ternarySearchTree.ts

134 > next(): this {

135 // this._data = key.split(/[\\/]/).filter(s => !!s);

136 this._from = this._to;

150 return this;

151 }

152 > ternarySearchTree.ts

153 > cmp(a: string): number {

154 return this._caseSensitive

155 ? compareSubstring(a, this._value, 0, a.length, this._from, this._to)

156 : compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);

157 }

158 > ternarySearchTree.ts

159 > value(): string {

160 return this._value.substring(this._from, this._to);

161 }

162 > } ternarySearchTree.ts

163 >

164 > const enum UriIteratorState {

165 > Scheme = 1, Authority = 2, Path = 3, Query = 4, Fragment = 5

166 > }

167 >

168 > export class UriIterator implements IKeyIterator<URI> {

169 >

170 > private _pathIterator!: PathIterator;

171 > private _value!: URI;

172 > private _states: UriIteratorState[] = [];

173 > private _stateIdx: number = 0;

174 >

175 > constructor(

176 private readonly _ignorePathCasing: (uri: URI) => boolean,

177 private readonly _ignoreQueryAndFragment: (uri: URI) => boolean) { }

178 > ternarySearchTree.ts

179 > reset(key: URI): this {

180 this._value = key;

181 this._states = [];

204 return this;

205 }

206 > ternarySearchTree.ts

207 > next(): this {

208 if (this._states[this._stateIdx] === UriIteratorState.Path && this._pathIterator.hasNext()) {

209 this._pathIterator.next();

213 return this;

214 }

215 > ternarySearchTree.ts

216 > hasNext(): boolean {

217 return (this._states[this._stateIdx] === UriIteratorState.Path && this._pathIterator.hasNext())

218 || this._stateIdx < this._states.length - 1;

219 }

220 > ternarySearchTree.ts

221 > cmp(a: string): number {

222 if (this._states[this._stateIdx] === UriIteratorState.Scheme) {

223 return compareIgnoreCase(a, this._value.scheme);

233 throw new Error();

234 }

235 > ternarySearchTree.ts

236 > value(): string {

237 if (this._states[this._stateIdx] === UriIteratorState.Scheme) {

238 return this._value.scheme;

248 throw new Error();

249 }

250 > } ternarySearchTree.ts

251 >

252 > abstract class Undef {

253 >

254 > static readonly Val: unique symbol = Symbol('undefined_placeholder');

255 >

256 > static wrap<V>(value: V | undefined): V | typeof Undef.Val {

257 return value === undefined ? Undef.Val : value;

258 }

259 > ternarySearchTree.ts

260 > static unwrap<V>(value: V | typeof Undef.Val): V | undefined {

261 return value === Undef.Val ? undefined : value;

262 }

263 > } ternarySearchTree.ts

264 >

265 class TernarySearchTreeNode<K, V> {

266 height: number = 1;

271 mid: TernarySearchTreeNode<K, V> | undefined = undefined;

272 right: TernarySearchTreeNode<K, V> | undefined = undefined;

273 > ternarySearchTree.ts

274 > isEmpty(): boolean {

275 return !this.left && !this.mid && !this.right && this.value === undefined;

276 }

277 > ternarySearchTree.ts

278 > rotateLeft() {

279 const tmp = this.right!;

280 this.right = tmp.left;

284 return tmp;

285 }

286 > ternarySearchTree.ts

287 > rotateRight() {

288 const tmp = this.left!;

289 this.left = tmp.right;

293 return tmp;

294 }

295 > ternarySearchTree.ts

296 > updateHeight() {

297 this.height = 1 + Math.max(this.heightLeft, this.heightRight);

298 }

299 > ternarySearchTree.ts

300 > balanceFactor() {

301 return this.heightRight - this.heightLeft;

302 }

303 > ternarySearchTree.ts

304 > get heightLeft() {

305 return this.left?.height ?? 0;

306 }

307 > ternarySearchTree.ts

308 > get heightRight() {

309 return this.right?.height ?? 0;

310 }

311 > } ternarySearchTree.ts

312 >

313 > const enum Dir {

314 > Left = -1,

315 > Mid = 0,

316 > Right = 1

317 > }

318 >

319 > export class TernarySearchTree<K, V> {

320 >

321 > static forUris<E>(ignorePathCasing: (key: URI) => boolean = () => false, ignoreQueryAndFragment: (key: URI) => boolean = () => false): TernarySearchTree<URI, E> {

322 return new TernarySearchTree<URI, E>(new UriIterator(ignorePathCasing, ignoreQueryAndFragment));

323 }

324 > ternarySearchTree.ts

325 > static forPaths<E>(ignorePathCasing = false): TernarySearchTree<string, E> {

326 > return new TernarySearchTree<string, E>(new PathIterator(undefined, !ignorePathCasing)); ternarySearchTree.ts

327 > }

328 > ternarySearchTree.ts

329 > static forStrings<E>(): TernarySearchTree<string, E> {

330 return new TernarySearchTree<string, E>(new StringIterator());

331 }

332 > ternarySearchTree.ts

333 > static forConfigKeys<E>(): TernarySearchTree<string, E> {

334 return new TernarySearchTree<string, E>(new ConfigKeysIterator());

335 }

336 > ternarySearchTree.ts

337 > private _iter: IKeyIterator<K>;

338 > private _root: TernarySearchTreeNode<K, V> | undefined;

339 >

340 > constructor(segments: IKeyIterator<K>) {

341 > this._iter = segments; ternarySearchTree.ts

342 > }

343 > ternarySearchTree.ts

344 > clear(): void {

345 this._root = undefined;

346 }

347 > ternarySearchTree.ts

348 > /**

349 > * Fill the tree with the same value of the given keys

350 > */

351 > fill(element: V, keys: readonly K[]): void;

352 > /**

353 > * Fill the tree with given [key,value]-tuples

354 > */

355 > fill(values: readonly [K, V][]): void;

356 > fill(values: readonly [K, V][] | V, keys?: readonly K[]): void {

357 if (keys) {

358 const arr = keys.slice(0);

369 }

370 }

371 > ternarySearchTree.ts

372 > set(key: K, element: V): V | undefined {

373 const iter = this._iter.reset(key);

374 let node: TernarySearchTreeNode<K, V>;

476 return oldElement;

477 }

478 > ternarySearchTree.ts

479 > get(key: K): V | undefined {

480 return Undef.unwrap(this._getNode(key)?.value);

481 }

482 > ternarySearchTree.ts

483 > private _getNode(key: K) {

484 const iter = this._iter.reset(key);

485 let node = this._root;

502 return node;

503 }

504 > ternarySearchTree.ts

505 > has(key: K): boolean {

506 const node = this._getNode(key);

507 return !(node?.value === undefined && node?.mid === undefined);

508 }

509 > ternarySearchTree.ts

510 > delete(key: K): void {

511 return this._delete(key, false);

512 }

513 > ternarySearchTree.ts

514 > deleteSuperstr(key: K): void {

515 return this._delete(key, true);

516 }

517 > ternarySearchTree.ts

518 > private _delete(key: K, superStr: boolean): void {

519 const iter = this._iter.reset(key);

520 const stack: [Dir, TernarySearchTreeNode<K, V>][] = [];

620 this._root = this._balanceByStack(stack) ?? this._root;

621 }

622 > ternarySearchTree.ts

623 > private _min(node: TernarySearchTreeNode<K, V>, stack: [Dir, TernarySearchTreeNode<K, V>][]): TernarySearchTreeNode<K, V> {

624 while (node.left) {

625 stack.push([Dir.Left, node]);

628 return node;

629 }

630 > ternarySearchTree.ts

631 > private _balanceByStack(stack: [Dir, TernarySearchTreeNode<K, V>][]) {

632

633 for (let i = stack.length - 1; i >= 0; i--) {

679 return undefined;

680 }

681 > ternarySearchTree.ts

682 > findSubstr(key: K): V | undefined {

683 const iter = this._iter.reset(key);

684 let node = this._root;

703 return node && Undef.unwrap(node.value) || candidate;

704 }

705 > ternarySearchTree.ts

706 > findSuperstr(key: K): IterableIterator<[K, V]> | undefined {

707 return this._findSuperstrOrElement(key, false);

708 }

709 > ternarySearchTree.ts

710 > private _findSuperstrOrElement(key: K, allowValue: true): IterableIterator<[K, V]> | V | undefined;

711 > private _findSuperstrOrElement(key: K, allowValue: false): IterableIterator<[K, V]> | undefined;

712 > private _findSuperstrOrElement(key: K, allowValue: boolean): IterableIterator<[K, V]> | V | undefined {

713 const iter = this._iter.reset(key);

714 let node = this._root;

740 return undefined;

741 }

742 > ternarySearchTree.ts

743 > hasElementOrSubtree(key: K): boolean {

744 return this._findSuperstrOrElement(key, true) !== undefined;

745 }

746 > ternarySearchTree.ts

747 > forEach(callback: (value: V, index: K) => unknown): void {

748 for (const [key, value] of this) {

749 callback(value, key);

750 }

751 }

752 > ternarySearchTree.ts

753 > *[Symbol.iterator](): IterableIterator<[K, V]> {

754 yield* this._entries(this._root);

755 }

756 > ternarySearchTree.ts

757 > private _entries(node: TernarySearchTreeNode<K, V> | undefined): IterableIterator<[K, V]> {

758 const result: [K, V][] = [];

759 this._dfsEntries(node, result);

760 return result[Symbol.iterator]();

761 }

762 > ternarySearchTree.ts

763 > private _dfsEntries(node: TernarySearchTreeNode<K, V> | undefined, bucket: [K, V][]) {

764 // DFS

765 if (!node) {

779 }

780 }

781 > ternarySearchTree.ts

782 > // for debug/testing

783 > _isBalanced(): boolean {

784 const nodeIsBalanced = (node: TernarySearchTreeNode<unknown, unknown> | undefined): boolean => {

785 if (!node) {

794 return nodeIsBalanced(this._root);

795 }

796 > } ternarySearchTree.ts

src/vs/platform/telemetry/common/telemetryUtils.ts 199 covered LOC · 15 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- telemetryUtils.ts

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 { cloneAndChange, safeStringify } from '../../../base/common/objects.js';

7 > import { isObject } from '../../../base/common/types.js';

8 > import { URI } from '../../../base/common/uri.js';

9 > import { localize } from '../../../nls.js';

10 > import { IConfigurationService } from '../../configuration/common/configuration.js';

11 > import { IEnvironmentService } from '../../environment/common/environment.js';

12 > import { LoggerGroup } from '../../log/common/log.js';

13 > import { IProductService } from '../../product/common/productService.js';

14 > import { getRemoteName } from '../../remote/common/remoteHosts.js';

15 > import { verifyMicrosoftInternalDomain } from './commonProperties.js';

16 > import { ICustomEndpointTelemetryService, ITelemetryData, ITelemetryEndpoint, ITelemetryService, TelemetryConfiguration, TelemetryLevel, TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OLD_SETTING_ID, TELEMETRY_SETTING_ID } from './telemetry.js';

17 >

18 > /**

19 > * A special class used to denoting a telemetry value which should not be clean.

20 > * This is because that value is "Trusted" not to contain identifiable information such as paths.

21 > * NOTE: This is used as an API type as well, and should not be changed.

22 > */

23 > export class TelemetryTrustedValue<T> {

24 > // This is merely used as an identifier as the instance will be lost during serialization over the exthost

25 > public readonly isTrustedTelemetryValue = true;

26 > constructor(public readonly value: T) { }

27 > }

28 >

29 > export class NullTelemetryServiceShape implements ITelemetryService {

30 > declare readonly _serviceBrand: undefined;

31 > readonly telemetryLevel = TelemetryLevel.NONE;

32 > readonly sessionId = 'someValue.sessionId';

33 > readonly machineId = 'someValue.machineId';

34 > readonly sqmId = 'someValue.sqmId';

35 > readonly devDeviceId = 'someValue.devDeviceId';

36 > readonly firstSessionDate = 'someValue.firstSessionDate';

37 > readonly sendErrorTelemetry = false;

38 > publicLog() { }

39 > publicLog2() { }

40 > publicLogError() { }

41 > publicLogError2() { }

42 > setExperimentProperty() { }

43 > setCommonProperty() { }

44 > }

45 >

46 > export const NullTelemetryService = new NullTelemetryServiceShape();

47 >

48 > export class NullEndpointTelemetryService implements ICustomEndpointTelemetryService {

49 > _serviceBrand: undefined;

50 >

51 > async publicLog(_endpoint: ITelemetryEndpoint, _eventName: string, _data?: ITelemetryData): Promise<void> {

52 // noop

53 }

54 > telemetryUtils.ts

55 > async publicLogError(_endpoint: ITelemetryEndpoint, _errorEventName: string, _data?: ITelemetryData): Promise<void> {

56 // noop

57 }

58 > } telemetryUtils.ts

59 >

60 > export const telemetryLogId = 'telemetry';

61 > export const TelemetryLogGroup: LoggerGroup = { id: telemetryLogId, name: localize('telemetryLogName', "Telemetry") };

62 >

63 > export interface ITelemetryAppender {

64 > log(eventName: string, data: ITelemetryData): void;

65 > flush(): Promise<void>;

66 > }

67 >

68 > export const NullAppender: ITelemetryAppender = { log: () => null, flush: () => Promise.resolve(undefined) };

69 >

70 >

71 > /* __GDPR__FRAGMENT__

72 > "URIDescriptor" : {

73 > "mimeType" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

74 > "scheme": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

75 > "ext": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

76 > "path": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }

77 > }

78 > */

79 > export interface URIDescriptor {

80 > mimeType?: string;

81 > scheme?: string;

82 > ext?: string;

83 > path?: string;

84 > }

85 >

86 > /**

87 > * Determines whether or not we support logging telemetry.

88 > * This checks if the product is capable of collecting telemetry but not whether or not it can send it

89 > * For checking the user setting and what telemetry you can send please check `getTelemetryLevel`.

90 > * This returns true if `--disable-telemetry` wasn't used, the product.json allows for telemetry, and we're not testing an extension

91 > * If false telemetry is disabled throughout the product

92 > * @param productService

93 > * @param environmentService

94 > * @returns false - telemetry is completely disabled, true - telemetry is logged locally, but may not be sent

95 > */

96 > export function supportsTelemetry(productService: IProductService, environmentService: IEnvironmentService): boolean {

97 // If it's OSS and telemetry isn't disabled via the CLI we will allow it for logging only purposes

98 if (!environmentService.isBuilt && !environmentService.disableTelemetry) {

101 return !(environmentService.disableTelemetry || !productService.enableTelemetry);

102 }

103 > telemetryUtils.ts

104 > /**

105 > * Checks to see if we're in logging only mode to debug telemetry.

106 > * This is if telemetry is enabled and we're in OSS, but no telemetry key is provided so it's not being sent just logged.

107 > * @param productService

108 > * @param environmentService

109 > * @returns True if telemetry is actually disabled and we're only logging for debug purposes

110 > */

111 > export function isLoggingOnly(productService: IProductService, environmentService: IEnvironmentService): boolean {

112 // If we're testing an extension, log telemetry for debug purposes

113 if (environmentService.extensionTestsLocationURI) {

129 return true;

130 }

131 > telemetryUtils.ts

132 > /**

133 > * Determines how telemetry is handled based on the user's configuration.

134 > *

135 > * @param configurationService

136 > * @returns OFF, ERROR, ON

137 > */

138 > export function getTelemetryLevel(configurationService: IConfigurationService): TelemetryLevel {

139 const newConfig = configurationService.getValue<TelemetryConfiguration>(TELEMETRY_SETTING_ID);

140 const crashReporterConfig = configurationService.getValue<boolean | undefined>(TELEMETRY_CRASH_REPORTER_SETTING_ID);

158 }

159 }

160 > telemetryUtils.ts

161 > export interface Properties {

162 > [key: string]: string;

163 > }

164 >

165 > export interface Measurements {

166 > [key: string]: number;

167 > }

168 >

169 > export function validateTelemetryData(data?: unknown): { properties: Properties; measurements: Measurements } {

170

171 const properties: Properties = {};

204 };

205 }

206 > telemetryUtils.ts

207 > interface IRemoteAuthoringConfig {

208 > remoteExtensionTips?: { readonly [remoteName: string]: unknown };

209 > virtualWorkspaceExtensionTips?: { readonly [remoteName: string]: unknown };

210 > }

211 >

212 > export function cleanRemoteAuthority(remoteAuthority: string | undefined, config: IRemoteAuthoringConfig): string {

213 if (!remoteAuthority) {

214 return 'none';

229 return 'other';

230 }

231 > telemetryUtils.ts

232 function flatten(obj: unknown, result: Record<string, unknown>, order: number = 0, prefix?: string): void {

233 if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {

258 }

259 }

260 > telemetryUtils.ts

261 > /**

262 > * Whether or not this is an internal user

263 > * @param productService The product service

264 > * @param configService The config servivce

265 > * @returns true if internal, false otherwise

266 > */

267 > export function isInternalTelemetry(productService: IProductService, configService: IConfigurationService) {

268 const msftInternalDomains = productService.msftInternalDomains || [];

269 const internalTesting = configService.getValue<boolean>('telemetry.internalTesting');

270 return verifyMicrosoftInternalDomain(msftInternalDomains) || internalTesting;

271 }

272 > telemetryUtils.ts

273 > interface IPathEnvironment {

274 > appRoot: string;

275 > extensionsPath: string;

276 > userDataPath: string;

277 > userHome: URI;

278 > tmpDir: URI;

279 > }

280 >

281 > export function getPiiPathsFromEnvironment(paths: IPathEnvironment): string[] {

282 return [paths.appRoot, paths.extensionsPath, paths.userHome.fsPath, paths.tmpDir.fsPath, paths.userDataPath];

283 }

284 > telemetryUtils.ts

285 > //#region Telemetry Cleaning

286 >

287 > /**

288 > * Cleans a given stack of possible paths

289 > * @param stack The stack to sanitize

290 > * @param cleanupPatterns Cleanup patterns to remove from the stack

291 > * @returns The cleaned stack

292 > */

293 function anonymizeFilePaths(stack: string, cleanupPatterns: RegExp[]): string {

294

356 return updatedStack;

357 }

358 > telemetryUtils.ts

359 > const userDataRegexes = [

360 > { label: 'URL', regex: /[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^\s]*/ },

361 > { label: 'Google API Key', regex: /AIza[A-Za-z0-9_\\\-]{35}/ },

362 > { label: 'JWT', regex: /eyJ[0eXAiOiJKV1Qi|hbGci|a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+/ },

363 > { label: 'Slack Token', regex: /xox[pbar]\-[A-Za-z0-9]/ },

364 > { label: 'GitHub Token', regex: /(gh[psuro]_[a-zA-Z0-9]{36}|github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59})/ },

365 > { label: 'Generic Secret', regex: /(key|token|sig|secret|signature|password|passwd|pwd|android:value)[^a-zA-Z0-9]/i },

366 > { label: 'CLI Credentials', regex: /((login|psexec|(certutil|psexec)\.exe).{1,50}(\s-u(ser(name)?)?\s+.{3,100})?\s-(admin|user|vm|root)?p(ass(word)?)?\s+["']?[^$\-\/\s]|(^|[\s\r\n\\])net(\.exe)?.{1,5}(user\s+|share\s+\/user:| user -? secrets ? set) \s + [^ $\s \/])/ },

367 > { label: 'Microsoft Entra ID', regex: /eyJ(?:0eXAiOiJKV1Qi|hbGci|[a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+\.)/ },

368 > { label: 'Email', regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/ }

369 > ];

370 >

371 > /**

372 > * Redacts a value if it contains commonly leaked PII.

373 > * @param value The value returned (as-is) when no PII is detected

374 > * @param probe The string actually matched against the PII heuristics. Defaults

375 > * to `value`; callers may pass a value that includes a trailing delimiter (e.g. a

376 > * newline) so that heuristics relying on a non-alphanumeric boundary match the

377 > * same way they would against the original whole string.

378 > * @returns A `<REDACTED: ...>` marker if the probe matched, otherwise `value`

379 > */

380 function redactIfPossibleUserInfo(value: string, probe: string = value): string {

381 for (const secretRegex of userDataRegexes) {

386 return value;

387 }

388 > telemetryUtils.ts

389 > /**

390 > * Attempts to remove commonly leaked PII.

391 > *

392 > * When a match is found the check is applied per line so that a single suspicious

393 > * frame (e.g. a stack frame containing a function name such as `getStorageKey`

394 > * which matches the broad `Generic Secret` heuristic) only redacts that line —

395 > * replacing it with a `<REDACTED: ...>` marker — instead of wiping the entire

396 > * multi-line value such as a whole callstack.

397 > * @param property The property whose offending lines will be replaced with a redaction marker if they contain user data

398 > * @returns The new value for the property

399 > */

400 function removePropertiesWithPossibleUserInfo(property: string): string {

401 // If for some reason it is undefined we skip it (this shouldn't be possible);

436 return lines.join('\n');

437 }

438 > telemetryUtils.ts

439 >

440 > /**

441 > * Does a best possible effort to clean a data object from any possible PII.

442 > * @param data The data object to clean

443 > * @param paths Any additional patterns that should be removed from the data set

444 > * @returns A new object with the PII removed

445 > */

446 > export function cleanData(data: ITelemetryData | undefined, cleanUpPatterns: RegExp[]): Record<string, unknown> {

447 if (!data) {

448 return {};

475 });

476 }

477 > telemetryUtils.ts

478 > //#endregion

src/vs/base/common/jsonSchema.ts 194 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- jsonSchema.ts

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 > export type JSONSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'null' | 'array' | 'object';

7 >

8 > export interface IJSONSchema {

9 > id?: string;

10 > $id?: string;

11 > $schema?: string;

12 > type?: JSONSchemaType | JSONSchemaType[];

13 > title?: string;

14 > default?: any;

15 > definitions?: IJSONSchemaMap;

16 > description?: string;

17 > properties?: IJSONSchemaMap;

18 > patternProperties?: IJSONSchemaMap;

19 > additionalProperties?: boolean | IJSONSchema;

20 > minProperties?: number;

21 > maxProperties?: number;

22 > dependencies?: IJSONSchemaMap | { [prop: string]: string[] };

23 > items?: IJSONSchema | IJSONSchema[];

24 > minItems?: number;

25 > maxItems?: number;

26 > uniqueItems?: boolean;

27 > additionalItems?: boolean | IJSONSchema;

28 > pattern?: string;

29 > minLength?: number;

30 > maxLength?: number;

31 > minimum?: number;

32 > maximum?: number;

33 > exclusiveMinimum?: boolean | number;

34 > exclusiveMaximum?: boolean | number;

35 > multipleOf?: number;

36 > required?: string[];

37 > $ref?: string;

38 > anyOf?: IJSONSchema[];

39 > allOf?: IJSONSchema[];

40 > oneOf?: IJSONSchema[];

41 > not?: IJSONSchema;

42 > enum?: any[];

43 > format?: string;

44 >

45 > // schema draft 06

46 > const?: any;

47 > contains?: IJSONSchema;

48 > propertyNames?: IJSONSchema;

49 > examples?: any[];

50 >

51 > // schema draft 07

52 > $comment?: string;

53 > if?: IJSONSchema;

54 > then?: IJSONSchema;

55 > else?: IJSONSchema;

56 >

57 > // schema 2019-09

58 > unevaluatedProperties?: boolean | IJSONSchema;

59 > unevaluatedItems?: boolean | IJSONSchema;

60 > minContains?: number;

61 > maxContains?: number;

62 > deprecated?: boolean;

63 > dependentRequired?: { [prop: string]: string[] };

64 > dependentSchemas?: IJSONSchemaMap;

65 > $defs?: { [name: string]: IJSONSchema };

66 > $anchor?: string;

67 > $recursiveRef?: string;

68 > $recursiveAnchor?: string;

69 > $vocabulary?: any;

70 >

71 > // schema 2020-12

72 > prefixItems?: IJSONSchema[];

73 > $dynamicRef?: string;

74 > $dynamicAnchor?: string;

75 >

76 > // VSCode extensions

77 >

78 > defaultSnippets?: IJSONSchemaSnippet[];

79 > errorMessage?: string;

80 > patternErrorMessage?: string;

81 > deprecationMessage?: string;

82 > markdownDeprecationMessage?: string;

83 > enumDescriptions?: string[];

84 > markdownEnumDescriptions?: string[];

85 > markdownDescription?: string;

86 > doNotSuggest?: boolean;

87 > suggestSortText?: string;

88 > allowComments?: boolean;

89 > allowTrailingCommas?: boolean;

90 > secret?: boolean;

91 > }

92 >

93 > export interface IJSONSchemaMap {

94 > [name: string]: IJSONSchema;

95 > }

96 >

97 > export interface IJSONSchemaSnippet {

98 > label?: string;

99 > description?: string;

100 > body?: any; // a object that will be JSON stringified

101 > bodyText?: string; // an already stringified JSON object that can contain new lines (\n) and tabs (\t)

102 > }

103 >

104 > /**

105 > * Converts a basic JSON schema to a TypeScript type.

106 > */

107 > export type TypeFromJsonSchema<T> =

108 > // enum

109 > T extends { enum: infer EnumValues }

110 > ? UnionOf<EnumValues>

111 >

112 > // Object with list of required properties.

113 > // Values are required or optional based on `required` list.

114 > : T extends { type: 'object'; properties: infer P; required: infer RequiredList }

115 > ? {

116 > [K in keyof P]: IsRequired<K, RequiredList> extends true ? TypeFromJsonSchema<P[K]> : TypeFromJsonSchema<P[K]> | undefined;

117 > } & AdditionalPropertiesType<T>

118 >

119 > // Object with no required properties.

120 > // All values are optional

121 > : T extends { type: 'object'; properties: infer P }

122 > ? { [K in keyof P]: TypeFromJsonSchema<P[K]> | undefined } & AdditionalPropertiesType<T>

123 >

124 > // Array

125 > : T extends { type: 'array'; items: infer Items }

126 > ? Items extends [...infer R]

127 > // If items is an array, we treat it like a tuple

128 > ? { [K in keyof R]: TypeFromJsonSchema<Items[K]> }

129 > : Array<TypeFromJsonSchema<Items>>

130 >

131 > // oneOf / anyof

132 > // These are handled the same way as they both represent a union type.

133 > // However at the validation level, they have different semantics.

134 > : T extends { oneOf: infer I }

135 > ? MapSchemaToType<I>

136 > : T extends { anyOf: infer I }

137 > ? MapSchemaToType<I>

138 >

139 > // Primitive types

140 > : T extends { type: infer Type }

141 > // Basic type

142 > ? Type extends 'string' | 'number' | 'integer' | 'boolean' | 'null'

143 > ? SchemaPrimitiveTypeNameToType<Type>

144 > // Union of primitive types

145 > : Type extends [...infer R]

146 > ? UnionOf<{ [K in keyof R]: SchemaPrimitiveTypeNameToType<R[K]> }>

147 > : never

148 >

149 > // Fallthrough

150 > : never;

151 >

152 > type SchemaPrimitiveTypeNameToType<T> =

153 > T extends 'string' ? string :

154 > T extends 'number' | 'integer' ? number :

155 > T extends 'boolean' ? boolean :

156 > T extends 'null' ? null :

157 > never;

158 >

159 > type UnionOf<T> =

160 > T extends [infer First, ...infer Rest]

161 > ? First | UnionOf<Rest>

162 > : never;

163 >

164 > type IsRequired<K, RequiredList> =

165 > RequiredList extends []

166 > ? false

167 >

168 > : RequiredList extends [K, ...infer _]

169 > ? true

170 >

171 > : RequiredList extends [infer _, ...infer R]

172 > ? IsRequired<K, R>

173 >

174 > : false;

175 >

176 > type AdditionalPropertiesType<Schema> =

177 > Schema extends { additionalProperties: infer AP }

178 > ? AP extends false ? {} : { [key: string]: TypeFromJsonSchema<Schema['additionalProperties']> }

179 > : {};

180 >

181 > type MapSchemaToType<T> = T extends [infer First, ...infer Rest]

182 > ? TypeFromJsonSchema<First> | MapSchemaToType<Rest>

183 > : never;

184 >

185 > interface Equals { schemas: IJSONSchema[]; id?: string }

186 >

187 > export function getCompressedContent(schema: IJSONSchema): string {

188 let hasDups = false;

189

258 return str;

259 }

260 > jsonSchema.ts

261 > type IJSONSchemaRef = IJSONSchema | boolean;

262 >

263 function isObject(thing: unknown): thing is object {

264 return typeof thing === 'object' && thing !== null;

265 }

266 > jsonSchema.ts

267 > /*

268 > * Traverse a JSON schema and visit each schema node

269 > */

270 function traverseNodes(root: IJSONSchema, visit: (schema: IJSONSchema) => boolean) {

271 if (!root || typeof root !== 'object') {

src/vs/base/common/platform.ts 189 covered LOC · 12 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- platform.ts

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 * as nls from '../../nls.js';

7 >

8 > export const LANGUAGE_DEFAULT = 'en';

9 >

10 > let _isWindows = false;

11 > let _isMacintosh = false;

12 > let _isLinux = false;

13 > let _isLinuxSnap = false;

14 > let _isNative = false;

15 > let _isWeb = false;

16 > let _isElectron = false;

17 > let _isIOS = false;

18 > let _isCI = false;

19 > let _isMobile = false;

20 > let _locale: string | undefined = undefined;

21 > let _language: string = LANGUAGE_DEFAULT;

22 > let _platformLocale: string = LANGUAGE_DEFAULT;

23 > let _translationsConfigFile: string | undefined = undefined;

24 > let _userAgent: string | undefined = undefined;

25 >

26 > export interface IProcessEnvironment {

27 > [key: string]: string | undefined;

28 > }

29 >

30 > /**

31 > * This interface is intentionally not identical to node.js

32 > * process because it also works in sandboxed environments

33 > * where the process object is implemented differently. We

34 > * define the properties here that we need for `platform`

35 > * to work and nothing else.

36 > */

37 > export interface INodeProcess {

38 > platform: string;

39 > arch: string;

40 > env: IProcessEnvironment;

41 > versions?: {

42 > node?: string;

43 > electron?: string;

44 > chrome?: string;

45 > };

46 > type?: string;

47 > cwd: () => string;

48 > }

49 >

50 > declare const process: INodeProcess;

51 >

52 > const $globalThis: any = globalThis;

53 >

54 > let nodeProcess: INodeProcess | undefined = undefined;

55 > if (typeof $globalThis.vscode !== 'undefined' && typeof $globalThis.vscode.process !== 'undefined') {

56 // Native environment (sandboxed)

57 nodeProcess = $globalThis.vscode.process;

58 > } else if (typeof process !== 'undefined' && typeof process?.versions?.node === 'string') { platform.ts

59 > // Native environment (non-sandboxed)

60 > nodeProcess = process;

61 > }

62 >

63 > const isElectronProcess = typeof nodeProcess?.versions?.electron === 'string';

64 > const isElectronRenderer = isElectronProcess && nodeProcess?.type === 'renderer';

65 >

66 > interface INavigator {

67 > userAgent: string;

68 > maxTouchPoints?: number;

69 > language: string;

70 > }

71 > declare const navigator: INavigator;

72 >

73 > // Native environment

74 > if (typeof nodeProcess === 'object') {

75 > _isWindows = (nodeProcess.platform === 'win32');

76 > _isMacintosh = (nodeProcess.platform === 'darwin');

77 > _isLinux = (nodeProcess.platform === 'linux');

78 > _isLinuxSnap = _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION'];

79 > _isElectron = isElectronProcess;

80 > _isCI = !!nodeProcess.env['CI'] || !!nodeProcess.env['BUILD_ARTIFACTSTAGINGDIRECTORY'] || !!nodeProcess.env['GITHUB_WORKSPACE'];

81 > _locale = LANGUAGE_DEFAULT;

82 > _language = LANGUAGE_DEFAULT;

83 > const rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG'];

84 > if (rawNlsConfig) {

85 try {

86 const nlsConfig: nls.INLSConfiguration = JSON.parse(rawNlsConfig);

92 }

93 }

94 > _isNative = true; platform.ts

95 }

96

113 console.error('Unable to resolve platform.');

114 }

115 > platform.ts

116 > export const enum Platform {

117 > Web,

118 > Mac,

119 > Linux,

120 > Windows

121 > }

122 > export type PlatformName = 'Web' | 'Windows' | 'Mac' | 'Linux';

123 >

124 > export function PlatformToString(platform: Platform): PlatformName {

125 switch (platform) {

126 case Platform.Web: return 'Web';

130 }

131 }

132 > platform.ts

133 > let _platform: Platform = Platform.Web;

134 > if (_isMacintosh) {

135 _platform = Platform.Mac;

136 > } else if (_isWindows) { platform.ts

137 _platform = Platform.Windows;

138 > } else if (_isLinux) { platform.ts

139 > _platform = Platform.Linux;

140 > }

141 >

142 > export const isWindows = _isWindows;

143 > export const isMacintosh = _isMacintosh;

144 > export const isLinux = _isLinux;

145 > export const isLinuxSnap = _isLinuxSnap;

146 > export const isNative = _isNative;

147 > export const isElectron = _isElectron;

148 > export const isWeb = _isWeb;

149 > export const isWebWorker = (_isWeb && typeof $globalThis.importScripts === 'function');

150 > export const webWorkerOrigin = isWebWorker ? $globalThis.origin : undefined;

151 > export const isIOS = _isIOS;

152 > export const isMobile = _isMobile;

153 > /**

154 > * Whether we run inside a CI environment, such as

155 > * GH actions or Azure Pipelines.

156 > */

157 > export const isCI = _isCI;

158 > export const platform = _platform;

159 > export const userAgent = _userAgent;

160 >

161 > /**

162 > * The language used for the user interface. The format of

163 > * the string is all lower case (e.g. zh-tw for Traditional

164 > * Chinese or de for German)

165 > */

166 > export const language = _language;

167 >

168 > export namespace Language {

169 >

170 > export function value(): string {

171 return language;

172 }

173 > platform.ts

174 > export function isDefaultVariant(): boolean {

175 if (language.length === 2) {

176 return language === 'en';

181 }

182 }

183 > platform.ts

184 > export function isDefault(): boolean {

185 return language === 'en';

186 }

187 > } platform.ts

188 >

189 > /**

190 > * Desktop: The OS locale or the locale specified by --locale or `argv.json`.

191 > * Web: matches `platformLocale`.

192 > *

193 > * The UI is not necessarily shown in the provided locale.

194 > */

195 > export const locale = _locale;

196 >

197 > /**

198 > * This will always be set to the OS/browser's locale regardless of

199 > * what was specified otherwise. The format of the string is all

200 > * lower case (e.g. zh-tw for Traditional Chinese). The UI is not

201 > * necessarily shown in the provided locale.

202 > */

203 > export const platformLocale = _platformLocale;

204 >

205 > /**

206 > * The translations that are available through language packs.

207 > */

208 > export const translationsConfigFile = _translationsConfigFile;

209 >

210 > export const setTimeout0IsFaster = (typeof $globalThis.postMessage === 'function' && !$globalThis.importScripts);

211 >

212 > /**

213 > * See https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#:~:text=than%204%2C%20then-,set%20timeout%20to%204,-.

214 > *

215 > * Works similarly to `setTimeout(0)` but doesn't suffer from the 4ms artificial delay

216 > * that browsers set when the nesting level is > 5.

217 > */

218 > export const setTimeout0 = (() => {

219 > if (setTimeout0IsFaster) {

220 interface IQueueElement {

221 id: number;

246 };

247 }

248 > return (callback: () => void) => setTimeout(callback); platform.ts

249 > })();

250 >

251 > export const enum OperatingSystem {

252 > Windows = 1,

253 > Macintosh = 2,

254 > Linux = 3

255 > }

256 > export const OS = (_isMacintosh || _isIOS ? OperatingSystem.Macintosh : (_isWindows ? OperatingSystem.Windows : OperatingSystem.Linux));

257 >

258 > let _isLittleEndian = true;

259 > let _isLittleEndianComputed = false;

260 > export function isLittleEndian(): boolean {

261 if (!_isLittleEndianComputed) {

262 _isLittleEndianComputed = true;

269 return _isLittleEndian;

270 }

271 > platform.ts

272 > export const isChrome = !!(userAgent && userAgent.indexOf('Chrome') >= 0);

273 > export const isFirefox = !!(userAgent && userAgent.indexOf('Firefox') >= 0);

274 > export const isSafari = !!(!isChrome && (userAgent && userAgent.indexOf('Safari') >= 0));

275 > export const isEdge = !!(userAgent && userAgent.indexOf('Edg/') >= 0);

276 > export const isAndroid = !!(userAgent && userAgent.indexOf('Android') >= 0);

277 > export const hasElectronUserAgent = !!(userAgent && userAgent.indexOf('Electron') >= 0);

278 >

279 > export function isTahoeOrNewer(osVersion: string): boolean {

280 return parseFloat(osVersion) >= 25;

281 }

src/vs/base/common/errors.ts 183 covered LOC · 32 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- errors.ts

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 > export interface ErrorListenerCallback {

7 > (error: any): void;

8 > }

9 >

10 > export interface ErrorListenerUnbind {

11 > (): void;

12 > }

13 >

14 > // Avoid circular dependency on EventEmitter by implementing a subset of the interface.

15 > export class ErrorHandler {

16 > private unexpectedErrorHandler: (e: any) => void;

17 > private listeners: ErrorListenerCallback[];

18 >

19 > constructor() {

20 >

21 > this.listeners = [];

22 >

23 > this.unexpectedErrorHandler = function (e: any) {

24 setTimeout(() => {

25 if (e.stack) {

34 }, 0);

35 };

36 > } errors.ts

37 >

38 > addListener(listener: ErrorListenerCallback): ErrorListenerUnbind {

39 this.listeners.push(listener);

40

43 };

44 }

45 > errors.ts

46 > private emit(e: any): void {

47 this.listeners.forEach((listener) => {

48 listener(e);

49 });

50 }

51 > errors.ts

52 > private _removeListener(listener: ErrorListenerCallback): void {

53 this.listeners.splice(this.listeners.indexOf(listener), 1);

54 }

55 > errors.ts

56 > setUnexpectedErrorHandler(newUnexpectedErrorHandler: (e: any) => void): void {

57 > this.unexpectedErrorHandler = newUnexpectedErrorHandler;

58 > }

59 >

60 > getUnexpectedErrorHandler(): (e: any) => void {

61 return this.unexpectedErrorHandler;

62 }

63 > errors.ts

64 > onUnexpectedError(e: any): void {

65 this.unexpectedErrorHandler(e);

66 this.emit(e);

67 }

68 > errors.ts

69 > // For external errors, we don't want the listeners to be called

70 > onUnexpectedExternalError(e: any): void {

71 this.unexpectedErrorHandler(e);

72 }

73 > } errors.ts

74 >

75 > export const errorHandler = new ErrorHandler();

76 >

77 > /** @skipMangle */

78 > export function setUnexpectedErrorHandler(newUnexpectedErrorHandler: (e: any) => void): void {

79 > errorHandler.setUnexpectedErrorHandler(newUnexpectedErrorHandler);

80 > }

81 >

82 > /**

83 > * Returns if the error is a SIGPIPE error. SIGPIPE errors should generally be

84 > * logged at most once, to avoid a loop.

85 > *

86 > * @see https://github.com/microsoft/vscode-remote-release/issues/6481

87 > */

88 > export function isSigPipeError(e: unknown): e is Error {

89 if (!e || typeof e !== 'object') {

90 return false;

94 return cast.code === 'EPIPE' && cast.syscall?.toUpperCase() === 'WRITE';

95 }

96 > errors.ts

97 > /**

98 > * This function should only be called with errors that indicate a bug in the product.

99 > * E.g. buggy extensions/invalid user-input/network issues should not be able to trigger this code path.

100 > * If they are, this indicates there is also a bug in the product.

101 > */

102 > export function onBugIndicatingError(e: any): undefined {

103 errorHandler.onUnexpectedError(e);

104 return undefined;

105 }

106 > errors.ts

107 > export function onUnexpectedError(e: any): undefined {

108 // ignore errors from cancelled promises

109 if (!isCancellationError(e)) {

112 return undefined;

113 }

114 > errors.ts

115 > export function onUnexpectedExternalError(e: any): undefined {

116 // ignore errors from cancelled promises

117 if (!isCancellationError(e)) {

120 return undefined;

121 }

122 > errors.ts

123 > type ObjectWithCode = {

124 > readonly code: unknown;

125 > };

126 >

127 function hasErrorCode(error: object): error is ObjectWithCode {

128 return Object.hasOwn(error, 'code');

129 }

130 > errors.ts

131 > export function getErrorCode(error: unknown): string | undefined {

132 if (!error || typeof error !== 'object' || !hasErrorCode(error)) {

133 return undefined;

136 return typeof code === 'string' || typeof code === 'number' ? String(code) : undefined;

137 }

138 > errors.ts

139 > export interface SerializedError {

140 > readonly $isError: true;

141 > readonly name: string;

142 > readonly message: string;

143 > readonly stack: string;

144 > readonly noTelemetry: boolean;

145 > readonly code?: string;

146 > readonly cause?: SerializedError;

147 > }

148 >

149 > type ErrorWithCode = Error & {

150 > code: string | undefined;

151 > };

152 >

153 > export function transformErrorForSerialization(error: Error): SerializedError;

154 > export function transformErrorForSerialization(error: any): any;

155 > export function transformErrorForSerialization(error: any): any {

156 if (error instanceof Error) {

157 const { name, message, cause } = error;

172 return error;

173 }

174 > errors.ts

175 > export function transformErrorFromSerialization(data: SerializedError): Error {

176 let error: Error;

177 if (data.noTelemetry) {

191 return error;

192 }

193 > errors.ts

194 > // see https://github.com/v8/v8/wiki/Stack%20Trace%20API#basic-stack-traces

195 > export interface V8CallSite {

196 > getThis(): unknown;

197 > getTypeName(): string | null;

198 > getFunction(): Function | undefined;

199 > getFunctionName(): string | null;

200 > getMethodName(): string | null;

201 > getFileName(): string | null;

202 > getLineNumber(): number | null;

203 > getColumnNumber(): number | null;

204 > getEvalOrigin(): string | undefined;

205 > isToplevel(): boolean;

206 > isEval(): boolean;

207 > isNative(): boolean;

208 > isConstructor(): boolean;

209 > toString(): string;

210 > }

211 >

212 > export const canceledName = 'Canceled';

213 >

214 > /**

215 > * Checks if the given error is a promise in canceled state

216 > */

217 > export function isCancellationError(error: any): boolean {

218 if (error instanceof CancellationError) {

219 return true;

221 return error instanceof Error && error.name === canceledName && error.message === canceledName;

222 }

223 > errors.ts

224 > // !!!IMPORTANT!!!

225 > // Do NOT change this class because it is also used as an API-type.

226 > export class CancellationError extends Error {

227 > constructor() {

228 super(canceledName);

229 this.name = this.message;

230 }

231 > } errors.ts

232 >

233 > export class PendingMigrationError extends Error {

234 >

235 > private static readonly _name = 'PendingMigrationError';

236 >

237 > static is(error: unknown): error is PendingMigrationError {

238 return error instanceof PendingMigrationError || (error instanceof Error && error.name === PendingMigrationError._name);

239 }

240 > errors.ts

241 > constructor(message: string) {

242 super(message);

243 this.name = PendingMigrationError._name;

244 }

245 > } errors.ts

246 >

247 > /**

248 > * @deprecated use {@link CancellationError `new CancellationError()`} instead

249 > */

250 > export function canceled(): Error {

251 const error = new Error(canceledName);

252 error.name = error.message;

253 return error;

254 }

255 > errors.ts

256 > export function illegalArgument(name?: string): Error {

257 if (name) {

258 return new Error(`Illegal argument: ${name}`);

261 }

262 }

263 > errors.ts

264 > export function illegalState(name?: string): Error {

265 if (name) {

266 return new Error(`Illegal state: ${name}`);

269 }

270 }

271 > errors.ts

272 > export class ReadonlyError extends TypeError {

273 > constructor(name?: string) {

274 super(name ? `${name} is read-only and cannot be changed` : 'Cannot change read-only property');

275 }

276 > } errors.ts

277 >

278 > export function getErrorMessage(err: any): string {

279 if (!err) {

280 return 'Error';

291 return String(err);

292 }

293 > errors.ts

294 > export class NotImplementedError extends Error {

295 > constructor(message?: string) {

296 super('NotImplemented');

297 if (message) {

299 }

300 }

301 > } errors.ts

302 >

303 > export class NotSupportedError extends Error {

304 > constructor(message?: string) {

305 super('NotSupported');

306 if (message) {

308 }

309 }

310 > } errors.ts

311 >

312 > export class ExpectedError extends Error {

313 readonly isExpected = true;

314 > } errors.ts

315 >

316 > /**

317 > * Error that when thrown won't be logged in telemetry as an unhandled error.

318 > */

319 > export class ErrorNoTelemetry extends Error {

320 > override readonly name: string;

321 >

322 > constructor(msg?: string) {

323 super(msg);

324 this.name = 'CodeExpectedError';

325 }

326 > errors.ts

327 > public static fromError(err: Error): ErrorNoTelemetry {

328 if (err instanceof ErrorNoTelemetry) {

329 return err;

335 return result;

336 }

337 > errors.ts

338 > public static isErrorNoTelemetry(err: Error): err is ErrorNoTelemetry {

339 return err.name === 'CodeExpectedError';

340 }

341 > } errors.ts

342 >

343 > /**

344 > * This error indicates a bug.

345 > * Do not throw this for invalid user input.

346 > * Only catch this error to recover gracefully from bugs.

347 > */

348 > export class BugIndicatingError extends Error {

349 > constructor(message?: string) {

350 super(message || 'An unexpected bug occurred.');

351 Object.setPrototypeOf(this, BugIndicatingError.prototype);

355 // debugger;

356 }

357 > } errors.ts

src/vs/base/common/path.ts 177 covered LOC · 31 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- path.ts

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 > // NOTE: VSCode's copy of nodejs path library to be usable in common (non-node) namespace

7 > // Copied from: https://github.com/nodejs/node/commits/v22.15.0/lib/path.js

8 > // Excluding: the change that adds primordials

9 > // (https://github.com/nodejs/node/commit/187a862d221dec42fa9a5c4214e7034d9092792f and others)

10 > // Excluding: the change that adds glob matching

11 > // (https://github.com/nodejs/node/commit/57b8b8e18e5e2007114c63b71bf0baedc01936a6)

12 >

13 > /**

14 > * Copyright Joyent, Inc. and other Node contributors.

15 > *

16 > * Permission is hereby granted, free of charge, to any person obtaining a

17 > * copy of this software and associated documentation files (the

18 > * "Software"), to deal in the Software without restriction, including

19 > * without limitation the rights to use, copy, modify, merge, publish,

20 > * distribute, sublicense, and/or sell copies of the Software, and to permit

21 > * persons to whom the Software is furnished to do so, subject to the

22 > * following conditions:

23 > *

24 > * The above copyright notice and this permission notice shall be included

25 > * in all copies or substantial portions of the Software.

26 > *

27 > * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

28 > * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

29 > * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

30 > * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

31 > * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

32 > * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

33 > * USE OR OTHER DEALINGS IN THE SOFTWARE.

34 > */

35 >

36 > import * as process from './process.js';

37 >

38 > const CHAR_UPPERCASE_A = 65;/* A */

39 > const CHAR_LOWERCASE_A = 97; /* a */

40 > const CHAR_UPPERCASE_Z = 90; /* Z */

41 > const CHAR_LOWERCASE_Z = 122; /* z */

42 > const CHAR_DOT = 46; /* . */

43 > const CHAR_FORWARD_SLASH = 47; /* / */

44 > const CHAR_BACKWARD_SLASH = 92; /* \ */

45 > const CHAR_COLON = 58; /* : */

46 > const CHAR_QUESTION_MARK = 63; /* ? */

47 >

48 > class ErrorInvalidArgType extends Error {

49 > code: 'ERR_INVALID_ARG_TYPE';

50 > constructor(name: string, expected: string, actual: unknown) {

51 // determiner: 'must be' or 'must not be'

52 let determiner;

66 this.code = 'ERR_INVALID_ARG_TYPE';

67 }

68 > } path.ts

69 >

70 function validateObject(pathObject: object, name: string) {

71 if (pathObject === null || typeof pathObject !== 'object') {

73 }

74 }

75 > path.ts

76 function validateString(value: string, name: string) {

77 if (typeof value !== 'string') {

79 }

80 }

81 > path.ts

82 > const platformIsWin32 = (process.platform === 'win32');

83 >

84 function isPathSeparator(code: number | undefined) {

85 return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;

86 }

87 > path.ts

88 function isPosixPathSeparator(code: number | undefined) {

89 return code === CHAR_FORWARD_SLASH;

90 }

91 > path.ts

92 function isWindowsDeviceRoot(code: number) {

93 return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||

94 (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z);

95 }

96 > path.ts

97 > // Resolves . and .. elements in a path with directory names

98 function normalizeString(path: string, allowAboveRoot: boolean, separator: string, isPathSeparator: (code?: number) => boolean) {

99 let res = '';

163 return res;

164 }

165 > path.ts

166 function formatExt(ext: string): string {

167 return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';

168 }

169 > path.ts

170 function _format(sep: string, pathObject: ParsedPath) {

171 validateObject(pathObject, 'pathObject');

178 return dir === pathObject.root ? `${dir}${base}` : `${dir}${sep}${base}`;

179 }

180 > path.ts

181 > export interface ParsedPath {

182 > root: string;

183 > dir: string;

184 > base: string;

185 > ext: string;

186 > name: string;

187 > }

188 >

189 > export interface IPath {

190 > normalize(path: string): string;

191 > isAbsolute(path: string): boolean;

192 > join(...paths: string[]): string;

193 > resolve(...pathSegments: string[]): string;

194 > relative(from: string, to: string): string;

195 > dirname(path: string): string;

196 > basename(path: string, suffix?: string): string;

197 > extname(path: string): string;

198 > format(pathObject: ParsedPath): string;

199 > parse(path: string): ParsedPath;

200 > toNamespacedPath(path: string): string;

201 > sep: '\\' | '/';

202 > delimiter: string;

203 > win32: IPath | null;

204 > posix: IPath | null;

205 > }

206 >

207 > export const win32: IPath = {

208 > // path.resolve([from ...], to)

209 > resolve(...pathSegments: string[]): string {

210 let resolvedDevice = '';

211 let resolvedTail = '';

343 `${resolvedDevice}${resolvedTail}` || '.';

344 },

345 > path.ts

346 > normalize(path: string): string {

347 validateString(path, 'path');

348 const len = path.length;

450 return isAbsolute ? `${device}\\${tail}` : `${device}${tail}`;

451 },

452 > path.ts

453 > isAbsolute(path: string): boolean {

454 validateString(path, 'path');

455 const len = path.length;

466 isPathSeparator(path.charCodeAt(2)));

467 },

468 > path.ts

469 > join(...paths: string[]): string {

470 if (paths.length === 0) {

471 return '.';

536 return win32.normalize(joined);

537 },

538 > path.ts

539 >

540 > // It will solve the relative path from `from` to `to`, for instance:

541 > // from = 'C:\\orandea\\test\\aaa'

542 > // to = 'C:\\orandea\\impl\\bbb'

543 > // The output of the function should be: '..\\..\\impl\\bbb'

544 > relative(from: string, to: string): string {

545 validateString(from, 'from');

546 validateString(to, 'to');

699 return toOrig.slice(toStart, toEnd);

700 },

701 > path.ts

702 > toNamespacedPath(path: string): string {

703 // Note: this will *probably* throw somewhere.

704 if (typeof path !== 'string' || path.length === 0) {

730 return resolvedPath;

731 },

732 > path.ts

733 > dirname(path: string): string {

734 validateString(path, 'path');

735 const len = path.length;

818 return path.slice(0, end);

819 },

820 > path.ts

821 > basename(path: string, suffix?: string): string {

822 if (suffix !== undefined) {

823 validateString(suffix, 'suffix');

906 return path.slice(start, end);

907 },

908 > path.ts

909 > extname(path: string): string {

910 validateString(path, 'path');

911 let start = 0;

972 return path.slice(startDot, end);

973 },

974 > path.ts

975 > format: _format.bind(null, '\\'),

976 >

977 > parse(path) {

978 validateString(path, 'path');

979

1126 return ret;

1127 },

1128 > path.ts

1129 > sep: '\\',

1130 > delimiter: ';',

1131 > win32: null,

1132 > posix: null

1133 > };

1134 >

1135 > const posixCwd = (() => {

1136 > if (platformIsWin32) {

1137 // Converts Windows' backslash path separators to POSIX forward slashes

1138 // and truncates any drive indicator

1143 };

1144 }

1145 > path.ts

1146 > // We're already on POSIX, no need for any transformations

1147 > return () => process.cwd();

1148 > })();

1149 >

1150 > export const posix: IPath = {

1151 > // path.resolve([from ...], to)

1152 > resolve(...pathSegments: string[]): string {

1153 let resolvedPath = '';

1154 let resolvedAbsolute = false;

1186 return resolvedPath.length > 0 ? resolvedPath : '.';

1187 },

1188 > path.ts

1189 > normalize(path: string): string {

1190 validateString(path, 'path');

1191

1213 return isAbsolute ? `/${path}` : path;

1214 },

1215 > path.ts

1216 > isAbsolute(path: string): boolean {

1217 validateString(path, 'path');

1218 return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;

1219 },

1220 > path.ts

1221 > join(...paths: string[]): string {

1222 if (paths.length === 0) {

1223 return '.';

1239 return posix.normalize(path.join('/'));

1240 },

1241 > path.ts

1242 > relative(from: string, to: string): string {

1243 validateString(from, 'from');

1244 validateString(to, 'to');

1312 return `${out}${to.slice(toStart + lastCommonSep)}`;

1313 },

1314 > path.ts

1315 > toNamespacedPath(path: string): string {

1316 // Non-op on posix systems

1317 return path;

1318 },

1319 > path.ts

1320 > dirname(path: string): string {

1321 validateString(path, 'path');

1322 if (path.length === 0) {

1346 return path.slice(0, end);

1347 },

1348 > path.ts

1349 > basename(path: string, suffix?: string): string {

1350 if (suffix !== undefined) {

1351 validateString(suffix, 'suffix');

1426 return path.slice(start, end);

1427 },

1428 > path.ts

1429 > extname(path: string): string {

1430 validateString(path, 'path');

1431 let startDot = -1;

1480 return path.slice(startDot, end);

1481 },

1482 > path.ts

1483 > format: _format.bind(null, '/'),

1484 >

1485 > parse(path: string): ParsedPath {

1486 validateString(path, 'path');

1487

1565 return ret;

1566 },

1567 > path.ts

1568 > sep: '/',

1569 > delimiter: ':',

1570 > win32: null,

1571 > posix: null

1572 > };

1573 >

1574 > posix.win32 = win32.win32 = win32;

1575 > posix.posix = win32.posix = posix;

1576 >

1577 > export const normalize = (platformIsWin32 ? win32.normalize : posix.normalize);

1578 > export const isAbsolute = (platformIsWin32 ? win32.isAbsolute : posix.isAbsolute);

1579 > export const join = (platformIsWin32 ? win32.join : posix.join);

1580 > export const resolve = (platformIsWin32 ? win32.resolve : posix.resolve);

1581 > export const relative = (platformIsWin32 ? win32.relative : posix.relative);

1582 > export const dirname = (platformIsWin32 ? win32.dirname : posix.dirname);

1583 > export const basename = (platformIsWin32 ? win32.basename : posix.basename);

1584 > export const extname = (platformIsWin32 ? win32.extname : posix.extname);

1585 > export const format = (platformIsWin32 ? win32.format : posix.format);

1586 > export const parse = (platformIsWin32 ? win32.parse : posix.parse);

1587 > export const toNamespacedPath = (platformIsWin32 ? win32.toNamespacedPath : posix.toNamespacedPath);

1588 > export const sep = (platformIsWin32 ? win32.sep : posix.sep);

1589 > export const delimiter = (platformIsWin32 ? win32.delimiter : posix.delimiter);

src/vs/editor/common/languages/language.ts 168 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- language.ts

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 { Event } from '../../../base/common/event.js';

7 > import { IDisposable } from '../../../base/common/lifecycle.js';

8 > import { URI } from '../../../base/common/uri.js';

9 > import { ILanguageIdCodec } from '../languages.js';

10 > import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';

11 >

12 > export const ILanguageService = createDecorator<ILanguageService>('languageService');

13 >

14 > export interface ILanguageExtensionPoint {

15 > id: string;

16 > extensions?: string[];

17 > filenames?: string[];

18 > filenamePatterns?: string[];

19 > firstLine?: string;

20 > aliases?: string[];

21 > mimetypes?: string[];

22 > configuration?: URI;

23 > /**

24 > * @internal

25 > */

26 > icon?: ILanguageIcon;

27 > }

28 >

29 > export interface ILanguageSelection {

30 > readonly languageId: string;

31 > readonly onDidChange: Event<string>;

32 > }

33 >

34 > export interface ILanguageNameIdPair {

35 > readonly languageName: string;

36 > readonly languageId: string;

37 > }

38 >

39 > export interface ILanguageIcon {

40 > readonly light: URI;

41 > readonly dark: URI;

42 > }

43 >

44 > export interface ILanguageService {

45 > readonly _serviceBrand: undefined;

46 >

47 > /**

48 > * A codec which can encode and decode a string `languageId` as a number.

49 > */

50 > readonly languageIdCodec: ILanguageIdCodec;

51 >

52 > /**

53 > * An event emitted when basic language features are requested for the first time.

54 > * This event is emitted when embedded languages are encountered (e.g. JS code block inside Markdown)

55 > * or when a language is associated to a text model.

56 > *

57 > * **Note**: Basic language features refers to language configuration related features.

58 > * **Note**: This event is a superset of `onDidRequestRichLanguageFeatures`

59 > */

60 > readonly onDidRequestBasicLanguageFeatures: Event<string>;

61 >

62 > /**

63 > * An event emitted when rich language features are requested for the first time.

64 > * This event is emitted when a language is associated to a text model.

65 > *

66 > * **Note**: Rich language features refers to tokenizers, language features based on providers, etc.

67 > * **Note**: This event is a subset of `onDidRequestRichLanguageFeatures`

68 > */

69 > readonly onDidRequestRichLanguageFeatures: Event<string>;

70 >

71 > /**

72 > * An event emitted when languages have changed.

73 > */

74 > readonly onDidChange: Event<void>;

75 >

76 > /**

77 > * Register a language.

78 > */

79 > registerLanguage(def: ILanguageExtensionPoint): IDisposable;

80 >

81 > /**

82 > * Check if `languageId` is registered.

83 > */

84 > isRegisteredLanguageId(languageId: string): boolean;

85 >

86 > /**

87 > * Get a list of all registered languages.

88 > */

89 > getRegisteredLanguageIds(): string[];

90 >

91 > /**

92 > * Get a list of all registered languages with a name.

93 > * If a language is explicitly registered without a name, it will not be part of the result.

94 > * The result is sorted using by name case insensitive.

95 > */

96 > getSortedRegisteredLanguageNames(): ILanguageNameIdPair[];

97 >

98 > /**

99 > * Get the preferred language name for a language.

100 > */

101 > getLanguageName(languageId: string): string | null;

102 >

103 > /**

104 > * Get the mimetype for a language.

105 > */

106 > getMimeType(languageId: string): string | null;

107 >

108 > /**

109 > * Get the default icon for the language.

110 > */

111 > getIcon(languageId: string): ILanguageIcon | null;

112 >

113 > /**

114 > * Get all file extensions for a language.

115 > */

116 > getExtensions(languageId: string): ReadonlyArray<string>;

117 >

118 > /**

119 > * Get all file names for a language.

120 > */

121 > getFilenames(languageId: string): ReadonlyArray<string>;

122 >

123 > /**

124 > * Get all language configuration files for a language.

125 > */

126 > getConfigurationFiles(languageId: string): ReadonlyArray<URI>;

127 >

128 > /**

129 > * Look up a language by its name case insensitive.

130 > */

131 > getLanguageIdByLanguageName(languageName: string): string | null;

132 >

133 > /**

134 > * Look up a language by its mime type.

135 > */

136 > getLanguageIdByMimeType(mimeType: string | null | undefined): string | null;

137 >

138 > /**

139 > * Guess the language id for a resource.

140 > */

141 > guessLanguageIdByFilepathOrFirstLine(resource: URI, firstLine?: string): string | null;

142 >

143 > /**

144 > * Will fall back to 'plaintext' if `languageId` is unknown.

145 > */

146 > createById(languageId: string | null | undefined): ILanguageSelection;

147 >

148 > /**

149 > * Will fall back to 'plaintext' if `mimeType` is unknown.

150 > */

151 > createByMimeType(mimeType: string | null | undefined): ILanguageSelection;

152 >

153 > /**

154 > * Will fall back to 'plaintext' if the `languageId` cannot be determined.

155 > */

156 > createByFilepathOrFirstLine(resource: URI | null, firstLine?: string): ILanguageSelection;

157 >

158 > /**

159 > * Request basic language features for a language.

160 > */

161 > requestBasicLanguageFeatures(languageId: string): void;

162 >

163 > /**

164 > * Request rich language features for a language.

165 > */

166 > requestRichLanguageFeatures(languageId: string): void;

167 >

168 > }

src/vs/platform/environment/common/environment.ts 165 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- environment.ts

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 { URI } from '../../../base/common/uri.js';

7 > import { NativeParsedArgs } from './argv.js';

8 > import { createDecorator, refineServiceDecorator } from '../../instantiation/common/instantiation.js';

9 >

10 > export const IEnvironmentService = createDecorator<IEnvironmentService>('environmentService');

11 > export const INativeEnvironmentService = refineServiceDecorator<IEnvironmentService, INativeEnvironmentService>(IEnvironmentService);

12 >

13 > export interface IDebugParams {

14 > port: number | null;

15 > break: boolean;

16 > }

17 >

18 > export interface IExtensionHostDebugParams extends IDebugParams {

19 > debugId?: string;

20 > env?: Record<string, string>;

21 > }

22 >

23 > /**

24 > * Type of extension.

25 > *

26 > * **NOTE**: This is defined in `platform/environment` because it can appear as a CLI argument.

27 > */

28 > export type ExtensionKind = 'ui' | 'workspace' | 'web';

29 >

30 > /**

31 > * A basic environment service that can be used in various processes,

32 > * such as main, renderer and shared process. Use subclasses of this

33 > * service for specific environment.

34 > */

35 > export interface IEnvironmentService {

36 >

37 > readonly _serviceBrand: undefined;

38 >

39 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

40 > //

41 > // NOTE: KEEP THIS INTERFACE AS SMALL AS POSSIBLE.

42 > //

43 > // AS SUCH:

44 > // - PUT NON-WEB PROPERTIES INTO NATIVE ENVIRONMENT SERVICE

45 > // - PUT WORKBENCH ONLY PROPERTIES INTO WORKBENCH ENVIRONMENT SERVICE

46 > // - PUT ELECTRON-MAIN ONLY PROPERTIES INTO MAIN ENVIRONMENT SERVICE

47 > //

48 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

49 >

50 > // --- user roaming data

51 > stateResource: URI;

52 > userRoamingDataHome: URI;

53 > keyboardLayoutResource: URI;

54 > argvResource: URI;

55 >

56 > // --- data paths

57 > untitledWorkspacesHome: URI;

58 > workspaceStorageHome: URI;

59 > localHistoryHome: URI;

60 > cacheHome: URI;

61 > appSharedDataHome: URI;

62 >

63 > // --- settings sync

64 > userDataSyncHome: URI;

65 > sync: 'on' | 'off' | undefined;

66 >

67 > // --- continue edit session

68 > continueOn?: string;

69 > editSessionId?: string;

70 >

71 > // --- extension development

72 > debugExtensionHost: IExtensionHostDebugParams;

73 > isExtensionDevelopment: boolean;

74 > disableExtensions: boolean | string[];

75 > skipBuiltinExtensions?: readonly string[];

76 > enableExtensions?: readonly string[];

77 > extensionDevelopmentLocationURI?: URI[];

78 > extensionDevelopmentKind?: ExtensionKind[];

79 > extensionTestsLocationURI?: URI;

80 >

81 > // --- logging

82 > logsHome: URI;

83 > logLevel?: string;

84 > extensionLogLevel?: [string, string][];

85 > verbose: boolean;

86 > isBuilt: boolean;

87 >

88 > // --- telemetry/exp

89 > disableTelemetry: boolean;

90 > disableExperiments: boolean;

91 > serviceMachineIdResource: URI;

92 >

93 > // --- agent sessions workspace

94 > agentSessionsWorkspace: URI;

95 > // --- Policy

96 > policyFile?: URI;

97 >

98 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

99 > //

100 > // NOTE: KEEP THIS INTERFACE AS SMALL AS POSSIBLE.

101 > //

102 > // AS SUCH:

103 > // - PUT NON-WEB PROPERTIES INTO NATIVE ENVIRONMENT SERVICE

104 > // - PUT WORKBENCH ONLY PROPERTIES INTO WORKBENCH ENVIRONMENT SERVICE

105 > // - PUT ELECTRON-MAIN ONLY PROPERTIES INTO MAIN ENVIRONMENT SERVICE

106 > //

107 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

108 > }

109 >

110 > /**

111 > * A subclass of the `IEnvironmentService` to be used only in native

112 > * environments (Windows, Linux, macOS) but not e.g. web.

113 > */

114 > export interface INativeEnvironmentService extends IEnvironmentService {

115 >

116 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

117 > //

118 > // NOTE: KEEP THIS INTERFACE AS SMALL AS POSSIBLE.

119 > //

120 > // AS SUCH:

121 > // - PUT WORKBENCH ONLY PROPERTIES INTO WORKBENCH ENVIRONMENT SERVICE

122 > // - PUT ELECTRON-MAIN ONLY PROPERTIES INTO MAIN ENVIRONMENT SERVICE

123 > //

124 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

125 >

126 > // --- CLI Arguments

127 > args: NativeParsedArgs;

128 >

129 > // --- data paths

130 > /**

131 > * Root path of the JavaScript sources.

132 > *

133 > * Note: This is NOT the installation root

134 > * directory itself but contained in it at

135 > * a level that is platform dependent.

136 > */

137 > appRoot: string;

138 > userHome: URI;

139 > appSettingsHome: URI;

140 > tmpDir: URI;

141 > userDataPath: string;

142 >

143 > // --- extensions

144 > extensionsPath: string;

145 > extensionsDownloadLocation: URI;

146 > builtinExtensionsPath: string;

147 >

148 > // --- use in-memory Secret Storage

149 > useInMemorySecretStorage?: boolean;

150 >

151 > crossOriginIsolated?: boolean;

152 > exportPolicyData?: string;

153 > exportDefaultKeybindings?: string;

154 >

155 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

156 > //

157 > // NOTE: KEEP THIS INTERFACE AS SMALL AS POSSIBLE.

158 > //

159 > // AS SUCH:

160 > // - PUT NON-WEB PROPERTIES INTO NATIVE ENVIRONMENT SERVICE

161 > // - PUT WORKBENCH ONLY PROPERTIES INTO WORKBENCH ENVIRONMENT SERVICE

162 > // - PUT ELECTRON-MAIN ONLY PROPERTIES INTO MAIN ENVIRONMENT SERVICE

163 > //

164 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

165 > }

src/vs/base/common/buffer.ts 158 covered LOC · 42 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- buffer.ts

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 { Lazy } from './lazy.js';

7 > import * as streams from './stream.js';

8 >

9 > interface NodeBuffer {

10 > allocUnsafe(size: number): Uint8Array;

11 > isBuffer(obj: unknown): obj is NodeBuffer;

12 > from(arrayBuffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array;

13 > from(data: string): Uint8Array;

14 > }

15 >

16 > declare const Buffer: NodeBuffer;

17 >

18 > const hasBuffer = (typeof Buffer !== 'undefined');

19 > const indexOfTable = new Lazy(() => new Uint8Array(256));

20 >

21 > let textEncoder: { encode: (input: string) => Uint8Array } | null;

22 > let textDecoder: { decode: (input: Uint8Array) => string } | null;

23 >

24 > export class VSBuffer {

25 >

26 > /**

27 > * When running in a nodejs context, the backing store for the returned `VSBuffer` instance

28 > * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.

29 > */

30 > static alloc(byteLength: number): VSBuffer {

31 if (hasBuffer) {

32 return new VSBuffer(Buffer.allocUnsafe(byteLength));

35 }

36 }

37 > buffer.ts

38 > /**

39 > * When running in a nodejs context, if `actual` is not a nodejs Buffer, the backing store for

40 > * the returned `VSBuffer` instance might use a nodejs Buffer allocated from node's Buffer pool,

41 > * which is not transferrable.

42 > */

43 > static wrap(actual: Uint8Array): VSBuffer {

44 if (hasBuffer && !(Buffer.isBuffer(actual))) {

45 // https://nodejs.org/dist/latest-v10.x/docs/api/buffer.html#buffer_class_method_buffer_from_arraybuffer_byteoffset_length

49 return new VSBuffer(actual);

50 }

51 > buffer.ts

52 > /**

53 > * When running in a nodejs context, the backing store for the returned `VSBuffer` instance

54 > * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.

55 > */

56 > static fromString(source: string, options?: { dontUseNodeBuffer?: boolean }): VSBuffer {

57 const dontUseNodeBuffer = options?.dontUseNodeBuffer || false;

58 if (!dontUseNodeBuffer && hasBuffer) {

65 }

66 }

67 > buffer.ts

68 > /**

69 > * When running in a nodejs context, the backing store for the returned `VSBuffer` instance

70 > * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.

71 > */

72 > static fromByteArray(source: number[]): VSBuffer {

73 const result = VSBuffer.alloc(source.length);

74 for (let i = 0, len = source.length; i < len; i++) {

77 return result;

78 }

79 > buffer.ts

80 > /**

81 > * When running in a nodejs context, the backing store for the returned `VSBuffer` instance

82 > * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.

83 > */

84 > static concat(buffers: VSBuffer[], totalLength?: number): VSBuffer {

85 if (typeof totalLength === 'undefined') {

86 totalLength = 0;

100 return ret;

101 }

102 > buffer.ts

103 > static isNativeBuffer(buffer: unknown): boolean {

104 return hasBuffer && Buffer.isBuffer(buffer);

105 }

106 > buffer.ts

107 > readonly buffer: Uint8Array;

108 > readonly byteLength: number;

109 >

110 > private constructor(buffer: Uint8Array) {

111 this.buffer = buffer;

112 this.byteLength = this.buffer.byteLength;

113 }

114 > buffer.ts

115 > /**

116 > * When running in a nodejs context, the backing store for the returned `VSBuffer` instance

117 > * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.

118 > */

119 > clone(): VSBuffer {

120 const result = VSBuffer.alloc(this.byteLength);

121 result.set(this);

122 return result;

123 }

124 > buffer.ts

125 > toString(): string {

126 if (hasBuffer) {

127 return this.buffer.toString();

133 }

134 }

135 > buffer.ts

136 > slice(start?: number, end?: number): VSBuffer {

137 // IMPORTANT: use subarray instead of slice because TypedArray#slice

138 // creates shallow copy and NodeBuffer#slice doesn't. The use of subarray

140 return new VSBuffer(this.buffer.subarray(start, end));

141 }

142 > buffer.ts

143 > set(array: VSBuffer, offset?: number): void;

144 > set(array: Uint8Array, offset?: number): void;

145 > set(array: ArrayBuffer, offset?: number): void;

146 > set(array: ArrayBufferView, offset?: number): void;

147 > set(array: VSBuffer | Uint8Array | ArrayBuffer | ArrayBufferView, offset?: number): void;

148 > set(array: VSBuffer | Uint8Array | ArrayBuffer | ArrayBufferView, offset?: number): void {

149 if (array instanceof VSBuffer) {

150 this.buffer.set(array.buffer, offset);

159 }

160 }

161 > buffer.ts

162 > readUInt32BE(offset: number): number {

163 return readUInt32BE(this.buffer, offset);

164 }

165 > buffer.ts

166 > writeUInt32BE(value: number, offset: number): void {

167 writeUInt32BE(this.buffer, value, offset);

168 }

169 > buffer.ts

170 > readUInt32LE(offset: number): number {

171 return readUInt32LE(this.buffer, offset);

172 }

173 > buffer.ts

174 > writeUInt32LE(value: number, offset: number): void {

175 writeUInt32LE(this.buffer, value, offset);

176 }

177 > buffer.ts

178 > readUInt8(offset: number): number {

179 return readUInt8(this.buffer, offset);

180 }

181 > buffer.ts

182 > writeUInt8(value: number, offset: number): void {

183 writeUInt8(this.buffer, value, offset);

184 }

185 > buffer.ts

186 > indexOf(subarray: VSBuffer | Uint8Array, offset = 0) {

187 return binaryIndexOf(this.buffer, subarray instanceof VSBuffer ? subarray.buffer : subarray, offset);

188 }

189 > buffer.ts

190 > equals(other: VSBuffer): boolean {

191 if (this === other) {

192 return true;

199 return this.buffer.every((value, index) => value === other.buffer[index]);

200 }

201 > } buffer.ts

202 >

203 > /**

204 > * Like String.indexOf, but works on Uint8Arrays.

205 > * Uses the boyer-moore-horspool algorithm to be reasonably speedy.

206 > */

207 > export function binaryIndexOf(haystack: Uint8Array, needle: Uint8Array, offset = 0): number {

208 const needleLen = needle.byteLength;

209 const haystackLen = haystack.byteLength;

248 return result;

249 }

250 > buffer.ts

251 > export function readUInt16LE(source: Uint8Array, offset: number): number {

252 return (

253 ((source[offset + 0] << 0) >>> 0) |

255 );

256 }

257 > buffer.ts

258 > export function writeUInt16LE(destination: Uint8Array, value: number, offset: number): void {

259 destination[offset + 0] = (value & 0b11111111);

260 value = value >>> 8;

261 destination[offset + 1] = (value & 0b11111111);

262 }

263 > buffer.ts

264 > export function readUInt32BE(source: Uint8Array, offset: number): number {

265 return (

266 source[offset] * 2 ** 24

270 );

271 }

272 > buffer.ts

273 > export function writeUInt32BE(destination: Uint8Array, value: number, offset: number): void {

274 destination[offset + 3] = value;

275 value = value >>> 8;

280 destination[offset] = value;

281 }

282 > buffer.ts

283 > export function readUInt32LE(source: Uint8Array, offset: number): number {

284 return (

285 ((source[offset + 0] << 0) >>> 0) |

289 );

290 }

291 > buffer.ts

292 > export function writeUInt32LE(destination: Uint8Array, value: number, offset: number): void {

293 destination[offset + 0] = (value & 0b11111111);

294 value = value >>> 8;

299 destination[offset + 3] = (value & 0b11111111);

300 }

301 > buffer.ts

302 > export function readUInt8(source: Uint8Array, offset: number): number {

303 return source[offset];

304 }

305 > buffer.ts

306 > export function writeUInt8(destination: Uint8Array, value: number, offset: number): void {

307 destination[offset] = value;

308 }

309 > buffer.ts

310 > export interface VSBufferReadable extends streams.Readable<VSBuffer> { }

311 >

312 > export interface VSBufferReadableStream extends streams.ReadableStream<VSBuffer> { }

313 >

314 > export interface VSBufferWriteableStream extends streams.WriteableStream<VSBuffer> { }

315 >

316 > export interface VSBufferReadableBufferedStream extends streams.ReadableBufferedStream<VSBuffer> { }

317 >

318 > export function readableToBuffer(readable: VSBufferReadable): VSBuffer {

319 return streams.consumeReadable<VSBuffer>(readable, chunks => VSBuffer.concat(chunks));

320 }

321 > buffer.ts

322 > export function bufferToReadable(buffer: VSBuffer): VSBufferReadable {

323 return streams.toReadable<VSBuffer>(buffer);

324 }

325 > buffer.ts

326 > export function streamToBuffer(stream: streams.ReadableStream<VSBuffer>): Promise<VSBuffer> {

327 return streams.consumeStream<VSBuffer>(stream, chunks => VSBuffer.concat(chunks));

328 }

329 > buffer.ts

330 export async function bufferedStreamToBuffer(bufferedStream: streams.ReadableBufferedStream<VSBuffer>): Promise<VSBuffer> {

331 if (bufferedStream.ended) {

342 ]);

343 }

344 > buffer.ts

345 > export function bufferToStream(buffer: VSBuffer): streams.ReadableStream<VSBuffer> {

346 return streams.toStream<VSBuffer>(buffer, chunks => VSBuffer.concat(chunks));

347 }

348 > buffer.ts

349 > export function streamToBufferReadableStream(stream: streams.ReadableStreamEvents<Uint8Array | string>): streams.ReadableStream<VSBuffer> {

350 return streams.transform<Uint8Array | string, VSBuffer>(stream, { data: data => typeof data === 'string' ? VSBuffer.fromString(data) : VSBuffer.wrap(data) }, chunks => VSBuffer.concat(chunks));

351 }

352 > buffer.ts

353 > export function newWriteableBufferStream(options?: streams.WriteableStreamOptions): streams.WriteableStream<VSBuffer> {

354 return streams.newWriteableStream<VSBuffer>(chunks => VSBuffer.concat(chunks), options);

355 }

356 > buffer.ts

357 > export function prefixedBufferReadable(prefix: VSBuffer, readable: VSBufferReadable): VSBufferReadable {

358 return streams.prefixedReadable(prefix, readable, chunks => VSBuffer.concat(chunks));

359 }

360 > buffer.ts

361 > export function prefixedBufferStream(prefix: VSBuffer, stream: VSBufferReadableStream): VSBufferReadableStream {

362 return streams.prefixedStream(prefix, stream, chunks => VSBuffer.concat(chunks));

363 }

364 > buffer.ts

365 > /** Decodes base64 to a uint8 array. URL-encoded and unpadded base64 is allowed. */

366 > export function decodeBase64(encoded: string) {

367 let building = 0;

368 let remainder = 0;

424 return VSBuffer.wrap(buffer).slice(0, unpadded);

425 }

426 > buffer.ts

427 > const base64Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

428 > const base64UrlSafeAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';

429 >

430 > /** Encodes a buffer to a base64 string. */

431 > export function encodeBase64({ buffer }: VSBuffer, padded = true, urlSafe = false) {

432 const dictionary = urlSafe ? base64UrlSafeAlphabet : base64Alphabet;

433 let output = '';

463 return output;

464 }

465 > buffer.ts

466 > const hexChars = '0123456789abcdef';

467 > export function encodeHex({ buffer }: VSBuffer): string {

468 let result = '';

469 for (let i = 0; i < buffer.length; i++) {

474 return result;

475 }

476 > buffer.ts

477 > export function decodeHex(hex: string): VSBuffer {

478 if (hex.length % 2 !== 0) {

479 throw new SyntaxError('Hex string must have an even length');

485 return VSBuffer.wrap(out);

486 }

487 > buffer.ts

488 function decodeHexChar(str: string, position: number) {

489 const s = str.charCodeAt(position);

src/vs/base/common/actions.ts 151 covered LOC · 25 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- actions.ts

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 { Emitter, Event } from './event.js';

7 > import { Disposable, IDisposable } from './lifecycle.js';

8 > import * as nls from '../../nls.js';

9 >

10 > export interface ITelemetryData {

11 > readonly from?: string;

12 > readonly target?: string;

13 > [key: string]: unknown;

14 > }

15 >

16 > export type WorkbenchActionExecutedClassification = {

17 > id: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The identifier of the action that was run.' };

18 > from: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The name of the component the action was run from.' };

19 > detail?: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Optional details about how the action was run, e.g which keybinding was used.' };

20 > owner: 'isidorn';

21 > comment: 'Provides insight into actions that are executed within the workbench.';

22 > };

23 >

24 > export type WorkbenchActionExecutedEvent = {

25 > id: string;

26 > from: string;

27 > detail?: string;

28 > };

29 >

30 > export interface IAction {

31 > readonly id: string;

32 > label: string;

33 > tooltip: string;

34 > class: string | undefined;

35 > enabled: boolean;

36 > checked?: boolean;

37 > run(...args: unknown[]): unknown;

38 > }

39 >

40 > export interface IActionRunner extends IDisposable {

41 > readonly onDidRun: Event<IRunEvent>;

42 > readonly onWillRun: Event<IRunEvent>;

43 >

44 > run(action: IAction, context?: unknown): unknown;

45 > }

46 >

47 > export interface IActionChangeEvent {

48 > readonly label?: string;

49 > readonly tooltip?: string;

50 > readonly class?: string;

51 > readonly enabled?: boolean;

52 > readonly checked?: boolean;

53 > }

54 >

55 > /**

56 > * A concrete implementation of {@link IAction}.

57 > *

58 > * Note that in most cases you should use the lighter-weight {@linkcode toAction} function instead.

59 > */

60 > export class Action extends Disposable implements IAction {

61 >

62 > protected _onDidChange = this._register(new Emitter<IActionChangeEvent>());

63 > get onDidChange() { return this._onDidChange.event; }

64 >

65 > protected readonly _id: string;

66 > protected _label: string;

67 > protected _tooltip: string | undefined;

68 > protected _cssClass: string | undefined;

69 > protected _enabled: boolean = true;

70 > protected _checked?: boolean;

71 > protected readonly _actionCallback?: (event?: unknown) => unknown;

72 >

73 > constructor(id: string, label: string = '', cssClass: string = '', enabled: boolean = true, actionCallback?: (event?: unknown) => unknown) {

74 super();

75 this._id = id;

79 this._actionCallback = actionCallback;

80 }

81 > actions.ts

82 > get id(): string {

83 return this._id;

84 }

85 > actions.ts

86 > get label(): string {

87 return this._label;

88 }

89 > actions.ts

90 > set label(value: string) {

91 this._setLabel(value);

92 }

93 > actions.ts

94 > private _setLabel(value: string): void {

95 if (this._label !== value) {

96 this._label = value;

98 }

99 }

100 > actions.ts

101 > get tooltip(): string {

102 return this._tooltip || '';

103 }

104 > actions.ts

105 > set tooltip(value: string) {

106 this._setTooltip(value);

107 }

108 > actions.ts

109 > protected _setTooltip(value: string): void {

110 if (this._tooltip !== value) {

111 this._tooltip = value;

113 }

114 }

115 > actions.ts

116 > get class(): string | undefined {

117 return this._cssClass;

118 }

119 > actions.ts

120 > set class(value: string | undefined) {

121 this._setClass(value);

122 }

123 > actions.ts

124 > protected _setClass(value: string | undefined): void {

125 if (this._cssClass !== value) {

126 this._cssClass = value;

128 }

129 }

130 > actions.ts

131 > get enabled(): boolean {

132 return this._enabled;

133 }

134 > actions.ts

135 > set enabled(value: boolean) {

136 this._setEnabled(value);

137 }

138 > actions.ts

139 > protected _setEnabled(value: boolean): void {

140 if (this._enabled !== value) {

141 this._enabled = value;

143 }

144 }

145 > actions.ts

146 > get checked(): boolean | undefined {

147 return this._checked;

148 }

149 > actions.ts

150 > set checked(value: boolean | undefined) {

151 this._setChecked(value);

152 }

153 > actions.ts

154 > protected _setChecked(value: boolean | undefined): void {

155 if (this._checked !== value) {

156 this._checked = value;

158 }

159 }

160 > actions.ts

161 > async run(event?: unknown, data?: ITelemetryData): Promise<void> {

162 if (this._actionCallback) {

163 await this._actionCallback(event);

164 }

165 }

166 > } actions.ts

167 >

168 > export interface IRunEvent {

169 > readonly action: IAction;

170 > readonly error?: Error;

171 > }

172 >

173 > export class ActionRunner extends Disposable implements IActionRunner {

174

175 private readonly _onWillRun = this._register(new Emitter<IRunEvent>());

177

178 private readonly _onDidRun = this._register(new Emitter<IRunEvent>());

179 > get onDidRun() { return this._onDidRun.event; } actions.ts

180 >

181 > async run(action: IAction, context?: unknown): Promise<void> {

182 if (!action.enabled) {

183 return;

195 this._onDidRun.fire({ action, error });

196 }

197 > actions.ts

198 > protected async runAction(action: IAction, context?: unknown): Promise<void> {

199 await action.run(context);

200 }

201 > } actions.ts

202 >

203 > export class Separator implements IAction {

204

205 /**

248 readonly enabled: boolean = false;

249 readonly checked: undefined = undefined;

250 > async run() { } actions.ts

251 > }

252 >

253 > export class SubmenuAction implements IAction {

254 >

255 > readonly id: string;

256 > readonly label: string;

257 > readonly class: string | undefined;

258 > readonly tooltip: string = '';

259 > readonly enabled: boolean = true;

260 > readonly checked: undefined = undefined;

261 >

262 > private readonly _actions: readonly IAction[];

263 > get actions(): readonly IAction[] { return this._actions; }

264 >

265 > constructor(id: string, label: string, actions: readonly IAction[], cssClass?: string) {

266 this.id = id;

267 this.label = label;

269 this._actions = actions;

270 }

271 > actions.ts

272 > async run(): Promise<void> { }

273 > }

274 >

275 > export class EmptySubmenuAction extends Action {

276 >

277 > static readonly ID = 'vs.actions.empty';

278 >

279 > constructor() {

280 super(EmptySubmenuAction.ID, nls.localize('submenu.empty', '(empty)'), undefined, false);

281 }

282 > } actions.ts

283 >

284 > export function toAction(props: { id: string; label: string; tooltip?: string; enabled?: boolean; checked?: boolean; class?: string; run: Function }): IAction {

285 return {

286 id: props.id,

src/vs/platform/opener/common/opener.ts 139 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- opener.ts

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 { CancellationToken } from '../../../base/common/cancellation.js';

7 > import { IDisposable } from '../../../base/common/lifecycle.js';

8 > import { URI } from '../../../base/common/uri.js';

9 > import { IEditorOptions, ITextEditorSelection } from '../../editor/common/editor.js';

10 > import { createDecorator } from '../../instantiation/common/instantiation.js';

11 >

12 > export const IOpenerService = createDecorator<IOpenerService>('openerService');

13 >

14 > export type OpenInternalOptions = {

15 >

16 > /**

17 > * Signals that the intent is to open an editor to the side

18 > * of the currently active editor.

19 > */

20 > readonly openToSide?: boolean;

21 >

22 > /**

23 > * Extra editor options to apply in case an editor is used to open.

24 > */

25 > readonly editorOptions?: IEditorOptions;

26 >

27 > /**

28 > * Signals that the editor to open was triggered through a user

29 > * action, such as keyboard or mouse usage.

30 > */

31 > readonly fromUserGesture?: boolean;

32 >

33 > /**

34 > * Allow command links to be handled.

35 > *

36 > * If this is an array, then only the commands included in the array can be run.

37 > */

38 > readonly allowCommands?: boolean | readonly string[];

39 > };

40 >

41 > export type OpenExternalOptions = {

42 > readonly openExternal?: boolean;

43 > readonly allowTunneling?: boolean;

44 > readonly allowContributedOpeners?: boolean | string;

45 > readonly fromWorkspace?: boolean;

46 > readonly skipValidation?: boolean;

47 > };

48 >

49 > export type OpenOptions = OpenInternalOptions & OpenExternalOptions;

50 >

51 > export type ResolveExternalUriOptions = { readonly allowTunneling?: boolean };

52 >

53 > export interface IResolvedExternalUri extends IDisposable {

54 > resolved: URI;

55 > }

56 >

57 > export interface IOpener {

58 > open(resource: URI | string, options?: OpenInternalOptions | OpenExternalOptions): Promise<boolean>;

59 > }

60 >

61 > export interface IExternalOpener {

62 > openExternal(href: string, ctx: { sourceUri: URI; preferredOpenerId?: string }, token: CancellationToken): Promise<boolean>;

63 > dispose?(): void;

64 > }

65 >

66 > export interface IValidator {

67 > shouldOpen(resource: URI | string, openOptions?: OpenOptions): Promise<boolean>;

68 > }

69 >

70 > export interface IExternalUriResolver {

71 > resolveExternalUri(resource: URI, options?: OpenOptions): Promise<{ resolved: URI; dispose(): void } | undefined>;

72 > }

73 >

74 > export interface IOpenerService {

75 >

76 > readonly _serviceBrand: undefined;

77 >

78 > /**

79 > * Register a participant that can handle the open() call.

80 > */

81 > registerOpener(opener: IOpener): IDisposable;

82 >

83 > /**

84 > * Register a participant that can validate if the URI resource be opened.

85 > * Validators are run before openers.

86 > */

87 > registerValidator(validator: IValidator): IDisposable;

88 >

89 > /**

90 > * Register a participant that can resolve an external URI resource to be opened.

91 > */

92 > registerExternalUriResolver(resolver: IExternalUriResolver): IDisposable;

93 >

94 > /**

95 > * Sets the handler for opening externally. If not provided,

96 > * a default handler will be used.

97 > */

98 > setDefaultExternalOpener(opener: IExternalOpener): void;

99 >

100 > /**

101 > * Registers a new opener external resources openers.

102 > */

103 > registerExternalOpener(opener: IExternalOpener): IDisposable;

104 >

105 > /**

106 > * Opens a resource, like a webaddress, a document uri, or executes command.

107 > *

108 > * @param resource A resource

109 > * @return A promise that resolves when the opening is done.

110 > */

111 > open(resource: URI | string, options?: OpenInternalOptions | OpenExternalOptions): Promise<boolean>;

112 >

113 > /**

114 > * Resolve a resource to its external form.

115 > * @throws whenever resolvers couldn't resolve this resource externally.

116 > */

117 > resolveExternalUri(resource: URI, options?: ResolveExternalUriOptions): Promise<IResolvedExternalUri>;

118 > }

119 >

120 > /**

121 > * Encodes selection into the `URI`.

122 > *

123 > * IMPORTANT: you MUST use `extractSelection` to separate the selection

124 > * again from the original `URI` before passing the `URI` into any

125 > * component that is not aware of selections.

126 > */

127 > export function withSelection(uri: URI, selection: ITextEditorSelection): URI {

128 return uri.with({ fragment: `${selection.startLineNumber},${selection.startColumn}${selection.endLineNumber ? `-${selection.endLineNumber}${selection.endColumn ? `,${selection.endColumn}` : ''}` : ''}` });

129 }

130 > opener.ts

131 > /**

132 > * file:///some/file.js#73

133 > * file:///some/file.js#L73

134 > * file:///some/file.js#73,84

135 > * file:///some/file.js#L73,84

136 > * file:///some/file.js#73-83

137 > * file:///some/file.js#L73-L83

138 > * file:///some/file.js#73,84-83,52

139 > * file:///some/file.js#L73,84-L83,52

140 > */

141 > export function extractSelection(uri: URI): { selection: ITextEditorSelection | undefined; uri: URI } {

142 let selection: ITextEditorSelection | undefined = undefined;

143 const match = /^L?(\d+)(?:,(\d+))?(-L?(\d+)(?:,(\d+))?)?/.exec(uri.fragment);

src/vs/platform/agentHost/common/agentHostConnectionsService.ts 126 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- agentHostConnectionsService.ts

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 { Event } from '../../../base/common/event.js';

7 > import type { URI } from '../../../base/common/uri.js';

8 > import { createDecorator } from '../../instantiation/common/instantiation.js';

9 > import type { IAgentConnection } from './agentService.js';

10 >

11 > /**

12 > * Chat-session resource scheme prefix for the window's ambient/local agent

13 > * host: `agent-host-<provider>`.

14 > *

15 > * Remote agent host session schemes (`remote-<authority>-<provider>`) are

16 > * handled by `agentHostSessionType.ts` (`isRemoteAgentHostSessionType` and

17 > * friends), which also owns the authority disambiguation.

18 > */

19 > export const LOCAL_AGENT_HOST_SCHEME_PREFIX = 'agent-host-';

20 >

21 > /**

22 > * Reserved connection authority for the window's ambient/primary agent host.

23 > *

24 > * NOTE: "ambient" is not the same as "local". In a local window the ambient

25 > * host is the in-process utility agent host; in a window attached to a remote

26 > * authority the ambient host is itself remote (the `EditorRemoteAgentHostServiceClient`).

27 > * The `'local'` string is reserved/canonical for this ambient connection — it

28 > * is already used as the agent-host URI authority for in-window resources

29 > * (see `toAgentHostUri` in `agentHostUri.ts`).

30 > */

31 > export const AMBIENT_AGENT_HOST_AUTHORITY = 'local';

32 >

33 > /**

34 > * A descriptor for a single agent-host connection exposed by

35 > * {@link IAgentHostConnectionsService}. Covers both the window's ambient host

36 > * and every connected remote host with one uniform shape.

37 > */

38 > export interface IAgentHostConnectionInfo {

39 > /**

40 > * Sanitized connection authority. The ambient host uses

41 > * {@link AMBIENT_AGENT_HOST_AUTHORITY}; remotes use the authority derived

42 > * from their address via `agentHostAuthority`.

43 > */

44 > readonly authority: string;

45 > /** Raw remote address. `undefined` for the ambient host. */

46 > readonly address: string | undefined;

47 > /** Human-readable label for the connection. */

48 > readonly name: string;

49 > /**

50 > * `true` for the window's ambient/primary host. Remember this host may

51 > * itself be remote in a remote window — see {@link AMBIENT_AGENT_HOST_AUTHORITY}.

52 > */

53 > readonly isAmbient: boolean;

54 > /** The live connection, or `undefined` when not currently connected. */

55 > readonly connection: IAgentConnection | undefined;

56 > }

57 >

58 > /**

59 > * The result of resolving a chat-session resource to its backing agent host:

60 > * the owning {@link IAgentConnection} and the canonical backend agent-session

61 > * URI (`<provider>:/<rawId>`) used for protocol operations on that connection.

62 > */

63 > export interface IAgentHostSessionResolution {

64 > readonly connection: IAgentConnection;

65 > readonly backendSession: URI;

66 > }

67 >

68 > export const IAgentHostConnectionsService = createDecorator<IAgentHostConnectionsService>('agentHostConnectionsService');

69 >

70 > /**

71 > * A thin, read-only facade over the window's ambient agent host

72 > * (`IAgentHostService`) and the registry of remote agent hosts

73 > * (`IRemoteAgentHostService`), so consumers can enumerate and resolve

74 > * {@link IAgentConnection}s without branching on local-vs-remote or

75 > * fanning out over "1 ambient + N remote" themselves.

76 > *

77 > * This service deliberately does NOT expose lifecycle/management operations:

78 > * ambient-process concerns (restart, inspect, auth-pending) stay on

79 > * `IAgentHostService`, and remote-registry mutations (add/remove/reconnect/

80 > * upgrade) stay on `IRemoteAgentHostService`. This facade only answers

81 > * "which connections exist?" and "give me the connection for X".

82 > */

83 > export interface IAgentHostConnectionsService {

84 > readonly _serviceBrand: undefined;

85 >

86 > /** Fires when the set of connections changes (ambient lifecycle or remotes added/removed). */

87 > readonly onDidChangeConnections: Event<void>;

88 >

89 > /**

90 > * All known connections as `[ambient, ...remotes]`. The ambient entry is

91 > * always present with a live `connection`; only remote entries may have

92 > * `connection: undefined` (e.g. while connecting/disconnected). Remote

93 > * entries reflect the current `IRemoteAgentHostService` registry.

94 > */

95 > readonly connections: readonly IAgentHostConnectionInfo[];

96 >

97 > /** The window's ambient/primary connection (local, or the window-remote bridge). */

98 > readonly ambientConnection: IAgentConnection;

99 >

100 > /**

101 > * Resolves a live connection by sanitized authority, including

102 > * {@link AMBIENT_AGENT_HOST_AUTHORITY} for the ambient host. Returns

103 > * `undefined` when no connected host matches.

104 > */

105 > getConnectionByAuthority(authority: string): IAgentConnection | undefined;

106 >

107 > /**

108 > * Resolves a live remote connection by raw address. The ambient host has no

109 > * address and is never returned here — use {@link ambientConnection} or

110 > * {@link getConnectionByAuthority} with {@link AMBIENT_AGENT_HOST_AUTHORITY}.

111 > */

112 > getConnectionByAddress(address: string): IAgentConnection | undefined;

113 >

114 > /**

115 > * Resolves an agent-host chat-session resource to its owning connection and

116 > * backend session URI. Handles both local schemes

117 > * (`agent-host-<provider>`) — backed by the ambient connection — and remote

118 > * schemes (`remote-<authority>-<provider>`) — resolved against the live

119 > * remote registry. Returns `undefined` when the resource is not an

120 > * agent-host session, or when the matching remote host is not connected.

121 > *

122 > * NOTE: provisional/untitled sessions are a workbench concern and are NOT

123 > * handled here — callers that support them should resolve those first.

124 > */

125 > resolveSessionResource(sessionResource: URI): IAgentHostSessionResolution | undefined;

126 > }

src/vs/platform/instantiation/common/instantiation.ts 124 covered LOC · 11 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- instantiation.ts

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 { DisposableStore } from '../../../base/common/lifecycle.js';

7 > import * as descriptors from './descriptors.js';

8 > import { ServiceCollection } from './serviceCollection.js';

9 >

10 > // ------ internal util

11 >

12 > export namespace _util {

13 >

14 > export const serviceIds = new Map<string, ServiceIdentifier<any>>();

15 >

16 > export const DI_TARGET = '$di$target';

17 > export const DI_DEPENDENCIES = '$di$dependencies';

18 >

19 > export function getServiceDependencies(ctor: DI_TARGET_OBJ): { id: ServiceIdentifier<any>; index: number }[] {

20 return ctor[DI_DEPENDENCIES] || [];

21 }

22 > instantiation.ts

23 > export interface DI_TARGET_OBJ extends Function {

24 > [DI_TARGET]: Function;

25 > [DI_DEPENDENCIES]: { id: ServiceIdentifier<any>; index: number }[];

26 > }

27 > }

28 >

29 > // --- interfaces ------

30 >

31 > export type BrandedService = { _serviceBrand: undefined };

32 >

33 > export interface IConstructorSignature<T, Args extends any[] = []> {

34 > new <Services extends BrandedService[]>(...args: [...Args, ...Services]): T;

35 > }

36 >

37 > export interface ServicesAccessor {

38 > get<T>(id: ServiceIdentifier<T>): T;

39 > }

40 >

41 > export const IInstantiationService = createDecorator<IInstantiationService>('instantiationService');

42 >

43 > /**

44 > * Given a list of arguments as a tuple, attempt to extract the leading, non-service arguments

45 > * to their own tuple.

46 > */

47 > export type GetLeadingNonServiceArgs<TArgs extends any[]> =

48 > TArgs extends [] ? []

49 > : TArgs extends [...infer TFirst, BrandedService] ? GetLeadingNonServiceArgs<TFirst>

50 > : TArgs;

51 >

52 > export interface IInstantiationService {

53 >

54 > readonly _serviceBrand: undefined;

55 >

56 > /**

57 > * Synchronously creates an instance that is denoted by the descriptor

58 > */

59 > createInstance<T>(descriptor: descriptors.SyncDescriptor0<T>): T;

60 > createInstance<Ctor extends new (...args: any[]) => unknown, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;

61 >

62 > /**

63 > * Calls a function with a service accessor.

64 > */

65 > invokeFunction<R, TS extends any[] = []>(fn: (accessor: ServicesAccessor, ...args: TS) => R, ...args: TS): R;

66 >

67 > /**

68 > * Creates a child of this service which inherits all current services

69 > * and adds/overwrites the given services.

70 > *

71 > * NOTE that the returned child is `disposable` and should be disposed when not used

72 > * anymore. This will also dispose all the services that this service has created.

73 > */

74 > createChild(services: ServiceCollection, store?: DisposableStore): IInstantiationService;

75 >

76 > /**

77 > * Disposes this instantiation service.

78 > *

79 > * - Will dispose all services that this instantiation service has created.

80 > * - Will dispose all its children but not its parent.

81 > * - Will NOT dispose services-instances that this service has been created with

82 > * - Will NOT dispose consumer-instances this service has created

83 > */

84 > dispose(): void;

85 > }

86 >

87 >

88 > /**

89 > * Identifies a service of type `T`.

90 > */

91 > export interface ServiceIdentifier<T> {

92 > (...args: any[]): void;

93 > type: T;

94 > }

95 >

96 >

97 > function storeServiceDependency(id: ServiceIdentifier<unknown>, target: Function, index: number): void { instantiation.ts

98 > if ((target as _util.DI_TARGET_OBJ)[_util.DI_TARGET] === target) {

99 > (target as _util.DI_TARGET_OBJ)[_util.DI_DEPENDENCIES].push({ id, index }); instantiation.ts

100 > } else { instantiation.ts

101 > (target as _util.DI_TARGET_OBJ)[_util.DI_DEPENDENCIES] = [{ id, index }];

102 > (target as _util.DI_TARGET_OBJ)[_util.DI_TARGET] = target;

103 > }

104 > }

105 > instantiation.ts

106 > /**

107 > * The *only* valid way to create a {{ServiceIdentifier}}.

108 > */

109 > export function createDecorator<T>(serviceId: string): ServiceIdentifier<T> {

110 >

111 > if (_util.serviceIds.has(serviceId)) {

112 return _util.serviceIds.get(serviceId)!;

113 }

114 > instantiation.ts

115 > const id = function (target: Function, key: string, index: number) {

116 > if (arguments.length !== 3) { instantiation.ts

117 throw new Error('@IServiceName-decorator can only be used to decorate a parameter');

118 }

119 > storeServiceDependency(id, target, index); instantiation.ts

120 > } as ServiceIdentifier<T>;

121 > instantiation.ts

122 > id.toString = () => serviceId;

123 >

124 > _util.serviceIds.set(serviceId, id);

125 > return id;

126 > }

127 >

128 > export function refineServiceDecorator<T1, T extends T1>(serviceIdentifier: ServiceIdentifier<T1>): ServiceIdentifier<T> {

129 > return <ServiceIdentifier<T>>serviceIdentifier; instantiation.ts

130 > }

src/vs/base/common/htmlContent.ts 115 covered LOC · 24 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- htmlContent.ts

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 { illegalArgument } from './errors.js';

7 > import { escapeIcons } from './iconLabels.js';

8 > import { Schemas } from './network.js';

9 > import { isEqual } from './resources.js';

10 > import { escapeRegExpCharacters } from './strings.js';

11 > import { URI, UriComponents } from './uri.js';

12 >

13 > export interface MarkdownStringTrustedOptions {

14 > readonly enabledCommands: readonly string[];

15 > }

16 >

17 > export interface IMarkdownString {

18 > readonly value: string;

19 > readonly isTrusted?: boolean | MarkdownStringTrustedOptions;

20 > readonly supportThemeIcons?: boolean;

21 > readonly supportHtml?: boolean;

22 > /** @internal */

23 > readonly supportAlertSyntax?: boolean;

24 > readonly baseUri?: UriComponents;

25 > uris?: { [href: string]: UriComponents };

26 > }

27 >

28 > export const enum MarkdownStringTextNewlineStyle {

29 > Paragraph = 0,

30 > Break = 1,

31 > }

32 >

33 > export class MarkdownString implements IMarkdownString {

34 >

35 > public value: string;

36 > public isTrusted?: boolean | MarkdownStringTrustedOptions;

37 > public supportThemeIcons?: boolean;

38 > public supportHtml?: boolean;

39 > public supportAlertSyntax?: boolean;

40 > public baseUri?: URI;

41 > public uris?: { [href: string]: UriComponents } | undefined;

42 >

43 > public static lift(dto: IMarkdownString): MarkdownString {

44 const markdownString = new MarkdownString(dto.value, dto);

45 markdownString.uris = dto.uris;

47 return markdownString;

48 }

49 > htmlContent.ts

50 > constructor(

51 > value: string = '', htmlContent.ts

52 > isTrustedOrOptions: boolean | { isTrusted?: boolean | MarkdownStringTrustedOptions; supportThemeIcons?: boolean; supportHtml?: boolean; supportAlertSyntax?: boolean } = false,

53 > ) {

54 > this.value = value;

55 > if (typeof this.value !== 'string') {

56 throw illegalArgument('value');

57 }

58 > htmlContent.ts

59 > if (typeof isTrustedOrOptions === 'boolean') {

60 > this.isTrusted = isTrustedOrOptions; htmlContent.ts

61 > this.supportThemeIcons = false;

62 > this.supportHtml = false;

63 > this.supportAlertSyntax = false;

64 > }

65 else {

66 this.isTrusted = isTrustedOrOptions.isTrusted ?? undefined;

69 this.supportAlertSyntax = isTrustedOrOptions.supportAlertSyntax ?? false;

70 }

71 > } htmlContent.ts

72 > htmlContent.ts

73 > appendText(value: string, newlineStyle: MarkdownStringTextNewlineStyle = MarkdownStringTextNewlineStyle.Paragraph): MarkdownString {

74 this.value += escapeMarkdownSyntaxTokens(this.supportThemeIcons ? escapeIcons(value) : value) // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.

75 .replace(/([ \t]+)/g, (_match, g1) => ' '.repeat(g1.length)) // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.

79 return this;

80 }

81 > htmlContent.ts

82 > appendMarkdown(value: string): MarkdownString {

83 this.value += value;

84 return this;

85 }

86 > htmlContent.ts

87 > appendCodeblock(langId: string, code: string): MarkdownString {

88 this.value += `\n${appendEscapedMarkdownCodeBlockFence(code, langId)}\n`;

89 return this;

90 }

91 > htmlContent.ts

92 > appendLink(target: URI | string, label: string, title?: string): MarkdownString {

93 this.value += '[';

94 this.value += this._escape(label, ']');

101 return this;

102 }

103 > htmlContent.ts

104 > private _escape(value: string, ch: string): string {

105 const r = new RegExp(escapeRegExpCharacters(ch), 'g');

106 return value.replace(r, (match, offset) => {

112 });

113 }

114 > } htmlContent.ts

115 >

116 > export function isEmptyMarkdownString(oneOrMany: IMarkdownString | IMarkdownString[] | null | undefined): boolean {

117 if (isMarkdownString(oneOrMany)) {

118 return !oneOrMany.value;

123 }

124 }

125 > htmlContent.ts

126 > export function isMarkdownString(thing: unknown): thing is IMarkdownString {

127 if (thing instanceof MarkdownString) {

128 return true;

135 return false;

136 }

137 > htmlContent.ts

138 > export function markdownStringEqual(a: IMarkdownString, b: IMarkdownString): boolean {

139 if (a === b) {

140 return true;

150 }

151 }

152 > htmlContent.ts

153 > export function escapeMarkdownSyntaxTokens(text: string): string {

154 // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash

155 return text

157 .replace(/^([ \t]*)-/gm, '$1\\-'); // CodeQL [SM02383] Backslash is escaped in the character class

158 }

159 > htmlContent.ts

160 > /**

161 > * Escapes only the characters that would break out of markdown link text

162 > * (`[label](url)`) syntax: `\` and `]`. Use this when the escaped string is

163 > * displayed as the visible label of a link, since renderers that extract the

164 > * link text without re-parsing markdown (e.g. the chat inline anchor / skill

165 > * pill) would otherwise show full `escapeMarkdownSyntaxTokens` backslashes

166 > * (`\-`, `\.`, ...) verbatim.

167 > */

168 > export function escapeMarkdownLinkLabel(text: string): string {

169 return text.replace(/[\\\]]/g, '\\$&');

170 }

171 > htmlContent.ts

172 > /**

173 > * @see https://github.com/microsoft/vscode/issues/193746

174 > */

175 > export function appendEscapedMarkdownCodeBlockFence(code: string, langId: string) {

176 const longestFenceLength =

177 code.match(/^`+/gm)?.reduce((a, b) => (a.length > b.length ? a : b)).length ??

187 ].join('\n');

188 }

189 > htmlContent.ts

190 > /**

191 > * Wraps arbitrary text in a markdown inline code span using a backtick fence

192 > * long enough to safely contain any backtick sequences present in the text.

193 > *

194 > * Backticks inside an inline code span cannot be backslash-escaped per the

195 > * CommonMark spec — the only safe way is to choose a delimiter run longer

196 > * than any run of backticks in the content (and pad with spaces if the

197 > * content begins or ends with a backtick).

198 > */

199 > export function appendEscapedMarkdownInlineCode(text: string): string {

200 const longestBacktickRun = Math.max(0, ...(text.match(/`+/g) ?? []).map(m => m.length));

201 const fence = '`'.repeat(longestBacktickRun + 1);

204 return `${fence}${content}${fence}`;

205 }

206 > htmlContent.ts

207 > export function escapeDoubleQuotes(input: string) {

208 return input.replace(/"/g, '"');

209 }

210 > htmlContent.ts

211 > export function removeMarkdownEscapes(text: string): string {

212 if (!text) {

213 return text;

215 return text.replace(/\\([\\`*_{}[\]()#+\-.!~])/g, '$1');

216 }

217 > htmlContent.ts

218 > export function parseHrefAndDimensions(href: string): { href: string; dimensions: string[] } {

219 const dimensions: string[] = [];

220 const splitted = href.split('|').map(s => s.trim());

237 return { href, dimensions };

238 }

239 > htmlContent.ts

240 > export function createMarkdownLink(text: string, href: string, title?: string, escapeTokens = true): string {

241 return `[${escapeTokens ? escapeMarkdownSyntaxTokens(text) : text}](${href}${title ? ` "${escapeMarkdownSyntaxTokens(title)}"` : ''})`;

242 }

243 > htmlContent.ts

244 > export function createMarkdownCommandLink(command: { text: string; id: string; arguments?: unknown[]; tooltip: string }, escapeTokens = true): string {

245 const uri = createCommandUri(command.id, ...(command.arguments || [])).toString();

246 return createMarkdownLink(command.text, uri, command.tooltip, escapeTokens);

247 }

248 > htmlContent.ts

249 > export function createCommandUri(commandId: string, ...commandArgs: unknown[]): URI {

250 return URI.from({

251 scheme: Schemas.command,

src/vs/platform/telemetry/common/telemetry.ts 115 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- telemetry.ts

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 { createDecorator } from '../../instantiation/common/instantiation.js';

7 > import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from './gdprTypings.js';

8 >

9 > export const ITelemetryService = createDecorator<ITelemetryService>('telemetryService');

10 >

11 > export interface ITelemetryData {

12 > from?: string;

13 > target?: string;

14 > [key: string]: string | unknown | undefined;

15 > }

16 >

17 > export interface ITelemetryService {

18 >

19 > readonly _serviceBrand: undefined;

20 >

21 > readonly telemetryLevel: TelemetryLevel;

22 >

23 > readonly sessionId: string;

24 > readonly machineId: string;

25 > readonly sqmId: string;

26 > readonly devDeviceId: string;

27 > readonly firstSessionDate: string;

28 > readonly msftInternal?: boolean;

29 >

30 > /**

31 > * Whether error telemetry will get sent. If false, `publicLogError` will no-op.

32 > */

33 > readonly sendErrorTelemetry: boolean;

34 >

35 > /**

36 > * @deprecated Use publicLog2 and the typescript GDPR annotation where possible

37 > */

38 > publicLog(eventName: string, data?: ITelemetryData): void;

39 >

40 > /**

41 > * Sends a telemetry event that has been privacy approved.

42 > * Do not call this unless you have been given approval.

43 > */

44 > publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;

45 >

46 > /**

47 > * @deprecated Use publicLogError2 and the typescript GDPR annotation where possible

48 > */

49 > publicLogError(errorEventName: string, data?: ITelemetryData): void;

50 >

51 > publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;

52 >

53 > setExperimentProperty(name: string, value: string): void;

54 >

55 > /**

56 > * Sets a common property that will be attached to all telemetry events.

57 > * Common properties are added after PII cleaning and cannot be overridden by event data.

58 > */

59 > setCommonProperty(name: string, value: string | boolean): void;

60 > }

61 >

62 > export function telemetryLevelEnabled(service: ITelemetryService, level: TelemetryLevel): boolean {

63 return service.telemetryLevel >= level;

64 }

65 > telemetry.ts

66 > /**

67 > * Replaces `/` and `\` with `|` in model identifiers to prevent the

68 > * telemetry pipeline from redacting them as file paths.

69 > */

70 > export function escapeModelIdForTelemetry(modelId: string | undefined): string | undefined {

71 return modelId?.replace(/[\/\\]/g, '|');

72 }

73 > telemetry.ts

74 > export interface ITelemetryEndpoint {

75 > id: string;

76 > aiKey: string;

77 > sendErrorTelemetry: boolean;

78 > }

79 >

80 > export const ICustomEndpointTelemetryService = createDecorator<ICustomEndpointTelemetryService>('customEndpointTelemetryService');

81 >

82 > export interface ICustomEndpointTelemetryService {

83 > readonly _serviceBrand: undefined;

84 >

85 > publicLog(endpoint: ITelemetryEndpoint, eventName: string, data?: ITelemetryData): void;

86 > publicLogError(endpoint: ITelemetryEndpoint, errorEventName: string, data?: ITelemetryData): void;

87 > }

88 >

89 > // Keys

90 > export const currentSessionDateStorageKey = 'telemetry.currentSessionDate';

91 > export const firstSessionDateStorageKey = 'telemetry.firstSessionDate';

92 > export const lastSessionDateStorageKey = 'telemetry.lastSessionDate';

93 > export const machineIdKey = 'telemetry.machineId';

94 > export const sqmIdKey = 'telemetry.sqmId';

95 > export const devDeviceIdKey = 'telemetry.devDeviceId';

96 >

97 > // Configuration Keys

98 > export const TELEMETRY_SECTION_ID = 'telemetry';

99 > export const TELEMETRY_SETTING_ID = 'telemetry.telemetryLevel';

100 > export const TELEMETRY_CRASH_REPORTER_SETTING_ID = 'telemetry.enableCrashReporter';

101 > export const TELEMETRY_OLD_SETTING_ID = 'telemetry.enableTelemetry';

102 >

103 > export const enum TelemetryLevel {

104 > NONE = 0,

105 > CRASH = 1,

106 > ERROR = 2,

107 > USAGE = 3

108 > }

109 >

110 > export const enum TelemetryConfiguration {

111 > OFF = 'off',

112 > CRASH = 'crash',

113 > ERROR = 'error',

114 > ON = 'all'

115 > }

116 >

117 > export interface ICommonProperties {

118 > [name: string]: string | boolean | undefined;

119 > }

src/vs/editor/common/core/position.ts 113 covered LOC · 16 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- position.ts

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 > /**

7 > * A position in the editor. This interface is suitable for serialization.

8 > */

9 > export interface IPosition {

10 > /**

11 > * line number (starts at 1)

12 > */

13 > readonly lineNumber: number;

14 > /**

15 > * column (the first character in a line is between column 1 and column 2)

16 > */

17 > readonly column: number;

18 > }

19 >

20 > /**

21 > * A position in the editor.

22 > */

23 > export class Position {

24 > /**

25 > * line number (starts at 1)

26 > */

27 > public readonly lineNumber: number;

28 > /**

29 > * column (the first character in a line is between column 1 and column 2)

30 > */

31 > public readonly column: number;

32 >

33 > constructor(lineNumber: number, column: number) {

34 this.lineNumber = lineNumber;

35 this.column = column;

36 }

37 > position.ts

38 > /**

39 > * Create a new position from this position.

40 > *

41 > * @param newLineNumber new line number

42 > * @param newColumn new column

43 > */

44 > with(newLineNumber: number = this.lineNumber, newColumn: number = this.column): Position {

45 if (newLineNumber === this.lineNumber && newColumn === this.column) {

46 return this;

49 }

50 }

51 > position.ts

52 > /**

53 > * Derive a new position from this position.

54 > *

55 > * @param deltaLineNumber line number delta

56 > * @param deltaColumn column delta

57 > */

58 > delta(deltaLineNumber: number = 0, deltaColumn: number = 0): Position {

59 return this.with(Math.max(1, this.lineNumber + deltaLineNumber), Math.max(1, this.column + deltaColumn));

60 }

61 > position.ts

62 > /**

63 > * Test if this position equals other position

64 > */

65 > public equals(other: IPosition): boolean {

66 return Position.equals(this, other);

67 }

68 > position.ts

69 > /**

70 > * Test if position `a` equals position `b`

71 > */

72 > public static equals(a: IPosition | null, b: IPosition | null): boolean {

73 if (!a && !b) {

74 return true;

81 );

82 }

83 > position.ts

84 > /**

85 > * Test if this position is before other position.

86 > * If the two positions are equal, the result will be false.

87 > */

88 > public isBefore(other: IPosition): boolean {

89 return Position.isBefore(this, other);

90 }

91 > position.ts

92 > /**

93 > * Test if position `a` is before position `b`.

94 > * If the two positions are equal, the result will be false.

95 > */

96 > public static isBefore(a: IPosition, b: IPosition): boolean {

97 if (a.lineNumber < b.lineNumber) {

98 return true;

103 return a.column < b.column;

104 }

105 > position.ts

106 > /**

107 > * Test if this position is before other position.

108 > * If the two positions are equal, the result will be true.

109 > */

110 > public isBeforeOrEqual(other: IPosition): boolean {

111 return Position.isBeforeOrEqual(this, other);

112 }

113 > position.ts

114 > /**

115 > * Test if position `a` is before position `b`.

116 > * If the two positions are equal, the result will be true.

117 > */

118 > public static isBeforeOrEqual(a: IPosition, b: IPosition): boolean {

119 if (a.lineNumber < b.lineNumber) {

120 return true;

125 return a.column <= b.column;

126 }

127 > position.ts

128 > /**

129 > * A function that compares positions, useful for sorting

130 > */

131 > public static compare(a: IPosition, b: IPosition): number {

132 const aLineNumber = a.lineNumber | 0;

133 const bLineNumber = b.lineNumber | 0;

141 return aLineNumber - bLineNumber;

142 }

143 > position.ts

144 > /**

145 > * Clone this position.

146 > */

147 > public clone(): Position {

148 return new Position(this.lineNumber, this.column);

149 }

150 > position.ts

151 > /**

152 > * Convert to a human-readable representation.

153 > */

154 > public toString(): string {

155 return '(' + this.lineNumber + ',' + this.column + ')';

156 }

157 > position.ts

158 > // ---

159 >

160 > /**

161 > * Create a `Position` from an `IPosition`.

162 > */

163 > public static lift(pos: IPosition): Position {

164 return new Position(pos.lineNumber, pos.column);

165 }

166 > position.ts

167 > /**

168 > * Test if `obj` is an `IPosition`.

169 > */

170 > public static isIPosition(obj: unknown): obj is IPosition {

171 return (

172 !!obj

175 );

176 }

177 > position.ts

178 > public toJSON(): IPosition {

179 return {

180 lineNumber: this.lineNumber,

182 };

183 }

184 > } position.ts

src/vs/base/common/observableInternal/observables/derivedImpl.ts 112 covered LOC · 23 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- derivedImpl.ts

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 { IObservable, IObservableWithChange, IObserver, IReaderWithStore, ISettableObservable, ITransaction, } from '../base.js';

7 > import { BaseObservable } from './baseObservable.js';

8 > import { DebugNameData } from '../debugName.js';

9 > import { BugIndicatingError, DisposableStore, EqualityComparer, assertFn, onBugIndicatingError } from '../commonFacade/deps.js';

10 > import { getLogger } from '../logging/logging.js';

11 > import { IChangeTracker } from '../changeTracker.js';

12 > import { DebugLocation } from '../debugLocation.js';

13 >

14 > export interface IDerivedReader<TChange = void> extends IReaderWithStore {

15 > /**

16 > * Call this to report a change delta or to force report a change, even if the new value is the same as the old value.

17 > */

18 > reportChange(change: TChange): void;

19 > }

20 >

21 > export const enum DerivedState {

22 > /** Initial state, no previous value, recomputation needed */

23 > initial = 0,

24 >

25 > /**

26 > * A dependency could have changed.

27 > * We need to explicitly ask them if at least one dependency changed.

28 > */

29 > dependenciesMightHaveChanged = 1,

30 >

31 > /**

32 > * A dependency changed and we need to recompute.

33 > * After recomputation, we need to check the previous value to see if we changed as well.

34 > */

35 > stale = 2,

36 >

37 > /**

38 > * No change reported, our cached value is up to date.

39 > */

40 > upToDate = 3,

41 > }

42 >

43 function derivedStateToString(state: DerivedState): string {

44 switch (state) {

50 }

51 }

52 > derivedImpl.ts

53 > export class Derived<T, TChangeSummary = any, TChange = void> extends BaseObservable<T, TChange> implements IDerivedReader<TChange>, IObserver {

54 > private _state = DerivedState.initial;

55 > private _value: T | undefined = undefined;

56 > private _updateCount = 0;

57 > private _dependencies = new Set<IObservable<any>>();

58 > private _dependenciesToBeRemoved = new Set<IObservable<any>>();

59 > private _changeSummary: TChangeSummary | undefined = undefined;

60 > private _isUpdating = false;

61 > private _isComputing = false;

62 > private _didReportChange = false;

63 > private _isInBeforeUpdate = false;

64 > private _isReaderValid = false;

65 > private _store: DisposableStore | undefined = undefined;

66 > private _delayedStore: DisposableStore | undefined = undefined;

67 > private _removedObserverToCallEndUpdateOn: Set<IObserver> | null = null;

68 >

69 > public override get debugName(): string {

70 > return this._debugNameData.getDebugName(this) ?? '(anonymous)';

71 > }

72 >

73 > constructor(

74 public readonly _debugNameData: DebugNameData,

75 public readonly _computeFn: (reader: IDerivedReader<TChange>, changeSummary: TChangeSummary) => T,

82 this._changeSummary = this._changeTracker?.createChangeSummary(undefined);

83 }

84 > derivedImpl.ts

85 > protected override onLastObserverRemoved(): void {

86 /**

87 * We are not tracking changes anymore, thus we have to assume

107 this._handleLastObserverRemoved?.();

108 }

109 > derivedImpl.ts

110 > public override get(): T {

111 const checkEnabled = false; // TODO set to true

112 if (this._isComputing && checkEnabled) {

164 }

165 }

166 > derivedImpl.ts

167 > private _recompute() {

168 let didChange = false;

169 this._isComputing = true;

238 }

239 }

240 > derivedImpl.ts

241 > public override toString(): string {

242 return `LazyDerived<${this.debugName}>`;

243 }

244 > derivedImpl.ts

245 > // IObserver Implementation

246 >

247 > public beginUpdate<T>(_observable: IObservable<T>): void {

248 if (this._isUpdating) {

249 throw new BugIndicatingError('Cyclic deriveds are not supported yet!');

272 }

273 }

274 > derivedImpl.ts

275 > public endUpdate<T>(_observable: IObservable<T>): void {

276 this._updateCount--;

277 if (this._updateCount === 0) {

291 assertFn(() => this._updateCount >= 0);

292 }

293 > derivedImpl.ts

294 > public handlePossibleChange<T>(observable: IObservable<T>): void {

295 // In all other states, observers already know that we might have changed.

296 if (this._state === DerivedState.upToDate && this._dependencies.has(observable) && !this._dependenciesToBeRemoved.has(observable)) {

301 }

302 }

303 > derivedImpl.ts

304 > public handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void {

305 if (this._dependencies.has(observable) && !this._dependenciesToBeRemoved.has(observable) || this._isInBeforeUpdate) {

306 getLogger()?.handleDerivedDependencyChanged(this, observable, change);

329 }

330 }

331 > derivedImpl.ts

332 > // IReader Implementation

333 >

334 > private _ensureReaderValid(): void {

335 if (!this._isReaderValid) { throw new BugIndicatingError('The reader object cannot be used outside its compute function!'); }

336 }

337 > derivedImpl.ts

338 > public readObservable<T>(observable: IObservable<T>): T {

339 this._ensureReaderValid();

340

348 return value;

349 }

350 > derivedImpl.ts

351 > public reportChange(change: TChange): void {

352 this._ensureReaderValid();

353

358 }

359 }

360 > derivedImpl.ts

361 > get store(): DisposableStore {

362 this._ensureReaderValid();

363

367 return this._store;

368 }

369 > derivedImpl.ts

370 > get delayedStore(): DisposableStore {

371 this._ensureReaderValid();

372

376 return this._delayedStore;

377 }

378 > derivedImpl.ts

379 > public override addObserver(observer: IObserver): void {

380 const shouldCallBeginUpdate = !this._observers.has(observer) && this._updateCount > 0;

381 super.addObserver(observer);

387 }

388 }

389 > derivedImpl.ts

390 > public override removeObserver(observer: IObserver): void {

391 if (this._observers.has(observer) && this._updateCount > 0) {

392 if (!this._removedObserverToCallEndUpdateOn) {

397 super.removeObserver(observer);

398 }

399 > derivedImpl.ts

400 > public debugGetState() {

401 return {

402 state: this._state,

408 };

409 }

410 > derivedImpl.ts

411 > public debugSetValue(newValue: unknown) {

412 // eslint-disable-next-line local/code-no-any-casts

413 this._value = newValue as any;

414 }

415 > derivedImpl.ts

416 > public debugRecompute(): void {

417 this.beginUpdate(this);

418 try {

426 }

427 }

428 > derivedImpl.ts

429 > public setValue(newValue: T, tx: ITransaction, change: TChange): void {

430 this._value = newValue;

431 const observers = this._observers;

435 }

436 }

437 > } derivedImpl.ts

438 >

439 >

440 > export class DerivedWithSetter<T, TChangeSummary = any, TOutChanges = any> extends Derived<T, TChangeSummary, TOutChanges> implements ISettableObservable<T, TOutChanges> {

441 > constructor(

442 debugNameData: DebugNameData,

443 computeFn: (reader: IDerivedReader<TOutChanges>, changeSummary: TChangeSummary) => T,

457 );

458 }

459 > } derivedImpl.ts

src/vs/base/common/equals.ts 108 covered LOC · 14 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- equals.ts

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 * as arrays from './arrays.js';

7 >

8 > /*

9 > * Each function in this file which offers an equality comparison, has an accompanying

10 > * `*C` variant which returns an EqualityComparer function.

11 > *

12 > * The `*C` variant allows for easier composition of equality comparers and improved type-inference.

13 > */

14 >

15 >

16 > /** Represents a function that decides if two values are equal. */

17 > export type EqualityComparer<T> = (a: T, b: T) => boolean;

18 >

19 > export interface IEquatable<T> {

20 > equals(other: T): boolean;

21 > }

22 >

23 > /**

24 > * Compares two items for equality using strict equality.

25 > */

26 > export function strictEquals<T>(a: T, b: T): boolean {

27 return a === b;

28 }

29 > equals.ts

30 > export function strictEqualsC<T>(): EqualityComparer<T> {

31 return (a, b) => a === b;

32 }

33 > equals.ts

34 > /**

35 > * Checks if the items of two arrays are equal.

36 > * By default, strict equality is used to compare elements, but a custom equality comparer can be provided.

37 > */

38 > export function arrayEquals<T>(a: readonly T[], b: readonly T[], itemEquals?: EqualityComparer<T>): boolean {

39 return arrays.equals(a, b, itemEquals ?? strictEquals);

40 }

41 > equals.ts

42 > /**

43 > * Checks if the items of two arrays are equal.

44 > * By default, strict equality is used to compare elements, but a custom equality comparer can be provided.

45 > */

46 > export function arrayEqualsC<T>(itemEquals?: EqualityComparer<T>): EqualityComparer<readonly T[]> {

47 return (a, b) => arrays.equals(a, b, itemEquals ?? strictEquals);

48 }

49 > equals.ts

50 > /**

51 > * Drills into arrays (items ordered) and objects (keys unordered) and uses strict equality on everything else.

52 > */

53 > export function structuralEquals<T>(a: T, b: T): boolean {

54 if (a === b) {

55 return true;

95 return false;

96 }

97 > equals.ts

98 > export function structuralEqualsC<T>(): EqualityComparer<T> {

99 return (a, b) => structuralEquals(a, b);

100 }

101 > equals.ts

102 > /**

103 > * `getStructuralKey(a) === getStructuralKey(b) <=> structuralEquals(a, b)`

104 > * (assuming that a and b are not cyclic structures and nothing extends globalThis Array).

105 > */

106 > export function getStructuralKey(t: unknown): string {

107 return JSON.stringify(toNormalizedJsonStructure(t));

108 }

109 > equals.ts

110 > let objectId = 0;

111 > const objIds = new WeakMap<object, number>();

112 >

113 function toNormalizedJsonStructure(t: unknown): unknown {

114 if (Array.isArray(t)) {

136 return t;

137 }

138 > equals.ts

139 >

140 > /**

141 > * Two items are considered equal, if their stringified representations are equal.

142 > */

143 > export function jsonStringifyEquals<T>(a: T, b: T): boolean {

144 return JSON.stringify(a) === JSON.stringify(b);

145 }

146 > equals.ts

147 > /**

148 > * Two items are considered equal, if their stringified representations are equal.

149 > */

150 > export function jsonStringifyEqualsC<T>(): EqualityComparer<T> {

151 return (a, b) => JSON.stringify(a) === JSON.stringify(b);

152 }

153 > equals.ts

154 > /**

155 > * Uses `item.equals(other)` to determine equality.

156 > */

157 > export function thisEqualsC<T extends IEquatable<T>>(): EqualityComparer<T> {

158 return (a, b) => a.equals(b);

159 }

160 > equals.ts

161 > /**

162 > * Checks if two items are both null or undefined, or are equal according to the provided equality comparer.

163 > */

164 > export function equalsIfDefined<T>(v1: T | undefined | null, v2: T | undefined | null, equals: EqualityComparer<T>): boolean {

165 if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {

166 return v2 === v1;

168 return equals(v1, v2);

169 }

170 > equals.ts

171 > /**

172 > * Returns an equality comparer that checks if two items are both null or undefined, or are equal according to the provided equality comparer.

173 > */

174 > export function equalsIfDefinedC<T>(equals: EqualityComparer<T>): EqualityComparer<T | undefined | null> {

175 return (v1, v2) => {

176 if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {

180 };

181 }

182 > equals.ts

183 > /**

184 > * Each function in this file which offers an equality comparison, has an accompanying

185 > * `*C` variant which returns an EqualityComparer function.

186 > *

187 > * The `*C` variant allows for easier composition of equality comparers and improved type-inference.

188 > */

189 > export namespace equals {

190 > export const strict = strictEquals;

191 > export const strictC = strictEqualsC;

192 >

193 > export const array = arrayEquals;

194 > export const arrayC = arrayEqualsC;

195 >

196 > export const structural = structuralEquals;

197 > export const structuralC = structuralEqualsC;

198 >

199 > export const jsonStringify = jsonStringifyEquals;

200 > export const jsonStringifyC = jsonStringifyEqualsC;

201 >

202 > export const thisC = thisEqualsC;

203 >

204 > export const ifDefined = equalsIfDefined;

205 > export const ifDefinedC = equalsIfDefinedC;

206 > }

src/vs/base/common/observableInternal/observables/baseObservable.ts 104 covered LOC · 17 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- baseObservable.ts

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 { IObservableWithChange, IObserver, IReader, IObservable } from '../base.js';

7 > import { DisposableStore } from '../commonFacade/deps.js';

8 > import { DebugLocation } from '../debugLocation.js';

9 > import { DebugOwner, getFunctionName } from '../debugName.js';

10 > import { debugGetObservableGraph } from '../logging/debugGetDependencyGraph.js';

11 > import { getLogger, logObservable } from '../logging/logging.js';

12 > import type { keepObserved, recomputeInitiallyAndOnChange } from '../utils/utils.js';

13 > import { derivedOpts } from './derived.js';

14 >

15 > let _derived: typeof derivedOpts;

16 > /**

17 > * @internal

18 > * This is to allow splitting files.

19 > */

20 > export function _setDerivedOpts(derived: typeof _derived) {

21 > _derived = derived;

22 > }

23 >

24 > let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange;

25 > export function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange) {

26 > _recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;

27 > }

28 >

29 > let _keepObserved: typeof keepObserved;

30 > export function _setKeepObserved(keepObserved: typeof _keepObserved) {

31 > _keepObserved = keepObserved;

32 > }

33 >

34 > let _debugGetObservableGraph: typeof debugGetObservableGraph;

35 > export function _setDebugGetObservableGraph(debugGetObservableGraph: typeof _debugGetObservableGraph) {

36 > _debugGetObservableGraph = debugGetObservableGraph;

37 > }

38 >

39 > export abstract class ConvenientObservable<T, TChange> implements IObservableWithChange<T, TChange> {

40 > get TChange(): TChange { return null!; }

41 >

42 > public abstract get(): T;

43 >

44 > public reportChanges(): void {

45 this.get();

46 }

47 > baseObservable.ts

48 > public abstract addObserver(observer: IObserver): void;

49 > public abstract removeObserver(observer: IObserver): void;

50 >

51 > /** @sealed */

52 > public read(reader: IReader | undefined): T {

53 if (reader) {

54 return reader.readObservable(this);

57 }

58 }

59 > baseObservable.ts

60 > /** @sealed */

61 > public map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;

62 > public map<TNew>(owner: DebugOwner, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;

63 > public map<TNew>(fnOrOwner: DebugOwner | ((value: T, reader: IReader) => TNew), fnOrUndefined?: (value: T, reader: IReader) => TNew, debugLocation: DebugLocation = DebugLocation.ofCaller()): IObservable<TNew> {

64 const owner = fnOrUndefined === undefined ? undefined : fnOrOwner as DebugOwner;

65 const fn = fnOrUndefined === undefined ? fnOrOwner as (value: T, reader: IReader) => TNew : fnOrUndefined;

91 );

92 }

93 > baseObservable.ts

94 > public abstract log(): IObservableWithChange<T, TChange>;

95 >

96 > /**

97 > * @sealed

98 > * Converts an observable of an observable value into a direct observable of the value.

99 > */

100 > public flatten<TNew>(this: IObservable<IObservableWithChange<TNew, any>>): IObservable<TNew> {

101 return _derived(

102 {

107 );

108 }

109 > baseObservable.ts

110 > public recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T> {

111 store.add(_recomputeInitiallyAndOnChange!(this, handleValue));

112 return this;

113 }

114 > baseObservable.ts

115 > /**

116 > * Ensures that this observable is observed. This keeps the cache alive.

117 > * However, in case of deriveds, it does not force eager evaluation (only when the value is read/get).

118 > * Use `recomputeInitiallyAndOnChange` for eager evaluation.

119 > */

120 > public keepObserved(store: DisposableStore): IObservable<T> {

121 store.add(_keepObserved!(this));

122 return this;

123 }

124 > baseObservable.ts

125 > public abstract get debugName(): string;

126 >

127 > protected get debugValue() {

128 return this.get();

129 }

130 > baseObservable.ts

131 > get debug(): DebugHelper {

132 return new DebugHelper(this);

133 }

134 > } baseObservable.ts

135 >

136 > class DebugHelper {

137 > constructor(public readonly observable: IObservableWithChange<any, any>) {

138 }

139 > baseObservable.ts

140 > getDependencyGraph(): string {

141 return _debugGetObservableGraph(this.observable, { type: 'dependencies' });

142 }

143 > baseObservable.ts

144 > getObserverGraph(): string {

145 return _debugGetObservableGraph(this.observable, { type: 'observers' });

146 }

147 > } baseObservable.ts

148 >

149 > export abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {

150 > protected readonly _observers = new Set<IObserver>();

151 >

152 > constructor(debugLocation: DebugLocation) {

153 super();

154 getLogger()?.handleObservableCreated(this, debugLocation);

155 }

156 > baseObservable.ts

157 > public addObserver(observer: IObserver): void {

158 const len = this._observers.size;

159 this._observers.add(observer);

165 }

166 }

167 > baseObservable.ts

168 > public removeObserver(observer: IObserver): void {

169 const deleted = this._observers.delete(observer);

170 if (deleted && this._observers.size === 0) {

175 }

176 }

177 > baseObservable.ts

178 > protected onFirstObserverAdded(): void { }

179 > protected onLastObserverRemoved(): void { }

180 >

181 > public override log(): IObservableWithChange<T, TChange> {

182 const hadLogger = !!getLogger();

183 logObservable(this);

187 return this;

188 }

189 > baseObservable.ts

190 > public debugGetObservers() {

191 return this._observers;

192 }

193 > } baseObservable.ts

src/vs/base/common/observableInternal/utils/promise.ts 104 covered LOC · 12 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- promise.ts

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 > import { DisposableStore } from '../../lifecycle.js';

6 > import { IObservable, ISettableObservable } from '../base.js';

7 > import { autorun } from '../reactions/autorun.js';

8 > import { transaction } from '../transaction.js';

9 > import { derived } from '../observables/derived.js';

10 > import { observableValue } from '../observables/observableValue.js';

11 >

12 > export class ObservableLazy<T> {

13 > private readonly _value = observableValue<T | undefined>(this, undefined);

14 >

15 > /**

16 > * The cached value.

17 > * Does not force a computation of the value.

18 > */

19 > public get cachedValue(): IObservable<T | undefined> { return this._value; }

20 >

21 > constructor(private readonly _computeValue: () => T) {

22 }

23 > promise.ts

24 > /**

25 > * Returns the cached value.

26 > * Computes the value if the value has not been cached yet.

27 > */

28 > public getValue(): T {

29 let v = this._value.get();

30 if (!v) {

34 return v;

35 }

36 > } promise.ts

37 >

38 > /**

39 > * A promise whose state is observable.

40 > */

41 > export class ObservablePromise<T> {

42 > public static fromFn<T>(fn: () => Promise<T>): ObservablePromise<T> {

43 > return new ObservablePromise(fn());

44 > }

45 >

46 > public static resolved<T>(value: T): ObservablePromise<T> {

47 return new ObservablePromise(Promise.resolve(value));

48 }

49 > promise.ts

50 > private readonly _value = observableValue<PromiseResult<T> | undefined>(this, undefined);

51 >

52 > /**

53 > * The promise that this object wraps.

54 > */

55 > public readonly promise: Promise<T>;

56 >

57 > /**

58 > * The current state of the promise.

59 > * Is `undefined` if the promise didn't resolve yet.

60 > */

61 > public readonly promiseResult: IObservable<PromiseResult<T> | undefined> = this._value;

62 >

63 > constructor(promise: Promise<T>) {

64 this.promise = promise.then(value => {

65 transaction(tx => {

76 });

77 }

78 > promise.ts

79 > public readonly resolvedValue = derived(this, reader => {

80 > const result = this.promiseResult.read(reader); promise.ts

81 > if (!result) {

82 > return undefined;

83 > }

84 > return result.getDataOrThrow();

85 > }); promise.ts

86 > }

87 >

88 > export class PromiseResult<T> {

89 > constructor(

90 /**

91 * The value of the resolved promise.

101 ) {

102 }

103 > promise.ts

104 > /**

105 > * Returns the value if the promise resolved, otherwise throws the error.

106 > */

107 > public getDataOrThrow(): T {

108 if (this.error) {

109 throw this.error;

111 return this.data!;

112 }

113 > } promise.ts

114 >

115 > /**

116 > * Tracks a changing {@link ObservablePromise}, exposing the last resolved value

117 > * and whether a newer promise is still pending.

118 > */

119 > export class ObservableResolvedPromise<T> {

120 > private readonly _lastResolved: ISettableObservable<T>;

121 > public readonly lastResolved: IObservable<T>;

122 >

123 > private readonly _isResolving = observableValue<boolean>(this, false);

124 > public readonly isResolving: IObservable<boolean> = this._isResolving;

125 >

126 > private _runningPromise: ObservablePromise<T> | undefined;

127 >

128 > constructor(

129 source: IObservable<ObservablePromise<T>>,

130 initialValue: T,

149 }));

150 }

151 > } promise.ts

152 >

153 > /**

154 > * A lazy promise whose state is observable.

155 > */

156 > export class ObservableLazyPromise<T> {

157 > private readonly _lazyValue = new ObservableLazy(() => new ObservablePromise(this._computePromise()));

158 >

159 > /**

160 > * Does not enforce evaluation of the promise compute function.

161 > * Is undefined if the promise has not been computed yet.

162 > */

163 > public readonly cachedPromiseResult = derived(this, reader => this._lazyValue.cachedValue.read(reader)?.promiseResult.read(reader));

164 >

165 > constructor(private readonly _computePromise: () => Promise<T>) {

166 }

167 > promise.ts

168 > public getPromise(): Promise<T> {

169 return this._lazyValue.getValue().promise;

170 }

171 > } promise.ts

src/vs/platform/jsonschemas/common/jsonContributionRegistry.ts 100 covered LOC · 9 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- jsonContributionRegistry.ts

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 { Emitter, Event } from '../../../base/common/event.js';

7 > import { getCompressedContent, IJSONSchema } from '../../../base/common/jsonSchema.js';

8 > import { Disposable, DisposableStore, IDisposable, toDisposable } from '../../../base/common/lifecycle.js';

9 > import * as platform from '../../registry/common/platform.js';

10 >

11 > export const Extensions = {

12 > JSONContribution: 'base.contributions.json'

13 > };

14 >

15 > export interface ISchemaContributions {

16 > schemas: { [id: string]: IJSONSchema };

17 > }

18 >

19 > export interface IJSONContributionRegistry {

20 >

21 > readonly onDidChangeSchema: Event<string>;

22 > readonly onDidChangeSchemaAssociations: Event<void>;

23 >

24 > /**

25 > * Register a schema to the registry.

26 > */

27 > registerSchema(uri: string, unresolvedSchemaContent: IJSONSchema, store?: DisposableStore): void;

28 >

29 > registerSchemaAssociation(uri: string, glob: string): IDisposable;

30 >

31 > /**

32 > * Notifies all listeners that the content of the given schema has changed.

33 > * @param uri The id of the schema

34 > */

35 > notifySchemaChanged(uri: string): void;

36 >

37 > /**

38 > * Get all schemas

39 > */

40 > getSchemaContributions(): ISchemaContributions;

41 >

42 > getSchemaAssociations(): { [uri: string]: string[] };

43 >

44 > /**

45 > * Gets the (compressed) content of the schema with the given schema ID (if any)

46 > * @param uri The id of the schema

47 > */

48 > getSchemaContent(uri: string): string | undefined;

49 >

50 > /**

51 > * Returns true if there's a schema that matches the given schema ID

52 > * @param uri The id of the schema

53 > */

54 > hasSchemaContent(uri: string): boolean;

55 > }

56 >

57 >

58 >

59 > function normalizeId(id: string) {

60 > if (id.length > 0 && id.charAt(id.length - 1) === '#') {

61 return id.substring(0, id.length - 1);

62 }

63 > return id; jsonContributionRegistry.ts

64 > }

65 >

66 >

67 >

68 > class JSONContributionRegistry extends Disposable implements IJSONContributionRegistry {

69 >

70 > private readonly schemasById: { [id: string]: IJSONSchema } = {};

71 > private readonly schemaAssociations: { [uri: string]: string[] } = {};

72 >

73 > private readonly _onDidChangeSchema = this._register(new Emitter<string>());

74 > readonly onDidChangeSchema: Event<string> = this._onDidChangeSchema.event;

75 >

76 > private readonly _onDidChangeSchemaAssociations = this._register(new Emitter<void>());

77 > readonly onDidChangeSchemaAssociations: Event<void> = this._onDidChangeSchemaAssociations.event;

78 >

79 > public registerSchema(uri: string, unresolvedSchemaContent: IJSONSchema, store?: DisposableStore): void {

80 > const normalizedUri = normalizeId(uri);

81 > this.schemasById[normalizedUri] = unresolvedSchemaContent;

82 > this._onDidChangeSchema.fire(uri);

83 >

84 > if (store) {

85 store.add(toDisposable(() => {

86 delete this.schemasById[normalizedUri];

88 }));

89 }

90 > } jsonContributionRegistry.ts

91 >

92 > public registerSchemaAssociation(uri: string, glob: string): IDisposable {

93 const normalizedUri = normalizeId(uri);

94 if (!this.schemaAssociations[normalizedUri]) {

114 });

115 }

116 > jsonContributionRegistry.ts

117 > public notifySchemaChanged(uri: string): void {

118 this._onDidChangeSchema.fire(uri);

119 }

120 > jsonContributionRegistry.ts

121 > public getSchemaContributions(): ISchemaContributions {

122 return {

123 schemas: this.schemasById,

124 };

125 }

126 > jsonContributionRegistry.ts

127 > public getSchemaContent(uri: string): string | undefined {

128 const schema = this.schemasById[uri];

129 return schema ? getCompressedContent(schema) : undefined;

130 }

131 > jsonContributionRegistry.ts

132 > public hasSchemaContent(uri: string): boolean {

133 return !!this.schemasById[uri];

134 }

135 > jsonContributionRegistry.ts

136 > public getSchemaAssociations(): { [uri: string]: string[] } {

137 return this.schemaAssociations;

138 }

139 > jsonContributionRegistry.ts

140 > }

141 >

142 > const jsonContributionRegistry = new JSONContributionRegistry();

143 > platform.Registry.add(Extensions.JSONContribution, jsonContributionRegistry);

src/vs/base/common/arraysFind.ts 95 covered LOC · 16 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- arraysFind.ts

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 { Comparator } from './arrays.js';

7 >

8 > export function findLast<T, R extends T>(array: readonly T[], predicate: (item: T, index: number) => item is R, fromIndex?: number): R | undefined;

9 > export function findLast<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex?: number): T | undefined;

10 > export function findLast<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex = array.length - 1): T | undefined {

11 const idx = findLastIdx(array, predicate, fromIndex);

12 if (idx === -1) {

15 return array[idx];

16 }

17 > arraysFind.ts

18 > export function findLastIdx<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex = array.length - 1): number {

19 for (let i = fromIndex; i >= 0; i--) {

20 const element = array[i];

27 return -1;

28 }

29 > arraysFind.ts

30 > export function findFirst<T, R extends T>(array: readonly T[], predicate: (item: T, index: number) => item is R, fromIndex?: number): R | undefined;

31 > export function findFirst<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex?: number): T | undefined;

32 > export function findFirst<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex = 0): T | undefined {

33 const idx = findFirstIdx(array, predicate, fromIndex);

34 if (idx === -1) {

37 return array[idx];

38 }

39 > arraysFind.ts

40 > export function findFirstIdx<T>(array: readonly T[], predicate: (item: T, index: number) => unknown, fromIndex = 0): number {

41 for (let i = fromIndex; i < array.length; i++) {

42 const element = array[i];

49 return -1;

50 }

51 > arraysFind.ts

52 > /**

53 > * Finds the last item where predicate is true using binary search.

54 > * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!

55 > *

56 > * @returns `undefined` if no item matches, otherwise the last item that matches the predicate.

57 > */

58 > export function findLastMonotonous<T>(array: readonly T[], predicate: (item: T) => boolean): T | undefined {

59 const idx = findLastIdxMonotonous(array, predicate);

60 return idx === -1 ? undefined : array[idx];

61 }

62 > arraysFind.ts

63 > /**

64 > * Finds the last item where predicate is true using binary search.

65 > * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!

66 > *

67 > * @returns `startIdx - 1` if predicate is false for all items, otherwise the index of the last item that matches the predicate.

68 > */

69 > export function findLastIdxMonotonous<T>(array: readonly T[], predicate: (item: T) => boolean, startIdx = 0, endIdxEx = array.length): number {

70 let i = startIdx;

71 let j = endIdxEx;

80 return i - 1;

81 }

82 > arraysFind.ts

83 > /**

84 > * Finds the first item where predicate is true using binary search.

85 > * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!

86 > *

87 > * @returns `undefined` if no item matches, otherwise the first item that matches the predicate.

88 > */

89 > export function findFirstMonotonous<T>(array: readonly T[], predicate: (item: T) => boolean): T | undefined {

90 const idx = findFirstIdxMonotonousOrArrLen(array, predicate);

91 return idx === array.length ? undefined : array[idx];

92 }

93 > arraysFind.ts

94 > /**

95 > * Finds the first item where predicate is true using binary search.

96 > * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!

97 > *

98 > * @returns `endIdxEx` if predicate is false for all items, otherwise the index of the first item that matches the predicate.

99 > */

100 > export function findFirstIdxMonotonousOrArrLen<T>(array: readonly T[], predicate: (item: T) => boolean, startIdx = 0, endIdxEx = array.length): number {

101 let i = startIdx;

102 let j = endIdxEx;

111 return i;

112 }

113 > arraysFind.ts

114 > export function findFirstIdxMonotonous<T>(array: readonly T[], predicate: (item: T) => boolean, startIdx = 0, endIdxEx = array.length): number {

115 const idx = findFirstIdxMonotonousOrArrLen(array, predicate, startIdx, endIdxEx);

116 return idx === array.length ? -1 : idx;

117 }

118 > arraysFind.ts

119 > /**

120 > * Use this when

121 > * * You have a sorted array

122 > * * You query this array with a monotonous predicate to find the last item that has a certain property.

123 > * * You query this array multiple times with monotonous predicates that get weaker and weaker.

124 > */

125 > export class MonotonousArray<T> {

126 > public static assertInvariants = false;

127 >

128 > private _findLastMonotonousLastIdx = 0;

129 > private _prevFindLastPredicate: ((item: T) => boolean) | undefined;

130 >

131 > constructor(private readonly _array: readonly T[]) {

132 }

133 > arraysFind.ts

134 > /**

135 > * The predicate must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!

136 > * For subsequent calls, current predicate must be weaker than (or equal to) the previous predicate, i.e. more entries must be `true`.

137 > */

138 > findLastMonotonous(predicate: (item: T) => boolean): T | undefined {

139 if (MonotonousArray.assertInvariants) {

140 if (this._prevFindLastPredicate) {

152 return idx === -1 ? undefined : this._array[idx];

153 }

154 > } arraysFind.ts

155 >

156 > /**

157 > * Returns the first item that is equal to or greater than every other item.

158 > */

159 > export function findFirstMax<T>(array: readonly T[], comparator: Comparator<T>): T | undefined {

160 if (array.length === 0) {

161 return undefined;

171 return max;

172 }

173 > arraysFind.ts

174 > /**

175 > * Returns the last item that is equal to or greater than every other item.

176 > */

177 > export function findLastMax<T>(array: readonly T[], comparator: Comparator<T>): T | undefined {

178 if (array.length === 0) {

179 return undefined;

189 return max;

190 }

191 > arraysFind.ts

192 > /**

193 > * Returns the first item that is equal to or less than every other item.

194 > */

195 > export function findFirstMin<T>(array: readonly T[], comparator: Comparator<T>): T | undefined {

196 return findFirstMax(array, (a, b) => -comparator(a, b));

197 }

198 > arraysFind.ts

199 > export function findMaxIdx<T>(array: readonly T[], comparator: Comparator<T>): number {

200 if (array.length === 0) {

201 return -1;

211 return maxIdx;

212 }

213 > arraysFind.ts

214 > /**

215 > * Returns the first mapped value of the array which is not undefined.

216 > */

217 > export function mapFindFirst<T, R>(items: Iterable<T>, mapFn: (value: T) => R | undefined): R | undefined {

218 for (const value of items) {

219 const mapped = mapFn(value);

src/vs/base/common/extpath.ts 91 covered LOC · 17 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- extpath.ts

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 { CharCode } from './charCode.js';

7 > import { isAbsolute, join, normalize, posix, sep } from './path.js';

8 > import { isWindows } from './platform.js';

9 > import { equalsIgnoreCase, rtrim, startsWithIgnoreCase } from './strings.js';

10 > import { isNumber } from './types.js';

11 >

12 > export function isPathSeparator(code: number) {

13 return code === CharCode.Slash || code === CharCode.Backslash;

14 }

15 > extpath.ts

16 > /**

17 > * Takes a Windows OS path and changes backward slashes to forward slashes.

18 > * This should only be done for OS paths from Windows (or user provided paths potentially from Windows).

19 > * Using it on a Linux or MaxOS path might change it.

20 > */

21 > export function toSlashes(osPath: string) {

22 return osPath.replace(/[\\/]/g, posix.sep);

23 }

24 > extpath.ts

25 > /**

26 > * Takes a Windows OS path (using backward or forward slashes) and turns it into a posix path:

27 > * - turns backward slashes into forward slashes

28 > * - makes it absolute if it starts with a drive letter

29 > * This should only be done for OS paths from Windows (or user provided paths potentially from Windows).

30 > * Using it on a Linux or MaxOS path might change it.

31 > */

32 > export function toPosixPath(osPath: string) {

33 if (osPath.indexOf('/') === -1) {

34 osPath = toSlashes(osPath);

39 return osPath;

40 }

41 > extpath.ts

42 > /**

43 > * Computes the _root_ this path, like `getRoot('c:\files') === c:\`,

44 > * `getRoot('files:///files/path') === files:///`,

45 > * or `getRoot('\\server\shares\path') === \\server\shares\`

46 > */

47 > export function getRoot(path: string, sep: string = posix.sep): string {

48 if (!path) {

49 return '';

111 return '';

112 }

113 > extpath.ts

114 > /**

115 > * Check if the path follows this pattern: `\\hostname\sharename`.

116 > *

117 > * @see https://msdn.microsoft.com/en-us/library/gg465305.aspx

118 > * @return A boolean indication if the path is a UNC path, on none-windows

119 > * always false.

120 > */

121 > export function isUNC(path: string): boolean {

122 if (!isWindows) {

123 // UNC is a windows concept

162 return true;

163 }

164 > extpath.ts

165 > // Reference: https://en.wikipedia.org/wiki/Filename

166 > const WINDOWS_INVALID_FILE_CHARS = /[\\/:\*\?"<>\|]/g;

167 > const UNIX_INVALID_FILE_CHARS = /[/]/g;

168 > const WINDOWS_FORBIDDEN_NAMES = /^(con|prn|aux|clock\$|nul|lpt[0-9]|com[0-9])(\.(.*?))?$/i;

169 > export function isValidBasename(name: string | null | undefined, isWindowsOS: boolean = isWindows): boolean {

170 const invalidFileChars = isWindowsOS ? WINDOWS_INVALID_FILE_CHARS : UNIX_INVALID_FILE_CHARS;

171

201 return true;

202 }

203 > extpath.ts

204 > /**

205 > * @deprecated please use `IUriIdentityService.extUri.isEqual` instead. If you are

206 > * in a context without services, consider to pass down the `extUri` from the outside

207 > * or use `extUriBiasedIgnorePathCase` if you know what you are doing.

208 > */

209 > export function isEqual(pathA: string, pathB: string, ignoreCase?: boolean): boolean {

210 const identityEquals = (pathA === pathB);

211 if (!ignoreCase || identityEquals) {

219 return equalsIgnoreCase(pathA, pathB);

220 }

221 > extpath.ts

222 > /**

223 > * @deprecated please use `IUriIdentityService.extUri.isEqualOrParent` instead. If

224 > * you are in a context without services, consider to pass down the `extUri` from the

225 > * outside, or use `extUriBiasedIgnorePathCase` if you know what you are doing.

226 > */

227 > export function isEqualOrParent(base: string, parentCandidate: string, ignoreCase?: boolean, forcePosixSemantics = false): boolean {

228 const separator = forcePosixSemantics ? posix.sep : sep;

229

272 return base.indexOf(parentCandidate) === 0;

273 }

274 > extpath.ts

275 > export function isWindowsDriveLetter(char0: number): boolean {

276 return char0 >= CharCode.A && char0 <= CharCode.Z || char0 >= CharCode.a && char0 <= CharCode.z;

277 }

278 > extpath.ts

279 > export function sanitizeFilePath(candidate: string, cwd: string): string {

280

281 // Special case: allow to open a drive letter without trailing backslash

295 return removeTrailingPathSeparator(candidate);

296 }

297 > extpath.ts

298 > export function removeTrailingPathSeparator(candidate: string): string {

299 if (isWindows) {

300 candidate = rtrim(candidate, sep);

316 return candidate;

317 }

318 > extpath.ts

319 > export function isRootOrDriveLetter(path: string): boolean {

320 const pathNormalized = normalize(path);

321

331 return pathNormalized === posix.sep;

332 }

333 > extpath.ts

334 > export function hasDriveLetter(path: string, isWindowsOS: boolean = isWindows): boolean {

335 if (isWindowsOS) {

336 return isWindowsDriveLetter(path.charCodeAt(0)) && path.charCodeAt(1) === CharCode.Colon;

339 return false;

340 }

341 > extpath.ts

342 > export function getDriveLetter(path: string, isWindowsOS: boolean = isWindows): string | undefined {

343 return hasDriveLetter(path, isWindowsOS) ? path[0] : undefined;

344 }

345 > extpath.ts

346 > export function indexOfPath(path: string, candidate: string, ignoreCase?: boolean): number {

347 if (candidate.length > path.length) {

348 return -1;

360 return path.indexOf(candidate);

361 }

362 > extpath.ts

363 > export interface IPathWithLineAndColumn {

364 > path: string;

365 > line?: number;

366 > column?: number;

367 > }

368 >

369 > export function parseLineAndColumnAware(rawPath: string): IPathWithLineAndColumn {

370 const segments = rawPath.split(':'); // C:\file.txt:<line>:<column>

371

395 };

396 }

397 > extpath.ts

398 > const pathChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

399 > const windowsSafePathFirstChars = 'BDEFGHIJKMOQRSTUVWXYZbdefghijkmoqrstuvwxyz0123456789';

400 >

401 > export function randomPath(parent?: string, prefix?: string, randomLength = 8): string {

402 let suffix = '';

403 for (let i = 0; i < randomLength; i++) {

src/vs/base/common/observableInternal/reactions/autorun.ts 91 covered LOC · 10 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- autorun.ts

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 { IReaderWithStore, IReader, IObservable, ISettableObservable } from '../base.js';

7 > import { IChangeTracker } from '../changeTracker.js';

8 > import { DisposableStore, IDisposable, toDisposable } from '../commonFacade/deps.js';

9 > import { DebugNameData, IDebugNameData } from '../debugName.js';

10 > import { AutorunObserver } from './autorunImpl.js';

11 > import { DebugLocation } from '../debugLocation.js';

12 > import { observableValue } from '../observables/observableValue.js';

13 > import { transaction } from '../transaction.js';

14 >

15 > /**

16 > * Runs immediately and whenever a transaction ends and an observed observable changed.

17 > * {@link fn} should start with a JS Doc using `@description` to name the autorun.

18 > */

19 > export function autorun(fn: (reader: IReaderWithStore) => void, debugLocation = DebugLocation.ofCaller()): IDisposable {

20 return new AutorunObserver(

21 new DebugNameData(undefined, undefined, fn),

25 );

26 }

27 > autorun.ts

28 > /**

29 > * Runs immediately and whenever a transaction ends and an observed observable changed.

30 > * {@link fn} should start with a JS Doc using `@description` to name the autorun.

31 > */

32 > export function autorunOpts(options: IDebugNameData & {}, fn: (reader: IReaderWithStore) => void, debugLocation = DebugLocation.ofCaller()): IDisposable {

33 return new AutorunObserver(

34 new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn),

38 );

39 }

40 > autorun.ts

41 > /**

42 > * Runs immediately and whenever a transaction ends and an observed observable changed.

43 > * {@link fn} should start with a JS Doc using `@description` to name the autorun.

44 > *

45 > * Use `changeTracker.createChangeSummary` to create a "change summary" that can collect the changes.

46 > * Use `changeTracker.handleChange` to add a reported change to the change summary.

47 > * The run function is given the last change summary.

48 > * The change summary is discarded after the run function was called.

49 > *

50 > * @see autorun

51 > */

52 > export function autorunHandleChanges<TChangeSummary>(

53 options: IDebugNameData & {

54 changeTracker: IChangeTracker<TChangeSummary>;

64 );

65 }

66 > autorun.ts

67 > /**

68 > * @see autorunHandleChanges (but with a disposable store that is cleared before the next run or on dispose)

69 > */

70 > export function autorunWithStoreHandleChanges<TChangeSummary>(

71 options: IDebugNameData & {

72 changeTracker: IChangeTracker<TChangeSummary>;

92 });

93 }

94 > autorun.ts

95 > /**

96 > * @see autorun (but with a disposable store that is cleared before the next run or on dispose)

97 > *

98 > * @deprecated Use `autorun(reader => { reader.store.add(...) })` instead!

99 > */

100 > export function autorunWithStore(fn: (reader: IReader, store: DisposableStore) => void): IDisposable {

101 const store = new DisposableStore();

102 const disposable = autorunOpts(

116 });

117 }

118 > autorun.ts

119 > export function autorunDelta<T>(

120 observable: IObservable<T>,

121 handler: (args: { lastValue: T | undefined; newValue: T }) => void

129 });

130 }

131 > autorun.ts

132 > export function autorunIterableDelta<T>(

133 getValue: (reader: IReader) => Iterable<T>,

134 handler: (args: { addedValues: T[]; removedValues: T[] }) => void,

157 });

158 }

159 > autorun.ts

160 > /**

161 > * For each key-stable item in {@link items}, runs {@link setup} once when the

162 > * key is first observed and disposes the per-key {@link DisposableStore} when

163 > * the key is no longer present in the array (or when the returned disposable

164 > * is disposed).

165 > *

166 > * The {@link IObservable} handed to {@link setup} fires whenever the array

167 > * still contains an item with the same key but the item value itself has

168 > * changed (e.g. because the upstream state is immutable and produced a new

169 > * object with the same id). All per-key value updates triggered by a single

170 > * change to {@link items} are batched into one transaction, so dependent

171 > * autoruns observe a consistent snapshot.

172 > *

173 > * Per-key state should be stored in closures or in disposables registered

174 > * against the per-key {@link DisposableStore}. {@link setup} should not call

175 > * `.read()` on the outer {@link items} observable from its body (use the

176 > * provided per-key value observable, or create inner autoruns).

177 > */

178 > export function autorunPerKeyedItem<TIn, TKey>(

179 items: IObservable<readonly TIn[]>,

180 keyFn: (input: TIn) => TKey,

227 });

228 }

229 > autorun.ts

230 > export interface IReaderWithDispose extends IReaderWithStore, IDisposable { }

231 >

232 > /**

233 > * An autorun with a `dispose()` method on its `reader` which cancels the autorun.

234 > * It it safe to call `dispose()` synchronously.

235 > * @deprecated Use autorunSelfDisposable2

236 > */

237 > export function autorunSelfDisposable(fn: (reader: IReaderWithDispose) => void, debugLocation = DebugLocation.ofCaller()): IDisposable {

238 let ar: IDisposable | undefined;

239 let disposed = false;

258 return ar;

259 }

260 > autorun.ts

261 >

262 > /**

263 > * An autorun with a `dispose()` method on its `reader` which cancels the autorun.

264 > * It it safe to call `dispose()` synchronously.

265 > * TODO@hediet/copilot: rename to delete autorunSelfDisposable, and rename autorunSelfDisposable2 to autorunSelfDisposable.

266 > */

267 > export function registerAutorunSelfDisposable(store: DisposableStore, fn: (reader: IReaderWithDispose) => void, debugLocation = DebugLocation.ofCaller()): void {

268 let ar: IDisposable | undefined;

269 let disposeSync = false;

src/vs/base/common/cancellation.ts 90 covered LOC · 18 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- cancellation.ts

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 { Emitter, Event } from './event.js';

7 > import { DisposableStore, IDisposable } from './lifecycle.js';

8 >

9 > export interface CancellationToken {

10 >

11 > /**

12 > * A flag signalling is cancellation has been requested.

13 > */

14 > readonly isCancellationRequested: boolean;

15 >

16 > /**

17 > * An event which fires when cancellation is requested. This event

18 > * only ever fires `once` as cancellation can only happen once. Listeners

19 > * that are registered after cancellation will be called (next event loop run),

20 > * but also only once.

21 > *

22 > * @event

23 > */

24 > readonly onCancellationRequested: (listener: (e: void) => unknown, thisArgs?: unknown, disposables?: IDisposable[]) => IDisposable;

25 > }

26 >

27 > const shortcutEvent: Event<void> = Object.freeze(function (callback, context?): IDisposable {

28 const handle = setTimeout(callback.bind(context), 0);

29 return { dispose() { clearTimeout(handle); } };

30 });

31 > cancellation.ts

32 > export namespace CancellationToken {

33 >

34 > export function isCancellationToken(thing: unknown): thing is CancellationToken {

35 if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {

36 return true;

45 && typeof (thing as CancellationToken).onCancellationRequested === 'function';

46 }

47 > cancellation.ts

48 >

49 > export const None = Object.freeze<CancellationToken>({

50 > isCancellationRequested: false,

51 > onCancellationRequested: Event.None

52 > });

53 >

54 > export const Cancelled = Object.freeze<CancellationToken>({

55 > isCancellationRequested: true,

56 > onCancellationRequested: shortcutEvent

57 > });

58 > }

59 >

60 class MutableToken implements CancellationToken {

61

62 private _isCancelled: boolean = false;

63 private _emitter: Emitter<void> | null = null;

64 > cancellation.ts

65 > public cancel() {

66 if (!this._isCancelled) {

67 this._isCancelled = true;

72 }

73 }

74 > cancellation.ts

75 > get isCancellationRequested(): boolean {

76 return this._isCancelled;

77 }

78 > cancellation.ts

79 > get onCancellationRequested(): Event<void> {

80 if (this._isCancelled) {

81 return shortcutEvent;

86 return this._emitter.event;

87 }

88 > cancellation.ts

89 > public dispose(): void {

90 if (this._emitter) {

91 this._emitter.dispose();

93 }

94 }

95 > } cancellation.ts

96 >

97 > export class CancellationTokenSource {

98 >

99 > private _token?: CancellationToken = undefined;

100 > private _parentListener?: IDisposable = undefined;

101 >

102 > constructor(parent?: CancellationToken) {

103 this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);

104 }

105 > cancellation.ts

106 > get token(): CancellationToken {

107 if (!this._token) {

108 // be lazy and create the token only when

112 return this._token;

113 }

114 > cancellation.ts

115 > cancel(): void {

116 if (!this._token) {

117 // save an object by returning the default

125 }

126 }

127 > cancellation.ts

128 > dispose(cancel: boolean = false): void {

129 if (cancel) {

130 this.cancel();

140 }

141 }

142 > } cancellation.ts

143 >

144 > export function cancelOnDispose(store: DisposableStore): CancellationToken {

145 const source = new CancellationTokenSource();

146 store.add({ dispose() { source.cancel(); } });

147 return source.token;

148 }

149 > cancellation.ts

150 > /**

151 > * A pool that aggregates multiple cancellation tokens. The pool's own token

152 > * (accessible via `pool.token`) is cancelled only after every token added

153 > * to the pool has been cancelled. Adding tokens after the pool token has

154 > * been cancelled has no effect.

155 > */

156 > export class CancellationTokenPool {

157

158 private readonly _source = new CancellationTokenSource();

162 private _cancelled: number = 0;

163 private _isDone: boolean = false;

164 > cancellation.ts

165 > get token(): CancellationToken {

166 return this._source.token;

167 }

168 > cancellation.ts

169 > /**

170 > * Add a token to the pool. If the token is already cancelled it is counted

171 > * immediately. Tokens added after the pool token has been cancelled are ignored.

172 > */

173 > add(token: CancellationToken): void {

174 if (this._isDone) {

175 return;

191 this._listeners.add(d);

192 }

193 > cancellation.ts

194 > private _check(): void {

195 if (!this._isDone && this._total > 0 && this._total === this._cancelled) {

196 this._isDone = true;

199 }

200 }

201 > cancellation.ts

202 > dispose(): void {

203 this._listeners.dispose();

204 this._source.dispose();

205 }

206 > } cancellation.ts

src/vs/base/common/observableInternal/utils/utils.ts 89 covered LOC · 21 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- utils.ts

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 { autorun } from '../reactions/autorun.js';

7 > import { IObservable, IObservableWithChange, IObserver, IReader, ITransaction } from '../base.js';

8 > import { observableValue } from '../observables/observableValue.js';

9 > import { DebugOwner } from '../debugName.js';

10 > import { DisposableStore, Event, IDisposable, toDisposable } from '../commonFacade/deps.js';

11 > import { derived, derivedOpts } from '../observables/derived.js';

12 > import { observableFromEvent } from '../observables/observableFromEvent.js';

13 > import { observableSignal } from '../observables/observableSignal.js';

14 > import { _setKeepObserved, _setRecomputeInitiallyAndOnChange } from '../observables/baseObservable.js';

15 > import { DebugLocation } from '../debugLocation.js';

16 >

17 > export function observableFromPromise<T>(promise: Promise<T>): IObservable<{ value?: T }> {

18 const observable = observableValue<{ value?: T }>('promiseValue', {});

19 promise.then((value) => {

22 return observable;

23 }

24 > utils.ts

25 > export function signalFromObservable<T>(owner: DebugOwner | undefined, observable: IObservable<T>): IObservable<void> {

26 return derivedOpts({

27 owner,

31 });

32 }

33 > utils.ts

34 > /**

35 > * Creates an observable that debounces the input observable.

36 > */

37 > export function debouncedObservable<T>(observable: IObservable<T>, debounceMs: number | ((lastValue: T | undefined, newValue: T) => number), debugLocation = DebugLocation.ofCaller()): IObservable<T> {

38 let hasValue = false;

39 let lastValue: T | undefined;

79 }, debugLocation);

80 }

81 > utils.ts

82 > /**

83 > * Creates an observable that throttles the input observable.

84 > * Unlike {@link debouncedObservable}, the timer starts on the first change

85 > * and is not reset by subsequent changes, preventing starvation.

86 > */

87 > export function throttledObservable<T>(observable: IObservable<T>, throttleMs: number, debugLocation = DebugLocation.ofCaller()): IObservable<T> {

88 let hasValue = false;

89 let lastValue: T | undefined;

126 }, debugLocation);

127 }

128 > utils.ts

129 > /**

130 > * Creates an observable that debounces the input observable.

131 > */

132 > export function debouncedObservable2<T>(observable: IObservable<T>, debounceMs: number | ((currentValue: T | undefined, newValue: T) => number), debugLocation = DebugLocation.ofCaller()): IObservable<T> {

133 const s = observableSignal('handleTimeout');

134

167 return d;

168 }

169 > utils.ts

170 > export function wasEventTriggeredRecently(event: Event<any>, timeoutMs: number, disposableStore: DisposableStore): IObservable<boolean> {

171 const observable = observableValue('triggeredRecently', false);

172

186 return observable;

187 }

188 > utils.ts

189 > /**

190 > * This makes sure the observable is being observed and keeps its cache alive.

191 > */

192 > export function keepObserved<T>(observable: IObservable<T>): IDisposable {

193 const o = new KeepAliveObserver(false, undefined);

194 observable.addObserver(o);

197 });

198 }

199 > utils.ts

200 > _setKeepObserved(keepObserved);

201 >

202 > /**

203 > * This converts the given observable into an autorun.

204 > */

205 > export function recomputeInitiallyAndOnChange<T>(observable: IObservable<T>, handleValue?: (value: T) => void): IDisposable {

206 const o = new KeepAliveObserver(true, handleValue);

207 observable.addObserver(o);

216 });

217 }

218 > utils.ts

219 > _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange);

220 >

221 > export class KeepAliveObserver implements IObserver {

222 > private _counter = 0;

223 >

224 > constructor(

225 private readonly _forceRecompute: boolean,

226 private readonly _handleValue: ((value: any) => void) | undefined,

227 ) { }

228 > utils.ts

229 > beginUpdate<T>(observable: IObservable<T>): void {

230 this._counter++;

231 }

232 > utils.ts

233 > endUpdate<T>(observable: IObservable<T>): void {

234 if (this._counter === 1 && this._forceRecompute) {

235 if (this._handleValue) {

241 this._counter--;

242 }

243 > utils.ts

244 > handlePossibleChange<T>(observable: IObservable<T>): void {

245 // NO OP

246 }

247 > utils.ts

248 > handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void {

249 // NO OP

250 }

251 > } utils.ts

252 >

253 > export function derivedObservableWithCache<T>(owner: DebugOwner, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T> {

254 let lastValue: T | undefined = undefined;

255 const observable = derivedOpts({ owner, debugReferenceFn: computeFn }, reader => {

259 return observable;

260 }

261 > utils.ts

262 > export function derivedObservableWithWritableCache<T>(owner: object, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T>

263 & { clearCache(transaction: ITransaction): void; setCache(newValue: T | undefined, tx: ITransaction | undefined): void } {

264 let lastValue: T | undefined = undefined;

280 });

281 }

282 > utils.ts

283 > /**

284 > * When the items array changes, referential equal items are not mapped again.

285 > */

286 > export function mapObservableArrayCached<TIn, TOut, TKey = TIn>(owner: DebugOwner, items: IObservable<readonly TIn[]>, map: (input: TIn, store: DisposableStore) => TOut, keySelector?: (input: TIn) => TKey): IObservable<readonly TOut[]> {

287 let m = new ArrayMap(map, keySelector);

288 const self = derivedOpts({

300 return self;

301 }

302 > utils.ts

303 > class ArrayMap<TIn, TOut, TKey> implements IDisposable {

304 > private readonly _cache = new Map<TKey, { out: TOut; store: DisposableStore }>();

305 > private _items: TOut[] = [];

306 > constructor(

307 private readonly _map: (input: TIn, store: DisposableStore) => TOut,

308 private readonly _keySelector?: (input: TIn) => TKey,

309 ) {

310 }

311 > utils.ts

312 > public dispose(): void {

313 this._cache.forEach(entry => entry.store.dispose());

314 this._cache.clear();

315 }

316 > utils.ts

317 > public setItems(items: readonly TIn[]): void {

318 const newItems: TOut[] = [];

319 const itemsToRemove = new Set(this._cache.keys());

342 this._items = newItems;

343 }

344 > utils.ts

345 > public getItems(): TOut[] {

346 return this._items;

347 }

348 > } utils.ts

349 >

350 > export function isObservable<T>(obj: unknown): obj is IObservable<T> {

351 return !!obj && (<IObservable<T>>obj).read !== undefined && (<IObservable<T>>obj).reportChanges !== undefined;

352 }

src/vs/base/common/cache.ts 88 covered LOC · 9 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- cache.ts

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 { CancellationToken, CancellationTokenSource } from './cancellation.js';

7 > import { IDisposable } from './lifecycle.js';

8 >

9 > export interface CacheResult<T> extends IDisposable {

10 > promise: Promise<T>;

11 > }

12 >

13 > export class Cache<T> {

14 >

15 > private result: CacheResult<T> | null = null;

16 > constructor(private task: (ct: CancellationToken) => Promise<T>) { }

17 >

18 > get(): CacheResult<T> {

19 if (this.result) {

20 return this.result;

35 return this.result;

36 }

37 > } cache.ts

38 >

39 > export function identity<T>(t: T): T {

40 return t;

41 }

42 > cache.ts

43 > interface ICacheOptions<TArg> {

44 > /**

45 > * The cache key is used to identify the cache entry.

46 > * Strict equality is used to compare cache keys.

47 > */

48 > getCacheKey: (arg: TArg) => unknown;

49 > }

50 >

51 > /**

52 > * Uses a LRU cache to make a given parametrized function cached.

53 > * Caches just the last key/value.

54 > */

55 > export class LRUCachedFunction<TArg, TComputed> {

56 > private lastCache: TComputed | undefined = undefined;

57 > private lastArgKey: unknown | undefined = undefined;

58 >

59 > private readonly _fn: (arg: TArg) => TComputed;

60 > private readonly _computeKey: (arg: TArg) => unknown;

61 >

62 > constructor(fn: (arg: TArg) => TComputed);

63 > constructor(options: ICacheOptions<TArg>, fn: (arg: TArg) => TComputed);

64 > constructor(arg1: ICacheOptions<TArg> | ((arg: TArg) => TComputed), arg2?: (arg: TArg) => TComputed) {

65 > if (typeof arg1 === 'function') {

66 > this._fn = arg1;

67 > this._computeKey = identity;

68 > } else {

69 this._fn = arg2!;

70 this._computeKey = arg1.getCacheKey;

71 }

72 > } cache.ts

73 >

74 > public get(arg: TArg): TComputed {

75 const key = this._computeKey(arg);

76 if (this.lastArgKey !== key) {

80 return this.lastCache!;

81 }

82 > } cache.ts

83 >

84 > /**

85 > * Uses an unbounded cache to memoize the results of the given function.

86 > */

87 > export class CachedFunction<TArg, TComputed> {

88 > private readonly _map = new Map<TArg, TComputed>();

89 > private readonly _map2 = new Map<unknown, TComputed>();

90 > public get cachedValues(): ReadonlyMap<TArg, TComputed> {

91 > return this._map;

92 > }

93 >

94 > private readonly _fn: (arg: TArg) => TComputed;

95 > private readonly _computeKey: (arg: TArg) => unknown;

96 >

97 > constructor(fn: (arg: TArg) => TComputed);

98 > constructor(options: ICacheOptions<TArg>, fn: (arg: TArg) => TComputed);

99 > constructor(arg1: ICacheOptions<TArg> | ((arg: TArg) => TComputed), arg2?: (arg: TArg) => TComputed) {

100 if (typeof arg1 === 'function') {

101 this._fn = arg1;

106 }

107 }

108 > cache.ts

109 > public get(arg: TArg): TComputed {

110 const key = this._computeKey(arg);

111 if (this._map2.has(key)) {

118 return value;

119 }

120 > } cache.ts

121 >

122 > /**

123 > * Uses an unbounded cache to memoize the results of the given function.

124 > */

125 > export class WeakCachedFunction<TArg, TComputed> {

126 > private readonly _map = new WeakMap<WeakKey, TComputed>();

127 >

128 > private readonly _fn: (arg: TArg) => TComputed;

129 > private readonly _computeKey: (arg: TArg) => unknown;

130 >

131 > constructor(fn: (arg: TArg) => TComputed);

132 > constructor(options: ICacheOptions<TArg>, fn: (arg: TArg) => TComputed);

133 > constructor(arg1: ICacheOptions<TArg> | ((arg: TArg) => TComputed), arg2?: (arg: TArg) => TComputed) {

134 if (typeof arg1 === 'function') {

135 this._fn = arg1;

140 }

141 }

142 > cache.ts

143 > public get(arg: TArg): TComputed {

144 const key = this._computeKey(arg) as WeakKey;

145 if (this._map.has(key)) {

151 return value;

152 }

153 > } cache.ts

src/vs/platform/defaultAccount/common/defaultAccount.ts 88 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- defaultAccount.ts

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 { ICopilotTokenInfo, IDefaultAccount, IDefaultAccountAuthenticationProvider, IPolicyData } from '../../../base/common/defaultAccount.js';

7 > import { Event } from '../../../base/common/event.js';

8 > import { createDecorator } from '../../instantiation/common/instantiation.js';

9 >

10 > /**

11 > * Well-known GitHub URL paths used with {@link IDefaultAccountService.resolveGitHubUrl}.

12 > */

13 > export const GitHubPaths = {

14 > copilotSettings: 'settings/copilot/features',

15 > billingBudgets: 'settings/copilot/features?utm_source=vscode',

16 > copilotUpgrade: 'github-copilot/upgrade?utm_source=vscode',

17 > } as const;

18 >

19 > /**

20 > * Outcome of the last `/copilot_internal/managed_settings` fetch.

21 > * - A numeric HTTP status code indicates the server responded with that code.

22 > * - `'ok'`: response parsed and adapted successfully (including an empty `{}` body).

23 > * - `'no-url'`: no `managedSettingsUrl` configured in product.json.

24 > * - `'no-response'`: network error, all sessions rejected, or active rate-limit backoff.

25 > * - `'parse-error'`: response received but JSON parsing failed.

26 > * - `null`: never fetched.

27 > */

28 > export type ManagedSettingsFetchStatus = number | 'ok' | 'no-url' | 'no-response' | 'parse-error' | null;

29 >

30 > export interface IDefaultAccountProvider {

31 > readonly defaultAccount: IDefaultAccount | null;

32 > readonly onDidChangeDefaultAccount: Event<IDefaultAccount | null>;

33 > readonly policyData: IPolicyData | null;

34 > readonly onDidChangePolicyData: Event<IPolicyData | null>;

35 > readonly copilotTokenInfo: ICopilotTokenInfo | null;

36 > readonly onDidChangeCopilotTokenInfo: Event<ICopilotTokenInfo | null>;

37 > readonly managedSettingsFetchStatus: ManagedSettingsFetchStatus;

38 > /** Timestamp (ms) of the last managed-settings fetch, or `null` if never fetched. */

39 > readonly managedSettingsFetchedAt: number | null;

40 > /** The raw JSON response from the managed-settings endpoint, for diagnostics. */

41 > readonly managedSettingsRawResponse: unknown;

42 > getDefaultAccountAuthenticationProvider(): IDefaultAccountAuthenticationProvider;

43 >

44 > /**

45 > * Resolves a GitHub URL path to a full URL, using the GitHub Enterprise

46 > * base URL when the user is authenticated via a GHE provider, or

47 > * `https://github.com` otherwise.

48 > *

49 > * @param path The path portion of the URL (e.g. `settings/copilot/features`).

50 > */

51 > resolveGitHubUrl(path: string): string;

52 >

53 > refresh(options?: { forceRefresh?: boolean }): Promise<IDefaultAccount | null>;

54 > signIn(options?: { additionalScopes?: readonly string[];[key: string]: unknown }): Promise<IDefaultAccount | null>;

55 > signOut(): Promise<void>;

56 > }

57 >

58 > export const IDefaultAccountService = createDecorator<IDefaultAccountService>('defaultAccountService');

59 >

60 > export interface IDefaultAccountService {

61 > readonly _serviceBrand: undefined;

62 > readonly onDidChangeDefaultAccount: Event<IDefaultAccount | null>;

63 > readonly onDidChangePolicyData: Event<IPolicyData | null>;

64 > readonly policyData: IPolicyData | null;

65 > readonly currentDefaultAccount: IDefaultAccount | null;

66 > readonly copilotTokenInfo: ICopilotTokenInfo | null;

67 > readonly onDidChangeCopilotTokenInfo: Event<ICopilotTokenInfo | null>;

68 > readonly managedSettingsFetchStatus: ManagedSettingsFetchStatus;

69 > /** Timestamp (ms) of the last managed-settings fetch, or `null` if never fetched. */

70 > readonly managedSettingsFetchedAt: number | null;

71 > /** The raw JSON response from the managed-settings endpoint, for diagnostics. */

72 > readonly managedSettingsRawResponse: unknown;

73 > getDefaultAccount(): Promise<IDefaultAccount | null>;

74 > getDefaultAccountAuthenticationProvider(): IDefaultAccountAuthenticationProvider;

75 > setDefaultAccountProvider(provider: IDefaultAccountProvider): void;

76 > refresh(options?: { forceRefresh?: boolean }): Promise<IDefaultAccount | null>;

77 > signIn(options?: { additionalScopes?: readonly string[];[key: string]: unknown }): Promise<IDefaultAccount | null>;

78 > signOut(): Promise<void>;

79 >

80 > /**

81 > * Resolves a GitHub URL path to a full URL, using the GitHub Enterprise

82 > * base URL when the user is authenticated via a GHE provider, or

83 > * `https://github.com` otherwise.

84 > *

85 > * @param path The path portion of the URL (e.g. `settings/copilot/features`).

86 > */

87 > resolveGitHubUrl(path: string): string;

88 > }

src/vs/base/common/performance.ts 84 covered LOC · 6 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- performance.ts

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 type { INodeProcess } from './platform.js';

7 >

8 > function _definePolyfillMarks(timeOrigin?: number) {

9 > const _data: [string?, number?] = [];

10 > if (typeof timeOrigin === 'number') {

11 > _data.push('code/timeOrigin', timeOrigin);

12 > }

13 >

14 > function mark(name: string, markOptions?: { startTime?: number }) {

15 _data.push(name, markOptions?.startTime ?? Date.now());

16 }

17 > function getMarks() { performance.ts

18 const result = [];

19 for (let i = 0; i < _data.length; i += 2) {

25 return result;

26 }

27 > function clearMarks(name?: string) { performance.ts

28 if (typeof name === 'undefined') {

29 const hasTimeOrigin = _data.length >= 2 && _data[0] === 'code/timeOrigin';

41 }

42 }

43 > return { mark, getMarks, clearMarks }; performance.ts

44 > }

45 >

46 > declare const process: INodeProcess;

47 >

48 > interface IPerformanceEntry {

49 > readonly name: string;

50 > readonly startTime: number;

51 > }

52 >

53 > interface IPerformanceTiming {

54 > readonly navigationStart?: number;

55 > readonly redirectStart?: number;

56 > readonly fetchStart?: number;

57 > }

58 >

59 > interface IPerformance {

60 > mark(name: string, markOptions?: { startTime?: number }): void;

61 > clearMarks(name?: string): void;

62 > getEntriesByType(type: string): IPerformanceEntry[];

63 > readonly timeOrigin: number;

64 > readonly timing: IPerformanceTiming;

65 > readonly nodeTiming?: any;

66 > }

67 >

68 > declare const performance: IPerformance;

69 >

70 > function _define() {

71 >

72 > // Identify browser environment when following property is not present

73 > // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#performancenodetiming

74 > // @ts-ignore

75 > if (typeof performance === 'object' && typeof performance.mark === 'function' && !performance.nodeTiming) {

76 // in a browser context, reuse performance-util

77

109 }

110

111 > } else if (typeof process === 'object') { performance.ts

112 > // node.js: use the normal polyfill but add the timeOrigin

113 > // from the node perf_hooks API as very first mark

114 > const timeOrigin = performance?.timeOrigin;

115 > return _definePolyfillMarks(timeOrigin);

116 >

117 > } else {

118 // unknown environment

119 console.trace('perf-util loaded in UNKNOWN environment');

120 return _definePolyfillMarks();

121 }

122 > } performance.ts

123 >

124 > function _factory(sharedObj: any) {

125 > if (!sharedObj.MonacoPerformanceMarks) {

126 > sharedObj.MonacoPerformanceMarks = _define();

127 > }

128 > return sharedObj.MonacoPerformanceMarks;

129 > }

130 >

131 > const perf = _factory(globalThis);

132 >

133 > export const mark: (name: string, markOptions?: { startTime?: number }) => void = perf.mark;

134 >

135 > /**

136 > * Clears performance marks. If a name is given, only marks with that exact

137 > * name are removed. If no name is given, all marks are removed.

138 > */

139 > export const clearMarks: (name?: string) => void = perf.clearMarks;

140 >

141 > export interface PerformanceMark {

142 > readonly name: string;

143 > readonly startTime: number;

144 > }

145 >

146 > /**

147 > * Returns all marks, sorted by `startTime`.

148 > */

149 > export const getMarks: () => PerformanceMark[] = perf.getMarks;

src/vs/base/common/observableInternal/reactions/autorunImpl.ts 78 covered LOC · 18 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- autorunImpl.ts

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 { IObservable, IObservableWithChange, IObserver, IReaderWithStore } from '../base.js';

7 > import { DebugNameData } from '../debugName.js';

8 > import { assertFn, BugIndicatingError, DisposableStore, IDisposable, markAsDisposed, onBugIndicatingError, trackDisposable } from '../commonFacade/deps.js';

9 > import { getLogger } from '../logging/logging.js';

10 > import { IChangeTracker } from '../changeTracker.js';

11 > import { DebugLocation } from '../debugLocation.js';

12 >

13 > export const enum AutorunState {

14 > /**

15 > * A dependency could have changed.

16 > * We need to explicitly ask them if at least one dependency changed.

17 > */

18 > dependenciesMightHaveChanged = 1,

19 >

20 > /**

21 > * A dependency changed and we need to recompute.

22 > */

23 > stale = 2,

24 > upToDate = 3,

25 > }

26 >

27 function autorunStateToString(state: AutorunState): string {

28 switch (state) {

33 }

34 }

35 > autorunImpl.ts

36 > export class AutorunObserver<TChangeSummary = any> implements IObserver, IReaderWithStore, IDisposable {

37 > private _state = AutorunState.stale;

38 > private _updateCount = 0;

39 > private _disposed = false;

40 > private _dependencies = new Set<IObservable<any>>();

41 > private _dependenciesToBeRemoved = new Set<IObservable<any>>();

42 > private _changeSummary: TChangeSummary | undefined;

43 > private _isRunning = false;

44 > private _iteration = 0;

45 >

46 > public get debugName(): string {

47 > return this._debugNameData.getDebugName(this) ?? '(anonymous)';

48 > }

49 >

50 > constructor(

51 public readonly _debugNameData: DebugNameData,

52 public readonly _runFn: (reader: IReaderWithStore, changeSummary: TChangeSummary) => void,

60 trackDisposable(this);

61 }

62 > autorunImpl.ts

63 > public dispose(): void {

64 if (this._disposed) {

65 return;

81 markAsDisposed(this);

82 }

83 > autorunImpl.ts

84 > private _run() {

85 const emptySet = this._dependenciesToBeRemoved;

86 this._dependenciesToBeRemoved = this._dependencies;

130 }

131 }

132 > autorunImpl.ts

133 > public toString(): string {

134 return `Autorun<${this.debugName}>`;

135 }

136 > autorunImpl.ts

137 > // IObserver implementation

138 > public beginUpdate(_observable: IObservable<any>): void {

139 if (this._state === AutorunState.upToDate) {

140 this._checkIterations();

143 this._updateCount++;

144 }

145 > autorunImpl.ts

146 > public endUpdate(_observable: IObservable<any>): void {

147 try {

148 if (this._updateCount === 1) {

175 assertFn(() => this._updateCount >= 0);

176 }

177 > autorunImpl.ts

178 > public handlePossibleChange(observable: IObservable<any>): void {

179 if (this._state === AutorunState.upToDate && this._isDependency(observable)) {

180 this._checkIterations();

182 }

183 }

184 > autorunImpl.ts

185 > public handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void {

186 if (this._isDependency(observable)) {

187 getLogger()?.handleAutorunDependencyChanged(this, observable, change);

203 }

204 }

205 > autorunImpl.ts

206 > private _isDependency(observable: IObservableWithChange<any, any>): boolean {

207 return this._dependencies.has(observable) && !this._dependenciesToBeRemoved.has(observable);

208 }

209 > autorunImpl.ts

210 > // IReader implementation

211 >

212 > private _ensureNoRunning(): void {

213 if (!this._isRunning) { throw new BugIndicatingError('The reader object cannot be used outside its compute function!'); }

214 }

215 > autorunImpl.ts

216 > public readObservable<T>(observable: IObservable<T>): T {

217 this._ensureNoRunning();

218

228 return value;

229 }

230 > autorunImpl.ts

231 > private _store: DisposableStore | undefined = undefined;

232 > get store(): DisposableStore {

233 this._ensureNoRunning();

234 if (this._disposed) {

241 return this._store;

242 }

243 > autorunImpl.ts

244 > private _delayedStore: DisposableStore | undefined = undefined;

245 > get delayedStore(): DisposableStore {

246 this._ensureNoRunning();

247 if (this._disposed) {

254 return this._delayedStore;

255 }

256 > autorunImpl.ts

257 > public debugGetState() {

258 return {

259 isRunning: this._isRunning,

264 };

265 }

266 > autorunImpl.ts

267 > public debugRerun(): void {

268 if (!this._isRunning) {

269 this._run();

272 }

273 }

274 > autorunImpl.ts

275 > private _checkIterations(): boolean {

276 if (this._iteration > 100) {

277 onBugIndicatingError(new BugIndicatingError(`Autorun '${this.debugName}' is stuck in an infinite update loop.`));

280 return false;

281 }

282 > } autorunImpl.ts

src/vs/base/common/observableInternal/logging/debugGetDependencyGraph.ts 75 covered LOC · 10 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- debugGetDependencyGraph.ts

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 { IObservable, IObserver } from '../base.js';

7 > import { Derived } from '../observables/derivedImpl.js';

8 > import { FromEventObservable } from '../observables/observableFromEvent.js';

9 > import { ObservableValue } from '../observables/observableValue.js';

10 > import { AutorunObserver } from '../reactions/autorunImpl.js';

11 > import { formatValue } from './consoleObservableLogger.js';

12 >

13 > interface IOptions {

14 > type: 'dependencies' | 'observers';

15 > debugNamePostProcessor?: (name: string) => string;

16 > }

17 >

18 > export function debugGetObservableGraph(obs: IObservable<any> | IObserver, options: IOptions): string {

19 const debugNamePostProcessor = options?.debugNamePostProcessor ?? ((str: string) => str);

20 const info = Info.from(obs, debugNamePostProcessor);

31 }

32 }

33 > debugGetDependencyGraph.ts

34 function formatObservableInfoWithDependencies(info: Info, indentLevel: number, alreadyListed: Set<IObservable<any> | IObserver>, options: IOptions): string {

35 const indent = '\t\t'.repeat(indentLevel);

58 return lines.join('\n');

59 }

60 > debugGetDependencyGraph.ts

61 function formatObservableInfoWithObservers(info: Info, indentLevel: number, alreadyListed: Set<IObservable<any> | IObserver>, options: IOptions): string {

62 const indent = '\t\t'.repeat(indentLevel);

85 return lines.join('\n');

86 }

87 > debugGetDependencyGraph.ts

88 > class Info {

89 > public static from(obs: IObservable<any> | IObserver, debugNamePostProcessor: (name: string) => string): Info | undefined {

90 > if (obs instanceof AutorunObserver) {

91 > const state = obs.debugGetState(); debugGetDependencyGraph.ts

92 > return new Info(

93 > obs,

94 > debugNamePostProcessor(obs.debugName),

95 > 'autorun',

96 > undefined,

97 > state.stateStr,

98 > Array.from(state.dependencies),

99 > []

100 > );

101 > } else if (obs instanceof Derived) { debugGetDependencyGraph.ts

102 > const state = obs.debugGetState();

103 > return new Info(

104 > obs,

105 > debugNamePostProcessor(obs.debugName),

106 > 'derived',

107 > state.value,

108 > state.stateStr,

109 > Array.from(state.dependencies),

110 > Array.from(obs.debugGetObservers())

111 > );

112 > } else if (obs instanceof ObservableValue) {

113 > const state = obs.debugGetState();

114 > return new Info(

115 > obs,

116 > debugNamePostProcessor(obs.debugName),

117 > 'observableValue',

118 > state.value,

119 > 'upToDate',

120 > [],

121 > Array.from(obs.debugGetObservers())

122 > );

123 > } else if (obs instanceof FromEventObservable) {

124 > const state = obs.debugGetState(); debugGetDependencyGraph.ts

125 > return new Info(

126 > obs,

127 > debugNamePostProcessor(obs.debugName),

128 > 'fromEvent',

129 > state.value,

130 > state.hasValue ? 'upToDate' : 'initial',

131 > [],

132 > Array.from(obs.debugGetObservers())

133 > );

134 > }

135 > return undefined;

136 > } debugGetDependencyGraph.ts

137 >

138 > public static unknown(obs: IObservable<any> | IObserver): Info {

139 return new Info(

140 obs,

147 );

148 }

149 > debugGetDependencyGraph.ts

150 > constructor(

151 public readonly sourceObj: IObservable<any> | IObserver,

152 public readonly name: string,

157 public readonly observers: (IObservable<any> | IObserver)[],

158 ) { }

159 > } debugGetDependencyGraph.ts

src/vs/base/common/collections.ts 74 covered LOC · 18 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- collections.ts

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 > /**

7 > * An interface for a JavaScript object that

8 > * acts a dictionary. The keys are strings.

9 > */

10 > export type IStringDictionary<V> = Record<string, V>;

11 >

12 > /**

13 > * An interface for a JavaScript object that

14 > * acts a dictionary. The keys are numbers.

15 > */

16 > export type INumberDictionary<V> = Record<number, V>;

17 >

18 > /**

19 > * Groups the collection into a dictionary based on the provided

20 > * group function.

21 > */

22 > export function groupBy<K extends string | number | symbol, V>(data: readonly V[], groupFn: (element: V) => K): Partial<Record<K, V[]>> {

23 const result: Partial<Record<K, V[]>> = Object.create(null);

24 for (const element of data) {

32 return result;

33 }

34 > collections.ts

35 > export function groupByMap<K, V>(data: V[], groupFn: (element: V) => K): Map<K, V[]> {

36 const result = new Map<K, V[]>();

37 for (const element of data) {

46 return result;

47 }

48 > collections.ts

49 > export function diffSets<T>(before: ReadonlySet<T>, after: ReadonlySet<T>): { removed: T[]; added: T[] } {

50 const removed: T[] = [];

51 const added: T[] = [];

62 return { removed, added };

63 }

64 > collections.ts

65 > /**

66 > * Checks whether two sets contain exactly the same elements.

67 > *

68 > * @param a - The first set.

69 > * @param b - The second set.

70 > * @returns `true` if both sets have the same size and every element of `a` is also in `b`.

71 > */

72 > export function equalSets<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean {

73 if (a === b) {

74 return true;

84 return true;

85 }

86 > collections.ts

87 > export function diffMaps<K, V>(before: Map<K, V>, after: Map<K, V>): { removed: V[]; added: V[] } {

88 const removed: V[] = [];

89 const added: V[] = [];

100 return { removed, added };

101 }

102 > collections.ts

103 > /**

104 > * Computes the intersection of two sets.

105 > *

106 > * @param setA - The first set.

107 > * @param setB - The second iterable.

108 > * @returns A new set containing the elements that are in both `setA` and `setB`.

109 > */

110 > export function intersection<T>(setA: Set<T>, setB: Iterable<T>): Set<T> {

111 const result = new Set<T>();

112 for (const elem of setB) {

117 return result;

118 }

119 > collections.ts

120 > export class SetWithKey<T> implements Set<T> {

121 > private _map = new Map<unknown, T>();

122 >

123 > constructor(values: T[], private toKey: (t: T) => unknown) {

124 for (const value of values) {

125 this.add(value);

126 }

127 }

128 > collections.ts

129 > get size(): number {

130 return this._map.size;

131 }

132 > collections.ts

133 > add(value: T): this {

134 const key = this.toKey(value);

135 this._map.set(key, value);

136 return this;

137 }

138 > collections.ts

139 > delete(value: T): boolean {

140 return this._map.delete(this.toKey(value));

141 }

142 > collections.ts

143 > has(value: T): boolean {

144 return this._map.has(this.toKey(value));

145 }

146 > collections.ts

147 > *entries(): SetIterator<[T, T]> {

148 for (const entry of this._map.values()) {

149 yield [entry, entry];

150 }

151 }

152 > collections.ts

153 > keys(): SetIterator<T> {

154 return this.values();

155 }

156 > collections.ts

157 > *values(): SetIterator<T> {

158 for (const entry of this._map.values()) {

159 yield entry;

160 }

161 }

162 > collections.ts

163 > clear(): void {

164 this._map.clear();

165 }

166 > collections.ts

167 > forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: unknown): void {

168 this._map.forEach(entry => callbackfn.call(thisArg, entry, entry, this));

169 }

170 > collections.ts

171 > [Symbol.iterator](): SetIterator<T> {

172 return this.values();

173 }

174 > collections.ts

175 > [Symbol.toStringTag]: string = 'SetWithKey';

176 > }

src/vs/base/common/hash.ts 74 covered LOC · 17 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- hash.ts

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 { encodeHex, VSBuffer } from './buffer.js';

7 > import * as strings from './strings.js';

8 >

9 > type NotSyncHashable = ArrayBufferLike | ArrayBufferView;

10 >

11 > /**

12 > * Return a hash value for an object.

13 > *

14 > * Note that this should not be used for binary data types. Instead,

15 > * prefer {@link hashAsync}.

16 > */

17 > export function hash<T>(obj: T extends NotSyncHashable ? never : T): number {

18 return doHash(obj, 0);

19 }

20 > hash.ts

21 > export function doHash(obj: unknown, hashVal: number): number {

22 switch (typeof obj) {

23 case 'object':

40 }

41 }

42 > hash.ts

43 > export function numberHash(val: number, initialHashVal: number): number {

44 return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32

45 }

46 > hash.ts

47 function booleanHash(b: boolean, initialHashVal: number): number {

48 return numberHash(b ? 433 : 863, initialHashVal);

49 }

50 > hash.ts

51 > export function stringHash(s: string, hashVal: number) {

52 hashVal = numberHash(149417, hashVal);

53 for (let i = 0, length = s.length; i < length; i++) {

56 return hashVal;

57 }

58 > hash.ts

59 function arrayHash(arr: unknown[], initialHashVal: number): number {

60 initialHashVal = numberHash(104579, initialHashVal);

61 return arr.reduce<number>((hashVal, item) => doHash(item, hashVal), initialHashVal);

62 }

63 > hash.ts

64 function objectHash(obj: object, initialHashVal: number): number {

65 initialHashVal = numberHash(181387, initialHashVal);

69 }, initialHashVal);

70 }

71 > hash.ts

72 >

73 >

74 > /** Hashes the input as SHA-1, returning a hex-encoded string. */

75 > export const hashAsync = (input: string | ArrayBufferView | VSBuffer) => {

76 // Note: I would very much like to expose a streaming interface for hashing

77 // generally, but this is not available in web crypto yet, see

96 return crypto.subtle.digest('sha-1', buff as ArrayBufferView<ArrayBuffer>).then(toHexString); // CodeQL [SM04514] we use sha1 here for validating old stored client state, not for security

97 };

98 > hash.ts

99 > const enum SHA1Constant {

100 > BLOCK_SIZE = 64, // 512 / 8

101 > UNICODE_REPLACEMENT = 0xFFFD,

102 > }

103 >

104 function leftRotate(value: number, bits: number, totalBits: number = 32): number {

105 // delta + bits = totalBits

112 return ((value << bits) | ((mask & value) >>> delta)) >>> 0;

113 }

114 > hash.ts

115 > function toHexString(buffer: ArrayBuffer): string;

116 > function toHexString(value: number, bitsize?: number): string;

117 function toHexString(bufferOrValue: ArrayBuffer | number, bitsize: number = 32): string {

118 if (bufferOrValue instanceof ArrayBuffer) {

122 return (bufferOrValue >>> 0).toString(16).padStart(bitsize / 4, '0');

123 }

124 > hash.ts

125 > /**

126 > * A SHA1 implementation that works with strings and does not allocate.

127 > *

128 > * Prefer to use {@link hashAsync} in async contexts

129 > */

130 > export class StringSHA1 {

131 > private static _bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320

132 >

133 > private _h0 = 0x67452301;

134 > private _h1 = 0xEFCDAB89;

135 > private _h2 = 0x98BADCFE;

136 > private _h3 = 0x10325476;

137 > private _h4 = 0xC3D2E1F0;

138 >

139 > private readonly _buff: Uint8Array;

140 > private readonly _buffDV: DataView;

141 > private _buffLen: number;

142 > private _totalLen: number;

143 > private _leftoverHighSurrogate: number;

144 > private _finished: boolean;

145 >

146 > constructor() {

147 this._buff = new Uint8Array(SHA1Constant.BLOCK_SIZE + 3 /* to fit any utf-8 */);

148 this._buffDV = new DataView(this._buff.buffer);

152 this._finished = false;

153 }

154 > hash.ts

155 > public update(str: string): void {

156 const strLen = str.length;

157 if (strLen === 0) {

208 this._leftoverHighSurrogate = leftoverHighSurrogate;

209 }

210 > hash.ts

211 > private _push(buff: Uint8Array, buffLen: number, codePoint: number): number {

212 if (codePoint < 0x0080) {

213 buff[buffLen++] = codePoint;

238 return buffLen;

239 }

240 > hash.ts

241 > public digest(): string {

242 if (!this._finished) {

243 this._finished = true;

253 return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);

254 }

255 > hash.ts

256 > private _wrapUp(): void {

257 this._buff[this._buffLen++] = 0x80;

258 this._buff.subarray(this._buffLen).fill(0);

271 this._step();

272 }

273 > hash.ts

274 > private _step(): void {

275 const bigBlock32 = StringSHA1._bigBlock32;

276 const data = this._buffDV;

322 this._h4 = (this._h4 + e) & 0xffffffff;

323 }

324 > } hash.ts

src/vs/base/common/observableInternal/logging/logging.ts 67 covered LOC · 17 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- logging.ts

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 { AutorunObserver } from '../reactions/autorunImpl.js';

7 > import { IObservable } from '../base.js';

8 > import { TransactionImpl } from '../transaction.js';

9 > import type { Derived } from '../observables/derivedImpl.js';

10 > import { DebugLocation } from '../debugLocation.js';

11 >

12 > let globalObservableLogger: IObservableLogger | undefined;

13 >

14 > export function addLogger(logger: IObservableLogger): void {

15 if (!globalObservableLogger) {

16 globalObservableLogger = logger;

21 }

22 }

23 > logging.ts

24 > export function getLogger(): IObservableLogger | undefined {

25 return globalObservableLogger;

26 }

27 > logging.ts

28 > let globalObservableLoggerFn: ((obs: IObservable<any>) => void) | undefined = undefined;

29 > export function setLogObservableFn(fn: (obs: IObservable<any>) => void): void {

30 > globalObservableLoggerFn = fn;

31 > }

32 >

33 > export function logObservable(obs: IObservable<any>): void {

34 if (globalObservableLoggerFn) {

35 globalObservableLoggerFn(obs);

36 }

37 }

38 > logging.ts

39 > export interface IChangeInformation {

40 > oldValue: unknown;

41 > newValue: unknown;

42 > change: unknown;

43 > didChange: boolean;

44 > hadValue: boolean;

45 > }

46 >

47 > export interface IObservableLogger {

48 > handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void;

49 > handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;

50 >

51 > handleObservableUpdated(observable: IObservable<any>, info: IChangeInformation): void;

52 >

53 > handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void;

54 > handleAutorunDisposed(autorun: AutorunObserver): void;

55 > handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;

56 > handleAutorunStarted(autorun: AutorunObserver): void;

57 > handleAutorunFinished(autorun: AutorunObserver): void;

58 >

59 > handleDerivedDependencyChanged(derived: Derived<any, any, any>, observable: IObservable<any>, change: unknown): void;

60 > handleDerivedCleared(observable: Derived<any, any, any>): void;

61 >

62 > handleBeginTransaction(transaction: TransactionImpl): void;

63 > handleEndTransaction(transaction: TransactionImpl): void;

64 > }

65 >

66 > class ComposedLogger implements IObservableLogger {

67 > constructor(

68 public readonly loggers: IObservableLogger[],

69 ) { }

70 > logging.ts

71 > handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void {

72 for (const logger of this.loggers) {

73 logger.handleObservableCreated(observable, location);

74 }

75 }

76 > handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void { logging.ts

77 for (const logger of this.loggers) {

78 logger.handleOnListenerCountChanged(observable, newCount);

79 }

80 }

81 > handleObservableUpdated(observable: IObservable<any>, info: IChangeInformation): void { logging.ts

82 for (const logger of this.loggers) {

83 logger.handleObservableUpdated(observable, info);

84 }

85 }

86 > handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void { logging.ts

87 for (const logger of this.loggers) {

88 logger.handleAutorunCreated(autorun, location);

89 }

90 }

91 > handleAutorunDisposed(autorun: AutorunObserver): void { logging.ts

92 for (const logger of this.loggers) {

93 logger.handleAutorunDisposed(autorun);

94 }

95 }

96 > handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void { logging.ts

97 for (const logger of this.loggers) {

98 logger.handleAutorunDependencyChanged(autorun, observable, change);

99 }

100 }

101 > handleAutorunStarted(autorun: AutorunObserver): void { logging.ts

102 for (const logger of this.loggers) {

103 logger.handleAutorunStarted(autorun);

104 }

105 }

106 > handleAutorunFinished(autorun: AutorunObserver): void { logging.ts

107 for (const logger of this.loggers) {

108 logger.handleAutorunFinished(autorun);

109 }

110 }

111 > handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void { logging.ts

112 for (const logger of this.loggers) {

113 logger.handleDerivedDependencyChanged(derived, observable, change);

114 }

115 }

116 > handleDerivedCleared(observable: Derived<any>): void { logging.ts

117 for (const logger of this.loggers) {

118 logger.handleDerivedCleared(observable);

119 }

120 }

121 > handleBeginTransaction(transaction: TransactionImpl): void { logging.ts

122 for (const logger of this.loggers) {

123 logger.handleBeginTransaction(transaction);

124 }

125 }

126 > handleEndTransaction(transaction: TransactionImpl): void { logging.ts

127 for (const logger of this.loggers) {

128 logger.handleEndTransaction(transaction);

129 }

130 }

131 > } logging.ts

src/vs/base/common/themables.ts 67 covered LOC · 15 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- themables.ts

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 { Codicon } from './codicons.js';

7 >

8 > export type ColorIdentifier = string;

9 >

10 > export type IconIdentifier = string;

11 >

12 > export interface ThemeColor {

13 > id: string;

14 > }

15 >

16 > export namespace ThemeColor {

17 > export function isThemeColor(obj: unknown): obj is ThemeColor {

18 return !!obj && typeof obj === 'object' && typeof (<ThemeColor>obj).id === 'string';

19 }

20 > } themables.ts

21 >

22 > export function themeColorFromId(id: ColorIdentifier) {

23 return { id };

24 }

25 > themables.ts

26 >

27 > export interface ThemeIcon {

28 > readonly id: string;

29 > readonly color?: ThemeColor;

30 > }

31 >

32 > export namespace ThemeIcon {

33 > export const iconNameSegment = '[A-Za-z0-9]+';

34 > export const iconNameExpression = '[A-Za-z0-9-]+';

35 > export const iconModifierExpression = '~[A-Za-z]+';

36 > export const iconNameCharacter = '[A-Za-z0-9~-]';

37 >

38 > const ThemeIconIdRegex = new RegExp(`^(${iconNameExpression})(${iconModifierExpression})?$`);

39 >

40 > export function asClassNameArray(icon: ThemeIcon): string[] {

41 const match = ThemeIconIdRegex.exec(icon.id);

42 if (!match) {

50 return classNames;

51 }

52 > themables.ts

53 > export function asClassName(icon: ThemeIcon): string {

54 return asClassNameArray(icon).join(' ');

55 }

56 > themables.ts

57 > export function asCSSSelector(icon: ThemeIcon): string {

58 return '.' + asClassNameArray(icon).join('.');

59 }

60 > themables.ts

61 > export function isThemeIcon(obj: unknown): obj is ThemeIcon {

62 return !!obj && typeof obj === 'object' && typeof (<ThemeIcon>obj).id === 'string' && (typeof (<ThemeIcon>obj).color === 'undefined' || ThemeColor.isThemeColor((<ThemeIcon>obj).color));

63 }

64 > themables.ts

65 > const _regexFromString = new RegExp(`^\\$\\((${ThemeIcon.iconNameExpression}(?:${ThemeIcon.iconModifierExpression})?)\\)$`);

66 >

67 > export function fromString(str: string): ThemeIcon | undefined {

68 const match = _regexFromString.exec(str);

69 if (!match) {

73 return { id: name };

74 }

75 > themables.ts

76 > export function fromId(id: string): ThemeIcon {

77 > return { id }; themables.ts

78 > }

79 > themables.ts

80 > export function modify(icon: ThemeIcon, modifier: 'disabled' | 'spin' | undefined): ThemeIcon {

81 let id = icon.id;

82 const tildeIndex = id.lastIndexOf('~');

89 return { id };

90 }

91 > themables.ts

92 > export function getModifier(icon: ThemeIcon): string | undefined {

93 const tildeIndex = icon.id.lastIndexOf('~');

94 if (tildeIndex !== -1) {

97 return undefined;

98 }

99 > themables.ts

100 > export function isEqual(ti1: ThemeIcon, ti2: ThemeIcon): boolean {

101 return ti1.id === ti2.id && ti1.color?.id === ti2.color?.id;

102 }

103 > themables.ts

104 > /**

105 > * Returns whether specified icon is defined and has 'file' ID.

106 > */

107 > export function isFile(icon: ThemeIcon | undefined): boolean {

108 return icon?.id === Codicon.file.id;

109 }

110 > themables.ts

111 > /**

112 > * Returns whether specified icon is defined and has 'folder' ID.

113 > */

114 > export function isFolder(icon: ThemeIcon | undefined): boolean {

115 return icon?.id === Codicon.folder.id;

116 }

117 > } themables.ts

src/vs/base/common/iterator.ts 65 covered LOC · 23 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- iterator.ts

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 { isIterable } from './types.js';

7 >

8 > export namespace Iterable {

9 >

10 > export function is<T = unknown>(thing: unknown): thing is Iterable<T> {

11 > return !!thing && typeof thing === 'object' && typeof (thing as Iterable<T>)[Symbol.iterator] === 'function'; iterator.ts

12 > }

13 > iterator.ts

14 > const _empty: Iterable<never> = Object.freeze([]);

15 > export function empty<T = never>(): readonly never[] {

16 return _empty as readonly never[];

17 }

18 > iterator.ts

19 > export function* single<T>(element: T): Iterable<T> {

20 yield element;

21 }

22 > iterator.ts

23 > export function wrap<T>(iterableOrElement: Iterable<T> | T): Iterable<T> {

24 if (is(iterableOrElement)) {

25 return iterableOrElement;

28 }

29 }

30 > iterator.ts

31 > export function from<T>(iterable: Iterable<T> | undefined | null): Iterable<T> {

32 return iterable ?? (_empty as Iterable<T>);

33 }

34 > iterator.ts

35 > export function* reverse<T>(array: ReadonlyArray<T>): Iterable<T> {

36 for (let i = array.length - 1; i >= 0; i--) {

37 yield array[i];

38 }

39 }

40 > iterator.ts

41 > export function isEmpty<T>(iterable: Iterable<T> | undefined | null): boolean {

42 return !iterable || iterable[Symbol.iterator]().next().done === true;

43 }

44 > iterator.ts

45 > export function first<T>(iterable: Iterable<T>): T | undefined {

46 return iterable[Symbol.iterator]().next().value;

47 }

48 > iterator.ts

49 > export function some<T>(iterable: Iterable<T>, predicate: (t: T, i: number) => unknown): boolean {

50 let i = 0;

51 for (const element of iterable) {

56 return false;

57 }

58 > iterator.ts

59 > export function every<T>(iterable: Iterable<T>, predicate: (t: T, i: number) => unknown): boolean {

60 let i = 0;

61 for (const element of iterable) {

66 return true;

67 }

68 > iterator.ts

69 > export function find<T, R extends T>(iterable: Iterable<T>, predicate: (t: T) => t is R): R | undefined;

70 > export function find<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): T | undefined;

71 > export function find<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): T | undefined {

72 for (const element of iterable) {

73 if (predicate(element)) {

78 return undefined;

79 }

80 > iterator.ts

81 > export function filter<T, R extends T>(iterable: Iterable<T>, predicate: (t: T) => t is R): Iterable<R>;

82 > export function filter<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): Iterable<T>;

83 > export function* filter<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): Iterable<T> {

84 for (const element of iterable) {

85 if (predicate(element)) {

88 }

89 }

90 > iterator.ts

91 > export function* map<T, R>(iterable: Iterable<T>, fn: (t: T, index: number) => R): Iterable<R> {

92 let index = 0;

93 for (const element of iterable) {

95 }

96 }

97 > iterator.ts

98 > export function* flatMap<T, R>(iterable: Iterable<T>, fn: (t: T, index: number) => Iterable<R>): Iterable<R> {

99 let index = 0;

100 for (const element of iterable) {

102 }

103 }

104 > iterator.ts

105 > export function* concat<T>(...iterables: (Iterable<T> | T)[]): Iterable<T> {

106 for (const item of iterables) {

107 if (isIterable(item)) {

112 }

113 }

114 > iterator.ts

115 > export function reduce<T, R>(iterable: Iterable<T>, reducer: (previousValue: R, currentValue: T) => R, initialValue: R): R {

116 let value = initialValue;

117 for (const element of iterable) {

120 return value;

121 }

122 > iterator.ts

123 > export function length<T>(iterable: Iterable<T>): number {

124 let count = 0;

125 for (const _ of iterable) {

128 return count;

129 }

130 > iterator.ts

131 > /**

132 > * Returns an iterable slice of the array, with the same semantics as `array.slice()`.

133 > */

134 > export function* slice<T>(arr: ReadonlyArray<T>, from: number, to = arr.length): Iterable<T> {

135 if (from < -arr.length) {

136 from = 0;

150 }

151 }

152 > iterator.ts

153 > /**

154 > * Consumes `atMost` elements from iterable and returns the consumed elements,

155 > * and an iterable for the rest of the elements.

156 > */

157 > export function consume<T>(iterable: Iterable<T>, atMost: number = Number.POSITIVE_INFINITY): [T[], Iterable<T>] {

158 const consumed: T[] = [];

159

176 return [consumed, { [Symbol.iterator]() { return iterator; } }];

177 }

178 > iterator.ts

179 > export async function asyncToArray<T>(iterable: AsyncIterable<T>): Promise<T[]> {

180 const result: T[] = [];

181 for await (const item of iterable) {

184 return result;

185 }

186 > iterator.ts

187 > export async function asyncToArrayFlat<T>(iterable: AsyncIterable<T[]>): Promise<T[]> {

188 let result: T[] = [];

189 for await (const item of iterable) {

192 return result;

193 }

194 > } iterator.ts

src/vs/base/common/objects.ts 65 covered LOC · 13 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- objects.ts

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 { isTypedArray, isObject, isUndefinedOrNull } from './types.js';

7 >

8 > export function deepClone<T>(obj: T): T {

9 if (!obj || typeof obj !== 'object') {

10 return obj;

19 return result;

20 }

21 > objects.ts

22 > export function deepFreeze<T>(obj: T): T {

23 if (!obj || typeof obj !== 'object') {

24 return obj;

39 return obj;

40 }

41 > objects.ts

42 > const _hasOwnProperty = Object.prototype.hasOwnProperty;

43 >

44 >

45 > export function cloneAndChange(obj: any, changer: (orig: any) => any): any {

46 return _cloneAndChange(obj, changer, new Set());

47 }

48 > objects.ts

49 function _cloneAndChange(obj: any, changer: (orig: any) => any, seen: Set<any>): any {

50 if (isUndefinedOrNull(obj)) {

82 return obj;

83 }

84 > objects.ts

85 > /**

86 > * Copies all properties of source into destination. The optional parameter "overwrite" allows to control

87 > * if existing properties on the destination should be overwritten or not. Defaults to true (overwrite).

88 > */

89 > export function mixin(destination: any, source: any, overwrite: boolean = true): any {

90 if (!isObject(destination)) {

91 return source;

109 return destination;

110 }

111 > objects.ts

112 > export function equals(one: any, other: any): boolean {

113 if (one === other) {

114 return true;

162 return true;

163 }

164 > objects.ts

165 > /**

166 > * Calls `JSON.Stringify` with a replacer to break apart any circular references.

167 > * This prevents `JSON`.stringify` from throwing the exception

168 > * "Uncaught TypeError: Converting circular structure to JSON"

169 > */

170 > export function safeStringify(obj: any): string {

171 const seen = new Set<any>();

172 return JSON.stringify(obj, (key, value) => {

184 });

185 }

186 > objects.ts

187 > /**

188 > * Like `JSON.stringify`, but with deterministic ordering of object keys so that

189 > * structurally equal inputs always produce the same string. Useful for cache

190 > * keys derived from arbitrary object payloads.

191 > *

192 > * - Object keys are sorted at every level of nesting.

193 > * - Properties whose value is `undefined` are omitted (matching `JSON.stringify`).

194 > * - Circular references are replaced with the string `"[Circular]"` to avoid

195 > * throwing.

196 > * - A top-level `undefined` returns the string `'undefined'`; any other

197 > * stringification failure returns the empty string.

198 > */

199 > export function stableStringify(value: unknown): string {

200 if (value === undefined) {

201 return 'undefined';

207 }

208 }

209 > objects.ts

210 function _stableStringify(value: unknown, seen: WeakSet<object>): string {

211 if (value === null || typeof value !== 'object') {

230 return '{' + parts.join(',') + '}';

231 }

232 > objects.ts

233 > type obj = { [key: string]: any };

234 > /**

235 > * Returns an object that has keys for each value that is different in the base object. Keys

236 > * that do not exist in the target but in the base object are not considered.

237 > *

238 > * Note: This is not a deep-diffing method, so the values are strictly taken into the resulting

239 > * object if they differ.

240 > *

241 > * @param base the object to diff against

242 > * @param obj the object to use for diffing

243 > */

244 > export function distinct(base: obj, target: obj): obj {

245 const result = Object.create(null);

246

261 return result;

262 }

263 > objects.ts

264 > export function getCaseInsensitive(target: obj, key: string): unknown {

265 const lowercaseKey = key.toLowerCase();

266 const equivalentKey = Object.keys(target).find(k => k.toLowerCase() === lowercaseKey);

267 return equivalentKey ? target[equivalentKey] : target[key];

268 }

269 > objects.ts

270 > export function filter(obj: obj, predicate: (key: string, value: any) => boolean): obj {

271 const result = Object.create(null);

272 for (const [key, value] of Object.entries(obj)) {

277 return result;

278 }

279 > objects.ts

280 > export function mapValues<T extends {}, R>(obj: T, fn: (value: T[keyof T], key: string) => R): { [K in keyof T]: R } {

281 const result: { [key: string]: R } = {};

282 for (const [key, value] of Object.entries(obj)) {

src/vs/base/common/codicons.ts 64 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- codicons.ts

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 > import { ThemeIcon } from './themables.js';

6 > import { register } from './codiconsUtil.js';

7 > import { codiconsLibrary } from './codiconsLibrary.js';

8 >

9 >

10 > /**

11 > * Only to be used by the iconRegistry.

12 > */

13 > export function getAllCodicons(): ThemeIcon[] {

14 return Object.values(Codicon);

15 }

16 > codicons.ts

17 > /**

18 > * Derived icons, that could become separate icons.

19 > * These mappings should be moved into the mapping file in the vscode-codicons repo at some point.

20 > */

21 > export const codiconsDerived = {

22 > dialogError: register('dialog-error', 'error'),

23 > dialogWarning: register('dialog-warning', 'warning'),

24 > dialogInfo: register('dialog-info', 'info'),

25 > dialogClose: register('dialog-close', 'close'),

26 > treeItemExpanded: register('tree-item-expanded', 'chevron-down'), // collapsed is done with rotation

27 > treeFilterOnTypeOn: register('tree-filter-on-type-on', 'list-filter'),

28 > treeFilterOnTypeOff: register('tree-filter-on-type-off', 'list-selection'),

29 > treeFilterClear: register('tree-filter-clear', 'close'),

30 > treeItemLoading: register('tree-item-loading', 'loading'),

31 > menuSelection: register('menu-selection', 'check'),

32 > menuSubmenu: register('menu-submenu', 'chevron-right'),

33 > menuBarMore: register('menubar-more', 'more'),

34 > scrollbarButtonLeft: register('scrollbar-button-left', 'triangle-left'),

35 > scrollbarButtonRight: register('scrollbar-button-right', 'triangle-right'),

36 > scrollbarButtonUp: register('scrollbar-button-up', 'triangle-up'),

37 > scrollbarButtonDown: register('scrollbar-button-down', 'triangle-down'),

38 > toolBarMore: register('toolbar-more', 'more'),

39 > quickInputBack: register('quick-input-back', 'arrow-left'),

40 > dropDownButton: register('drop-down-button', 0xeab4),

41 > symbolCustomColor: register('symbol-customcolor', 0xeb5c),

42 > exportIcon: register('export', 0xebac),

43 > workspaceUnspecified: register('workspace-unspecified', 0xebc3),

44 > newLine: register('newline', 0xebea),

45 > thumbsDownFilled: register('thumbsdown-filled', 0xec13),

46 > thumbsUpFilled: register('thumbsup-filled', 0xec14),

47 > gitFetch: register('git-fetch', 0xec1d),

48 > lightbulbSparkleAutofix: register('lightbulb-sparkle-autofix', 0xec1f),

49 > debugBreakpointPending: register('debug-breakpoint-pending', 0xebd9),

50 > chatImport: register('chat-import', 0xec86),

51 > chatExport: register('chat-export', 0xec87),

52 >

53 > } as const;

54 >

55 > /**

56 > * The Codicon library is a set of default icons that are built-in in VS Code.

57 > *

58 > * In the product (outside of base) Codicons should only be used as defaults. In order to have all icons in VS Code

59 > * themeable, component should define new, UI component specific icons using `iconRegistry.registerIcon`.

60 > * In that call a Codicon can be named as default.

61 > */

62 > export const Codicon = {

63 > ...codiconsLibrary,

64 > ...codiconsDerived

65 >

66 > } as const;

src/vs/base/common/observableInternal/observables/observableValue.ts 58 covered LOC · 12 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- observableValue.ts

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 { ISettableObservable, ITransaction } from '../base.js';

7 > import { TransactionImpl } from '../transaction.js';

8 > import { BaseObservable } from './baseObservable.js';

9 > import { EqualityComparer, IDisposable, strictEquals } from '../commonFacade/deps.js';

10 > import { DebugNameData } from '../debugName.js';

11 > import { getLogger } from '../logging/logging.js';

12 > import { DebugLocation } from '../debugLocation.js';

13 >

14 > /**

15 > * Creates an observable value.

16 > * Observers get informed when the value changes.

17 > * @template TChange An arbitrary type to describe how or why the value changed. Defaults to `void`.

18 > * Observers will receive every single change value.

19 > */

20 >

21 > export function observableValue<T, TChange = void>(name: string, initialValue: T): ISettableObservable<T, TChange>;

22 > export function observableValue<T, TChange = void>(owner: object, initialValue: T): ISettableObservable<T, TChange>;

23 > export function observableValue<T, TChange = void>(nameOrOwner: string | object, initialValue: T, debugLocation = DebugLocation.ofCaller()): ISettableObservable<T, TChange> {

24 let debugNameData: DebugNameData;

25 if (typeof nameOrOwner === 'string') {

30 return new ObservableValue(debugNameData, initialValue, strictEquals, debugLocation);

31 }

32 > observableValue.ts

33 > export class ObservableValue<T, TChange = void>

34 > extends BaseObservable<T, TChange>

35 > implements ISettableObservable<T, TChange> {

36 > protected _value: T;

37 >

38 > get debugName() {

39 > return this._debugNameData.getDebugName(this) ?? 'ObservableValue';

40 > }

41 >

42 > constructor(

43 private readonly _debugNameData: DebugNameData,

44 initialValue: T,

51 getLogger()?.handleObservableUpdated(this, { hadValue: false, newValue: initialValue, change: undefined, didChange: true, oldValue: undefined });

52 }

53 > public override get(): T { observableValue.ts

54 return this._value;

55 }

56 > observableValue.ts

57 > public set(value: T, tx: ITransaction | undefined, change: TChange): void {

58 if (change === undefined && this._equalityComparator(this._value, value)) {

59 return;

79 }

80 }

81 > observableValue.ts

82 > override toString(): string {

83 return `${this.debugName}: ${this._value}`;

84 }

85 > observableValue.ts

86 > protected _setValue(newValue: T): void {

87 this._value = newValue;

88 }

89 > observableValue.ts

90 > public debugGetState() {

91 return {

92 value: this._value,

93 };

94 }

95 > observableValue.ts

96 > public debugSetValue(value: unknown) {

97 this._value = value as T;

98 }

99 > } observableValue.ts

100 > /**

101 > * A disposable observable. When disposed, its value is also disposed.

102 > * When a new value is set, the previous value is disposed.

103 > */

104 >

105 > export function disposableObservableValue<T extends IDisposable | undefined, TChange = void>(nameOrOwner: string | object, initialValue: T, debugLocation = DebugLocation.ofCaller()): ISettableObservable<T, TChange> & IDisposable {

106 let debugNameData: DebugNameData;

107 if (typeof nameOrOwner === 'string') {

112 return new DisposableObservableValue(debugNameData, initialValue, strictEquals, debugLocation);

113 }

114 > observableValue.ts

115 > export class DisposableObservableValue<T extends IDisposable | undefined, TChange = void> extends ObservableValue<T, TChange> implements IDisposable {

116 > protected override _setValue(newValue: T): void {

117 if (this._value === newValue) {

118 return;

123 this._value = newValue;

124 }

125 > observableValue.ts

126 > public dispose(): void {

127 this._value?.dispose();

128 }

129 > } observableValue.ts

src/vs/base/test/common/utils.ts 58 covered LOC · 14 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- utils.ts

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 { DisposableStore, DisposableTracker, IDisposable, setDisposableTracker } from '../../common/lifecycle.js';

7 > import { join } from '../../common/path.js';

8 > import { isWindows } from '../../common/platform.js';

9 > import { URI } from '../../common/uri.js';

10 >

11 > export type ValueCallback<T = any> = (value: T | Promise<T>) => void;

12 >

13 > export function toResource(this: any, path: string): URI {

14 if (isWindows) {

15 return URI.file(join('C:\\', btoa(this.test.fullTitle()), path));

18 return URI.file(join('/', btoa(this.test.fullTitle()), path));

19 }

20 > utils.ts

21 > export function suiteRepeat(n: number, description: string, callback: (this: any) => void): void {

22 for (let i = 0; i < n; i++) {

23 suite(`${description} (iteration ${i})`, callback);

24 }

25 }

26 > utils.ts

27 > export function testRepeat(n: number, description: string, callback: (this: any) => any): void {

28 for (let i = 0; i < n; i++) {

29 test(`${description} (iteration ${i})`, callback);

30 }

31 }

32 > utils.ts

33 export async function assertThrowsAsync(block: () => any, message: string | Error = 'Missing expected exception'): Promise<void> {

34 try {

41 throw err;

42 }

43 > utils.ts

44 > /**

45 > * Use this function to ensure that all disposables are cleaned up at the end of each test in the current suite.

46 > *

47 > * Use `markAsSingleton` if disposable singletons are created lazily that are allowed to outlive the test.

48 > * Make sure that the singleton properly registers all child disposables so that they are excluded too.

49 > *

50 > * @returns A {@link DisposableStore} that can optionally be used to track disposables in the test.

51 > * This will be automatically disposed on test teardown.

52 > */

53 > export function ensureNoDisposablesAreLeakedInTestSuite(): Pick<DisposableStore, 'add'> {

54 > let tracker: DisposableTracker | undefined;

55 > let store: DisposableStore;

56 > setup(() => {

57 > store = new DisposableStore(); utils.ts

58 > tracker = new DisposableTracker();

59 > setDisposableTracker(tracker);

60 > }); utils.ts

61 >

62 > teardown(function (this: import('mocha').Context) {

63 > store.dispose(); utils.ts

64 > setDisposableTracker(null);

65 > if (this.currentTest?.state !== 'failed') {

66 > const result = tracker!.computeLeakingDisposables();

67 > if (result) {

68 console.error(result.details);

69 throw new Error(`There are ${result.leaks.length} undisposed disposables!${result.details}`);

70 }

71 > } utils.ts

72 > }); utils.ts

73 >

74 > // Wrap store as the suite function is called before it's initialized

75 > const testContext = {

76 > add<T extends IDisposable>(o: T): T {

77 > return store.add(o); utils.ts

78 > }

79 > }; utils.ts

80 > return testContext;

81 > }

82 >

83 > export function throwIfDisposablesAreLeaked(body: () => void, logToConsole = true): void {

84 const tracker = new DisposableTracker();

85 setDisposableTracker(tracker);

88 computeLeakingDisposables(tracker, logToConsole);

89 }

90 > utils.ts

91 export async function throwIfDisposablesAreLeakedAsync(body: () => Promise<void>): Promise<void> {

92 const tracker = new DisposableTracker();

96 computeLeakingDisposables(tracker);

97 }

98 > utils.ts

99 function computeLeakingDisposables(tracker: DisposableTracker, logToConsole = true) {

100 const result = tracker.computeLeakingDisposables();

src/vs/base/common/observableInternal/index.ts 57 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- index.ts

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 > // This is a facade for the observable implementation. Only import from here!

7 >

8 > export { observableValueOpts } from './observables/observableValueOpts.js';

9 > export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta, autorunPerKeyedItem, autorunSelfDisposable, registerAutorunSelfDisposable } from './reactions/autorun.js';

10 > export { type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type IReaderWithStore, type ISettableObservable, type ITransaction } from './base.js';

11 > export { disposableObservableValue } from './observables/observableValue.js';

12 > export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from './observables/derived.js';

13 > export { type IDerivedReader } from './observables/derivedImpl.js';

14 > export { ObservableLazy, ObservableLazyPromise, ObservablePromise, ObservableResolvedPromise, PromiseResult, } from './utils/promise.js';

15 > export { derivedWithCancellationToken, waitForState } from './utils/utilsCancellation.js';

16 > export {

17 > debouncedObservable, debouncedObservable2, derivedObservableWithCache,

18 > derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise,

19 > recomputeInitiallyAndOnChange,

20 > signalFromObservable, throttledObservable, wasEventTriggeredRecently,

21 > isObservable,

22 > } from './utils/utils.js';

23 > export { type DebugOwner } from './debugName.js';

24 > export { type IChangeContext, type IChangeTracker, recordChanges, recordChangesLazy } from './changeTracker.js';

25 > export { constObservable } from './observables/constObservable.js';

26 > export { type IObservableSignal, observableSignal } from './observables/observableSignal.js';

27 > export { observableFromEventOpts } from './observables/observableFromEvent.js';

28 > export { observableSignalFromEvent } from './observables/observableSignalFromEvent.js';

29 > export { asyncTransaction, globalTransaction, subtransaction, transaction, TransactionImpl } from './transaction.js';

30 > export { observableFromValueWithChangeEvent, ValueWithChangeEventFromObservable } from './utils/valueWithChangeEvent.js';

31 > export { runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore, type RemoveUndefined } from './utils/runOnChange.js';

32 > export { derivedConstOnceDefined, latestChangedValue } from './experimental/utils.js';

33 > export { observableFromEvent } from './observables/observableFromEvent.js';

34 > export { observableValue } from './observables/observableValue.js';

35 >

36 > export { ObservableSet } from './set.js';

37 > export { ObservableMap } from './map.js';

38 > export { DebugLocation } from './debugLocation.js';

39 >

40 > import { addLogger, setLogObservableFn } from './logging/logging.js';

41 > import { ConsoleObservableLogger, logObservableToConsole } from './logging/consoleObservableLogger.js';

42 > import { DevToolsLogger } from './logging/debugger/devToolsLogger.js';

43 > import { env } from '../process.js';

44 > import { _setDebugGetObservableGraph } from './observables/baseObservable.js';

45 > import { debugGetObservableGraph } from './logging/debugGetDependencyGraph.js';

46 >

47 > _setDebugGetObservableGraph(debugGetObservableGraph);

48 > setLogObservableFn(logObservableToConsole);

49 >

50 > // Remove "//" in the next line to enable logging

51 > const enableLogging = false

52 > // || Boolean("true") // done "weirdly" so that a lint warning prevents you from pushing this

53 > ;

54 >

55 > if (enableLogging) {

56 addLogger(new ConsoleObservableLogger());

57 }

58 > index.ts

59 > if (env && env['VSCODE_DEV_DEBUG_OBSERVABLES']) {

60 // To debug observables you also need the extension "ms-vscode.debug-value-editor"

61 addLogger(DevToolsLogger.getInstance());

src/vs/base/common/observableInternal/observables/derived.ts 57 covered LOC · 6 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- derived.ts

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 { IObservable, IReader, ITransaction, ISettableObservable, IObservableWithChange } from '../base.js';

7 > import { IChangeTracker } from '../changeTracker.js';

8 > import { DisposableStore, EqualityComparer, IDisposable, strictEquals } from '../commonFacade/deps.js';

9 > import { DebugLocation } from '../debugLocation.js';

10 > import { DebugOwner, DebugNameData, IDebugNameData } from '../debugName.js';

11 > import { _setDerivedOpts } from './baseObservable.js';

12 > import { IDerivedReader, Derived, DerivedWithSetter } from './derivedImpl.js';

13 >

14 > /**

15 > * Creates an observable that is derived from other observables.

16 > * The value is only recomputed when absolutely needed.

17 > *

18 > * {@link computeFn} should start with a JS Doc using `@description` to name the derived.

19 > */

20 > export function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>, debugLocation?: DebugLocation) => T): IObservableWithChange<T, TChange>;

21 > export function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T, debugLocation?: DebugLocation): IObservableWithChange<T, TChange>;

22 > export function derived<T, TChange = void>(

23 computeFnOrOwner: ((reader: IDerivedReader<TChange>) => T) | DebugOwner,

24 computeFn?: ((reader: IDerivedReader<TChange>) => T) | undefined,

46 );

47 }

48 > derived.ts

49 > export function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void, debugLocation = DebugLocation.ofCaller()): ISettableObservable<T> {

50 return new DerivedWithSetter(

51 new DebugNameData(owner, undefined, computeFn),

58 );

59 }

60 > derived.ts

61 > export function derivedOpts<T>(

62 options: IDebugNameData & {

63 equalsFn?: EqualityComparer<T>;

76 );

77 }

78 > _setDerivedOpts(derivedOpts); derived.ts

79 >

80 > /**

81 > * Represents an observable that is derived from other observables.

82 > * The value is only recomputed when absolutely needed.

83 > *

84 > * {@link computeFn} should start with a JS Doc using `@description` to name the derived.

85 > *

86 > * Use `createEmptyChangeSummary` to create a "change summary" that can collect the changes.

87 > * Use `handleChange` to add a reported change to the change summary.

88 > * The compute function is given the last change summary.

89 > * The change summary is discarded after the compute function was called.

90 > *

91 > * @see derived

92 > */

93 > export function derivedHandleChanges<T, TDelta, TChangeSummary>(

94 options: IDebugNameData & {

95 changeTracker: IChangeTracker<TChangeSummary>;

108 );

109 }

110 > derived.ts

111 > /**

112 > * @deprecated Use `derived(reader => { reader.store.add(...) })` instead!

113 > */

114 > export function derivedWithStore<T>(computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;

115 >

116 > /**

117 > * @deprecated Use `derived(reader => { reader.store.add(...) })` instead!

118 > */

119 > export function derivedWithStore<T>(owner: DebugOwner, computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;

120 > export function derivedWithStore<T>(computeFnOrOwner: ((reader: IReader, store: DisposableStore) => T) | DebugOwner, computeFnOrUndefined?: ((reader: IReader, store: DisposableStore) => T), debugLocation = DebugLocation.ofCaller()): IObservable<T> {

121 let computeFn: (reader: IReader, store: DisposableStore) => T;

122 let owner: DebugOwner;

151 );

152 }

153 > derived.ts

154 > export function derivedDisposable<T extends IDisposable | undefined>(computeFn: (reader: IReader) => T): IObservable<T>;

155 > export function derivedDisposable<T extends IDisposable | undefined>(owner: DebugOwner, computeFn: (reader: IReader) => T): IObservable<T>;

156 > export function derivedDisposable<T extends IDisposable | undefined>(computeFnOrOwner: ((reader: IReader) => T) | DebugOwner, computeFnOrUndefined?: ((reader: IReader) => T), debugLocation = DebugLocation.ofCaller()): IObservable<T> {

157 let computeFn: (reader: IReader) => T;

158 let owner: DebugOwner;

src/vs/workbench/services/environment/common/environmentService.ts 56 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- environmentService.ts

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 { refineServiceDecorator } from '../../../../platform/instantiation/common/instantiation.js';

7 > import { IPath } from '../../../../platform/window/common/window.js';

8 > import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';

9 > import { URI } from '../../../../base/common/uri.js';

10 >

11 > export const IWorkbenchEnvironmentService = refineServiceDecorator<IEnvironmentService, IWorkbenchEnvironmentService>(IEnvironmentService);

12 >

13 > /**

14 > * A workbench specific environment service that is only present in workbench

15 > * layer.

16 > */

17 > export interface IWorkbenchEnvironmentService extends IEnvironmentService {

18 >

19 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

20 > // NOTE: KEEP THIS INTERFACE AS SMALL AS POSSIBLE. AS SUCH:

21 > // PUT NON-WEB PROPERTIES INTO THE NATIVE WORKBENCH

22 > // ENVIRONMENT SERVICE

23 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

24 >

25 > // --- Paths

26 > readonly logFile: URI;

27 > readonly windowLogsPath: URI;

28 > readonly extHostLogsPath: URI;

29 >

30 > // --- Extensions

31 > readonly extensionEnabledProposedApi?: string[];

32 >

33 > // --- Config

34 > readonly remoteAuthority?: string;

35 > readonly skipReleaseNotes: boolean;

36 > readonly skipWelcome: boolean;

37 > readonly disableWorkspaceTrust: boolean;

38 > readonly isSessionsWindow: boolean;

39 > readonly webviewExternalEndpoint: string;

40 >

41 > // --- Development

42 > readonly debugRenderer: boolean;

43 > readonly logExtensionHostCommunication?: boolean;

44 > readonly enableSmokeTestDriver?: boolean;

45 > readonly profDurationMarkers?: string[];

46 >

47 > // --- Editors to open

48 > readonly filesToOpenOrCreate?: IPath[] | undefined;

49 > readonly filesToDiff?: IPath[] | undefined;

50 > readonly filesToMerge?: IPath[] | undefined;

51 >

52 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

53 > // NOTE: KEEP THIS INTERFACE AS SMALL AS POSSIBLE. AS SUCH:

54 > // - PUT NON-WEB PROPERTIES INTO NATIVE WB ENV SERVICE

55 > // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

56 > }

src/vs/workbench/contrib/chat/common/tools/promptTsxTypes.ts 55 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- promptTsxTypes.ts

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 > /**

7 > * This is a subset of the types export from jsonTypes.d.ts in @vscode/prompt-tsx.

8 > * It's just the types needed to stringify prompt-tsx tool results.

9 > * It should be kept in sync with the types in that file.

10 > *

11 > * Note: do NOT use `declare` with const enums, esbuild doesn't inline them.

12 > * See https://github.com/evanw/esbuild/issues/4394

13 > */

14 >

15 > export const enum PromptNodeType {

16 > Piece = 1,

17 > Text = 2

18 > }

19 > export interface TextJSON {

20 > type: PromptNodeType.Text;

21 > text: string;

22 > lineBreakBefore: boolean | undefined;

23 > }

24 > /**

25 > * Constructor kind of the node represented by {@link PieceJSON}. This is

26 > * less descriptive than the actual constructor, as we only care to preserve

27 > * the element data that the renderer cares about.

28 > */

29 > export const enum PieceCtorKind {

30 > BaseChatMessage = 1,

31 > Other = 2,

32 > ImageChatMessage = 3

33 > }

34 > export interface BasePieceJSON {

35 > type: PromptNodeType.Piece;

36 > ctor: PieceCtorKind.BaseChatMessage | PieceCtorKind.Other;

37 > children: PromptNodeJSON[];

38 > }

39 > export interface ImageChatMessagePieceJSON {

40 > type: PromptNodeType.Piece;

41 > ctor: PieceCtorKind.ImageChatMessage;

42 > children: PromptNodeJSON[];

43 > props: {

44 > src: string;

45 > detail?: 'low' | 'high';

46 > };

47 > }

48 > export type PieceJSON = BasePieceJSON | ImageChatMessagePieceJSON;

49 > export type PromptNodeJSON = PieceJSON | TextJSON;

50 > export interface PromptElementJSON {

51 > node: PieceJSON;

52 > }

53 >

54 > export function stringifyPromptElementJSON(element: PromptElementJSON): string {

55 const strs: string[] = [];

56 stringifyPromptNodeJSON(element.node, strs);

57 return strs.join('');

58 }

59 > promptTsxTypes.ts

60 function stringifyPromptNodeJSON(node: PromptNodeJSON, strs: string[]): void {

61 if (node.type === PromptNodeType.Text) {

src/vs/platform/registry/common/platform.ts 54 covered LOC · 7 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- platform.ts

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 * as Assert from '../../../base/common/assert.js';

7 > import * as Types from '../../../base/common/types.js';

8 >

9 > export interface IRegistry {

10 >

11 > /**

12 > * Adds the extension functions and properties defined by data to the

13 > * platform. The provided id must be unique.

14 > * @param id a unique identifier

15 > * @param data a contribution

16 > */

17 > add(id: string, data: any): void;

18 >

19 > /**

20 > * Returns true iff there is an extension with the provided id.

21 > * @param id an extension identifier

22 > */

23 > knows(id: string): boolean;

24 >

25 > /**

26 > * Returns the extension functions and properties defined by the specified key or null.

27 > * @param id an extension identifier

28 > */

29 > as<T>(id: string): T;

30 > }

31 >

32 > class RegistryImpl implements IRegistry {

33 >

34 > private readonly data = new Map<string, any>();

35 >

36 > public add(id: string, data: any): void {

37 > Assert.ok(Types.isString(id)); platform.ts

38 > Assert.ok(Types.isObject(data));

39 > Assert.ok(!this.data.has(id), 'There is already an extension with this id');

40 >

41 > this.data.set(id, data);

42 > }

43 > platform.ts

44 > public knows(id: string): boolean {

45 return this.data.has(id);

46 }

47 > platform.ts

48 > public as(id: string): any {

49 > return this.data.get(id) || null; platform.ts

50 > }

51 > platform.ts

52 > public dispose() {

53 this.data.forEach((value) => {

54 if (Types.isFunction(value.dispose)) {

58 this.data.clear();

59 }

60 > platform.ts

61 > }

62 >

63 > export const Registry: IRegistry = new RegistryImpl();

src/vs/base/common/observableInternal/logging/debugger/rpc.ts 53 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- rpc.ts

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 > export type ChannelFactory = (handler: IChannelHandler) => IChannel;

7 >

8 > export interface IChannel {

9 > sendNotification(data: unknown): void;

10 > sendRequest(data: unknown): Promise<RpcRequestResult>;

11 > }

12 >

13 > export interface IChannelHandler {

14 > handleNotification(notificationData: unknown): void;

15 > handleRequest(requestData: unknown): Promise<RpcRequestResult> | RpcRequestResult;

16 > }

17 >

18 > export type RpcRequestResult = { type: 'result'; value: unknown } | { type: 'error'; value: unknown };

19 >

20 > export type API = {

21 > host: Side;

22 > client: Side;

23 > };

24 >

25 > export type Side = {

26 > notifications: Record<string, (...args: any[]) => void>;

27 > requests: Record<string, (...args: any[]) => Promise<unknown> | unknown>;

28 > };

29 >

30 > type MakeAsyncIfNot<TFn> = TFn extends (...args: infer TArgs) => infer TResult ? TResult extends Promise<unknown> ? TFn : (...args: TArgs) => Promise<TResult> : never;

31 >

32 > export type MakeSideAsync<T extends Side> = {

33 > notifications: T['notifications'];

34 > requests: { [K in keyof T['requests']]: MakeAsyncIfNot<T['requests'][K]> };

35 > };

36 >

37 > export class SimpleTypedRpcConnection<T extends Side> {

38 > public static createHost<T extends API>(channelFactory: ChannelFactory, getHandler: () => T['host']): SimpleTypedRpcConnection<MakeSideAsync<T['client']>> {

39 > return new SimpleTypedRpcConnection(channelFactory, getHandler);

40 > }

41 >

42 > public static createClient<T extends API>(channelFactory: ChannelFactory, getHandler: () => T['client']): SimpleTypedRpcConnection<MakeSideAsync<T['host']>> {

43 return new SimpleTypedRpcConnection(channelFactory, getHandler);

44 }

45 > rpc.ts

46 > public readonly api: T;

47 > private readonly _channel: IChannel;

48 >

49 > private constructor(

50 private readonly _channelFactory: ChannelFactory,

51 private readonly _getHandler: () => Side,

95 this.api = { notifications: notifications, requests: requests } as any;

96 }

97 > } rpc.ts

98 >

99 > type OutgoingMessage = [

100 > method: string,

101 > args: unknown[],

102 > ];

src/vs/base/common/process.ts 53 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- process.ts

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 { INodeProcess, isMacintosh, isWindows } from './platform.js';

7 >

8 > let safeProcess: Omit<INodeProcess, 'arch'> & { arch: string | undefined };

9 > declare const process: INodeProcess;

10 >

11 > // Native sandbox environment

12 > const vscodeGlobal = (globalThis as { vscode?: { process?: INodeProcess } }).vscode;

13 > if (typeof vscodeGlobal !== 'undefined' && typeof vscodeGlobal.process !== 'undefined') {

14 const sandboxProcess: INodeProcess = vscodeGlobal.process;

15 safeProcess = {

20 };

21 }

22 > process.ts

23 > // Native node.js environment

24 > else if (typeof process !== 'undefined' && typeof process?.versions?.node === 'string') {

25 > safeProcess = {

26 > get platform() { return process.platform; },

27 > get arch() { return process.arch; },

28 > get env() { return process.env; },

29 > cwd() { return process.env['VSCODE_CWD'] || process.cwd(); }

30 > };

31 }

32

44 };

45 }

46 > process.ts

47 > /**

48 > * Provides safe access to the `cwd` property in node.js, sandboxed or web

49 > * environments.

50 > *

51 > * Note: in web, this property is hardcoded to be `/`.

52 > *

53 > * @skipMangle

54 > */

55 > export const cwd = safeProcess.cwd;

56 >

57 > /**

58 > * Provides safe access to the `env` property in node.js, sandboxed or web

59 > * environments.

60 > *

61 > * Note: in web, this property is hardcoded to be `{}`.

62 > */

63 > export const env = safeProcess.env;

64 >

65 > /**

66 > * Provides safe access to the `platform` property in node.js, sandboxed or web

67 > * environments.

68 > */

69 > export const platform = safeProcess.platform;

70 >

71 > /**

72 > * Provides safe access to the `arch` method in node.js, sandboxed or web

73 > * environments.

74 > * Note: `arch` is `undefined` in web

75 > */

76 > export const arch = safeProcess.arch;

src/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatQuestionCarouselData.ts 53 covered LOC · 5 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- chatQuestionCarouselData.ts

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 { DeferredPromise } from '../../../../../../base/common/async.js';

7 > import { IMarkdownString } from '../../../../../../base/common/htmlContent.js';

8 > import { IChatQuestion, IChatQuestionAnswers, IChatQuestionCarousel } from '../../chatService/chatService.js';

9 > import { ToolDataSource } from '../../tools/languageModelToolsService.js';

10 >

11 > /**

12 > * Runtime representation of a question carousel with a {@link DeferredPromise}

13 > * that is resolved when the user submits answers. {@link toJSON} strips the

14 > * completion so only serialisable data is persisted.

15 > */

16 > export class ChatQuestionCarouselData implements IChatQuestionCarousel {

17 > public readonly kind = 'questionCarousel' as const;

18 > public readonly completion = new DeferredPromise<{ answers: IChatQuestionAnswers | undefined }>();

19 > public draftAnswers: IChatQuestionAnswers | undefined;

20 > public draftCurrentIndex: number | undefined;

21 > public draftCollapsed: boolean | undefined;

22 > /**

23 > * Set to `true` when the carousel was dismissed because the user typed

24 > * directly in the associated terminal instead of using the carousel UI.

25 > */

26 > public dismissedByTerminalInput?: boolean;

27 >

28 > /**

29 > * True when the input was accepted/answered outside the carousel UI (e.g.

30 > * via voice) without structured answers, so the summary reads "Answered".

31 > */

32 > public answeredExternally?: boolean;

33 >

34 > /**

35 > * Marks the carousel as dismissed with the given answers and clears draft

36 > * state. Safe to call multiple times — subsequent calls are no-ops.

37 > */

38 > dismiss(answers: IChatQuestionAnswers | undefined): void {

39 > if (this.isUsed) {

40 > return; chatQuestionCarouselData.ts

41 > }

42 > this.data = answers ?? {}; chatQuestionCarouselData.ts

43 > this.isUsed = true;

44 > this.draftAnswers = undefined;

45 > this.draftCurrentIndex = undefined;

46 > this.draftCollapsed = undefined;

47 > void this.completion.complete({ answers });

48 > }

49 >

50 > constructor(

51 public questions: IChatQuestion[],

52 public allowSkip: boolean,

58 public terminalId?: string,

59 ) { }

60 > chatQuestionCarouselData.ts

61 > toJSON(): IChatQuestionCarousel {

62 return {

63 kind: this.kind,

73 };

74 }

75 > } chatQuestionCarouselData.ts

src/vs/base/common/observableInternal/debugName.ts 52 covered LOC · 8 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- debugName.ts

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 > export interface IDebugNameData {

7 > /**

8 > * The owner object of an observable.

9 > * Used for debugging only, such as computing a name for the observable by iterating over the fields of the owner.

10 > */

11 > readonly owner?: DebugOwner | undefined;

12 >

13 > /**

14 > * A string or function that returns a string that represents the name of the observable.

15 > * Used for debugging only.

16 > */

17 > readonly debugName?: DebugNameSource | undefined;

18 >

19 > /**

20 > * A function that points to the defining function of the object.

21 > * Used for debugging only.

22 > */

23 > readonly debugReferenceFn?: Function | undefined;

24 > }

25 >

26 > export class DebugNameData {

27 > constructor(

28 public readonly owner: DebugOwner | undefined,

29 public readonly debugNameSource: DebugNameSource | undefined,

30 public readonly referenceFn: Function | undefined,

31 ) { }

32 > debugName.ts

33 > public getDebugName(target: object): string | undefined {

34 return getDebugName(target, this);

35 }

36 > } debugName.ts

37 >

38 > /**

39 > * The owning object of an observable.

40 > * Is only used for debugging purposes, such as computing a name for the observable by iterating over the fields of the owner.

41 > */

42 > export type DebugOwner = object | undefined;

43 > export type DebugNameSource = string | (() => string | undefined);

44 >

45 > const countPerName = new Map<string, number>();

46 > const cachedDebugName = new WeakMap<object, string>();

47 >

48 > export function getDebugName(target: object, data: DebugNameData): string | undefined {

49 const cached = cachedDebugName.get(target);

50 if (cached) {

63 return undefined;

64 }

65 > debugName.ts

66 function computeDebugName(self: object, data: DebugNameData): string | undefined {

67 const cached = cachedDebugName.get(self);

101 return undefined;

102 }

103 > debugName.ts

104 function findKey(obj: object, value: object): string | undefined {

105 for (const key in obj) {

110 return undefined;

111 }

112 > debugName.ts

113 > const countPerClassName = new Map<string, number>();

114 > const ownerId = new WeakMap<object, string>();

115 >

116 function formatOwner(owner: object): string {

117 const id = ownerId.get(owner);

127 return result;

128 }

129 > debugName.ts

130 > export function getClassName(obj: object): string | undefined {

131 const ctor = obj.constructor;

132 if (ctor) {

138 return undefined;

139 }

140 > debugName.ts

141 > export function getFunctionName(fn: Function): string | undefined {

142 const fnSrc = fn.toString();

143 // Pattern: /** @description ... */

src/vs/base/common/observableInternal/logging/consoleObservableLogger.ts 52 covered LOC · 20 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- consoleObservableLogger.ts

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 { IObservable } from '../base.js';

7 > import { TransactionImpl } from '../transaction.js';

8 > import { IObservableLogger, IChangeInformation, addLogger } from './logging.js';

9 > import { FromEventObservable } from '../observables/observableFromEvent.js';

10 > import { getClassName } from '../debugName.js';

11 > import { Derived } from '../observables/derivedImpl.js';

12 > import { AutorunObserver } from '../reactions/autorunImpl.js';

13 >

14 > let consoleObservableLogger: ConsoleObservableLogger | undefined;

15 >

16 > export function logObservableToConsole(obs: IObservable<any>): void {

17 if (!consoleObservableLogger) {

18 consoleObservableLogger = new ConsoleObservableLogger();

21 consoleObservableLogger.addFilteredObj(obs);

22 }

23 > consoleObservableLogger.ts

24 > export class ConsoleObservableLogger implements IObservableLogger {

25 private indentation = 0;

26

118

119 private readonly changedObservablesSets = new WeakMap<object, Set<IObservable<any>>>();

120 > consoleObservableLogger.ts

121 > formatChanges(changes: Set<IObservable<any>>): ConsoleText | undefined {

122 if (changes.size === 0) {

123 return undefined;

130 );

131 }

132 > consoleObservableLogger.ts

133 > handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void {

134 if (!this._isIncluded(derived)) { return; }

135

136 this.changedObservablesSets.get(derived)?.add(observable);

137 }

138 > consoleObservableLogger.ts

139 > _handleDerivedRecomputed(derived: Derived<unknown>, info: IChangeInformation): void {

140 if (!this._isIncluded(derived)) { return; }

141

151 changedObservables.clear();

152 }

153 > consoleObservableLogger.ts

154 > handleDerivedCleared(derived: Derived<unknown>): void {

155 if (!this._isIncluded(derived)) { return; }

156

160 ]));

161 }

162 > consoleObservableLogger.ts

163 > handleFromEventObservableTriggered(observable: FromEventObservable<any, any>, info: IChangeInformation): void {

164 if (!this._isIncluded(observable)) { return; }

165

171 ]));

172 }

173 > consoleObservableLogger.ts

174 > handleAutorunCreated(autorun: AutorunObserver): void {

175 if (!this._isIncluded(autorun)) { return; }

176

177 this.changedObservablesSets.set(autorun, new Set());

178 }

179 > consoleObservableLogger.ts

180 > handleAutorunDisposed(autorun: AutorunObserver): void {

181 }

182 > consoleObservableLogger.ts

183 > handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void {

184 if (!this._isIncluded(autorun)) { return; }

185

186 this.changedObservablesSets.get(autorun)!.add(observable);

187 }

188 > consoleObservableLogger.ts

189 > handleAutorunStarted(autorun: AutorunObserver): void {

190 const changedObservables = this.changedObservablesSets.get(autorun);

191 if (!changedObservables) { return; }

202 this.indentation++;

203 }

204 > consoleObservableLogger.ts

205 > handleAutorunFinished(autorun: AutorunObserver): void {

206 this.indentation--;

207 }

208 > consoleObservableLogger.ts

209 > handleBeginTransaction(transaction: TransactionImpl): void {

210 let transactionName = transaction.getDebugName();

211 if (transactionName === undefined) {

221 this.indentation++;

222 }

223 > consoleObservableLogger.ts

224 > handleEndTransaction(): void {

225 this.indentation--;

226 }

227 > } consoleObservableLogger.ts

228 > type ConsoleText = (ConsoleText | undefined)[] |

229 > { text: string; style: string; data?: unknown[] } |

230 > { data: unknown[] };

231 function consoleTextToArgs(text: ConsoleText): unknown[] {

232 const styles = new Array<any>();

294 };

295 }

296 > consoleObservableLogger.ts

297 > export function formatValue(value: unknown, availableLen: number): string {

298 switch (typeof value) {

299 case 'number':

325 }

326 }

327 > consoleObservableLogger.ts

328 function formatArray(value: unknown[], availableLen: number): string {

329 let result = '[ ';

343 return result;

344 }

345 > consoleObservableLogger.ts

346 function formatObject(value: object, availableLen: number): string {

347 if (typeof value.toString === 'function' && value.toString !== Object.prototype.toString) {

371 return result;

372 }

373 > consoleObservableLogger.ts

374 function repeat(str: string, count: number): string {

375 let result = '';

379 return result;

380 }

381 > consoleObservableLogger.ts

382 function padStr(str: string, length: number): string {

383 while (str.length < length) {

src/vs/platform/remote/common/remoteHosts.ts 52 covered LOC · 7 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- remoteHosts.ts

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 { Schemas } from '../../../base/common/network.js';

7 > import { URI } from '../../../base/common/uri.js';

8 >

9 > export function getRemoteAuthority(uri: URI): string | undefined {

10 return uri.scheme === Schemas.vscodeRemote ? uri.authority : undefined;

11 }

12 > remoteHosts.ts

13 > export function getRemoteName(authority: string): string;

14 > export function getRemoteName(authority: undefined): undefined;

15 > export function getRemoteName(authority: string | undefined): string | undefined;

16 > export function getRemoteName(authority: string | undefined): string | undefined {

17 if (!authority) {

18 return undefined;

25 return authority.substr(0, pos);

26 }

27 > remoteHosts.ts

28 > /**

29 > * Returns the suffix part of the authority after the '+' character.

30 > * For remote connections, this is typically the server/tunnel identifier.

31 > * Examples:

32 > * - For tunnels: `tunnel+myTunnel` returns `myTunnel`

33 > * - For SSH: `ssh+myserver` returns `myserver`

34 > * - For localhost: `localhost:8000` returns `undefined`

35 > * @param authority The remote authority string.

36 > * @returns The suffix after the '+' character, or undefined if there is no '+' character.

37 > */

38 > export function getRemoteServerRootPath(authority: string): string | undefined;

39 > export function getRemoteServerRootPath(authority: undefined): undefined;

40 > export function getRemoteServerRootPath(authority: string | undefined): string | undefined;

41 > export function getRemoteServerRootPath(authority: string | undefined): string | undefined {

42 if (!authority) {

43 return undefined;

49 return authority.substring(pos + 1);

50 }

51 > remoteHosts.ts

52 > export function parseAuthorityWithPort(authority: string): { host: string; port: number } {

53 const { host, port } = parseAuthority(authority);

54 if (typeof port === 'undefined') {

57 return { host, port };

58 }

59 > remoteHosts.ts

60 > export function parseAuthorityWithOptionalPort(authority: string, defaultPort: number): { host: string; port: number } {

61 let { host, port } = parseAuthority(authority);

62 if (typeof port === 'undefined') {

65 return { host, port };

66 }

67 > remoteHosts.ts

68 function parseAuthority(authority: string): { host: string; port: number | undefined } {

69 // check for ipv6 with port

88 return { host: authority, port: undefined };

89 }

90 > remoteHosts.ts

91 > const loopbackHosts = new Set([

92 > 'localhost',

93 > '127.0.0.1',

94 > '::1',

95 > '[::1]',

96 > '0000:0000:0000:0000:0000:0000:0000:0001',

97 > '[0000:0000:0000:0000:0000:0000:0000:0001]'

98 > ]);

99 >

100 > /**

101 > * Returns whether the given host (as found in a direct `<host>:<port>` remote

102 > * authority) refers to the local loopback interface. The check is intentionally

103 > * strict: only `localhost` and the IPv4/IPv6 loopback literals are considered

104 > * local. Any other host (a routable IP address or a hostname) is treated as a

105 > * connection that leaves the local machine.

106 > */

107 > export function isLoopbackHost(host: string): boolean {

108 return loopbackHosts.has(host.toLowerCase());

109 }

src/vs/base/common/observableInternal/observables/observableFromEvent.ts 51 covered LOC · 9 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- observableFromEvent.ts

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 { IObservable, ITransaction } from '../base.js';

7 > import { subtransaction } from '../transaction.js';

8 > import { EqualityComparer, Event, IDisposable, strictEquals } from '../commonFacade/deps.js';

9 > import { DebugOwner, DebugNameData, IDebugNameData } from '../debugName.js';

10 > import { getLogger } from '../logging/logging.js';

11 > import { BaseObservable } from './baseObservable.js';

12 > import { DebugLocation } from '../debugLocation.js';

13 >

14 >

15 > export function observableFromEvent<T, TArgs = unknown>(

16 > owner: DebugOwner,

17 > event: Event<TArgs>,

18 > getValue: (args: TArgs | undefined) => T,

19 > debugLocation?: DebugLocation,

20 > ): IObservable<T>;

21 > export function observableFromEvent<T, TArgs = unknown>(

22 > event: Event<TArgs>,

23 > getValue: (args: TArgs | undefined) => T,

24 > ): IObservable<T>;

25 > export function observableFromEvent(...args:

26 [owner: DebugOwner, event: Event<any>, getValue: (args: any | undefined) => any, debugLocation?: DebugLocation] |

27 [event: Event<any>, getValue: (args: any | undefined) => any]

45 );

46 }

47 > observableFromEvent.ts

48 > export function observableFromEventOpts<T, TArgs = unknown>(

49 options: IDebugNameData & {

50 equalsFn?: EqualityComparer<T>;

64 );

65 }

66 > observableFromEvent.ts

67 > export class FromEventObservable<TArgs, T> extends BaseObservable<T> {

68 > public static globalTransaction: ITransaction | undefined;

69 >

70 > private _value: T | undefined;

71 > private _hasValue = false;

72 > private _subscription: IDisposable | undefined;

73 >

74 > constructor(

75 private readonly _debugNameData: DebugNameData,

76 private readonly event: Event<TArgs>,

131 }

132 };

133 > observableFromEvent.ts

134 > protected override onLastObserverRemoved(): void {

135 this._subscription!.dispose();

136 this._subscription = undefined;

138 this._value = undefined;

139 }

140 > observableFromEvent.ts

141 > public get(): T {

142 if (this._subscription) {

143 if (!this._hasValue) {

151 }

152 }

153 > observableFromEvent.ts

154 > public debugSetValue(value: unknown): void {

155 // eslint-disable-next-line local/code-no-any-casts

156 this._value = value as any;

157 }

158 > observableFromEvent.ts

159 > public debugGetState() {

160 return { value: this._value, hasValue: this._hasValue };

161 }

162 > } observableFromEvent.ts

163 >

164 > export namespace observableFromEvent {

165 > export const Observer = FromEventObservable;

166 >

167 > export function batchEventsGlobally(tx: ITransaction, fn: () => void): void {

168 let didSet = false;

169 if (FromEventObservable.globalTransaction === undefined) {

179 }

180 }

181 > } observableFromEvent.ts

src/vs/platform/agentHost/common/agentHostSessionType.ts 51 covered LOC · 7 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- agentHostSessionType.ts

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 { type AgentProvider } from './agentService.js';

7 >

8 > const REMOTE_AGENT_HOST_SESSION_TYPE_PREFIX = 'remote-';

9 >

10 > /**

11 > * Builds the unique per-connection identifier for a remote agent host.

12 > *

13 > * This string is used as the resource URI scheme registered via

14 > * `registerChatSessionContentProvider` and as the language model vendor /

15 > * `targetChatSessionType` published by `AgentHostLanguageModelProvider`.

16 > */

17 > export function remoteAgentHostSessionTypeId(connectionAuthority: string, agentProvider: AgentProvider): string {

18 return `${remoteAgentHostSessionTypeAuthorityPrefix(connectionAuthority)}${agentProvider}`;

19 }

20 > agentHostSessionType.ts

21 > /**

22 > * Builds the authority-specific prefix for remote agent host session types.

23 > */

24 > export function remoteAgentHostSessionTypeAuthorityPrefix(connectionAuthority: string): string {

25 return `${REMOTE_AGENT_HOST_SESSION_TYPE_PREFIX}${connectionAuthority}-`;

26 }

27 > agentHostSessionType.ts

28 > /**

29 > * Returns whether the given session type uses the remote agent host scheme.

30 > */

31 > export function isRemoteAgentHostSessionType(sessionType: string): boolean {

32 return sessionType.startsWith(REMOTE_AGENT_HOST_SESSION_TYPE_PREFIX);

33 }

34 > agentHostSessionType.ts

35 > /**

36 > * Finds the best matching remote agent host authority from a known candidate set.

37 > *

38 > * Remote session types are formatted as `remote-{authority}-{provider}` and

39 > * authorities may contain `-`, so callers should match against the full set of

40 > * known authorities instead of splitting the session type.

41 > */

42 > export function findRemoteAgentHostSessionTypeAuthority(sessionType: string, connectionAuthorities: Iterable<string>): string | undefined {

43 if (!isRemoteAgentHostSessionType(sessionType)) {

44 return undefined;

53 return bestMatch;

54 }

55 > agentHostSessionType.ts

56 function isRemoteAgentHostSessionTypeForAuthority(sessionType: string, connectionAuthority: string): boolean {

57 return !!connectionAuthority && sessionType.startsWith(remoteAgentHostSessionTypeAuthorityPrefix(connectionAuthority));

58 }

59 > agentHostSessionType.ts

60 > /**

61 > * Extracts the harness/provider suffix from a remote agent host session type.

62 > *

63 > * Remote session types are formatted as `remote-{authority}-{provider}`. The

64 > * authority may contain `-`, but provider names do not, so the harness is the

65 > * final `-`-delimited segment. Returns `undefined` for non-remote session types.

66 > */

67 > export function parseRemoteAgentHostHarness(sessionType: string): string | undefined {

68 if (!isRemoteAgentHostSessionType(sessionType)) {

69 return undefined;

73 return harness || undefined;

74 }

75 > agentHostSessionType.ts

76 > /**

77 > * Extracts the connection authority from a remote agent host session type when the provider is known.

78 > */

79 > export function parseRemoteAgentHostSessionTypeAuthority(sessionType: string, agentProvider: AgentProvider): string | undefined {

80 if (!isRemoteAgentHostSessionType(sessionType)) {

81 return undefined;

src/vs/base/common/assert.ts 50 covered LOC · 9 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- assert.ts

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 { BugIndicatingError, onUnexpectedError } from './errors.js';

7 >

8 > /**

9 > * Throws an error with the provided message if the provided value does not evaluate to a true Javascript value.

10 > *

11 > * @deprecated Use `assert(...)` instead.

12 > * This method is usually used like this:

13 > * ```ts

14 > * import * as assert from 'vs/base/common/assert';

15 > * assert.ok(...);

16 > * ```

17 > *

18 > * However, `assert` in that example is a user chosen name.

19 > * There is no tooling for generating such an import statement.

20 > * Thus, the `assert(...)` function should be used instead.

21 > */

22 > export function ok(value?: unknown, message?: string) {

23 > if (!value) { assert.ts

24 throw new Error(message ? `Assertion failed (${message})` : 'Assertion Failed');

25 }

26 > } assert.ts

27 > assert.ts

28 > export function assertNever(value: never, message = 'Unreachable'): never {

29 throw new Error(message);

30 }

31 > assert.ts

32 > export function softAssertNever(value: never): void {

33 // no-op

34 }

35 > assert.ts

36 > /**

37 > * Asserts that a condition is `truthy`.

38 > *

39 > * @throws provided {@linkcode messageOrError} if the {@linkcode condition} is `falsy`.

40 > *

41 > * @param condition The condition to assert.

42 > * @param messageOrError An error message or error object to throw if condition is `falsy`.

43 > */

44 > export function assert(

45 condition: boolean,

46 messageOrError: string | Error = 'unexpected state',

55 }

56 }

57 > assert.ts

58 > /**

59 > * Like assert, but doesn't throw.

60 > */

61 > export function softAssert(condition: boolean, message = 'Soft Assertion Failed'): void {

62 if (!condition) {

63 onUnexpectedError(new BugIndicatingError(message));

64 }

65 }

66 > assert.ts

67 > /**

68 > * condition must be side-effect free!

69 > */

70 > export function assertFn(condition: () => boolean): void {

71 if (!condition()) {

72 // eslint-disable-next-line no-debugger

77 }

78 }

79 > assert.ts

80 > export function checkAdjacentItems<T>(items: readonly T[], predicate: (item1: T, item2: T) => boolean): boolean {

81 let i = 0;

82 while (i < items.length - 1) {

src/vs/base/common/observableInternal/observables/lazyObservableValue.ts 49 covered LOC · 11 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- lazyObservableValue.ts

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 { EqualityComparer } from '../commonFacade/deps.js';

7 > import { IObserver, ISettableObservable, ITransaction } from '../base.js';

8 > import { TransactionImpl } from '../transaction.js';

9 > import { DebugNameData } from '../debugName.js';

10 > import { getLogger } from '../logging/logging.js';

11 > import { BaseObservable } from './baseObservable.js';

12 > import { DebugLocation } from '../debugLocation.js';

13 >

14 > /**

15 > * Holds off updating observers until the value is actually read.

16 > */

17 > export class LazyObservableValue<T, TChange = void>

18 > extends BaseObservable<T, TChange>

19 > implements ISettableObservable<T, TChange> {

20 > protected _value: T;

21 > private _isUpToDate = true;

22 > private readonly _deltas: TChange[] = [];

23 >

24 > get debugName() {

25 > return this._debugNameData.getDebugName(this) ?? 'LazyObservableValue';

26 > }

27 >

28 > constructor(

29 private readonly _debugNameData: DebugNameData,

30 initialValue: T,

35 this._value = initialValue;

36 }

37 > lazyObservableValue.ts

38 > public override get(): T {

39 this._update();

40 return this._value;

41 }

42 > lazyObservableValue.ts

43 > private _update(): void {

44 if (this._isUpToDate) {

45 return;

62 }

63 }

64 > lazyObservableValue.ts

65 > private _updateCounter = 0;

66 >

67 > private _beginUpdate(): void {

68 this._updateCounter++;

69 if (this._updateCounter === 1) {

73 }

74 }

75 > lazyObservableValue.ts

76 > private _endUpdate(): void {

77 this._updateCounter--;

78 if (this._updateCounter === 0) {

86 }

87 }

88 > lazyObservableValue.ts

89 > public override addObserver(observer: IObserver): void {

90 const shouldCallBeginUpdate = !this._observers.has(observer) && this._updateCounter > 0;

91 super.addObserver(observer);

95 }

96 }

97 > lazyObservableValue.ts

98 > public override removeObserver(observer: IObserver): void {

99 const shouldCallEndUpdate = this._observers.has(observer) && this._updateCounter > 0;

100 super.removeObserver(observer);

105 }

106 }

107 > lazyObservableValue.ts

108 > public set(value: T, tx: ITransaction | undefined, change: TChange): void {

109 if (change === undefined && this._equalityComparator(this._value, value)) {

110 return;

142 }

143 }

144 > lazyObservableValue.ts

145 > override toString(): string {

146 return `${this.debugName}: ${this._value}`;

147 }

148 > lazyObservableValue.ts

149 > protected _setValue(newValue: T): void {

150 this._value = newValue;

151 }

152 > } lazyObservableValue.ts

src/vs/workbench/contrib/chat/common/model/chatUri.ts 49 covered LOC · 8 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- chatUri.ts

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 { encodeBase64, VSBuffer, decodeBase64 } from '../../../../../base/common/buffer.js';

7 > import { Schemas } from '../../../../../base/common/network.js';

8 > import { URI } from '../../../../../base/common/uri.js';

9 > import { localChatSessionType } from '../chatSessionsService.js';

10 >

11 > type ChatSessionIdentifier = {

12 > readonly chatSessionType: string;

13 > readonly sessionId: string;

14 > };

15 >

16 >

17 > export namespace LocalChatSessionUri {

18 >

19 > export const scheme = Schemas.vscodeLocalChatSession;

20 >

21 > export function forSession(sessionId: string): URI {

22 const encodedId = encodeBase64(VSBuffer.wrap(new TextEncoder().encode(sessionId)), false, true);

23 return URI.from({ scheme, authority: localChatSessionType, path: '/' + encodedId });

24 }

25 > chatUri.ts

26 > export function getNewSessionUri(): URI {

27 const handle = Math.floor(Math.random() * 1e9);

28 return forSession(`chat-${handle}`);

29 }

30 > chatUri.ts

31 > export function parseLocalSessionId(resource: URI): string | undefined {

32 const parsed = parse(resource);

33 return parsed?.chatSessionType === localChatSessionType ? parsed.sessionId : undefined;

34 }

35 > chatUri.ts

36 > export function isLocalSession(resource: URI): boolean {

37 return !!parseLocalSessionId(resource);

38 }

39 > chatUri.ts

40 > function parse(resource: URI): ChatSessionIdentifier | undefined {

41 if (resource.scheme !== scheme) {

42 return undefined;

56 return { chatSessionType, sessionId: new TextDecoder().decode(decodedSessionId.buffer) };

57 }

58 > } chatUri.ts

59 >

60 > /**

61 > * Converts a chat session resource URI to a string ID.

62 > *

63 > * This exists mainly for backwards compatibility with existing code that uses string IDs in telemetry and storage.

64 > */

65 > export function chatSessionResourceToId(resource: URI): string {

66 // If we have a local session, prefer using just the id part

67 const localId = LocalChatSessionUri.parseLocalSessionId(resource);

72 return resource.toString();

73 }

74 > chatUri.ts

75 > /**

76 > * Extracts the chat session type from a resource URI.

77 > *

78 > * @param resource - The chat session resource URI

79 > * @returns The session type string. Returns `localChatSessionType` for local sessions

80 > * (vscodeChatEditor and vscodeLocalChatSession schemes), or the scheme/authority

81 > * for contributed sessions.

82 > */

83 > export function getChatSessionType(resource: URI): string {

84 if (resource.scheme === Schemas.vscodeChatEditor) {

85 return localChatSessionType;

92 return resource.scheme;

93 }

94 > chatUri.ts

95 > export function isUntitledChatSession(resource: URI): boolean {

96 return resource.path.startsWith('/untitled-');

97 }

src/vs/base/common/iconLabels.ts 47 covered LOC · 6 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- iconLabels.ts

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 { IMatch, matchesFuzzy } from './filters.js';

7 > import { ltrim } from './strings.js';

8 > import { ThemeIcon } from './themables.js';

9 >

10 > const iconStartMarker = '$(';

11 >

12 > const iconsRegex = new RegExp(`\\$\\(${ThemeIcon.iconNameExpression}(?:${ThemeIcon.iconModifierExpression})?\\)`, 'g'); // no capturing groups

13 >

14 > const escapeIconsRegex = new RegExp(`(\\\\)?${iconsRegex.source}`, 'g');

15 > export function escapeIcons(text: string): string {

16 return text.replace(escapeIconsRegex, (match, escaped) => escaped ? match : `\\${match}`);

17 }

18 > iconLabels.ts

19 > const markdownEscapedIconsRegex = new RegExp(`\\\\${iconsRegex.source}`, 'g');

20 > export function markdownEscapeEscapedIcons(text: string): string {

21 // Need to add an extra \ for escaping in markdown

22 return text.replace(markdownEscapedIconsRegex, match => `\\${match}`);

23 }

24 > iconLabels.ts

25 > const stripIconsRegex = new RegExp(`(\\s)?(\\\\)?${iconsRegex.source}(\\s)?`, 'g');

26 >

27 > /**

28 > * Takes a label with icons (`$(iconId)xyz`) and strips the icons out (`xyz`)

29 > */

30 > export function stripIcons(text: string): string {

31 if (text.indexOf(iconStartMarker) === -1) {

32 return text;

35 return text.replace(stripIconsRegex, (match, preWhitespace, escaped, postWhitespace) => escaped ? match : preWhitespace || postWhitespace || '');

36 }

37 > iconLabels.ts

38 >

39 > /**

40 > * Takes a label with icons (`$(iconId)xyz`), removes the icon syntax adds whitespace so that screen readers can read the text better.

41 > */

42 > export function getCodiconAriaLabel(text: string | undefined) {

43 if (!text) {

44 return '';

47 return text.replace(/\$\((.*?)\)/g, (_match, codiconName) => ` ${codiconName} `).trim();

48 }

49 > iconLabels.ts

50 >

51 > export interface IParsedLabelWithIcons {

52 > readonly text: string;

53 > readonly iconOffsets?: readonly number[];

54 > }

55 >

56 > const _parseIconsRegex = new RegExp(`\\$\\(${ThemeIcon.iconNameCharacter}+\\)`, 'g');

57 >

58 > /**

59 > * Takes a label with icons (`abc $(iconId)xyz`) and returns the text (`abc xyz`) and the offsets of the icons (`[3]`)

60 > */

61 > export function parseLabelWithIcons(input: string): IParsedLabelWithIcons {

62

63 _parseIconsRegex.lastIndex = 0;

86 return { text, iconOffsets };

87 }

88 > iconLabels.ts

89 >

90 > export function matchesFuzzyIconAware(query: string, target: IParsedLabelWithIcons, enableSeparateSubstringMatching = false): IMatch[] | null {

91 const { text, iconOffsets } = target;

92

src/vs/platform/uriIdentity/common/uriIdentity.ts 46 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- uriIdentity.ts

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 { URI } from '../../../base/common/uri.js';

7 > import { createDecorator } from '../../instantiation/common/instantiation.js';

8 > import { IExtUri } from '../../../base/common/resources.js';

9 >

10 >

11 > export const IUriIdentityService = createDecorator<IUriIdentityService>('IUriIdentityService');

12 >

13 > export interface IUriIdentityService {

14 >

15 > readonly _serviceBrand: undefined;

16 >

17 > /**

18 > * Uri extensions that are aware of casing.

19 > */

20 > readonly extUri: IExtUri;

21 >

22 > /**

23 > * Returns a canonical uri for the given resource. Different uris can point to the same

24 > * resource. That's because of casing or missing normalization, e.g the following uris

25 > * are different but refer to the same document (because windows paths are not case-sensitive)

26 > *

27 > * ```txt

28 > * file:///c:/foo/bar.txt

29 > * file:///c:/FOO/BAR.txt

30 > * ```

31 > *

32 > * This function should be invoked when feeding uris into the system that represent the truth,

33 > * e.g document uris or marker-to-document associations etc. This function should NOT be called

34 > * to pretty print a label nor to sanitize a uri.

35 > *

36 > * Samples:

37 > *

38 > * | in | out | |

39 > * |---|---|---|

40 > * | `file:///foo/bar/../bar` | `file:///foo/bar` | n/a |

41 > * | `file:///foo/bar/../bar#frag` | `file:///foo/bar#frag` | keep fragment |

42 > * | `file:///foo/BAR` | `file:///foo/bar` | assume ignore case |

43 > * | `file:///foo/bar/../BAR?q=2` | `file:///foo/BAR?q=2` | query makes it a different document |

44 > */

45 > asCanonicalUri(uri: URI): URI;

46 > }

src/vs/base/common/linkedList.ts 44 covered LOC · 13 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- linkedList.ts

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 > class Node<E> {

7 >

8 > static readonly Undefined = new Node<unknown>(undefined);

9 >

10 > element: E;

11 > next: Node<E> | typeof Node.Undefined;

12 > prev: Node<E> | typeof Node.Undefined;

13 >

14 > constructor(element: E) {

15 > this.element = element;

16 > this.next = Node.Undefined;

17 > this.prev = Node.Undefined;

18 > }

19 > }

20 >

21 > export class LinkedList<E> {

22

23 private _first: Node<E> | typeof Node.Undefined = Node.Undefined;

24 private _last: Node<E> | typeof Node.Undefined = Node.Undefined;

25 private _size: number = 0;

26 > linkedList.ts

27 > get size(): number {

28 return this._size;

29 }

30 > linkedList.ts

31 > isEmpty(): boolean {

32 return this._first === Node.Undefined;

33 }

34 > linkedList.ts

35 > clear(): void {

36 let node = this._first;

37 while (node !== Node.Undefined) {

46 this._size = 0;

47 }

48 > linkedList.ts

49 > unshift(element: E): () => void {

50 return this._insert(element, false);

51 }

52 > linkedList.ts

53 > push(element: E): () => void {

54 return this._insert(element, true);

55 }

56 > linkedList.ts

57 > private _insert(element: E, atTheEnd: boolean): () => void {

58 const newNode = new Node(element);

59 if (this._first === Node.Undefined) {

85 };

86 }

87 > linkedList.ts

88 > shift(): E | undefined {

89 if (this._first === Node.Undefined) {

90 return undefined;

95 }

96 }

97 > linkedList.ts

98 > pop(): E | undefined {

99 if (this._last === Node.Undefined) {

100 return undefined;

105 }

106 }

107 > linkedList.ts

108 > peek(): E | undefined {

109 if (this._last === Node.Undefined) {

110 return undefined;

114 }

115 }

116 > linkedList.ts

117 > private _remove(node: Node<E> | typeof Node.Undefined): void {

118 if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {

119 // middle

141 this._size -= 1;

142 }

143 > linkedList.ts

144 > *[Symbol.iterator](): Iterator<E> {

145 let node = this._first;

146 while (node !== Node.Undefined) {

149 }

150 }

151 > } linkedList.ts

src/vs/base/common/uint.ts 43 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- uint.ts

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 > export const enum Constants {

7 > /**

8 > * MAX SMI (SMall Integer) as defined in v8.

9 > * one bit is lost for boxing/unboxing flag.

10 > * one bit is lost for sign flag.

11 > * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values

12 > */

13 > MAX_SAFE_SMALL_INTEGER = 1 << 30,

14 >

15 > /**

16 > * MIN SMI (SMall Integer) as defined in v8.

17 > * one bit is lost for boxing/unboxing flag.

18 > * one bit is lost for sign flag.

19 > * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values

20 > */

21 > MIN_SAFE_SMALL_INTEGER = -(1 << 30),

22 >

23 > /**

24 > * Max unsigned integer that fits on 8 bits.

25 > */

26 > MAX_UINT_8 = 255, // 2^8 - 1

27 >

28 > /**

29 > * Max unsigned integer that fits on 16 bits.

30 > */

31 > MAX_UINT_16 = 65535, // 2^16 - 1

32 >

33 > /**

34 > * Max unsigned integer that fits on 32 bits.

35 > */

36 > MAX_UINT_32 = 4294967295, // 2^32 - 1

37 >

38 > UNICODE_SUPPLEMENTARY_PLANE_BEGIN = 0x010000

39 > }

40 >

41 > export function toUint8(v: number): number {

42 if (v < 0) {

43 return 0;

48 return v | 0;

49 }

50 > uint.ts

51 > export function toUint32(v: number): number {

52 if (v < 0) {

53 return 0;

src/vs/base/common/observableInternal/debugLocation.ts 42 covered LOC · 4 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- debugLocation.ts

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 > export type DebugLocation = DebugLocationImpl | undefined;

7 >

8 > export namespace DebugLocation {

9 > let enabled = false;

10 >

11 > export function enable(): void {

12 enabled = true;

13 }

14 > debugLocation.ts

15 > export function ofCaller(): DebugLocation {

16 if (!enabled) {

17 return undefined;

26 return DebugLocationImpl.fromStack(stack, 2);

27 }

28 > } debugLocation.ts

29 >

30 > class DebugLocationImpl implements ILocation {

31 > public static fromStack(stack: string, parentIdx: number): DebugLocationImpl | undefined {

32 > const lines = stack.split('\n');

33 > const location = parseLine(lines[parentIdx + 1]);

34 > if (location) {

35 > return new DebugLocationImpl(

36 > location.fileName,

37 > location.line,

38 > location.column,

39 > location.id

40 > );

41 > } else {

42 > return undefined;

43 > }

44 > }

45 >

46 > constructor(

47 public readonly fileName: string,

48 public readonly line: number,

51 ) {

52 }

53 > } debugLocation.ts

54 >

55 >

56 > export interface ILocation {

57 > fileName: string;

58 > line: number;

59 > column: number;

60 > id: string;

61 > }

62 >

63 function parseLine(stackLine: string): ILocation | undefined {

64 const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);

src/vs/platform/configuration/test/common/testConfigurationService.ts 42 covered LOC · 11 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- testConfigurationService.ts

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 { Emitter } from '../../../../base/common/event.js';

7 > import { TernarySearchTree } from '../../../../base/common/ternarySearchTree.js';

8 > import { URI } from '../../../../base/common/uri.js';

9 > import { getConfigurationValue, IConfigurationChangeEvent, IConfigurationOverrides, IConfigurationService, IConfigurationValue, isConfigurationOverrides } from '../../common/configuration.js';

10 > import { Extensions, IConfigurationRegistry } from '../../common/configurationRegistry.js';

11 > import { Registry } from '../../../registry/common/platform.js';

12 >

13 > export class TestConfigurationService implements IConfigurationService {

14 > public _serviceBrand: undefined;

15 >

16 > private configuration: Record<string, unknown>;

17 > readonly onDidChangeConfigurationEmitter = new Emitter<IConfigurationChangeEvent>();

18 > readonly onDidChangeConfiguration = this.onDidChangeConfigurationEmitter.event;

19 >

20 > constructor(configuration?: Record<string, unknown>) {

21 > this.configuration = configuration || Object.create(null); testConfigurationService.ts

22 > }

23 > testConfigurationService.ts

24 > private configurationByRoot: TernarySearchTree<string, Record<string, unknown>> = TernarySearchTree.forPaths<Record<string, unknown>>();

25 >

26 > public reloadConfiguration<T>(): Promise<T> {

27 return Promise.resolve(this.getValue() as T);

28 }

29 > testConfigurationService.ts

30 > public getValue<T>(arg1?: string | IConfigurationOverrides, arg2?: IConfigurationOverrides): T | undefined {

31 let configuration;

32 const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : undefined;

42 return configuration as T;

43 }

44 > testConfigurationService.ts

45 > public updateValue(key: string, value: unknown): Promise<void> {

46 return Promise.resolve(undefined);

47 }

48 > testConfigurationService.ts

49 > public setUserConfiguration(key: string, value: unknown, root?: URI): Promise<void> {

50 if (root) {

51 const configForRoot = this.configurationByRoot.get(root.fsPath) || Object.create(null);

58 return Promise.resolve(undefined);

59 }

60 > testConfigurationService.ts

61 > private overrideIdentifiers: Map<string, string[]> = new Map();

62 > public setOverrideIdentifiers(key: string, identifiers: string[]): void {

63 this.overrideIdentifiers.set(key, identifiers);

64 }

65 > testConfigurationService.ts

66 > public inspect<T>(key: string, overrides?: IConfigurationOverrides): IConfigurationValue<T> {

67 const value = this.getValue(key, overrides) as T;

68

75 };

76 }

77 > testConfigurationService.ts

78 > public keys() {

79 return {

80 default: Object.keys(Registry.as<IConfigurationRegistry>(Extensions.Configuration).getConfigurationProperties()),

85 };

86 }

87 > testConfigurationService.ts

88 > public getConfigurationData() {

89 return null;

90 }

91 > } testConfigurationService.ts

src/vs/base/common/lazy.ts 39 covered LOC · 4 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- lazy.ts

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 > enum LazyValueState {

7 > Uninitialized,

8 > Running,

9 > Completed,

10 > }

11 >

12 > export class Lazy<T> {

13 >

14 > private _state = LazyValueState.Uninitialized;

15 > private _value?: T;

16 > private _error: Error | undefined;

17 >

18 > constructor(

19 > private readonly executor: () => T, lazy.ts

20 > ) { }

21 > lazy.ts

22 > /**

23 > * True if the lazy value has been resolved.

24 > */

25 > get hasValue(): boolean { return this._state === LazyValueState.Completed; }

26 >

27 > /**

28 > * Get the wrapped value.

29 > *

30 > * This will force evaluation of the lazy value if it has not been resolved yet. Lazy values are only

31 > * resolved once. `getValue` will re-throw exceptions that are hit while resolving the value

32 > */

33 > get value(): T {

34 if (this._state === LazyValueState.Uninitialized) {

35 this._state = LazyValueState.Running;

50 return this._value!;

51 }

52 > lazy.ts

53 > /**

54 > * Get the wrapped value without forcing evaluation.

55 > */

56 > get rawValue(): T | undefined { return this._value; }

57 > }

src/vs/base/common/observableInternal/transaction.ts 39 covered LOC · 10 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- transaction.ts

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 { handleBugIndicatingErrorRecovery, IObservable, IObserver, ITransaction } from './base.js';

7 > import { getFunctionName } from './debugName.js';

8 > import { getLogger } from './logging/logging.js';

9 >

10 > /**

11 > * Starts a transaction in which many observables can be changed at once.

12 > * {@link fn} should start with a JS Doc using `@description` to give the transaction a debug name.

13 > * Reaction run on demand or when the transaction ends.

14 > */

15 >

16 > export function transaction(fn: (tx: ITransaction) => void, getDebugName?: () => string): void {

17 const tx = new TransactionImpl(fn, getDebugName);

18 try {

22 }

23 }

24 > let _globalTransaction: ITransaction | undefined = undefined; transaction.ts

25 >

26 > export function globalTransaction(fn: (tx: ITransaction) => void) {

27 if (_globalTransaction) {

28 fn(_globalTransaction);

40 }

41 }

42 > /** @deprecated */ transaction.ts

43 >

44 export async function asyncTransaction(fn: (tx: ITransaction) => Promise<void>, getDebugName?: () => string): Promise<void> {

45 const tx = new TransactionImpl(fn, getDebugName);

50 }

51 }

52 > /** transaction.ts

53 > * Allows to chain transactions.

54 > */

55 >

56 > export function subtransaction(tx: ITransaction | undefined, fn: (tx: ITransaction) => void, getDebugName?: () => string): void {

57 if (!tx) {

58 transaction(fn, getDebugName);

60 fn(tx);

61 }

62 > } export class TransactionImpl implements ITransaction { transaction.ts

63 > private _updatingObservers: { observer: IObserver; observable: IObservable<any> }[] | null = [];

64 >

65 > constructor(public readonly _fn: Function, private readonly _getDebugName?: () => string) {

66 getLogger()?.handleBeginTransaction(this);

67 }

68 > transaction.ts

69 > public getDebugName(): string | undefined {

70 if (this._getDebugName) {

71 return this._getDebugName();

73 return getFunctionName(this._fn);

74 }

75 > transaction.ts

76 > public updateObserver(observer: IObserver, observable: IObservable<any>): void {

77 if (!this._updatingObservers) {

78 // This happens when a transaction is used in a callback or async function.

90 observer.beginUpdate(observable);

91 }

92 > transaction.ts

93 > public finish(): void {

94 const updatingObservers = this._updatingObservers;

95 if (!updatingObservers) {

106 getLogger()?.handleEndTransaction(this);

107 }

108 > transaction.ts

109 > public debugGetUpdatingObservers() {

110 return this._updatingObservers;

111 }

112 > } transaction.ts

113

src/vs/platform/product/common/product.ts 39 covered LOC · 4 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- product.ts

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 { env } from '../../../base/common/process.js';

7 > import { IProductConfiguration } from '../../../base/common/product.js';

8 > import { ISandboxConfiguration } from '../../../base/parts/sandbox/common/sandboxTypes.js';

9 >

10 > /**

11 > * @deprecated It is preferred that you use `IProductService` if you can. This

12 > * allows web embedders to override our defaults. But for things like `product.quality`,

13 > * the use is fine because that property is not overridable.

14 > */

15 > let product: IProductConfiguration;

16 >

17 > // Native sandbox environment

18 > const vscodeGlobal = (globalThis as { vscode?: { context?: { configuration(): ISandboxConfiguration | undefined } } }).vscode;

19 > if (typeof vscodeGlobal !== 'undefined' && typeof vscodeGlobal.context !== 'undefined') {

20 const configuration: ISandboxConfiguration | undefined = vscodeGlobal.context.configuration();

21 if (configuration) {

25 }

26 }

27 > // _VSCODE environment product.ts

28 > else if (globalThis._VSCODE_PRODUCT_JSON && globalThis._VSCODE_PACKAGE_JSON) {

29 > // Obtain values from product.json and package.json-data

30 > product = globalThis._VSCODE_PRODUCT_JSON as unknown as IProductConfiguration;

31 >

32 > // Running out of sources

33 > if (env['VSCODE_DEV']) {

34 Object.assign(product, {

35 nameShort: `${product.nameShort} Dev`,

39 });

40 }

41 > product.ts

42 > // Version is added during built time, but we still

43 > // want to have it running out of sources so we

44 > // read it from package.json only when we need it.

45 > if (!product.version) {

46 > const pkg = globalThis._VSCODE_PACKAGE_JSON as { version: string };

47 >

48 > Object.assign(product, {

49 > version: pkg.version

50 > });

51 > }

52 }

53

90 }

91 }

92 > product.ts

93 > export default product;

src/vs/base/common/observableInternal/observables/observableSignalFromEvent.ts 38 covered LOC · 8 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- observableSignalFromEvent.ts

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 { IObservable } from '../base.js';

7 > import { transaction } from '../transaction.js';

8 > import { Event, IDisposable } from '../commonFacade/deps.js';

9 > import { DebugOwner, DebugNameData } from '../debugName.js';

10 > import { BaseObservable } from './baseObservable.js';

11 > import { DebugLocation } from '../debugLocation.js';

12 >

13 > export function observableSignalFromEvent(

14 owner: DebugOwner | string,

15 event: Event<any>,

18 return new FromEventObservableSignal(typeof owner === 'string' ? owner : new DebugNameData(owner, undefined, undefined), event, debugLocation);

19 }

20 > observableSignalFromEvent.ts

21 > class FromEventObservableSignal extends BaseObservable<void> {

22 > private subscription: IDisposable | undefined;

23 >

24 > public readonly debugName: string;

25 > constructor(

26 debugNameDataOrName: DebugNameData | string,

27 private readonly event: Event<any>,

33 : debugNameDataOrName.getDebugName(this) ?? 'Observable Signal From Event';

34 }

35 > observableSignalFromEvent.ts

36 > protected override onFirstObserverAdded(): void {

37 this.subscription = this.event(this.handleEvent);

38 }

39 > observableSignalFromEvent.ts

40 > private readonly handleEvent = () => {

41 > transaction( observableSignalFromEvent.ts

42 > (tx) => {

43 > for (const o of this._observers) {

44 > tx.updateObserver(o, this);

45 > o.handleChange(this, undefined);

46 > }

47 > },

48 > () => this.debugName

49 > );

50 > };

51 > observableSignalFromEvent.ts

52 > protected override onLastObserverRemoved(): void {

53 this.subscription!.dispose();

54 this.subscription = undefined;

55 }

56 > observableSignalFromEvent.ts

57 > public override get(): void {

58 // NO OP

59 }

60 > } observableSignalFromEvent.ts

src/vs/editor/common/services/model.ts 38 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- model.ts

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 { Event } from '../../../base/common/event.js';

7 > import { URI } from '../../../base/common/uri.js';

8 > import { ITextBufferFactory, ITextModel, ITextModelCreationOptions } from '../model.js';

9 > import { ILanguageSelection } from '../languages/language.js';

10 > import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';

11 > import { DocumentSemanticTokensProvider, DocumentRangeSemanticTokensProvider } from '../languages.js';

12 > import { TextModelEditSource } from '../textModelEditSource.js';

13 >

14 > export const IModelService = createDecorator<IModelService>('modelService');

15 >

16 > export type DocumentTokensProvider = DocumentSemanticTokensProvider | DocumentRangeSemanticTokensProvider;

17 >

18 > export interface IModelService {

19 > readonly _serviceBrand: undefined;

20 >

21 > createModel(value: string | ITextBufferFactory, languageSelection: ILanguageSelection | null, resource?: URI, isForSimpleWidget?: boolean): ITextModel;

22 >

23 > updateModel(model: ITextModel, value: string | ITextBufferFactory, reason?: TextModelEditSource): void;

24 >

25 > destroyModel(resource: URI): void;

26 >

27 > getModels(): ITextModel[];

28 >

29 > getCreationOptions(language: string, resource: URI, isForSimpleWidget: boolean): ITextModelCreationOptions;

30 >

31 > getModel(resource: URI): ITextModel | null;

32 >

33 > readonly onModelAdded: Event<ITextModel>;

34 >

35 > readonly onModelRemoved: Event<ITextModel>;

36 >

37 > readonly onModelLanguageChanged: Event<{ readonly model: ITextModel; readonly oldLanguageId: string }>;

38 > }

src/vs/base/common/observableInternal/observables/observableSignal.ts 37 covered LOC · 6 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- observableSignal.ts

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 { IObservableWithChange, ITransaction } from '../base.js';

7 > import { transaction } from '../transaction.js';

8 > import { DebugNameData } from '../debugName.js';

9 > import { BaseObservable } from './baseObservable.js';

10 > import { DebugLocation } from '../debugLocation.js';

11 >

12 > /**

13 > * Creates a signal that can be triggered to invalidate observers.

14 > * Signals don't have a value - when they are triggered they indicate a change.

15 > * However, signals can carry a delta that is passed to observers.

16 > */

17 > export function observableSignal<TDelta = void>(debugName: string): IObservableSignal<TDelta>;

18 > export function observableSignal<TDelta = void>(owner: object): IObservableSignal<TDelta>;

19 > export function observableSignal<TDelta = void>(debugNameOrOwner: string | object, debugLocation = DebugLocation.ofCaller()): IObservableSignal<TDelta> {

20 if (typeof debugNameOrOwner === 'string') {

21 return new ObservableSignal<TDelta>(debugNameOrOwner, undefined, debugLocation);

24 }

25 }

26 > observableSignal.ts

27 > export interface IObservableSignal<TChange> extends IObservableWithChange<void, TChange> {

28 > trigger(tx: ITransaction | undefined, change: TChange): void;

29 > }

30 >

31 > class ObservableSignal<TChange> extends BaseObservable<void, TChange> implements IObservableSignal<TChange> {

32 > public get debugName() {

33 > return new DebugNameData(this._owner, this._debugName, undefined).getDebugName(this) ?? 'Observable Signal';

34 > }

35 >

36 > public override toString(): string {

37 return this.debugName;

38 }

39 > observableSignal.ts

40 > constructor(

41 private readonly _debugName: string | undefined,

42 private readonly _owner: object | undefined,

45 super(debugLocation);

46 }

47 > observableSignal.ts

48 > public trigger(tx: ITransaction | undefined, change: TChange): void {

49 if (!tx) {

50 transaction(tx => {

59 }

60 }

61 > observableSignal.ts

62 > public override get(): void {

63 // NO OP

64 }

65 > } observableSignal.ts

src/vs/base/common/observableInternal/changeTracker.ts 35 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- changeTracker.ts

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 { BugIndicatingError } from './commonFacade/deps.js';

7 > import { IObservableWithChange, IReader } from './base.js';

8 >

9 > export interface IChangeTracker<TChangeSummary> {

10 > createChangeSummary(previousChangeSummary: TChangeSummary | undefined): TChangeSummary;

11 > handleChange(ctx: IChangeContext, change: TChangeSummary): boolean;

12 > beforeUpdate?(reader: IReader, change: TChangeSummary): void;

13 > }

14 >

15 > export interface IChangeContext {

16 > readonly changedObservable: IObservableWithChange<any, any>;

17 > readonly change: unknown;

18 >

19 > /**

20 > * Returns if the given observable caused the change.

21 > */

22 > didChange<T, TChange>(observable: IObservableWithChange<T, TChange>): this is { change: TChange };

23 > }

24 >

25 > /**

26 > * Subscribes to and records changes and the last value of the given observables.

27 > * Don't use the key "changes", as it is reserved for the changes array!

28 > */

29 > export function recordChanges<TObs extends Record<any, IObservableWithChange<any, any>>>(obs: TObs):

30 IChangeTracker<{ [TKey in keyof TObs]: ReturnType<TObs[TKey]['get']> }

31 & { changes: readonly ({ [TKey in keyof TObs]: { key: TKey; change: TObs[TKey]['TChange'] } }[keyof TObs])[] }> {

56 };

57 }

58 > changeTracker.ts

59 > /**

60 > * Subscribes to and records changes and the last value of the given observables.

61 > * Don't use the key "changes", as it is reserved for the changes array!

62 > */

63 > export function recordChangesLazy<TObs extends Record<any, IObservableWithChange<any, any>>>(getObs: () => TObs):

64 IChangeTracker<{ [TKey in keyof TObs]: ReturnType<TObs[TKey]['get']> }

65 & { changes: readonly ({ [TKey in keyof TObs]: { key: TKey; change: TObs[TKey]['TChange'] } }[keyof TObs])[] }> {

src/vs/base/common/observableInternal/map.ts 35 covered LOC · 14 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- map.ts

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 { IObservable, ITransaction } from '../observable.js';

7 > import { observableValueOpts } from './observables/observableValueOpts.js';

8 >

9 >

10 > export class ObservableMap<K, V> implements Map<K, V> {

11 private readonly _data = new Map<K, V>();

12

14

15 readonly observable: IObservable<Map<K, V>> = this._obs;

16 > map.ts

17 > get size(): number {

18 return this._data.size;

19 }

20 > map.ts

21 > has(key: K): boolean {

22 return this._data.has(key);

23 }

24 > map.ts

25 > get(key: K): V | undefined {

26 return this._data.get(key);

27 }

28 > map.ts

29 > set(key: K, value: V, tx?: ITransaction): this {

30 const hadKey = this._data.has(key);

31 const oldValue = this._data.get(key);

36 return this;

37 }

38 > map.ts

39 > delete(key: K, tx?: ITransaction): boolean {

40 const result = this._data.delete(key);

41 if (result) {

44 return result;

45 }

46 > map.ts

47 > clear(tx?: ITransaction): void {

48 if (this._data.size > 0) {

49 this._data.clear();

51 }

52 }

53 > map.ts

54 > forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: unknown): void {

55 this._data.forEach((value, key, _map) => {

56 callbackfn.call(thisArg, value, key, this);

57 });

58 }

59 > map.ts

60 > *entries(): MapIterator<[K, V]> {

61 yield* this._data.entries();

62 }

63 > map.ts

64 > *keys(): MapIterator<K> {

65 yield* this._data.keys();

66 }

67 > map.ts

68 > *values(): MapIterator<V> {

69 yield* this._data.values();

70 }

71 > map.ts

72 > [Symbol.iterator](): MapIterator<[K, V]> {

73 return this.entries();

74 }

75 > map.ts

76 > get [Symbol.toStringTag](): string {

77 return 'ObservableMap';

78 }

79 > } map.ts

src/vs/platform/instantiation/common/extensions.ts 35 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- extensions.ts

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 { SyncDescriptor } from './descriptors.js';

7 > import { BrandedService, ServiceIdentifier } from './instantiation.js';

8 >

9 > const _registry: [ServiceIdentifier<any>, SyncDescriptor<any>][] = [];

10 >

11 > export const enum InstantiationType {

12 > /**

13 > * Instantiate this service as soon as a consumer depends on it. _Note_ that this

14 > * is more costly as some upfront work is done that is likely not needed

15 > */

16 > Eager = 0,

17 >

18 > /**

19 > * Instantiate this service as soon as a consumer uses it. This is the _better_

20 > * way of registering a service.

21 > */

22 > Delayed = 1

23 > }

24 >

25 > export function registerSingleton<T, Services extends BrandedService[]>(id: ServiceIdentifier<T>, ctor: new (...services: Services) => T, supportsDelayedInstantiation: InstantiationType): void;

26 > export function registerSingleton<T, Services extends BrandedService[]>(id: ServiceIdentifier<T>, descriptor: SyncDescriptor<any>): void;

27 > export function registerSingleton<T, Services extends BrandedService[]>(id: ServiceIdentifier<T>, ctorOrDescriptor: { new(...services: Services): T } | SyncDescriptor<any>, supportsDelayedInstantiation?: boolean | InstantiationType): void {

28 > if (!(ctorOrDescriptor instanceof SyncDescriptor)) {

29 > ctorOrDescriptor = new SyncDescriptor<T>(ctorOrDescriptor as new (...args: unknown[]) => T, [], Boolean(supportsDelayedInstantiation));

30 > }

31 >

32 > _registry.push([id, ctorOrDescriptor]);

33 > }

34 >

35 > export function getSingletonServiceDescriptors(): [ServiceIdentifier<any>, SyncDescriptor<any>][] {

36 return _registry;

37 }

src/vs/base/common/marshallingIds.ts 33 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- marshallingIds.ts

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 > export const enum MarshalledId {

7 > Uri = 1,

8 > Regexp,

9 > ScmResource,

10 > ScmResourceGroup,

11 > ScmProvider,

12 > CommentController,

13 > CommentThread,

14 > CommentThreadInstance,

15 > CommentThreadReply,

16 > CommentNode,

17 > CommentThreadNode,

18 > TimelineActionContext,

19 > NotebookCellActionContext,

20 > NotebookActionContext,

21 > TerminalContext,

22 > TestItemContext,

23 > Date,

24 > TestMessageMenuArgs,

25 > ChatViewContext,

26 > LanguageModelToolResult,

27 > LanguageModelTextPart,

28 > LanguageModelThinkingPart,

29 > LanguageModelPromptTsxPart,

30 > LanguageModelDataPart,

31 > AgentSessionContext,

32 > ChatResponsePullRequestPart,

33 > }

src/vs/base/common/observableInternal/set.ts 32 covered LOC · 13 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- set.ts

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 { IObservable, ITransaction } from '../observable.js';

7 > import { observableValueOpts } from './observables/observableValueOpts.js';

8 >

9 > export class ObservableSet<T> implements Set<T> {

10

11 private readonly _data = new Set<T>();

14

15 readonly observable: IObservable<Set<T>> = this._obs;

16 > set.ts

17 > get size(): number {

18 return this._data.size;

19 }

20 > set.ts

21 > has(value: T): boolean {

22 return this._data.has(value);

23 }

24 > set.ts

25 > add(value: T, tx?: ITransaction): this {

26 const hadValue = this._data.has(value);

27 if (!hadValue) {

31 return this;

32 }

33 > set.ts

34 > delete(value: T, tx?: ITransaction): boolean {

35 const result = this._data.delete(value);

36 if (result) {

39 return result;

40 }

41 > set.ts

42 > clear(tx?: ITransaction): void {

43 if (this._data.size > 0) {

44 this._data.clear();

46 }

47 }

48 > set.ts

49 > forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: unknown): void {

50 this._data.forEach((value, value2, _set) => {

51 callbackfn.call(thisArg, value, value2, this);

52 });

53 }

54 > set.ts

55 > *entries(): SetIterator<[T, T]> {

56 for (const value of this._data) {

57 yield [value, value];

58 }

59 }

60 > set.ts

61 > *keys(): SetIterator<T> {

62 yield* this._data.keys();

63 }

64 > set.ts

65 > *values(): SetIterator<T> {

66 yield* this._data.values();

67 }

68 > set.ts

69 > [Symbol.iterator](): SetIterator<T> {

70 return this.values();

71 }

72 > set.ts

73 > get [Symbol.toStringTag](): string {

74 return 'ObservableSet';

75 }

76 > } set.ts

src/vs/base/common/severity.ts 32 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- severity.ts

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 * as strings from './strings.js';

7 >

8 > enum Severity {

9 > Ignore = 0,

10 > Info = 1,

11 > Warning = 2,

12 > Error = 3

13 > }

14 >

15 > namespace Severity {

16 >

17 > const _error = 'error';

18 > const _warning = 'warning';

19 > const _warn = 'warn';

20 > const _info = 'info';

21 > const _ignore = 'ignore';

22 >

23 > /**

24 > * Parses 'error', 'warning', 'warn', 'info' in call casings

25 > * and falls back to ignore.

26 > */

27 > export function fromValue(value: string): Severity {

28 if (!value) {

29 return Severity.Ignore;

43 return Severity.Ignore;

44 }

45 > severity.ts

46 > export function toString(severity: Severity): string {

47 switch (severity) {

48 case Severity.Error: return _error;

52 }

53 }

54 > } severity.ts

55 >

56 > export default Severity;

src/vs/base/common/errorMessage.ts 29 covered LOC · 6 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- errorMessage.ts

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 * as arrays from './arrays.js';

7 > import * as types from './types.js';

8 > import * as nls from '../../nls.js';

9 > import { IAction } from './actions.js';

10 >

11 function exceptionToErrorMessage(exception: any, verbose: boolean): string {

12 if (verbose && (exception.stack || exception.stacktrace)) {

16 return detectSystemErrorMessage(exception);

17 }

18 > errorMessage.ts

19 function stackToString(stack: string[] | string | undefined): string | undefined {

20 if (Array.isArray(stack)) {

24 return stack;

25 }

26 > errorMessage.ts

27 function detectSystemErrorMessage(exception: any): string {

28

39 return exception.message || nls.localize('error.defaultMessage', "An unknown error occurred. Please consult the log for more details.");

40 }

41 > errorMessage.ts

42 > /**

43 > * Tries to generate a human readable error message out of the error. If the verbose parameter

44 > * is set to true, the error message will include stacktrace details if provided.

45 > *

46 > * @returns A string containing the error message.

47 > */

48 > export function toErrorMessage(error: any = null, verbose: boolean = false): string {

49 if (!error) {

50 return nls.localize('error.defaultMessage', "An unknown error occurred. Please consult the log for more details.");

88 return nls.localize('error.defaultMessage', "An unknown error occurred. Please consult the log for more details.");

89 }

90 > errorMessage.ts

91 >

92 > export interface IErrorWithActions extends Error {

93 > actions: IAction[];

94 > }

95 >

96 > export function isErrorWithActions(obj: unknown): obj is IErrorWithActions {

97 const candidate = obj as IErrorWithActions | undefined;

98

99 return candidate instanceof Error && Array.isArray(candidate.actions);

100 }

101 > errorMessage.ts

102 > export function createErrorWithActions(messageOrError: string | Error, actions: IAction[]): IErrorWithActions {

103 let error: IErrorWithActions;

104 if (typeof messageOrError === 'string') {

src/vs/base/common/marshalling.ts 28 covered LOC · 4 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- marshalling.ts

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 { VSBuffer } from './buffer.js';

7 > import { URI, UriComponents } from './uri.js';

8 > import { MarshalledId } from './marshallingIds.js';

9 >

10 > export function stringify(obj: unknown): string {

11 return JSON.stringify(obj, replacer);

12 }

13 > marshalling.ts

14 > export function parse(text: string): any {

15 let data = JSON.parse(text);

16 data = revive(data);

17 return data;

18 }

19 > marshalling.ts

20 > export interface MarshalledObject {

21 > $mid: MarshalledId;

22 > }

23 >

24 function replacer(key: string, value: any): any {

25 // URI is done via toJSON-member

33 return value;

34 }

35 > marshalling.ts

36 >

37 > type Deserialize<T> = T extends UriComponents ? URI

38 > : T extends VSBuffer ? VSBuffer

39 > : T extends object

40 > ? Revived<T>

41 > : T;

42 >

43 > export type Revived<T> = { [K in keyof T]: Deserialize<T[K]> };

44 >

45 > export function revive<T = any>(obj: any, depth = 0): Revived<T> {

46 if (!obj || depth > 200) {

47 return obj;

src/vs/base/common/normalization.ts 27 covered LOC · 5 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- normalization.ts

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 { LRUCache } from './map.js';

7 >

8 > const nfcCache = new LRUCache<string, string>(10000); // bounded to 10000 elements

9 > export function normalizeNFC(str: string): string {

10 return normalize(str, 'NFC', nfcCache);

11 }

12 > normalization.ts

13 > const nfdCache = new LRUCache<string, string>(10000); // bounded to 10000 elements

14 > export function normalizeNFD(str: string): string {

15 return normalize(str, 'NFD', nfdCache);

16 }

17 > normalization.ts

18 > const nonAsciiCharactersPattern = /[^\u0000-\u0080]/;

19 function normalize(str: string, form: string, normalizedCache: LRUCache<string, string>): string {

20 if (!str) {

39 return res;

40 }

41 > normalization.ts

42 > /**

43 > * Attempts to normalize the string to Unicode base format (NFD -> remove accents -> lower case).

44 > * When original string contains accent characters directly, only lower casing will be performed.

45 > * This is done so as to keep the string length the same and not affect indices.

46 > *

47 > * @see https://stackoverflow.com/questions/990904/remove-accents-diacritics-in-a-string-in-javascript/37511463#37511463

48 > */

49 > export const tryNormalizeToBase: (str: string) => string = function () {

50 > const cache = new LRUCache<string, string>(10000); // bounded to 10000 elements

51 > const accentsRegex = /[\u0300-\u036f]/g;

52 > return function (str: string): string {

53 const cached = cache.get(str);

54 if (cached) {

61 return result;

62 };

63 > }(); normalization.ts

src/vs/base/common/observableInternal/experimental/utils.ts 26 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- utils.ts

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 { IObservable, IReader } from '../base.js';

7 > import { BugIndicatingError, DisposableStore } from '../commonFacade/deps.js';

8 > import { DebugOwner, getDebugName, DebugNameData } from '../debugName.js';

9 > import { observableFromEvent } from '../observables/observableFromEvent.js';

10 > import { autorunOpts } from '../reactions/autorun.js';

11 > import { derivedObservableWithCache } from '../utils/utils.js';

12 >

13 > /**

14 > * Creates an observable that has the latest changed value of the given observables.

15 > * Initially (and when not observed), it has the value of the last observable.

16 > * When observed and any of the observables change, it has the value of the last changed observable.

17 > * If multiple observables change in the same transaction, the last observable wins.

18 > */

19 > export function latestChangedValue<T extends IObservable<any>[]>(owner: DebugOwner, observables: T): IObservable<ReturnType<T[number]['get']>> {

20 if (observables.length === 0) {

21 throw new BugIndicatingError();

50 return result;

51 }

52 > utils.ts

53 > /**

54 > * Works like a derived.

55 > * However, if the value is not undefined, it is cached and will not be recomputed anymore.

56 > * In that case, the derived will unsubscribe from its dependencies.

57 > */

58 > export function derivedConstOnceDefined<T>(owner: DebugOwner, fn: (reader: IReader) => T): IObservable<T | undefined> {

59 return derivedObservableWithCache<T | undefined>(owner, (reader, lastValue) => lastValue ?? fn(reader));

60 }

src/vs/base/common/observableInternal/observables/constObservable.ts 26 covered LOC · 9 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- constObservable.ts

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 { IObservable, IObserver, IObservableWithChange } from '../base.js';

7 > import { ConvenientObservable } from './baseObservable.js';

8 >

9 > /**

10 > * Represents an efficient observable whose value never changes.

11 > */

12 >

13 > export function constObservable<T>(value: T): IObservable<T> {

14 return new ConstObservable(value);

15 }

16 > class ConstObservable<T> extends ConvenientObservable<T, void> { constObservable.ts

17 > constructor(private readonly value: T) {

18 super();

19 }

20 > constObservable.ts

21 > public override get debugName(): string {

22 return this.toString();

23 }

24 > constObservable.ts

25 > public get(): T {

26 return this.value;

27 }

28 > public addObserver(observer: IObserver): void { constObservable.ts

29 // NO OP

30 }

31 > public removeObserver(observer: IObserver): void { constObservable.ts

32 // NO OP

33 }

34 > constObservable.ts

35 > override log(): IObservableWithChange<T, void> {

36 return this;

37 }

38 > constObservable.ts

39 > override toString(): string {

40 return `Const: ${this.value}`;

41 }

42 > } constObservable.ts

src/vs/base/common/stopwatch.ts 25 covered LOC · 6 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- stopwatch.ts

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 > declare const globalThis: { performance: { now(): number } };

7 > const performanceNow = globalThis.performance.now.bind(globalThis.performance);

8 >

9 > export class StopWatch {

10 >

11 > private _startTime: number;

12 > private _stopTime: number;

13 >

14 > private readonly _now: () => number;

15 >

16 > public static create(highResolution?: boolean): StopWatch {

17 return new StopWatch(highResolution);

18 }

19 > stopwatch.ts

20 > constructor(highResolution?: boolean) {

21 this._now = highResolution === false ? Date.now : performanceNow;

22 this._startTime = this._now();

23 this._stopTime = -1;

24 }

25 > stopwatch.ts

26 > public stop(): void {

27 this._stopTime = this._now();

28 }

29 > stopwatch.ts

30 > public reset(): void {

31 this._startTime = this._now();

32 this._stopTime = -1;

33 }

34 > stopwatch.ts

35 > public elapsed(): number {

36 if (this._stopTime !== -1) {

37 return this._stopTime - this._startTime;

39 return this._now() - this._startTime;

40 }

41 > } stopwatch.ts

src/vs/base/common/uuid.ts 25 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- uuid.ts

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 >

7 > const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

8 >

9 > export function isUUID(value: string): boolean {

10 return _UUIDPattern.test(value);

11 }

12 > uuid.ts

13 > export const generateUuid = (function (): () => string {

14 >

15 > // use `randomUUID` if possible

16 > if (typeof crypto.randomUUID === 'function') {

17 > // see https://developer.mozilla.org/en-US/docs/Web/API/Window/crypto

18 > // > Although crypto is available on all windows, the returned Crypto object only has one

19 > // > usable feature in insecure contexts: the getRandomValues() method.

20 > // > In general, you should use this API only in secure contexts.

21 >

22 > return crypto.randomUUID.bind(crypto);

23 > }

24

25 // prep-work

63 return result;

64 };

65 > })(); uuid.ts

66 >

67 > /** Namespace should be 3 letters, e.g. `abc-<uuid>`. */

68 > export function prefixedUuid(namespace: string): string {

69 return `${namespace}-${generateUuid()}`;

70 }

src/vs/workbench/contrib/chat/common/tools/terminalToolIds.ts 25 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- terminalToolIds.ts

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 > /**

7 > * Terminal-related tool IDs shared between chat infrastructure and terminal

8 > * contrib. The canonical enum lives here so that `chat/common` can reference

9 > * the IDs without depending on `terminalContrib/`.

10 > *

11 > * `terminalContrib/chatAgentTools/browser/tools/toolIds.ts` re-exports this

12 > * enum so existing imports in that layer continue to work.

13 > */

14 > export const enum TerminalToolId {

15 > RunInTerminal = 'run_in_terminal',

16 > SendToTerminal = 'send_to_terminal',

17 > GetTerminalOutput = 'get_terminal_output',

18 > KillTerminal = 'kill_terminal',

19 > TerminalSelection = 'terminal_selection',

20 > TerminalLastCommand = 'terminal_last_command',

21 > ConfirmTerminalCommand = 'vscode_get_terminal_confirmation',

22 > CreateAndRunTask = 'create_and_run_task',

23 > GetTaskOutput = 'get_task_output',

24 > RunTask = 'run_task',

25 > }

src/vs/base/common/codiconsUtil.ts 24 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- codiconsUtil.ts

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 > import { ThemeIcon } from './themables.js';

6 > import { isString } from './types.js';

7 >

8 >

9 > const _codiconFontCharacters: { [id: string]: number } = Object.create(null);

10 >

11 > export function register(id: string, fontCharacter: number | string): ThemeIcon {

12 > if (isString(fontCharacter)) {

13 > const val = _codiconFontCharacters[fontCharacter];

14 > if (val === undefined) {

15 throw new Error(`${id} references an unknown codicon: ${fontCharacter}`);

16 }

17 > fontCharacter = val; codiconsUtil.ts

18 > }

19 > _codiconFontCharacters[id] = fontCharacter;

20 > return { id };

21 > }

22 >

23 > /**

24 > * Only to be used by the iconRegistry.

25 > */

26 > export function getCodiconFontCharacters(): { [id: string]: number } {

27 return _codiconFontCharacters;

28 }

src/vs/base/common/observableInternal/logging/debugger/utils.ts 24 covered LOC · 8 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- utils.ts

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 { IDisposable } from '../../../lifecycle.js';

7 >

8 > export class Debouncer implements IDisposable {

9 private _timeout: Timeout | undefined = undefined;

10 > utils.ts

11 > public debounce(fn: () => void, timeoutMs: number): void {

12 if (this._timeout !== undefined) {

13 clearTimeout(this._timeout);

18 }, timeoutMs);

19 }

20 > utils.ts

21 > dispose(): void {

22 if (this._timeout !== undefined) {

23 clearTimeout(this._timeout);

24 }

25 }

26 > } utils.ts

27 >

28 > export class Throttler implements IDisposable {

29 private _timeout: Timeout | undefined = undefined;

30 > utils.ts

31 > public throttle(fn: () => void, timeoutMs: number): void {

32 if (this._timeout === undefined) {

33 this._timeout = setTimeout(() => {

37 }

38 }

39 > utils.ts

40 > dispose(): void {

41 if (this._timeout !== undefined) {

42 clearTimeout(this._timeout);

43 }

44 }

45 > } utils.ts

46 >

47 > export function deepAssign<T>(target: T, source: T): void {

48 for (const key in source) {

49 if (!!target[key] && typeof target[key] === 'object' && !!source[key] && typeof source[key] === 'object') {

54 }

55 }

56 > utils.ts

57 > export function deepAssignDeleteNulls<T>(target: T, source: T): void {

58 for (const key in source) {

59 if (source[key] === null) {

src/vs/base/common/observableInternal/utils/utilsCancellation.ts 24 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- utilsCancellation.ts

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 { IReader, IObservable } from '../base.js';

7 > import { DebugOwner, DebugNameData } from '../debugName.js';

8 > import { CancellationError, CancellationToken, CancellationTokenSource } from '../commonFacade/cancellation.js';

9 > import { strictEquals } from '../commonFacade/deps.js';

10 > import { autorun } from '../reactions/autorun.js';

11 > import { Derived } from '../observables/derivedImpl.js';

12 > import { DebugLocation } from '../debugLocation.js';

13 >

14 > /**

15 > * Resolves the promise when the observables state matches the predicate.

16 > */

17 > export function waitForState<T>(observable: IObservable<T | null | undefined>): Promise<T>;

18 > export function waitForState<T, TState extends T>(observable: IObservable<T>, predicate: (state: T) => state is TState, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<TState>;

19 > export function waitForState<T>(observable: IObservable<T>, predicate: (state: T) => boolean, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<T>;

20 > export function waitForState<T>(observable: IObservable<T>, predicate?: (state: T) => boolean, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<T> {

21 if (!predicate) {

22 predicate = state => state !== null && state !== undefined;

69 });

70 }

71 > utilsCancellation.ts

72 > export function derivedWithCancellationToken<T>(computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;

73 > export function derivedWithCancellationToken<T>(owner: object, computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;

74 > export function derivedWithCancellationToken<T>(computeFnOrOwner: ((reader: IReader, cancellationToken: CancellationToken) => T) | object, computeFnOrUndefined?: ((reader: IReader, cancellationToken: CancellationToken) => T)): IObservable<T> {

75 let computeFn: (reader: IReader, store: CancellationToken) => T;

76 let owner: DebugOwner;

src/vs/platform/instantiation/common/descriptors.ts 21 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- descriptors.ts

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 > export class SyncDescriptor<T> {

7 >

8 > readonly ctor: any;

9 > readonly staticArguments: unknown[];

10 > readonly supportsDelayedInstantiation: boolean;

11 >

12 > constructor(ctor: new (...args: any[]) => T, staticArguments: unknown[] = [], supportsDelayedInstantiation: boolean = false) {

13 > this.ctor = ctor; descriptors.ts

14 > this.staticArguments = staticArguments;

15 > this.supportsDelayedInstantiation = supportsDelayedInstantiation;

16 > }

17 > } descriptors.ts

18 >

19 > export interface SyncDescriptor0<T> {

20 > readonly ctor: new () => T;

21 > }

src/vs/base/common/observableInternal/utils/valueWithChangeEvent.ts 19 covered LOC · 4 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- valueWithChangeEvent.ts

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 { IObservable } from '../base.js';

7 > import { Event, IValueWithChangeEvent } from '../commonFacade/deps.js';

8 > import { DebugOwner } from '../debugName.js';

9 > import { observableFromEvent } from '../observables/observableFromEvent.js';

10 >

11 > export class ValueWithChangeEventFromObservable<T> implements IValueWithChangeEvent<T> {

12 > constructor(public readonly observable: IObservable<T>) {

13 }

14 > valueWithChangeEvent.ts

15 > get onDidChange(): Event<void> {

16 return Event.fromObservableLight(this.observable);

17 }

18 > valueWithChangeEvent.ts

19 > get value(): T {

20 return this.observable.get();

21 }

22 > } valueWithChangeEvent.ts

23 >

24 > export function observableFromValueWithChangeEvent<T>(owner: DebugOwner, value: IValueWithChangeEvent<T>): IObservable<T> {

25 if (value instanceof ValueWithChangeEventFromObservable) {

26 return value.observable;

src/vs/workbench/contrib/chat/common/chatSessionTypePreference.ts 19 covered LOC · 5 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- chatSessionTypePreference.ts

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 { IStorageService, StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';

7 >

8 > export const CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY = 'chat.userSelectedSessionType';

9 > const CHAT_PREFERRED_COPILOT_HARNESS_STORAGE_KEY = 'chat.preferredCopilotHarness';

10 >

11 > export function getRememberedSessionType(storageService: IStorageService): string | undefined {

12 return storageService.get(CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY, StorageScope.PROFILE);

13 }

14 > chatSessionTypePreference.ts

15 > export function storeUserSelectedSessionType(storageService: IStorageService, sessionType: string): void {

16 storageService.store(CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY, sessionType, StorageScope.PROFILE, StorageTarget.MACHINE);

17 }

18 > chatSessionTypePreference.ts

19 > export function clearUserSelectedSessionType(storageService: IStorageService): void {

20 storageService.remove(CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY, StorageScope.PROFILE);

21 }

22 > chatSessionTypePreference.ts

23 > export function hasPreferredCopilotHarness(storageService: IStorageService): boolean {

24 return storageService.getBoolean(CHAT_PREFERRED_COPILOT_HARNESS_STORAGE_KEY, StorageScope.PROFILE, false);

25 }

26 > chatSessionTypePreference.ts

27 > export function markPreferredCopilotHarness(storageService: IStorageService): void {

28 storageService.store(CHAT_PREFERRED_COPILOT_HARNESS_STORAGE_KEY, true, StorageScope.PROFILE, StorageTarget.MACHINE);

29 }

src/vs/platform/workspace/common/virtualWorkspace.ts 18 covered LOC · 5 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- virtualWorkspace.ts

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 { Schemas } from '../../../base/common/network.js';

7 > import { URI } from '../../../base/common/uri.js';

8 > import { IWorkspace } from './workspace.js';

9 >

10 > export function isVirtualResource(resource: URI) {

11 return resource.scheme !== Schemas.file && resource.scheme !== Schemas.vscodeRemote;

12 }

13 > virtualWorkspace.ts

14 > export function getVirtualWorkspaceLocation(workspace: IWorkspace): { scheme: string; authority: string } | undefined {

15 if (workspace.folders.length) {

16 return workspace.folders.every(f => isVirtualResource(f.uri)) ? workspace.folders[0].uri : undefined;

20 return undefined;

21 }

22 > virtualWorkspace.ts

23 > export function getVirtualWorkspaceScheme(workspace: IWorkspace): string | undefined {

24 return getVirtualWorkspaceLocation(workspace)?.scheme;

25 }

26 > virtualWorkspace.ts

27 > export function getVirtualWorkspaceAuthority(workspace: IWorkspace): string | undefined {

28 return getVirtualWorkspaceLocation(workspace)?.authority;

29 }

30 > virtualWorkspace.ts

31 > export function isVirtualWorkspace(workspace: IWorkspace): boolean {

32 return getVirtualWorkspaceLocation(workspace) !== undefined;

33 }

src/vs/base/common/observableInternal/logging/debugger/debuggerRpc.ts 17 covered LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- debuggerRpc.ts

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 { ChannelFactory, IChannelHandler, API, SimpleTypedRpcConnection, MakeSideAsync } from './rpc.js';

7 >

8 > export function registerDebugChannel<T extends { channelId: string } & API>(

9 channelId: T['channelId'],

10 createClient: () => T['client'],

43 });

44 }

45 > debuggerRpc.ts

46 > interface GlobalObj {

47 > $$debugValueEditor_debugChannels: Record<string, (host: IHost) => { handleRequest: (data: unknown) => unknown }>;

48 > }

49 >

50 > interface IHost {

51 > sendNotification: (data: unknown) => void;

52 > }

53 >

54 function createChannelFactoryFromDebugChannel(host: IHost): { channel: ChannelFactory; handler: { handleRequest: (data: unknown) => unknown } } {

55 let h: IChannelHandler | undefined;

src/vs/base/common/observableInternal/utils/runOnChange.ts 17 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- runOnChange.ts

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 { IObservableWithChange } from '../base.js';

7 > import { CancellationToken, cancelOnDispose } from '../commonFacade/cancellation.js';

8 > import { DisposableStore, IDisposable } from '../commonFacade/deps.js';

9 > import { autorunWithStoreHandleChanges } from '../reactions/autorun.js';

10 >

11 > export type RemoveUndefined<T> = T extends undefined ? never : T;

12 >

13 > export function runOnChange<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[]) => void): IDisposable {

14 let _previousValue: T | undefined;

15 let _firstRun = true;

42 });

43 }

44 > runOnChange.ts

45 > export function runOnChangeWithStore<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], store: DisposableStore) => void): IDisposable {

46 const store = new DisposableStore();

47 const disposable = runOnChange(observable, (value, previousValue: T, deltas) => {

56 };

57 }

58 > runOnChange.ts

59 > export function runOnChangeWithCancellationToken<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], token: CancellationToken) => Promise<void>): IDisposable {

60 return runOnChangeWithStore(observable, (value, previousValue, deltas, store) => {

61 cb(value, previousValue, deltas, cancelOnDispose(store));

src/vs/platform/product/common/productService.ts 17 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- productService.ts

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 { IProductConfiguration } from '../../../base/common/product.js';

7 > import { createDecorator } from '../../instantiation/common/instantiation.js';

8 >

9 > export const IProductService = createDecorator<IProductService>('productService');

10 >

11 > export interface IProductService extends Readonly<IProductConfiguration> {

12 >

13 > readonly _serviceBrand: undefined;

14 >

15 > }

16 >

17 > export const productSchemaId = 'vscode://schemas/vscode-product';

src/vs/platform/telemetry/common/commonProperties.ts 14 covered LOC · 3 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- commonProperties.ts

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 { isLinuxSnap, platform, Platform, PlatformToString } from '../../../base/common/platform.js';

7 > import { env, platform as nodePlatform } from '../../../base/common/process.js';

8 > import { generateUuid } from '../../../base/common/uuid.js';

9 > import { ICommonProperties } from './telemetry.js';

10 >

11 function getPlatformDetail(hostname: string): string | undefined {

12 if (platform === Platform.Linux && /^penguin(\.|$)/i.test(hostname)) {

16 return undefined;

17 }

18 > commonProperties.ts

19 > export function resolveCommonProperties(

20 release: string,

21 hostname: string,

97 return result;

98 }

99 > commonProperties.ts

100 > export function verifyMicrosoftInternalDomain(domainList: readonly string[]): boolean {

101 const userDnsDomain = env['USERDNSDOMAIN'];

102 if (!userDnsDomain) {

src/vs/base/common/observableInternal/observables/observableValueOpts.ts 13 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- observableValueOpts.ts

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 { ISettableObservable } from '../base.js';

7 > import { DebugNameData, IDebugNameData } from '../debugName.js';

8 > import { EqualityComparer, strictEquals } from '../commonFacade/deps.js';

9 > import { ObservableValue } from './observableValue.js';

10 > import { LazyObservableValue } from './lazyObservableValue.js';

11 > import { DebugLocation } from '../debugLocation.js';

12 >

13 > export function observableValueOpts<T, TChange = void>(

14 options: IDebugNameData & {

15 equalsFn?: EqualityComparer<T>;

src/vs/base/common/observableInternal/commonFacade/deps.ts 10 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- deps.ts

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 > export { assertFn } from '../../assert.js';

7 > export { type EqualityComparer, strictEquals } from '../../equals.js';

8 > export { BugIndicatingError, onBugIndicatingError, onUnexpectedError } from '../../errors.js';

9 > export { Event, type IValueWithChangeEvent } from '../../event.js';

10 > export { DisposableStore, type IDisposable, markAsDisposed, toDisposable, trackDisposable } from '../../lifecycle.js';

src/vs/base/common/functional.ts 9 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- functional.ts

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 > /**

7 > * Given a function, returns a function that is only calling that function once.

8 > */

9 > export function createSingleCallFunction<T extends Function>(this: unknown, fn: T, fnDidRunCallback?: () => void): T {

10 const _this = this;

11 let didCall = false;

src/vs/base/common/symbols.ts 9 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- symbols.ts

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 > /**

7 > * Can be passed into the Delayed to defer using a microtask

8 > * */

9 > export const MicrotaskDelay = Symbol('MicrotaskDelay');

src/vs/base/common/observable.ts 8 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- observable.ts

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 > // This is a facade for the observable implementation. Only import from here!

7 >

8 > export * from './observableInternal/index.js';

src/vs/base/common/observableInternal/commonFacade/cancellation.ts 7 covered LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- cancellation.ts

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 > export { CancellationError } from '../../errors.js';

7 > export { CancellationToken, CancellationTokenSource, cancelOnDispose } from '../../cancellation.js';