@codingame/monaco-vscode-walkthrough-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedList.d.ts

@@ -0,0 +1,42 @@
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { Dimension } from "vscode/vscode/vs/base/browser/dom";
+import { ContextKeyExpression } from "vscode/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+type GettingStartedIndexListOptions<T> = {
+    title: string;
+    klass: string;
+    limit: number;
+    empty?: HTMLElement | undefined;
+    more?: HTMLElement | undefined;
+    footer?: HTMLElement | undefined;
+    renderElement: (item: T) => HTMLElement;
+    rankElement?: (item: T) => number | null;
+    contextService: IContextKeyService;
+};
+export declare class GettingStartedIndexList<T extends {
+    id: string;
+    when?: ContextKeyExpression;
+}> extends Disposable {
+    private options;
+    private readonly _onDidChangeEntries;
+    private readonly onDidChangeEntries;
+    private domElement;
+    private list;
+    private scrollbar;
+    private entries;
+    private lastRendered;
+    itemCount: number;
+    private isDisposed;
+    private contextService;
+    private contextKeysToWatch;
+    constructor(options: GettingStartedIndexListOptions<T>);
+    getDomElement(): HTMLElement;
+    layout(size: Dimension): void;
+    onDidChange(listener: () => void): void;
+    register(d: IDisposable): void;
+    dispose(): void;
+    setLimit(limit: number): void;
+    rerender(): void;
+    setEntries(entries: undefined | T[]): void;
+}
+export {};

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedList.js

@@ -1,3 +1,4 @@
+
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { $ } from 'vscode/vscode/vs/base/browser/dom';
 import { DomScrollableElement } from 'vscode/vscode/vs/base/browser/ui/scrollbar/scrollableElement';

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService._contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService._contribution.js

@@ -1,7 +1,9 @@
+
 import { localize2 } from 'vscode/vscode/vs/nls';
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
-import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { Memento } from '@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common/vscode/vs/workbench/common/memento';
 import { hiddenEntriesConfigurationKey, walkthroughMetadataConfigurationKey } from './gettingStartedService.js';
 import { IWalkthroughsService } from 'vscode/vscode/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService.service';
 
@@ -9,12 +11,12 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'resetGettingStartedProgress',
-            category: ( localize2(7333, "Developer")),
-            title: ( localize2(7334, "Reset Welcome Page Walkthrough Progress")),
+            category: ( localize2(10818, "Developer")),
+            title: ( localize2(10819, "Reset Welcome Page Walkthrough Progress")),
             f1: true,
             metadata: {
                 description: ( localize2(
-                    7335,
+                    10820,
                     'Reset the progress of all Walkthrough steps on the Welcome Page to make them appear as if they are being viewed for the first time, providing a fresh start to the getting started experience.'
                 )),
             }
