@codingame/monaco-vscode-api 1.85.0-next.2 → 1.85.1

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

@@ -0,0 +1,563 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Memento } from '../../../common/memento.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { ContextKeyExpr, IContextKeyService, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IUserDataSyncEnablementService } from '../../../../platform/userDataSync/common/userDataSync.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IExtensionManagementService, EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT, EXTENSION_INSTALL_DEP_PACK_CONTEXT } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { walkthroughs } from '../common/gettingStartedContent.js';
+import { IWorkbenchAssignmentService } from '../../../services/assignment/common/assignmentService.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { parseLinkedText } from 'monaco-editor/esm/vs/base/common/linkedText.js';
+import { walkthroughsExtensionPoint } from './gettingStartedExtensionPoint.js';
+import { dirname } from 'monaco-editor/esm/vs/base/common/path.js';
+import { coalesce, flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { IViewsService } from '../../../common/views.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { checkGlobFileExists } from '../../../services/extensions/common/workspaceContains.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { getDefaultIconPath } from '../../../services/extensionManagement/common/extensionManagement.js';
+const HasMultipleNewFileEntries = ( new RawContextKey('hasMultipleNewFileEntries', false));
+const IWalkthroughsService = ( createDecorator('walkthroughsService'));
+const hiddenEntriesConfigurationKey = 'workbench.welcomePage.hiddenCategories';
+const walkthroughMetadataConfigurationKey = 'workbench.welcomePage.walkthroughMetadata';
+const BUILT_IN_SOURCE = ( localizeWithPath(
+    'vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService',
+    'builtin',
+    "Built-In"
+));
+const DAYS = 24 * 60 * 60 * 1000;
+const NEW_WALKTHROUGH_TIME = 7 * DAYS;
+let WalkthroughsService = class WalkthroughsService extends Disposable {
+    constructor(storageService, commandService, instantiationService, workspaceContextService, contextService, userDataSyncEnablementService, configurationService, extensionManagementService, hostService, viewsService, telemetryService, tasExperimentService) {
+        super();
+        this.storageService = storageService;
+        this.commandService = commandService;
+        this.instantiationService = instantiationService;
+        this.workspaceContextService = workspaceContextService;
+        this.contextService = contextService;
+        this.userDataSyncEnablementService = userDataSyncEnablementService;
+        this.configurationService = configurationService;
+        this.extensionManagementService = extensionManagementService;
+        this.hostService = hostService;
+        this.viewsService = viewsService;
+        this.telemetryService = telemetryService;
+        this.tasExperimentService = tasExperimentService;
+        this._onDidAddWalkthrough = ( new Emitter());
+        this.onDidAddWalkthrough = this._onDidAddWalkthrough.event;
+        this._onDidRemoveWalkthrough = ( new Emitter());
+        this.onDidRemoveWalkthrough = this._onDidRemoveWalkthrough.event;
+        this._onDidChangeWalkthrough = ( new Emitter());
+        this.onDidChangeWalkthrough = this._onDidChangeWalkthrough.event;
+        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.initCompletionEventListeners();
+        HasMultipleNewFileEntries.bindTo(this.contextService).set(false);
+        this.registerWalkthroughs();
+    }
+    registerWalkthroughs() {
+        walkthroughs.forEach(async (category, index) => {
+            this._registerWalkthrough({
+                ...category,
+                icon: { type: 'icon', icon: category.icon },
+                order: walkthroughs.length - index,
+                source: BUILT_IN_SOURCE,
+                when: ContextKeyExpr.deserialize(category.when) ?? ContextKeyExpr.true(),
+                steps: ( category.content.steps.map((step, index) => {
+                    return ({
+                        ...step,
+                        completionEvents: step.completionEvents ?? [],
+                        description: parseDescription(step.description),
+                        category: category.id,
+                        order: index,
+                        when: ContextKeyExpr.deserialize(step.when) ?? ContextKeyExpr.true(),
+                        media: step.media.type === 'image'
+                            ? {
+                                type: 'image',
+                                altText: step.media.altText,
+                                path: convertInternalMediaPathsToBrowserURIs(step.media.path)
+                            }
+                            : step.media.type === 'svg'
+                                ? {
+                                    type: 'svg',
+                                    altText: step.media.altText,
+                                    path: convertInternalMediaPathToFileURI(step.media.path).with({ query: JSON.stringify({ moduleId: 'vs/workbench/contrib/welcomeGettingStarted/common/media/' + step.media.path }) })
+                                }
+                                : {
+                                    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/')),
+                                }
+                    });
+                }))
+            });
+        });
+        walkthroughsExtensionPoint.setHandler((_, { added, removed }) => {
+        });
+    }
+    initCompletionEventListeners() {
+        this._register(this.commandService.onDidExecuteCommand(command => this.progressByEvent(`onCommand:${command.commandId}`)));
+        this.extensionManagementService.getInstalled().then(installed => {
+            installed.forEach(ext => this.progressByEvent(`extensionInstalled:${ext.identifier.id.toLowerCase()}`));
+        });
+        this._register(this.extensionManagementService.onDidInstallExtensions(async (result) => {
+            const hadLastFoucs = await this.hostService.hadLastFocus();
+            for (const e of result) {
+                const skipWalkthrough = e?.context?.[EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT] || e?.context?.[EXTENSION_INSTALL_DEP_PACK_CONTEXT];
+                if (hadLastFoucs && !skipWalkthrough) {
+                    this.sessionInstalledExtensions.add(e.identifier.id.toLowerCase());
+                }
+                this.progressByEvent(`extensionInstalled:${e.identifier.id.toLowerCase()}`);
+            }
+        }));
+        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)) {
+                        this.progressByEvent(`onContext:` + expression.serialize());
+                    }
+                });
+            }
+        }));
+        this._register(this.viewsService.onDidChangeViewVisibility(e => {
+            if (e.visible) {
+                this.progressByEvent('onView:' + e.id);
+            }
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            e.affectedKeys.forEach(key => { this.progressByEvent('onSettingChanged:' + key); });
+        }));
+        if (this.userDataSyncEnablementService.isEnabled()) {
+            this.progressByEvent('onEvent:sync-enabled');
+        }
+        this._register(this.userDataSyncEnablementService.onDidChangeEnablement(() => {
+            if (this.userDataSyncEnablementService.isEnabled()) {
+                this.progressByEvent('onEvent:sync-enabled');
+            }
+        }));
+    }
+    markWalkthroughOpened(id) {
+        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.storageService.store(walkthroughMetadataConfigurationKey, JSON.stringify([...this.metadata.entries()]), 0 , 0 );
+    }
+    async registerExtensionWalkthroughContributions(extension) {
+        const convertExtensionPathToFileURI = (path) => path.startsWith('https://')
+            ? ( URI.parse(path, true))
+            : FileAccess.uriToFileUri(joinPath(extension.extensionLocation, path));
+        const convertExtensionRelativePathsToBrowserURIs = (path) => {
+            const convertPath = (path) => path.startsWith('https://')
+                ? ( URI.parse(path, true))
+                : FileAccess.uriToBrowserUri(joinPath(extension.extensionLocation, path));
+            if (typeof path === 'string') {
+                const converted = convertPath(path);
+                return { hcDark: converted, hcLight: converted, dark: converted, light: converted };
+            }
+            else {
+                return {
+                    hcDark: convertPath(path.hc),
+                    hcLight: convertPath(path.hcLight ?? path.light),
+                    light: convertPath(path.light),
+                    dark: convertPath(path.dark)
+                };
+            }
+        };
+        if (!(extension.contributes?.walkthroughs?.length)) {
+            return;
+        }
+        let sectionToOpen;
+        let sectionToOpenIndex = Math.min();
+        await Promise.all(extension.contributes?.walkthroughs?.map(async (walkthrough, index) => {
+            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 });
+            }
+            const override = await Promise.race([
+                this.tasExperimentService?.getTreatment(`gettingStarted.overrideCategory.${extension.identifier.value + '.' + walkthrough.id}.when`),
+                ( new Promise(resolve => setTimeout(() => resolve(walkthrough.when), 5000)))
+            ]);
+            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) {
+                    sectionToOpen = categoryID;
+                    sectionToOpenIndex = index;
+                }
+            }
+            const steps = ( (walkthrough.steps ?? []).map((step, index) => {
+                const description = parseDescription(step.description || '');
+                const fullyQualifiedID = extension.identifier.value + '#' + walkthrough.id + '#' + step.id;
+                let media;
+                if (!step.media) {
+                    throw Error('missing media in walkthrough step: ' + walkthrough.id + '@' + step.id);
+                }
+                if (step.media.image) {
+                    const altText = step.media.altText;
+                    if (altText === undefined) {
+                        console.error('Walkthrough item:', fullyQualifiedID, 'is missing altText for its media element.');
+                    }
+                    media = { type: 'image', altText, path: convertExtensionRelativePathsToBrowserURIs(step.media.image) };
+                }
+                else if (step.media.markdown) {
+                    media = {
+                        type: 'markdown',
+                        path: convertExtensionPathToFileURI(step.media.markdown),
+                        base: convertExtensionPathToFileURI(dirname(step.media.markdown)),
+                        root: FileAccess.uriToFileUri(extension.extensionLocation),
+                    };
+                }
+                else if (step.media.svg) {
+                    media = {
+                        type: 'svg',
+                        path: convertExtensionPathToFileURI(step.media.svg),
+                        altText: step.media.svg,
+                    };
+                }
+                else {
+                    throw new Error('Unknown walkthrough format detected for ' + fullyQualifiedID);
+                }
+                return ({
+                    description,
+                    media,
+                    completionEvents: step.completionEvents?.filter(x => typeof x === 'string') ?? [],
+                    id: fullyQualifiedID,
+                    title: step.title,
+                    when: ContextKeyExpr.deserialize(step.when) ?? ContextKeyExpr.true(),
+                    category: categoryID,
+                    order: index,
+                });
+            }));
+            let isFeatured = false;
+            if (walkthrough.featuredFor) {
+                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));
+            }
+            const iconStr = walkthrough.icon ?? extension.icon;
+            const walkthoughDescriptor = {
+                description: walkthrough.description,
+                title: walkthrough.title,
+                id: categoryID,
+                isFeatured,
+                source: extension.displayName ?? extension.name,
+                order: 0,
+                steps,
+                icon: {
+                    type: 'image',
+                    path: iconStr
+                        ? ( FileAccess.uriToBrowserUri(joinPath(extension.extensionLocation, iconStr)).toString(true))
+                        : getDefaultIconPath()
+                },
+                when: ContextKeyExpr.deserialize(override ?? walkthrough.when) ?? ContextKeyExpr.true(),
+            };
+            this._registerWalkthrough(walkthoughDescriptor);
+            this._onDidAddWalkthrough.fire(this.resolveWalkthrough(walkthoughDescriptor));
+        }));
+        this.storageService.store(walkthroughMetadataConfigurationKey, JSON.stringify([...this.metadata.entries()]), 0 , 0 );
+        if (sectionToOpen && this.configurationService.getValue('workbench.welcomePage.walkthroughs.openOnInstall')) {
+            this.telemetryService.publicLog2('gettingStarted.didAutoOpenWalkthrough', { id: sectionToOpen });
+            this.commandService.executeCommand('workbench.action.openWalkthrough', sectionToOpen, true);
+        }
+    }
+    unregisterExtensionWalkthroughContributions(extension) {
+        if (!(extension.contributes?.walkthroughs?.length)) {
+            return;
+        }
+        extension.contributes?.walkthroughs?.forEach(section => {
+            const categoryID = extension.identifier.value + '#' + section.id;
+            section.steps.forEach(step => {
+                const fullyQualifiedID = extension.identifier.value + '#' + section.id + '#' + step.id;
+                this.steps.delete(fullyQualifiedID);
+            });
+            this.gettingStartedContributions.delete(categoryID);
+            this._onDidRemoveWalkthrough.fire(categoryID);
+        });
+    }
+    getWalkthrough(id) {
+        const walkthrough = this.gettingStartedContributions.get(id);
+        if (!walkthrough) {
+            throw Error('Trying to get unknown walkthrough: ' + id);
+        }
+        return this.resolveWalkthrough(walkthrough);
+    }
+    getWalkthroughs() {
+        const registeredCategories = [...( this.gettingStartedContributions.values())];
+        const categoriesWithCompletion = ( ( registeredCategories
+            .map(category => {
+            return {
+                ...category,
+                content: {
+                    type: 'steps',
+                    steps: category.steps
+                }
+            };
+        }))
+            .filter(category => category.content.type !== 'steps' || category.content.steps.length)
+            .map(category => this.resolveWalkthrough(category)));
+        return categoriesWithCompletion;
+    }
+    resolveWalkthrough(category) {
+        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 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])));
+        let recencyBonus = 0;
+        if (firstSeenDate) {
+            const currentDate = +( new Date());
+            const timeSinceFirstSeen = currentDate - firstSeenDate;
+            recencyBonus = Math.max(0, (NEW_WALKTHROUGH_TIME - timeSinceFirstSeen) / NEW_WALKTHROUGH_TIME);
+        }
+        return {
+            ...category,
+            recencyBonus,
+            steps: stepsWithProgress,
+            newItems: !!hasNewSteps,
+            newEntry: !!(isNew && !hasOpened),
+        };
+    }
+    getStepProgress(step) {
+        return {
+            ...step,
+            done: false,
+            ...this.stepProgress[step.id]
+        };
+    }
+    progressStep(id) {
+        const oldProgress = this.stepProgress[id];
+        if (!oldProgress || oldProgress.done !== true) {
+            this.stepProgress[id] = { done: true };
+            this.memento.saveMemento();
+            const step = this.getStep(id);
+            if (!step) {
+                throw Error('Tried to progress unknown step');
+            }
+            this._onDidProgressStep.fire(this.getStepProgress(step));
+        }
+    }
+    deprogressStep(id) {
+        delete this.stepProgress[id];
+        this.memento.saveMemento();
+        const step = this.getStep(id);
+        this._onDidProgressStep.fire(this.getStepProgress(step));
+    }
+    progressByEvent(event) {
+        if (( this.sessionEvents.has(event))) {
+            return;
+        }
+        this.sessionEvents.add(event);
+        this.completionListeners.get(event)?.forEach(id => this.progressStep(id));
+    }
+    registerWalkthrough(walkthoughDescriptor) {
+        this._registerWalkthrough({
+            ...walkthoughDescriptor,
+            steps: ( walkthoughDescriptor.steps.map(step => ({ ...step, description: parseDescription(step.description) })))
+        });
+    }
+    _registerWalkthrough(walkthroughDescriptor) {
+        const oldCategory = this.gettingStartedContributions.get(walkthroughDescriptor.id);
+        if (oldCategory) {
+            console.error(`Skipping attempt to overwrite walkthrough. (${walkthroughDescriptor.id})`);
+            return;
+        }
+        this.gettingStartedContributions.set(walkthroughDescriptor.id, walkthroughDescriptor);
+        walkthroughDescriptor.steps.forEach(step => {
+            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));
+            this.registerDoneListeners(step);
+        });
+        ( walkthroughDescriptor.when.keys()).forEach(key => this.categoryVisibilityContextKeys.add(key));
+    }
+    registerDoneListeners(step) {
+        if (step.doneOn) {
+            console.error(`wakthrough step`, step, `uses deprecated 'doneOn' property. Adopt 'completionEvents' to silence this warning`);
+            return;
+        }
+        if (!step.completionEvents.length) {
+            step.completionEvents = coalesce(flatten(( step.description
+                .filter(linkedText => linkedText.nodes.length === 1)
+                .map(linkedText => ( linkedText.nodes
+                .filter(((node) => typeof node !== 'string'))
+                .map(({ href }) => {
+                if (href.startsWith('command:')) {
+                    return 'onCommand:' + href.slice('command:'.length, href.includes('?') ? href.indexOf('?') : undefined);
+                }
+                if (href.startsWith('https://') || href.startsWith('http://')) {
+                    return 'onLink:' + href;
+                }
+                return undefined;
+            }))))));
+        }
+        if (!step.completionEvents.length) {
+            step.completionEvents.push('stepSelected');
+        }
+        for (let event of step.completionEvents) {
+            const [_, eventType, argument] = /^([^:]*):?(.*)$/.exec(event) ?? [];
+            if (!eventType) {
+                console.error(`Unknown completionEvent ${event} when registering step ${step.id}`);
+                continue;
+            }
+            switch (eventType) {
+                case 'onLink':
+                case 'onEvent':
+                case 'onView':
+                case 'onSettingChanged':
+                    break;
+                case 'onContext': {
+                    const expression = ContextKeyExpr.deserialize(argument);
+                    if (expression) {
+                        this.stepCompletionContextKeyExpressions.add(expression);
+                        ( expression.keys()).forEach(key => this.stepCompletionContextKeys.add(key));
+                        event = eventType + ':' + expression.serialize();
+                        if (this.contextService.contextMatchesRules(expression)) {
+                            this.sessionEvents.add(event);
+                        }
+                    }
+                    else {
+                        console.error('Unable to parse context key expression:', expression, 'in walkthrough step', step.id);
+                    }
+                    break;
+                }
+                case 'onStepSelected':
+                case 'stepSelected':
+                    event = 'stepSelected:' + step.id;
+                    break;
+                case 'onCommand':
+                    event = eventType + ':' + argument.replace(/^toSide:/, '');
+                    break;
+                case 'onExtensionInstalled':
+                case 'extensionInstalled':
+                    event = 'extensionInstalled:' + argument.toLowerCase();
+                    break;
+                default:
+                    console.error(`Unknown completionEvent ${event} when registering step ${step.id}`);
+                    continue;
+            }
+            this.registerCompletionListener(event, step);
+        }
+    }
+    registerCompletionListener(event, step) {
+        if (!( this.completionListeners.has(event))) {
+            this.completionListeners.set(event, ( new Set()));
+        }
+        this.completionListeners.get(event)?.add(step.id);
+    }
+    getStep(id) {
+        const step = this.steps.get(id);
+        if (!step) {
+            throw Error('Attempting to access step which does not exist in registry ' + id);
+        }
+        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))
+], 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}`));
+const convertInternalMediaPathToBrowserURI = (path) => path.startsWith('https://')
+    ? ( URI.parse(path, true))
+    : ( FileAccess.asBrowserUri(`vs/workbench/contrib/welcomeGettingStarted/common/media/${path}`));
+const convertInternalMediaPathsToBrowserURIs = (path) => {
+    if (typeof path === 'string') {
+        const converted = convertInternalMediaPathToBrowserURI(path);
+        return { hcDark: converted, hcLight: converted, dark: converted, light: converted };
+    }
+    else {
+        return {
+            hcDark: convertInternalMediaPathToBrowserURI(path.hc),
+            hcLight: convertInternalMediaPathToBrowserURI(path.hcLight ?? path.light),
+            light: convertInternalMediaPathToBrowserURI(path.light),
+            dark: convertInternalMediaPathToBrowserURI(path.dark)
+        };
+    }
+};
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'resetGettingStartedProgress',
+            category: { original: 'Developer', value: ( localizeWithPath(
+                'vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService',
+                'developer',
+                "Developer"
+            )) },
+            title: { original: 'Reset Welcome Page Walkthrough Progress', value: ( localizeWithPath(
+                'vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService',
+                'resetWelcomePageWalkthroughProgress',
+                "Reset Welcome Page Walkthrough Progress"
+            )) },
+            f1: true
+        });
+    }
+    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 );
+        for (const key in record) {
+            if (Object.prototype.hasOwnProperty.call(record, key)) {
+                try {
+                    gettingStartedService.deprogressStep(key);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+        memento.saveMemento();
+    }
+});
+export { HasMultipleNewFileEntries, IWalkthroughsService, WalkthroughsService, convertInternalMediaPathToFileURI, hiddenEntriesConfigurationKey, walkthroughMetadataConfigurationKey };