jiebi/CodeConvo huggingface dataset:
- `schemas`: Configures association of file names to schema URL or schemas and/or associations of schema URL to schema content. - `fileMatch`: an array of file names or paths (separated by `/`). `*` can be used as a wildcard. Exclusion patterns can also be defined and start with '!'. A file matches when there is at least one matching pattern and the last matching pattern is not an exclusion pattern. - `url`: The URL of the schema, optional when also a schema is provided. <del> - `schema`: The schema content. </del> <ins> - `schema`: The schema content, optional - `folderUri`: If provided, the association is only used if the document is located in the given folder (directly or indirectly) </ins> - `resultLimit`: The max number of color decorators and outline symbols to be computed (for performance reasons) - `jsonFoldingLimit`: The max number of folding ranges to be computed for json documents (for performance reasons) - `jsoncFoldingLimit`: The max number of folding ranges to be computed for jsonc documents (for performance reasons)
* A match succeeds when there is at least one pattern matching and last matching pattern does not start with '!'. */ fileMatch: string[]; <ins> /** * If provided, the association is only used if the validated document is located in the given folder (directly or indirectly) */ folderUri?: string; </ins> /* * The schema for the given URI. * If no schema is provided, the schema will be fetched with the schema request service (if available).
}, "main": "./out/node/jsonServerMain", "dependencies": { <ins> "@vscode/l10n": "^0.0.11", </ins> "jsonc-parser": "^3.2.0", "request-light": "^0.7.0", <del> "vscode-json-languageservice": "^5.1.4", </del> <ins> "vscode-json-languageservice": "^5.2.0", </ins> "vscode-languageserver": "^8.1.0-next.6", <del> "vscode-uri": "^3.0.7", "@vscode/l10n": "^0.0.11" </del> <ins> "vscode-uri": "^3.0.7" </ins> }, "devDependencies": { "@types/mocha": "^9.1.1",
uri = schema.schema.id || `vscode://schemas/custom/${index}`; } if (uri) { <del> languageSettings.schemas.push({ uri, fileMatch: schema.fileMatch, schema: schema.schema }); </del> <ins> languageSettings.schemas.push({ uri, fileMatch: schema.fileMatch, schema: schema.schema, folderUri: schema.folderUri }); </ins> } }); }
resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.7.0.tgz#885628bb2f8040c26401ebf258ec51c4ae98ac2a" integrity sha512-lMbBMrDoxgsyO+yB3sDcrDuX85yYt7sS8BfQd11jtbW/z5ZWgLZRcEGLsLoYw7I0WSUGQBs8CC8ScIxkTX1+6Q== <del> vscode-json-languageservice@^5.1.4: version "5.1.4" resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-5.1.4.tgz#cbdb447f281dcd107705e7fe8fbfc0b71db7610d" integrity sha512-ROZ1ezYQUbq9b/07xYpHtZSyyhoUk3oTTGVAEr6bU1DKr8ELaz9fsDoHno34tKtHj/Tf3deQqfjQNGKdbRuvTw== </del> <ins> vscode-json-languageservice@^5.2.0: version "5.2.0" resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-5.2.0.tgz#884b7f108be4310e3332167c3ea60ab17f03418c" integrity sha512-q8Rdhu2HEddRxvlhVqwh0cWmKK+OtyMB2xRhtqXEQ7cjb0iZ14madb90iJe9fCHPjoj9CGBrq6QzuOp8OE6XWg== </ins> dependencies: "@vscode/l10n" "^0.0.11" jsonc-parser "^3.2.0"
} }; <del> const collectSchemaSettings = (schemaSettings: JSONSchemaSettings[], folderUri?: Uri) => { for (const setting of schemaSettings) { const url = getSchemaId(setting, folderUri); if (url) { const schemaSetting: JSONSchemaSettings = { url, fileMatch: setting.fileMatch, folderUri: folderUri?.toString(false), schema: setting.schema }; schemas.push(schemaSetting); </del> <ins> const collectSchemaSettings = (schemaSettings: JSONSchemaSettings[] | undefined, folderUri?: Uri) => { if (schemaSettings) { for (const setting of schemaSettings) { const url = getSchemaId(setting, folderUri); if (url) { const schemaSetting: JSONSchemaSettings = { url, fileMatch: setting.fileMatch, folderUri: folderUri?.toString(false), schema: setting.schema }; schemas.push(schemaSetting); } </ins> } } }; <del> const globalSettings = workspace.getConfiguration('json', null).get<JSONSchemaSettings[]>('schemas'); if (Array.isArray(globalSettings)) { collectSchemaSettings(globalSettings); </del> <ins> const schemaConfigInfo = workspace.getConfiguration('json', null).inspect<JSONSchemaSettings[]>('schemas'); if (schemaConfigInfo) { if (workspace.workspaceFile) { collectSchemaSettings(schemaConfigInfo.workspaceValue, workspace.workspaceFile); } collectSchemaSettings(schemaConfigInfo.globalValue); </ins> } const folders = workspace.workspaceFolders; if (folders) { for (const folder of folders) { const schemaConfigInfo = workspace.getConfiguration('json', folder.uri).inspect<JSONSchemaSettings[]>('schemas'); <del> if (schemaConfigInfo && Array.isArray(schemaConfigInfo.workspaceFolderValue)) { collectSchemaSettings(schemaConfigInfo.workspaceFolderValue, folder.uri); } </del> <ins> collectSchemaSettings(schemaConfigInfo?.workspaceFolderValue, folder.uri); </ins> } } return settings;
} }; <del> const collectSchemaSettings = (schemaSettings: JSONSchemaSettings[] | undefined, folderUri?: Uri) => { </del> <ins> const collectSchemaSettings = (schemaSettings: JSONSchemaSettings[] | undefined, folderUri: Uri | undefined = undefined, settingsLocation = folderUri) => { </ins> if (schemaSettings) { for (const setting of schemaSettings) { <del> const url = getSchemaId(setting, folderUri); </del> <ins> const url = getSchemaId(setting, settingsLocation); </ins> if (url) { const schemaSetting: JSONSchemaSettings = { url, fileMatch: setting.fileMatch, folderUri: folderUri?.toString(false), schema: setting.schema }; schemas.push(schemaSetting);
} }; <ins> const folders = workspace.workspaceFolders; </ins> const schemaConfigInfo = workspace.getConfiguration('json', null).inspect<JSONSchemaSettings[]>('schemas'); if (schemaConfigInfo) { <del> if (workspace.workspaceFile) { collectSchemaSettings(schemaConfigInfo.workspaceValue, workspace.workspaceFile); </del> <ins> if (schemaConfigInfo.workspaceValue && workspace.workspaceFile && folders && folders.length) { const settingsLocation = Uri.joinPath(workspace.workspaceFile, '..'); for (const folder of folders) { collectSchemaSettings(schemaConfigInfo.workspaceValue, folder.uri, settingsLocation); } </ins> } collectSchemaSettings(schemaConfigInfo.globalValue); } <del> const folders = workspace.workspaceFolders; </del> if (folders) { for (const folder of folders) { const schemaConfigInfo = workspace.getConfiguration('json', folder.uri).inspect<JSONSchemaSettings[]>('schemas');
return settings; } <del> function getSchemaId(schema: JSONSchemaSettings, folderUri?: Uri): string | undefined { </del> <ins> function getSchemaId(schema: JSONSchemaSettings, settingsLocation?: Uri): string | undefined { </ins> let url = schema.url; if (!url) { if (schema.schema) { url = schema.schema.id || `vscode://schemas/custom/${encodeURIComponent(hash(schema.schema).toString(16))}`; } <del> } else if (folderUri && (url[0] === '.' || url[0] === '/')) { url = Uri.joinPath(folderUri, url).toString(false); </del> <ins> } else if (settingsLocation && (url[0] === '.' || url[0] === '/')) { url = Uri.joinPath(settingsLocation, url).toString(false); </ins> } return url; }
if (isWeb()) { // On web, treat absolute paths as pointing to standard lib files if (filepath.startsWith('/')) { <del> return vscode.Uri.joinPath(this.context.extensionUri, 'node_modules', 'typescript', 'lib', filepath.slice(1)); </del> <ins> return vscode.Uri.joinPath(this.context.extensionUri, 'dist', 'browser', 'typescript', filepath.slice(1)); </ins> } }
import { IWorkspaceTrustManagementService, IWorkspaceTrustRequestService, workspaceTrustToString } from 'vs/platform/workspace/common/workspaceTrust'; import { Extensions as WorkbenchExtensions, IWorkbenchContribution, IWorkbenchContributionsRegistry } from 'vs/workbench/common/contributions'; import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle'; <del> import { Codicon, registerCodicon } from 'vs/base/common/codicons'; </del> <ins> import { Codicon } from 'vs/base/common/codicons'; </ins> import { ThemeColor } from 'vs/workbench/api/common/extHostTypes'; import { IEditorService } from 'vs/workbench/services/editor/common/editorService'; import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
import { LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID } from 'vs/workbench/contrib/extensions/common/extensions'; const BANNER_RESTRICTED_MODE = 'workbench.banner.restrictedMode'; <del> const BANNER_VIRTUAL_WORKSPACE = 'workbench.banner.virtualWorkspace'; const BANNER_VIRTUAL_AND_RESTRICTED = 'workbench.banner.virtualAndRestricted'; </del> const STARTUP_PROMPT_SHOWN_KEY = 'workspace.trust.startupPrompt.shown'; const BANNER_RESTRICTED_MODE_DISMISSED_KEY = 'workbench.banner.restrictedMode.dismissed'; <del> const BANNER_VIRTUAL_WORKSPACE_DISMISSED_KEY = 'workbench.banner.virtualWorkspace.dismissed'; const infoIcon = registerCodicon('workspace-banner-warning-icon', Codicon.info); </del> /* * Trust Request via Service UX handler
this.statusbarService.updateEntryVisibility(this.entryId, false); } <del> private getBannerItem(isInVirtualWorkspace: boolean, restrictedMode: boolean): IBannerItem | undefined { </del> <ins> private getBannerItem(restrictedMode: boolean): IBannerItem | undefined { </ins> <del> const dismissedVirtual = this.storageService.getBoolean(BANNER_VIRTUAL_WORKSPACE_DISMISSED_KEY, StorageScope.WORKSPACE, false); </del> const dismissedRestricted = this.storageService.getBoolean(BANNER_RESTRICTED_MODE_DISMISSED_KEY, StorageScope.WORKSPACE, false); <del> // all important info has been dismissed if (dismissedVirtual && dismissedRestricted) { return undefined; } // don't show restricted mode only banner if (dismissedRestricted && !isInVirtualWorkspace) { </del> <ins> // info has been dismissed if (dismissedRestricted) { </ins> return undefined; } <del> // don't show virtual workspace only banner if (dismissedVirtual && !restrictedMode) { return undefined; } const choose = (virtual: any, restricted: any, virtualAndRestricted: any) => { return (isInVirtualWorkspace && !dismissedVirtual) && (restrictedMode && !dismissedRestricted) ? virtualAndRestricted : ((isInVirtualWorkspace && !dismissedVirtual) ? virtual : restricted); }; const id = choose(BANNER_VIRTUAL_WORKSPACE, BANNER_RESTRICTED_MODE, BANNER_VIRTUAL_AND_RESTRICTED); const icon = choose(infoIcon, shieldIcon, infoIcon); const [virtualAriaLabel, restrictedModeAriaLabel, virtualAndRestrictedModeAriaLabel] = this.getBannerItemAriaLabels(); const ariaLabel = choose(virtualAriaLabel, restrictedModeAriaLabel, virtualAndRestrictedModeAriaLabel); const [virtualMessage, restrictedModeMessage, virtualAndRestrictedModeMessage] = this.getBannerItemMessages(); const message = choose(virtualMessage, restrictedModeMessage, virtualAndRestrictedModeMessage); const actions = choose( [ { label: localize('virtualBannerLearnMore', "Learn More"), href: 'https://aka.ms/vscode-virtual-workspaces' } ], </del> <ins> const actions = </ins> [ { label: localize('restrictedModeBannerManage', "Manage"), <del> href: 'command:workbench.trust.manage' </del> <ins> href: 'command:' + MANAGE_TRUST_COMMAND_ID </ins> }, { label: localize('restrictedModeBannerLearnMore', "Learn More"), href: 'https://aka.ms/vscode-workspace-trust' } <del> ], [ { label: localize('virtualAndRestrictedModeBannerManage', "Manage Trust"), href: 'command:workbench.trust.manage' }, { label: localize('virtualBannerLearnMore', "Learn More"), href: 'https://aka.ms/vscode-virtual-workspaces' } ] ); </del> <ins> ]; </ins> return { <del> id, icon, ariaLabel, message, </del> <ins> id: BANNER_RESTRICTED_MODE, icon: shieldIcon, ariaLabel: this.getBannerItemAriaLabels(), message: this.getBannerItemMessages(), </ins> actions, onClose: () => { <del> if (isInVirtualWorkspace) { this.storageService.store(BANNER_VIRTUAL_WORKSPACE_DISMISSED_KEY, true, StorageScope.WORKSPACE, StorageTarget.MACHINE); } </del> if (restrictedMode) { this.storageService.store(BANNER_RESTRICTED_MODE_DISMISSED_KEY, true, StorageScope.WORKSPACE, StorageTarget.MACHINE); }
} private updateWorkbenchIndicators(trusted: boolean): void { <del> const isInVirtualWorkspace = isVirtualWorkspace(this.workspaceContextService.getWorkspace()); </del> const isEmptyWorkspace = this.workspaceContextService.getWorkbenchState() === WorkbenchState.EMPTY; <del> const bannerItem = this.getBannerItem(isInVirtualWorkspace, !trusted); </del> <ins> const bannerItem = this.getBannerItem(!trusted); </ins> if (!isEmptyWorkspace || this.showIndicatorsInEmptyWindow) { this.updateStatusbarEntry(trusted); if (bannerItem) { <del> if (!isInVirtualWorkspace) { if (!trusted) { this.bannerService.show(bannerItem); } else { this.bannerService.hide(BANNER_RESTRICTED_MODE); } } else { </del> <ins> if (!trusted) { </ins> this.bannerService.show(bannerItem); <ins> } else { this.bannerService.hide(BANNER_RESTRICTED_MODE); </ins> } } }
[ localize('untrustedTasks', "Tasks are disabled"), localize('untrustedDebugging', "Debugging is disabled"), <del> localize('untrustedExtensions', "[{0} extensions](command:{1}) are disabled or have limited functionality", numExtensions, LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID) </del> <ins> localize('untrustedExtensions', "[{0} extensions]({1}) are disabled or have limited functionality", numExtensions, `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`) </ins> ] : [ localize('untrustedTasks', "Tasks are disabled"), localize('untrustedDebugging', "Debugging is disabled"), <del> numSettings ? localize('untrustedSettings', "[{0} workspace settings](command:{1}) are not applied", numSettings, 'settings.filterUntrusted') : localize('no untrustedSettings', "Workspace settings requiring trust are not applied"), localize('untrustedExtensions', "[{0} extensions](command:{1}) are disabled or have limited functionality", numExtensions, LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID) </del> <ins> numSettings ? localize('untrustedSettings', "[{0} workspace settings]({1}) are not applied", numSettings, 'command:settings.filterUntrusted') : localize('no untrustedSettings', "Workspace settings requiring trust are not applied"), localize('untrustedExtensions', "[{0} extensions]({1}) are disabled or have limited functionality", numExtensions, `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`) </ins> ]; this.renderLimitationsListElement(untrustedContainer, untrustedContainerItems, xListIcon.classNamesArray);
import { disposableTimeout, Throttler } from 'vs/base/common/async'; import { CancellationTokenSource } from 'vs/base/common/cancellation'; import { Disposable, toDisposable } from 'vs/base/common/lifecycle'; <del> import { ICellVisibilityChangeEvent, NotebookVisibleCellObserver } from 'vs/workbench/contrib/notebook/browser/contrib/statusBar/notebookVisibleCellObserver'; </del> <ins> import { NotebookVisibleCellObserver } from 'vs/workbench/contrib/notebook/browser/contrib/statusBar/notebookVisibleCellObserver'; </ins> import { ICellViewModel, INotebookEditor, INotebookEditorContribution } from 'vs/workbench/contrib/notebook/browser/notebookBrowser'; import { registerNotebookContribution } from 'vs/workbench/contrib/notebook/browser/notebookEditorExtensions'; <del> import { NotebookViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/notebookViewModel'; </del> <ins> import { CellViewModel, NotebookViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/notebookViewModel'; </ins> import { INotebookCellStatusBarService } from 'vs/workbench/contrib/notebook/common/notebookCellStatusBarService'; import { INotebookCellStatusBarItemList } from 'vs/workbench/contrib/notebook/common/notebookCommon';
} private _updateEverything(): void { <del> this._visibleCells.forEach(cell => cell.dispose()); this._visibleCells.clear(); this._updateVisibleCells({ added: this._observer.visibleCells, removed: [] }); </del> <ins> const newCells = this._observer.visibleCells.filter(cell => !this._visibleCells.has(cell.handle)); const visibleCellHandles = new Set(this._observer.visibleCells.map(item => item.handle)); const currentCellHandles = Array.from(this._visibleCells.keys()); const removedCells = currentCellHandles.filter(handle => !visibleCellHandles.has(handle)); const itemsToUpdate = currentCellHandles.filter(handle => visibleCellHandles.has(handle)); this._updateVisibleCells({ added: newCells, removed: removedCells.map(handle => ({ handle })) }); itemsToUpdate.forEach(handle => this._visibleCells.get(handle)?.update()); </ins> } <del> private _updateVisibleCells(e: ICellVisibilityChangeEvent): void { </del> <ins> private _updateVisibleCells(e: { added: CellViewModel[]; removed: { handle: number }[]; }): void { </ins> const vm = this._notebookEditor.viewModel; if (!vm) { return;
import { IEditorContribution } from 'vs/editor/common/editorCommon'; import { ITextModel } from 'vs/editor/common/model'; import { IDialogService } from 'vs/platform/dialogs/common/dialogs'; <ins> import { basename } from 'vs/base/common/resources'; </ins> const ignoreUnusualLineTerminators = 'ignoreUnusualLineTerminators';
const result = await this._dialogService.confirm({ title: nls.localize('unusualLineTerminators.title', "Unusual Line Terminators"), message: nls.localize('unusualLineTerminators.message', "Detected unusual line terminators"), <del> detail: nls.localize('unusualLineTerminators.detail', "This file contains one or more unusual line terminator characters, like Line Separator (LS) or Paragraph Separator (PS).nnIt is recommended to remove them from the file. This can be configured via `editor.unusualLineTerminators`."), primaryButton: nls.localize('unusualLineTerminators.fix', "Fix this file"), secondaryButton: nls.localize('unusualLineTerminators.ignore', "Ignore problem for this file") </del> <ins> detail: nls.localize('unusualLineTerminators.detail', "The file '{0}' contains one or more unusual line terminator characters, like Line Separator (LS) or Paragraph Separator (PS).nnIt is recommended to remove them from the file. This can be configured via `editor.unusualLineTerminators`.", basename(model.uri)), primaryButton: nls.localize('unusualLineTerminators.fix', "Remove Unusual Line Terminators"), secondaryButton: nls.localize('unusualLineTerminators.ignore', "Ignore") </ins> }); if (!result.confirmed) {
import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments'; import * as extHostTypeConverter from 'vs/workbench/api/common/extHostTypeConverters'; import * as types from 'vs/workbench/api/common/extHostTypes'; <del> import { checkProposedApiEnabled } from 'vs/workbench/services/extensions/common/extensions'; </del> import type * as vscode from 'vscode'; import { ExtHostCommentsShape, IMainContext, MainContext, CommentThreadChanges, CommentChanges } from './extHost.protocol'; import { ExtHostCommands } from './extHostCommands';
private _state?: vscode.CommentThreadState; get state(): vscode.CommentThreadState { <del> checkProposedApiEnabled(this.extensionDescription, 'commentsResolvedState'); </del> return this._state!; } set state(newState: vscode.CommentThreadState) { <del> checkProposedApiEnabled(this.extensionDescription, 'commentsResolvedState'); </del> this._state = newState; this.modifications.state = newState; this._onDidUpdateCommentThread.fire();
export const allApiProposals = Object.freeze({ authSession: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.authSession.d.ts', codiconDecoration: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.codiconDecoration.d.ts', <del> commentsResolvedState: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.commentsResolvedState.d.ts', </del> contribCommentEditorActionsMenu: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.contribCommentEditorActionsMenu.d.ts', contribCommentPeekContext: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.contribCommentPeekContext.d.ts', contribCommentThreadAdditionalMenu: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.contribCommentThreadAdditionalMenu.d.ts',
<del> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ declare module 'vscode' { // https://github.com/microsoft/vscode/issues/127473 /** * The state of a comment thread. */ export enum CommentThreadState { Unresolved = 0, Resolved = 1 } export interface CommentThread { /** * The optional state of a comment thread, which may affect how the comment is displayed. */ state?: CommentThreadState; } } </del>
} else { this._onDidChangeViewWelcomeState.fire(); } <del> if (!this._terminalService.activeInstance?.shellLaunchConfig.extHostTerminalId) { // showPanel is already called with !preserveFocus // when extension host terminals are created this._terminalGroupService.showPanel(true); } </del> <ins> // we don't know here whether or not it should be focused, so // defer focusing the panel to the focus() call // to prevent overriding preserveFocus for extensions this._terminalGroupService.showPanel(false); </ins> if (hadTerminals) { this._terminalGroupService.activeGroup?.setVisible(visible); }
// Only focus the terminal if the activeElement has not changed since focus() was called // TODO hack if (document.activeElement === activeElement) { <del> this._focus(); </del> <ins> this._terminalGroupService.showPanel(true); </ins> } })); return; } <del> this._focus(); } private _focus() { this._terminalService.activeInstance?.focusWhenReady(); </del> <ins> this._terminalGroupService.showPanel(true); </ins> } override shouldShowWelcome(): boolean {
} // Run Extension Host as fork of current process <del> this._extensionHostProcess = fork(FileAccess.asFileUri('bootstrap-fork', require).fsPath, ['--type=extensionHost'], opts); </del> <ins> this._extensionHostProcess = fork(FileAccess.asFileUri('bootstrap-fork', require).fsPath, ['--type=extensionHost', '--skipWorkspaceStorageLock'], opts); </ins> // Catch all output coming from the extension host process type Output = { data: string, format: string[] };
import { realpath } from 'vs/base/node/extpath'; import { IHostUtils } from 'vs/workbench/api/common/extHostExtensionService'; import { RunOnceScheduler } from 'vs/base/common/async'; <ins> import { boolean } from 'vs/editor/common/config/editorOptions'; </ins> import 'vs/workbench/api/common/extHost.common.services'; import 'vs/workbench/api/node/extHost.node.services'; interface ParsedExtHostArgs { uriTransformerPath?: string; <ins> skipWorkspaceStorageLock?: boolean; </ins> useHostProxy?: string; }
// setup things patchProcess(!!initData.environment.extensionTestsLocationURI); // to support other test frameworks like Jasmin that use process.exit (https://github.com/microsoft/vscode/issues/37708) initData.environment.useHostProxy = args.useHostProxy !== undefined ? args.useHostProxy !== 'false' : undefined; <ins> initData.environment.skipWorkspaceStorageLock = boolean(args.skipWorkspaceStorageLock, false); </ins> // host abstraction const hostUtils = new class NodeHost implements IHostUtils {
const editorInput = InteractiveEditorInput.create(accessor.get(IInstantiationService), notebookUri, inputUri); historyService.clearHistory(notebookUri); <del> await editorService.openEditor(editorInput, editorOptions, group); </del> <ins> await editorService.openEditor(editorInput, { ...editorOptions, pinned: true }, group); </ins> // Extensions must retain references to these URIs to manipulate the interactive editor return { notebookUri, inputUri }; }
if (args.verbose) { fancyLog(`${ansiColors.magenta('BuiltIn extensions')}: ${dedupedBuiltInExtensions.map(e => path.basename(e.extensionPath)).join(', ')}`); <del> fancyLog(`${ansiColors.magenta('Additional extensions')}: ${additionalBuiltinExtensions.map(e => path.basename(e.extensionLocation.path)).join(', ') || 'None'}`); </del> <ins> fancyLog(`${ansiColors.magenta('Additional extensions')}: ${additionalBuiltinExtensions.map(e => path.basename(e.path)).join(', ') || 'None'}`); </ins> } const secondaryHost = (