@@ -23,10 +25,10 @@ registerAction2(class extends Action2 {
     run(accessor) {
         const gettingStartedService = accessor.get(IWalkthroughsService);
         const storageService = accessor.get(IStorageService);
-        storageService.store(hiddenEntriesConfigurationKey, JSON.stringify([]), 0 , 0 );
-        storageService.store(walkthroughMetadataConfigurationKey, JSON.stringify([]), 0 , 0 );
-        const memento = ( (new Memento('gettingStartedService', accessor.get(IStorageService))));
-        const record = memento.getMemento(0 , 0 );
+        storageService.store(hiddenEntriesConfigurationKey, JSON.stringify([]), StorageScope.PROFILE, StorageTarget.USER);
+        storageService.store(walkthroughMetadataConfigurationKey, JSON.stringify([]), StorageScope.PROFILE, StorageTarget.USER);
+        const memento = ( new Memento('gettingStartedService', accessor.get(IStorageService)));
+        const record = memento.getMemento(StorageScope.PROFILE, StorageTarget.USER);
         for (const key in record) {
             if (Object.prototype.hasOwnProperty.call(record, key)) {
                 try {

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService.d.ts

@@ -0,0 +1,147 @@
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { ICommandService } from "vscode/vscode/vs/platform/commands/common/commands.service";
+import { ContextKeyExpression, RawContextKey } from "vscode/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IUserDataSyncEnablementService } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync.service";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IExtensionManagementService } from "vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { ThemeIcon } from "vscode/vscode/vs/base/common/themables";
+import { IWorkbenchAssignmentService } from "vscode/vscode/vs/workbench/services/assignment/common/assignmentService.service";
+import { IHostService } from "vscode/vscode/vs/workbench/services/host/browser/host.service";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { LinkedText } from "vscode/vscode/vs/base/common/linkedText";
+import { IViewsService } from "vscode/vscode/vs/workbench/services/views/common/viewsService.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { IProductService } from "vscode/vscode/vs/platform/product/common/productService.service";
+import { IWalkthroughsService } from "vscode/vscode/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService.service";
+export declare const HasMultipleNewFileEntries: RawContextKey<boolean>;
+export declare const hiddenEntriesConfigurationKey = "workbench.welcomePage.hiddenCategories";
+export declare const walkthroughMetadataConfigurationKey = "workbench.welcomePage.walkthroughMetadata";
+export type WalkthroughMetaDataType = Map<string, {
+    firstSeen: number;
+    stepIDs: string[];
+    manaullyOpened: boolean;
+}>;
+export interface IWalkthrough {
+    id: string;
+    title: string;
+    description: string;
+    order: number;
+    source: string;
+    isFeatured: boolean;
+    next?: string;
+    when: ContextKeyExpression;
+    steps: IWalkthroughStep[];
+    icon: {
+        type: "icon";
+        icon: ThemeIcon;
+    } | {
+        type: "image";
+        path: string;
+    };
+    walkthroughPageTitle: string;
+}
+export type IWalkthroughLoose = Omit<IWalkthrough, "steps"> & {
+    steps: (Omit<IWalkthroughStep, "description"> & {
+        description: string;
+    })[];
+};
+export interface IResolvedWalkthrough extends IWalkthrough {
+    steps: IResolvedWalkthroughStep[];
+    newItems: boolean;
+    recencyBonus: number;
+    newEntry: boolean;
+}
+export interface IWalkthroughStep {
+    id: string;
+    title: string;
+    description: LinkedText[];
+    category: string;
+    when: ContextKeyExpression;
+    order: number;
+    completionEvents: string[];
+    media: {
+        type: "image";
+        path: {
+            hcDark: URI;
+            hcLight: URI;
+            light: URI;
+            dark: URI;
+        };
+        altText: string;
+    } | {
+        type: "svg";
+        path: URI;
+        altText: string;
+    } | {
+        type: "markdown";
+        path: URI;
+        base: URI;
+        root: URI;
+    };
+}
+type StepProgress = {
+    done: boolean;
+};
+export interface IResolvedWalkthroughStep extends IWalkthroughStep, StepProgress {
+}
+export declare class WalkthroughsService extends Disposable implements IWalkthroughsService {
+    private readonly storageService;
+    private readonly commandService;
+    private readonly instantiationService;
+    private readonly workspaceContextService;
+    private readonly contextService;
+    private readonly userDataSyncEnablementService;
+    private readonly configurationService;
+    private readonly extensionManagementService;
+    private readonly hostService;
+    private readonly viewsService;
+    private readonly telemetryService;
+    private readonly tasExperimentService;
+    private readonly productService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidAddWalkthrough;
+    readonly onDidAddWalkthrough: Event<IResolvedWalkthrough>;
+    private readonly _onDidRemoveWalkthrough;
+    readonly onDidRemoveWalkthrough: Event<string>;
+    private readonly _onDidChangeWalkthrough;
+    readonly onDidChangeWalkthrough: Event<IResolvedWalkthrough>;
+    private readonly _onDidProgressStep;
+    readonly onDidProgressStep: Event<IResolvedWalkthroughStep>;
+    private memento;
+    private stepProgress;
+    private sessionEvents;
+    private completionListeners;
+    private gettingStartedContributions;
+    private steps;
+    private sessionInstalledExtensions;
+    private categoryVisibilityContextKeys;
+    private stepCompletionContextKeyExpressions;
+    private stepCompletionContextKeys;
+    private metadata;
+    constructor(storageService: IStorageService, commandService: ICommandService, instantiationService: IInstantiationService, workspaceContextService: IWorkspaceContextService, contextService: IContextKeyService, userDataSyncEnablementService: IUserDataSyncEnablementService, configurationService: IConfigurationService, extensionManagementService: IExtensionManagementService, hostService: IHostService, viewsService: IViewsService, telemetryService: ITelemetryService, tasExperimentService: IWorkbenchAssignmentService, productService: IProductService);
+    private registerWalkthroughs;
+    private initCompletionEventListeners;
+    markWalkthroughOpened(id: string): void;
+    private registerExtensionWalkthroughContributions;
+    private unregisterExtensionWalkthroughContributions;
+    getWalkthrough(id: string): IResolvedWalkthrough;
+    getWalkthroughs(): IResolvedWalkthrough[];
+    private resolveWalkthrough;
+    private getStepProgress;
+    progressStep(id: string): void;
+    deprogressStep(id: string): void;
+    progressByEvent(event: string): void;
+    registerWalkthrough(walkthoughDescriptor: IWalkthroughLoose): void;
+    _registerWalkthrough(walkthroughDescriptor: IWalkthrough): void;
+    private registerDoneListeners;
+    private registerCompletionListener;
+    private getStep;
+}
+export declare const parseDescription: (desc: string) => LinkedText[];
+export declare const convertInternalMediaPathToFileURI: (path: string) => URI;
+export {};

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService.js

@@ -1,8 +1,10 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
-import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { Memento } from '@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common/vscode/vs/workbench/common/memento';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 import { RawContextKey, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
@@ -20,6 +22,7 @@ import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/h
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { parseLinkedText } from 'vscode/vscode/vs/base/common/linkedText';
 import { walkthroughsExtensionPoint } from './gettingStartedExtensionPoint.js';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { dirname } from 'vscode/vscode/vs/base/common/path';
 import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
 import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
@@ -31,10 +34,10 @@ import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellati
 import { getDefaultIconPath } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
 
-const HasMultipleNewFileEntries = ( (new RawContextKey('hasMultipleNewFileEntries', false)));
+const HasMultipleNewFileEntries = ( new RawContextKey('hasMultipleNewFileEntries', false));
 const hiddenEntriesConfigurationKey = 'workbench.welcomePage.hiddenCategories';
 const walkthroughMetadataConfigurationKey = 'workbench.welcomePage.walkthroughMetadata';
-const BUILT_IN_SOURCE = ( localize(3121, "Built-In"));
+const BUILT_IN_SOURCE = ( localize(10821, "Built-In"));
 const DAYS = 24 * 60 * 60 * 1000;
 const NEW_WALKTHROUGH_TIME = 7 * DAYS;
 let WalkthroughsService = class WalkthroughsService extends Disposable {
@@ -53,27 +56,27 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
         this.telemetryService = telemetryService;
         this.tasExperimentService = tasExperimentService;
         this.productService = productService;
-        this._onDidAddWalkthrough = ( (new Emitter()));
+        this._onDidAddWalkthrough = ( new Emitter());
         this.onDidAddWalkthrough = this._onDidAddWalkthrough.event;
-        this._onDidRemoveWalkthrough = ( (new Emitter()));
+        this._onDidRemoveWalkthrough = ( new Emitter());
         this.onDidRemoveWalkthrough = this._onDidRemoveWalkthrough.event;
-        this._onDidChangeWalkthrough = ( (new Emitter()));
+        this._onDidChangeWalkthrough = ( new Emitter());
         this.onDidChangeWalkthrough = this._onDidChangeWalkthrough.event;
-        this._onDidProgressStep = ( (new Emitter()));
+        this._onDidProgressStep = ( new Emitter());
         this.onDidProgressStep = this._onDidProgressStep.event;
-        this.sessionEvents = ( (new Set()));
-        this.completionListeners = ( (new Map()));
-        this.gettingStartedContributions = ( (new Map()));
-        this.steps = ( (new Map()));
-        this.sessionInstalledExtensions = ( (new Set()));
-        this.categoryVisibilityContextKeys = ( (new Set()));
-        this.stepCompletionContextKeyExpressions = ( (new Set()));
-        this.stepCompletionContextKeys = ( (new Set()));
-        this.metadata = ( (new Map(
-            JSON.parse(this.storageService.get(walkthroughMetadataConfigurationKey, 0 , '[]'))
-        )));
-        this.memento = ( (new Memento('gettingStartedService', this.storageService)));
-        this.stepProgress = this.memento.getMemento(0 , 0 );
+        this.sessionEvents = ( new Set());
+        this.completionListeners = ( new Map());
+        this.gettingStartedContributions = ( new Map());
+        this.steps = ( new Map());
+        this.sessionInstalledExtensions = ( new Set());
+        this.categoryVisibilityContextKeys = ( new Set());
+        this.stepCompletionContextKeyExpressions = ( new Set());
+        this.stepCompletionContextKeys = ( new Set());
+        this.metadata = ( new Map(
+            JSON.parse(this.storageService.get(walkthroughMetadataConfigurationKey, StorageScope.PROFILE, '[]'))
+        ));
+        this.memento = ( new Memento('gettingStartedService', this.storageService));
+        this.stepProgress = this.memento.getMemento(StorageScope.PROFILE, StorageTarget.USER);
         this.initCompletionEventListeners();
         HasMultipleNewFileEntries.bindTo(this.contextService).set(false);
         this.registerWalkthroughs();
@@ -86,7 +89,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
                 order: walkthroughs.length - index,
                 source: BUILT_IN_SOURCE,
                 when: ContextKeyExpr.deserialize(category.when) ?? ContextKeyExpr.true(),
-                steps: ( (category.content.steps.map((step, index) => {
+                steps: ( category.content.steps.map((step, index) => {
                     return ({
                         ...step,
                         completionEvents: step.completionEvents ?? [],
@@ -109,11 +112,11 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
                                 : {
                                     type: 'markdown',
                                     path: convertInternalMediaPathToFileURI(step.media.path).with({ query: JSON.stringify({ moduleId: 'vs/workbench/contrib/welcomeGettingStarted/common/media/' + step.media.path }) }),
-                                    base: ( (FileAccess.asFileUri('vs/workbench/contrib/welcomeGettingStarted/common/media/'))),
-                                    root: ( (FileAccess.asFileUri('vs/workbench/contrib/welcomeGettingStarted/common/media/'))),
+                                    base: ( FileAccess.asFileUri('vs/workbench/contrib/welcomeGettingStarted/common/media/')),
+                                    root: ( FileAccess.asFileUri('vs/workbench/contrib/welcomeGettingStarted/common/media/')),
                                 }
                     });
-                })))
+                }))
             });
         });
         walkthroughsExtensionPoint.setHandler((_, { added, removed }) => {
@@ -125,9 +128,9 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
             installed.forEach(ext => this.progressByEvent(`extensionInstalled:${ext.identifier.id.toLowerCase()}`));
         });
         this._register(this.extensionManagementService.onDidInstallExtensions((result) => {
-            if (( (result.some(
-                e => ExtensionIdentifier.equals(this.productService.gitHubEntitlement?.extensionId, e.identifier.id) && !e?.context?.[EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]
-            )))) {
+            if (( result.some(
+                e => ExtensionIdentifier.equals(this.productService.defaultChatAgent?.extensionId, e.identifier.id) && !e?.context?.[EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]
+            ))) {
                 result.forEach(e => {
                     this.sessionInstalledExtensions.add(e.identifier.id.toLowerCase());
                     this.progressByEvent(`extensionInstalled:${e.identifier.id.toLowerCase()}`);
@@ -145,7 +148,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
         this._register(this.contextService.onDidChangeContext(event => {
             if (event.affectsSome(this.stepCompletionContextKeys)) {
                 this.stepCompletionContextKeyExpressions.forEach(expression => {
-                    if (event.affectsSome(( (new Set( (expression.keys()))))) && this.contextService.contextMatchesRules(expression)) {
+                    if (event.affectsSome(( new Set(( expression.keys())))) && this.contextService.contextMatchesRules(expression)) {
                         this.progressByEvent(`onContext:` + expression.serialize());
                     }
                 });
@@ -172,17 +175,17 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
         const walkthrough = this.gettingStartedContributions.get(id);
         const prior = this.metadata.get(id);
         if (prior && walkthrough) {
-            this.metadata.set(id, { ...prior, manaullyOpened: true, stepIDs: ( (walkthrough.steps.map(s => s.id))) });
+            this.metadata.set(id, { ...prior, manaullyOpened: true, stepIDs: ( walkthrough.steps.map(s => s.id)) });
         }
-        this.storageService.store(walkthroughMetadataConfigurationKey, JSON.stringify([...this.metadata.entries()]), 0 , 0 );
+        this.storageService.store(walkthroughMetadataConfigurationKey, JSON.stringify([...this.metadata.entries()]), StorageScope.PROFILE, StorageTarget.USER);
     }
     async registerExtensionWalkthroughContributions(extension) {
         const convertExtensionPathToFileURI = (path) => path.startsWith('https://')
-            ? ( (URI.parse(path, true)))
+            ? ( URI.parse(path, true))
             : FileAccess.uriToFileUri(joinPath(extension.extensionLocation, path));
         const convertExtensionRelativePathsToBrowserURIs = (path) => {
             const convertPath = (path) => path.startsWith('https://')
-                ? ( (URI.parse(path, true)))
+                ? ( URI.parse(path, true))
                 : FileAccess.uriToBrowserUri(joinPath(extension.extensionLocation, path));
             if (typeof path === 'string') {
                 const converted = convertPath(path);
@@ -206,13 +209,13 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
             const categoryID = extension.identifier.value + '#' + walkthrough.id;
             const isNewlyInstalled = !this.metadata.get(categoryID);
             if (isNewlyInstalled) {
-                this.metadata.set(categoryID, { firstSeen: +( (new Date())), stepIDs: walkthrough.steps?.map(s => s.id) ?? [], manaullyOpened: false });
+                this.metadata.set(categoryID, { firstSeen: +( new Date()), stepIDs: walkthrough.steps?.map(s => s.id) ?? [], manaullyOpened: false });
             }
             const override = await Promise.race([
                 this.tasExperimentService?.getTreatment(`gettingStarted.overrideCategory.${extension.identifier.value + '.' + walkthrough.id}.when`),
-                ( (new Promise(resolve => setTimeout(() => resolve(walkthrough.when), 5000))))
+                ( new Promise(resolve => setTimeout(() => resolve(walkthrough.when), 5000)))
             ]);
-            if (( (this.sessionInstalledExtensions.has(extension.identifier.value.toLowerCase())))
+            if (( this.sessionInstalledExtensions.has(extension.identifier.value.toLowerCase()))
                 && this.contextService.contextMatchesRules(ContextKeyExpr.deserialize(override ?? walkthrough.when) ?? ContextKeyExpr.true())) {
                 this.sessionInstalledExtensions.delete(extension.identifier.value.toLowerCase());
                 if (index < sectionToOpenIndex && isNewlyInstalled) {
@@ -220,7 +223,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
                     sectionToOpenIndex = index;
                 }
             }
-            const steps = ( ((walkthrough.steps ?? []).map((step, index) => {
+            const steps = ( (walkthrough.steps ?? []).map((step, index) => {
                 const description = parseDescription(step.description || '');
                 const fullyQualifiedID = extension.identifier.value + '#' + walkthrough.id + '#' + step.id;
                 let media;
@@ -250,7 +253,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
                     };
                 }
                 else {
-                    throw ( (new Error('Unknown walkthrough format detected for ' + fullyQualifiedID)));
+                    throw ( new Error('Unknown walkthrough format detected for ' + fullyQualifiedID));
                 }
                 return ({
                     description,
@@ -262,11 +265,11 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
                     category: categoryID,
                     order: index,
                 });
-            })));
+            }));
             let isFeatured = false;
             if (walkthrough.featuredFor) {
-                const folders = ( (this.workspaceContextService.getWorkspace().folders.map(f => f.uri)));
-                const token = ( (new CancellationTokenSource()));
+                const folders = ( this.workspaceContextService.getWorkspace().folders.map(f => f.uri));
+                const token = ( new CancellationTokenSource());
                 setTimeout(() => token.cancel(), 2000);
                 isFeatured = await this.instantiationService.invokeFunction(a => checkGlobFileExists(a, folders, walkthrough.featuredFor, token.token));
             }
@@ -283,7 +286,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
                 icon: {
                     type: 'image',
                     path: iconStr
-                        ? ( (FileAccess.uriToBrowserUri(joinPath(extension.extensionLocation, iconStr)).toString(true)))
+                        ? ( FileAccess.uriToBrowserUri(joinPath(extension.extensionLocation, iconStr)).toString(true))
                         : getDefaultIconPath()
                 },
                 when: ContextKeyExpr.deserialize(override ?? walkthrough.when) ?? ContextKeyExpr.true(),
@@ -291,11 +294,11 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
             this._registerWalkthrough(walkthoughDescriptor);
             this._onDidAddWalkthrough.fire(this.resolveWalkthrough(walkthoughDescriptor));
         }));
-        this.storageService.store(walkthroughMetadataConfigurationKey, JSON.stringify([...this.metadata.entries()]), 0 , 0 );
+        this.storageService.store(walkthroughMetadataConfigurationKey, JSON.stringify([...this.metadata.entries()]), StorageScope.PROFILE, StorageTarget.USER);
         const hadLastFoucs = await this.hostService.hadLastFocus();
         if (hadLastFoucs && sectionToOpen && this.configurationService.getValue('workbench.welcomePage.walkthroughs.openOnInstall')) {
             this.telemetryService.publicLog2('gettingStarted.didAutoOpenWalkthrough', { id: sectionToOpen });
-            this.commandService.executeCommand('workbench.action.openWalkthrough', sectionToOpen, true);
+            this.commandService.executeCommand('workbench.action.openWalkthrough', sectionToOpen);
         }
     }
     unregisterExtensionWalkthroughContributions(extension) {
@@ -320,8 +323,8 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
         return this.resolveWalkthrough(walkthrough);
     }
     getWalkthroughs() {
-        const registeredCategories = [...( (this.gettingStartedContributions.values()))];
-        const categoriesWithCompletion = ( (( (registeredCategories
+        const registeredCategories = [...( this.gettingStartedContributions.values())];
+        const categoriesWithCompletion = ( ( registeredCategories
             .map(category => {
             return {
                 ...category,
@@ -330,26 +333,26 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
                     steps: category.steps
                 }
             };
-        })))
+        }))
             .filter(category => category.content.type !== 'steps' || category.content.steps.length)
-            .map(category => this.resolveWalkthrough(category))));
+            .map(category => this.resolveWalkthrough(category)));
         return categoriesWithCompletion;
     }
     resolveWalkthrough(category) {
-        const stepsWithProgress = ( (category.steps.map(step => this.getStepProgress(step))));
+        const stepsWithProgress = ( category.steps.map(step => this.getStepProgress(step)));
         const hasOpened = this.metadata.get(category.id)?.manaullyOpened;
         const firstSeenDate = this.metadata.get(category.id)?.firstSeen;
-        const isNew = firstSeenDate && firstSeenDate > (+( (new Date())) - NEW_WALKTHROUGH_TIME);
+        const isNew = firstSeenDate && firstSeenDate > (+( new Date()) - NEW_WALKTHROUGH_TIME);
         const lastStepIDs = this.metadata.get(category.id)?.stepIDs;
         const rawCategory = this.gettingStartedContributions.get(category.id);
         if (!rawCategory) {
             throw Error('Could not find walkthrough with id ' + category.id);
         }
-        const currentStepIds = ( (rawCategory.steps.map(s => s.id)));
-        const hasNewSteps = lastStepIDs && (currentStepIds.length !== lastStepIDs.length || ( (currentStepIds.some((id, index) => id !== lastStepIDs[index]))));
+        const currentStepIds = ( rawCategory.steps.map(s => s.id));
+        const hasNewSteps = lastStepIDs && (currentStepIds.length !== lastStepIDs.length || ( currentStepIds.some((id, index) => id !== lastStepIDs[index])));
         let recencyBonus = 0;
         if (firstSeenDate) {
-            const currentDate = +( (new Date()));
+            const currentDate = +( new Date());
             const timeSinceFirstSeen = currentDate - firstSeenDate;
             recencyBonus = Math.max(0, (NEW_WALKTHROUGH_TIME - timeSinceFirstSeen) / NEW_WALKTHROUGH_TIME);
         }
@@ -387,7 +390,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
         this._onDidProgressStep.fire(this.getStepProgress(step));
     }
     progressByEvent(event) {
-        if (( (this.sessionEvents.has(event)))) {
+        if (( this.sessionEvents.has(event))) {
             return;
         }
         this.sessionEvents.add(event);
@@ -396,7 +399,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
     registerWalkthrough(walkthoughDescriptor) {
         this._registerWalkthrough({
             ...walkthoughDescriptor,
-            steps: ( (walkthoughDescriptor.steps.map(step => ({ ...step, description: parseDescription(step.description) }))))
+            steps: ( walkthoughDescriptor.steps.map(step => ({ ...step, description: parseDescription(step.description) })))
         });
     }
     _registerWalkthrough(walkthroughDescriptor) {
@@ -407,14 +410,14 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
         }
         this.gettingStartedContributions.set(walkthroughDescriptor.id, walkthroughDescriptor);
         walkthroughDescriptor.steps.forEach(step => {
-            if (( (this.steps.has(step.id)))) {
+            if (( this.steps.has(step.id))) {
                 throw Error('Attempting to register step with id ' + step.id + ' twice. Second is dropped.');
             }
             this.steps.set(step.id, step);
-            ( (step.when.keys())).forEach(key => this.categoryVisibilityContextKeys.add(key));
+            ( step.when.keys()).forEach(key => this.categoryVisibilityContextKeys.add(key));
             this.registerDoneListeners(step);
         });
-        ( (walkthroughDescriptor.when.keys())).forEach(key => this.categoryVisibilityContextKeys.add(key));
+        ( walkthroughDescriptor.when.keys()).forEach(key => this.categoryVisibilityContextKeys.add(key));
     }
     registerDoneListeners(step) {
         if (step.doneOn) {
@@ -424,7 +427,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
         if (!step.completionEvents.length) {
             step.completionEvents = coalesce(step.description
                 .filter(linkedText => linkedText.nodes.length === 1)
-                .flatMap(linkedText => ( (linkedText.nodes
+                .flatMap(linkedText => ( linkedText.nodes
                 .filter(((node) => typeof node !== 'string'))
                 .map(({ href }) => {
                 if (href.startsWith('command:')) {
@@ -434,7 +437,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
                     return 'onLink:' + href;
                 }
                 return undefined;
-            })))));
+            }))));
         }
         if (!step.completionEvents.length) {
             step.completionEvents.push('stepSelected');
@@ -455,7 +458,7 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
                     const expression = ContextKeyExpr.deserialize(argument);
                     if (expression) {
                         this.stepCompletionContextKeyExpressions.add(expression);
-                        ( (expression.keys())).forEach(key => this.stepCompletionContextKeys.add(key));
+                        ( expression.keys()).forEach(key => this.stepCompletionContextKeys.add(key));
                         event = eventType + ':' + expression.serialize();
                         if (this.contextService.contextMatchesRules(expression)) {
                             this.sessionEvents.add(event);
@@ -485,8 +488,8 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
         }
     }
     registerCompletionListener(event, step) {
-        if (!( (this.completionListeners.has(event)))) {
-            this.completionListeners.set(event, ( (new Set())));
+        if (!( this.completionListeners.has(event))) {
+            this.completionListeners.set(event, ( new Set()));
         }
         this.completionListeners.get(event)?.add(step.id);
     }
@@ -498,28 +501,28 @@ let WalkthroughsService = class WalkthroughsService extends Disposable {
         return step;
     }
 };
-WalkthroughsService = ( (__decorate([
-    ( (__param(0, IStorageService))),
-    ( (__param(1, ICommandService))),
-    ( (__param(2, IInstantiationService))),
-    ( (__param(3, IWorkspaceContextService))),
-    ( (__param(4, IContextKeyService))),
-    ( (__param(5, IUserDataSyncEnablementService))),
-    ( (__param(6, IConfigurationService))),
-    ( (__param(7, IExtensionManagementService))),
-    ( (__param(8, IHostService))),
-    ( (__param(9, IViewsService))),
-    ( (__param(10, ITelemetryService))),
-    ( (__param(11, IWorkbenchAssignmentService))),
-    ( (__param(12, IProductService)))
-], WalkthroughsService)));
-const parseDescription = (desc) => ( (desc.split('\n').filter(x => x).map(text => parseLinkedText(text))));
+WalkthroughsService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, ICommandService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IUserDataSyncEnablementService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IExtensionManagementService)),
+    ( __param(8, IHostService)),
+    ( __param(9, IViewsService)),
+    ( __param(10, ITelemetryService)),
+    ( __param(11, IWorkbenchAssignmentService)),
+    ( __param(12, IProductService))
+], WalkthroughsService));
+const parseDescription = (desc) => ( desc.split('\n').filter(x => x).map(text => parseLinkedText(text)));
 const convertInternalMediaPathToFileURI = (path) => path.startsWith('https://')
-    ? ( (URI.parse(path, true)))
-    : ( (FileAccess.asFileUri(`vs/workbench/contrib/welcomeGettingStarted/common/media/${path}`)));
+    ? ( URI.parse(path, true))
+    : ( FileAccess.asFileUri(`vs/workbench/contrib/welcomeGettingStarted/common/media/${path}`));
 const convertInternalMediaPathToBrowserURI = (path) => path.startsWith('https://')
-    ? ( (URI.parse(path, true)))
-    : ( (FileAccess.asBrowserUri(`vs/workbench/contrib/welcomeGettingStarted/common/media/${path}`)));
+    ? ( URI.parse(path, true))
+    : ( FileAccess.asBrowserUri(`vs/workbench/contrib/welcomeGettingStarted/common/media/${path}`));
 const convertInternalMediaPathsToBrowserURIs = (path) => {
     if (typeof path === 'string') {
         const converted = convertInternalMediaPathToBrowserURI(path);