@codingame/monaco-vscode-welcome-service-override 34.1.3 → 35.0.1

package/vscode/src/vs/workbench/contrib/onboarding/browser/onboardingService.js

@@ -0,0 +1,378 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import { Memento } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/memento';
+import { onboardingPresentationRegistry } from '../common/onboardingPresentation.js';
+import { onboardingScenarioRegistry } from '../common/onboardingRegistry.js';
+import { ONBOARDING_ASSIGNMENT_CONTEXT_PREFIX, OnboardingOutcome } from '../common/onboardingScenario.js';
+import { ONBOARDING_ENABLED_CONFIG, ONBOARDING_DEVELOPER_MODE_CONFIG, isOnboardingDeveloperModeEnabled } from '../common/onboardingScenarioService.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var OnboardingScenarioService_1;
+let OnboardingScenarioService = class OnboardingScenarioService extends Disposable {
+    static {
+        OnboardingScenarioService_1 = this;
+    }
+    static {
+        this.MEMENTO_ID = "onboarding";
+    }
+    static {
+        this.OPENED_IDS_STORAGE_KEY = "onboarding.openedAssignmentContextIds";
+    }
+    constructor(
+        storageService,
+        contextKeyService,
+        configurationService,
+        lifecycleService,
+        assignmentService,
+        telemetryService
+    ) {
+        super();
+        this.storageService = storageService;
+        this.contextKeyService = contextKeyService;
+        this.configurationService = configurationService;
+        this.lifecycleService = lifecycleService;
+        this.assignmentService = assignmentService;
+        this.telemetryService = telemetryService;
+        this._triggerListeners = this._register(( new DisposableStore()));
+        this._pending = ( new Set());
+        this._queue = [];
+        this._inflight = ( new Map());
+        this._pumping = false;
+        this._experimentStates = ( new Map());
+        this._onDidChangeOpenedIds = this._register(( new Emitter()));
+        this._started = false;
+        this._stopped = false;
+        this._shownSinceStart = ( new Set());
+        this._memento = ( new Memento(OnboardingScenarioService_1.MEMENTO_ID, this.storageService));
+        this._state = this._memento.getMemento(StorageScope.APPLICATION, StorageTarget.MACHINE);
+        this._openedAssignmentContextIds = this._loadOpenedIds();
+        this.assignmentService.addTelemetryAssignmentFilter({
+            id: "onboarding",
+            exclude: assignment => assignment.startsWith(ONBOARDING_ASSIGNMENT_CONTEXT_PREFIX) && !( this._openedAssignmentContextIds.has(assignment)),
+            onDidChange: this._onDidChangeOpenedIds.event
+        });
+        this._register(this.lifecycleService.onWillShutdown(() => this._stop()));
+    }
+    _stop() {
+        this._stopped = true;
+        this._activeAbort?.fire();
+        let entry;
+        while ((entry = this._queue.shift())) {
+            this._pending.delete(entry.scenario.id);
+            entry.deferred.complete(OnboardingOutcome.Aborted);
+        }
+    }
+    start() {
+        if (this._started) {
+            return;
+        }
+        this._started = true;
+        this._register(onboardingScenarioRegistry.onDidChange(() => {
+            this._registerTriggerListeners();
+            this._resolveExperiments();
+            this._evaluate();
+        }));
+        this._register(this.contextKeyService.onDidChangeContext(() => this._evaluate()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ONBOARDING_ENABLED_CONFIG) || e.affectsConfiguration(ONBOARDING_DEVELOPER_MODE_CONFIG)) {
+                this._evaluate();
+            }
+        }));
+        this._registerTriggerListeners();
+        this._resolveExperiments();
+        this._evaluate();
+    }
+    getScenarios() {
+        return onboardingScenarioRegistry.getScenarios();
+    }
+    async runScenario(id) {
+        const scenario = onboardingScenarioRegistry.getScenario(id);
+        if (!scenario) {
+            throw ( new Error(`Unknown onboarding scenario '${id}'.`));
+        }
+        return this._enqueue(scenario);
+    }
+    hasBeenShown(id) {
+        const scenario = onboardingScenarioRegistry.getScenario(id);
+        return this._hasBeenShownKey(scenario ? this._seenKey(scenario) : id, id);
+    }
+    reset(id) {
+        const scenario = onboardingScenarioRegistry.getScenario(id);
+        delete this._state[scenario ? this._seenKey(scenario) : id];
+        this._memento.saveMemento();
+    }
+    resetAll() {
+        for (const key of ( Object.keys(this._state))) {
+            delete this._state[key];
+        }
+        this._memento.saveMemento();
+    }
+    get _enabled() {
+        return this.configurationService.getValue(ONBOARDING_ENABLED_CONFIG) !== false;
+    }
+    _isDeveloperMode(scenarioId) {
+        return isOnboardingDeveloperModeEnabled(this.configurationService, scenarioId);
+    }
+    _evaluate() {
+        if (!this._enabled || this._stopped) {
+            return;
+        }
+        const claimedSeenKeys = ( new Set());
+        for (const scenario of onboardingScenarioRegistry.getScenarios()) {
+            if (!scenario.repeatable && ( this._pending.has(scenario.id))) {
+                claimedSeenKeys.add(this._seenKey(scenario));
+            }
+        }
+        for (const scenario of onboardingScenarioRegistry.getScenarios()) {
+            if (!this._isAutoEligible(scenario)) {
+                continue;
+            }
+            const seenKey = this._seenKey(scenario);
+            if (!scenario.repeatable && ( claimedSeenKeys.has(seenKey))) {
+                continue;
+            }
+            const experiment = scenario.experiment ? this._experimentStates.get(scenario.id) : undefined;
+            if (experiment?.active && !this._isDeveloperMode(scenario.id)) {
+                this._openGate(experiment.assignmentContextId);
+                if (!experiment.behavior) {
+                    continue;
+                }
+            }
+            this._enqueue(scenario);
+            if (!scenario.repeatable) {
+                claimedSeenKeys.add(seenKey);
+            }
+        }
+    }
+    _isAutoEligible(scenario) {
+        if (scenario.trigger.kind === "command") {
+            return false;
+        }
+        if (( this._pending.has(scenario.id))) {
+            return false;
+        }
+        if (!scenario.repeatable && this._hasBeenShownKey(this._seenKey(scenario), scenario.id)) {
+            return false;
+        }
+        if (scenario.when && !this.contextKeyService.contextMatchesRules(scenario.when)) {
+            return false;
+        }
+        if (scenario.experiment && this._experimentStates.get(scenario.id)?.active !== true && !this._isDeveloperMode(scenario.id)) {
+            return false;
+        }
+        if (scenario.trigger.kind === "observable" && scenario.trigger.signal.get() !== true) {
+            return false;
+        }
+        return true;
+    }
+    _enqueue(scenario) {
+        if (this._stopped) {
+            return Promise.resolve(OnboardingOutcome.Aborted);
+        }
+        const queued = this._queue.find(entry => entry.scenario.id === scenario.id);
+        if (queued) {
+            return queued.deferred.p;
+        }
+        const inflight = this._inflight.get(scenario.id);
+        if (inflight) {
+            return inflight.p;
+        }
+        const deferred = ( new DeferredPromise());
+        this._pending.add(scenario.id);
+        this._queue.push({
+            scenario,
+            deferred
+        });
+        this._queue.sort((a, b) => (b.scenario.priority ?? 0) - (a.scenario.priority ?? 0));
+        this._pump();
+        return deferred.p;
+    }
+    _pump() {
+        if (this._pumping) {
+            return;
+        }
+        this._pumping = true;
+        this._doPump();
+    }
+    async _doPump() {
+        await Promise.resolve();
+        try {
+            let entry;
+            while (!this._stopped && (entry = this._queue.shift())) {
+                const {
+                    scenario,
+                    deferred
+                } = entry;
+                this._inflight.set(scenario.id, deferred);
+                let outcome;
+                try {
+                    outcome = await this._runPresentation(scenario);
+                } catch (error) {
+                    onUnexpectedError(error);
+                    outcome = OnboardingOutcome.Aborted;
+                } finally {
+                    this._inflight.delete(scenario.id);
+                    this._pending.delete(scenario.id);
+                }
+                deferred.complete(outcome);
+            }
+        } finally {
+            this._pumping = false;
+        }
+    }
+    async _runPresentation(scenario) {
+        const presentation = onboardingPresentationRegistry.get(scenario.presentation.kind);
+        if (!presentation) {
+            return OnboardingOutcome.Aborted;
+        }
+        this._markShown(this._seenKey(scenario));
+        const abort = ( new Emitter());
+        this._activeAbort = abort;
+        const startTime = Date.now();
+        try {
+            const result = await presentation.run(scenario, {
+                targetWindow: mainWindow,
+                onAbort: abort.event
+            });
+            this._recordOutcome(this._seenKey(scenario), result.outcome);
+            if (result.shown) {
+                this._reportOutcome(scenario, result, Date.now() - startTime);
+            }
+            return result.outcome;
+        } finally {
+            this._activeAbort = undefined;
+            abort.dispose();
+        }
+    }
+    _reportOutcome(scenario, result, durationMs) {
+        const experimentActive = !!scenario.experiment && this._experimentStates.get(scenario.id)?.active === true;
+        this.telemetryService.publicLog2("onboarding.scenarioOutcome", {
+            scenarioId: scenario.id,
+            outcome: result.outcome,
+            dismissReason: result.dismissReason,
+            lastStepIndex: result.lastStepIndex,
+            stepCount: result.stepCount,
+            durationMs,
+            experimentActive
+        });
+    }
+    _registerTriggerListeners() {
+        this._triggerListeners.clear();
+        for (const scenario of onboardingScenarioRegistry.getScenarios()) {
+            if (scenario.trigger.kind === "observable") {
+                const signal = scenario.trigger.signal;
+                this._triggerListeners.add(autorun(reader => {
+                    signal.read(reader);
+                    this._evaluate();
+                }));
+            }
+        }
+    }
+    _resolveExperiments() {
+        for (const scenario of onboardingScenarioRegistry.getScenarios()) {
+            const experiment = scenario.experiment;
+            if (!experiment || ( this._experimentStates.has(scenario.id))) {
+                continue;
+            }
+            this._experimentStates.set(scenario.id, {
+                active: false,
+                behavior: false,
+                assignmentContextId: ""
+            });
+            Promise.all([
+                this.assignmentService.getTreatment(experiment.behaviorFlag),
+                this.assignmentService.getTreatment(experiment.assignmentContextIdFlag)
+            ]).then(([behavior, assignmentContextId]) => {
+                const hasBehavior = typeof behavior === "boolean";
+                const hasId = typeof assignmentContextId === "string" && assignmentContextId.length > 0;
+                const hasValidId = hasId && assignmentContextId.startsWith(ONBOARDING_ASSIGNMENT_CONTEXT_PREFIX);
+                if (hasId && !hasValidId) {
+                    onUnexpectedError(( new Error(
+                        `Onboarding experiment for scenario '${scenario.id}' resolved an assignment-context id '${assignmentContextId}' that does not start with the required '${ONBOARDING_ASSIGNMENT_CONTEXT_PREFIX}' prefix; treating the experiment as inactive.`
+                    )));
+                }
+                const active = hasBehavior && hasValidId;
+                this._experimentStates.set(scenario.id, {
+                    active,
+                    behavior: behavior === true,
+                    assignmentContextId: active ? assignmentContextId : ""
+                });
+                if (active) {
+                    this._evaluate();
+                }
+            }, error => onUnexpectedError(error));
+        }
+    }
+    _loadOpenedIds() {
+        const raw = this.storageService.get(
+            OnboardingScenarioService_1.OPENED_IDS_STORAGE_KEY,
+            StorageScope.APPLICATION
+        );
+        if (!raw) {
+            return ( new Set());
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? ( new Set(parsed.filter(id => typeof id === "string"))) : ( new Set());
+        } catch (error) {
+            onUnexpectedError(error);
+            return ( new Set());
+        }
+    }
+    _openGate(assignmentContextId) {
+        if (!assignmentContextId || ( this._openedAssignmentContextIds.has(assignmentContextId))) {
+            return;
+        }
+        this._openedAssignmentContextIds.add(assignmentContextId);
+        this.storageService.store(
+            OnboardingScenarioService_1.OPENED_IDS_STORAGE_KEY,
+            JSON.stringify(Array.from(this._openedAssignmentContextIds)),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+        this._onDidChangeOpenedIds.fire();
+    }
+    _seenKey(scenario) {
+        return scenario.seenKey ?? scenario.id;
+    }
+    _hasBeenShownKey(key, scenarioId) {
+        if (this._isDeveloperMode(scenarioId)) {
+            return ( this._shownSinceStart.has(key));
+        }
+        return !!this._state[key]?.shownAt;
+    }
+    _markShown(id) {
+        this._shownSinceStart.add(id);
+        const previous = this._state[id];
+        const next = {
+            shownAt: Date.now(),
+            outcome: previous?.outcome,
+            seenCount: (previous?.seenCount ?? 0) + 1
+        };
+        this._state[id] = next;
+        this._memento.saveMemento();
+    }
+    _recordOutcome(id, outcome) {
+        const state = this._state[id];
+        if (state) {
+            state.outcome = outcome;
+            this._memento.saveMemento();
+        }
+    }
+};
+OnboardingScenarioService = OnboardingScenarioService_1 = ( __decorate([( __param(0, IStorageService)), ( __param(1, IContextKeyService)), ( __param(2, IConfigurationService)), ( __param(3, ILifecycleService)), ( __param(4, IWorkbenchAssignmentService)), ( __param(5, ITelemetryService))], OnboardingScenarioService));
+
+export { OnboardingScenarioService };

package/vscode/src/vs/workbench/contrib/onboarding/browser/spotlight/onboardingTarget.d.ts

@@ -0,0 +1,31 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+/**
+ * Attribute used to mark a DOM element as an onboarding spotlight target.
+ *
+ * Components opt in by tagging their *own* element with this attribute. Tours
+ * reference the id; they never reach into another component's markup or CSS
+ * classes to locate a target (see the sessions "DOM Traversal & Intent" rule).
+ */
+export declare const ONBOARDING_TARGET_ATTR = "data-onboarding-id";
+export declare const ONBOARDING_TARGET_PULSE_CLASS = "onboarding-target-pulse";
+/**
+ * Marks `element` as the onboarding target identified by `id`.
+ *
+ * @returns A disposable that removes the attribute again.
+ */
+export declare function markOnboardingTarget(element: HTMLElement, id: string): IDisposable;
+/**
+ * Applies the standard onboarding pulse treatment to `element`.
+ *
+ * @returns A disposable that removes the pulse again.
+ */
+export declare function pulseOnboardingTarget(element: HTMLElement): IDisposable;
+/**
+ * Resolves the element marked with the given onboarding target id within the
+ * provided window's document. Returns `undefined` if no such element exists
+ * (e.g. the feature is not currently rendered).
+ *
+ * This is the *only* place onboarding queries the DOM, and it matches solely on
+ * the onboarding attribute — never on foreign classes or structure.
+ */
+export declare function findOnboardingTarget(targetWindow: Window, id: string): HTMLElement | undefined;

package/vscode/src/vs/workbench/contrib/onboarding/browser/spotlight/onboardingTarget.js

@@ -0,0 +1,25 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import * as onboardingTarget from '../media/onboardingTarget.css';
+
+registerCss(onboardingTarget);
+const ONBOARDING_TARGET_ATTR = "data-onboarding-id";
+function findOnboardingTarget(targetWindow, id) {
+    const selector = `[${ONBOARDING_TARGET_ATTR}="${CSS.escape(id)}"]`;
+    const targets = Array.from(targetWindow.document.querySelectorAll(selector));
+    return targets.find(target => isVisibleOnboardingTarget(targetWindow, target));
+}
+function isVisibleOnboardingTarget(targetWindow, target) {
+    if (!target.isConnected) {
+        return false;
+    }
+    const style = targetWindow.getComputedStyle(target);
+    if (style.display === "none" || style.visibility === "hidden") {
+        return false;
+    }
+    const rect = target.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+}
+
+export { ONBOARDING_TARGET_ATTR, findOnboardingTarget };

package/vscode/src/vs/workbench/contrib/onboarding/browser/spotlight/spotlightOverlay.d.ts

@@ -0,0 +1,96 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { SpotlightPlacement } from "./spotlightTypes.js";
+import { OnboardingDismissReason } from "../../common/onboardingScenario.js";
+/** How the user advanced to the next step. */
+export type SpotlightAdvanceSource = "button" | "target";
+/** Why a step ended in a skip: the Skip button or the Escape key. */
+export type SpotlightSkipReason = OnboardingDismissReason.SkipButton | OnboardingDismissReason.EscapeKey;
+/** Content rendered inside the spotlight callout for a single step. */
+export interface ISpotlightContent {
+    readonly title: string;
+    readonly description: string | IMarkdownString;
+    /** Zero-based index of the current step. */
+    readonly stepIndex: number;
+    /** Total number of steps in the tour. */
+    readonly stepCount: number;
+    /** Whether a "Back" action should be offered. */
+    readonly canGoBack: boolean;
+    /** Whether this is the final step (the primary button becomes "Done"). */
+    readonly isLastStep: boolean;
+}
+/** Options controlling how a step is shown. */
+export interface ISpotlightShowOptions {
+    readonly placement?: SpotlightPlacement;
+    readonly allowTargetInteraction?: boolean;
+    readonly padding?: number;
+    /**
+     * When set, the step advances (fires `onDidClickNext`) when the user clicks
+     * the spotlighted target itself. The "Next" button is hidden and the target
+     * is kept interactive so the user can press it to continue.
+     */
+    readonly advanceOnTargetClick?: boolean;
+}
+/**
+ * A pure-DOM spotlight overlay: dims the window, cuts a highlight hole around a
+ * target element and shows an anchored callout. It owns no VS Code services so
+ * it can be unit-tested and reused. Scheduling and content come from the
+ * spotlight presentation.
+ */
+export declare class SpotlightOverlay extends Disposable {
+    private readonly _container;
+    private readonly _resizeObserverCtor;
+    private readonly _root;
+    private readonly _blockers;
+    private readonly _hole;
+    private readonly _pointer;
+    private readonly _callout;
+    private readonly _title;
+    private readonly _description;
+    private readonly _counter;
+    private readonly _descriptionRenderStore;
+    private readonly _backButton;
+    private readonly _nextButton;
+    private readonly _skipButton;
+    /** Listeners scoped to the currently shown step (re-layout sources). */
+    private readonly _stepListeners;
+    private readonly _onDidClickNext;
+    readonly onDidClickNext: Event<SpotlightAdvanceSource>;
+    private readonly _onDidClickPrevious;
+    readonly onDidClickPrevious: Event<void>;
+    private readonly _onDidSkip;
+    readonly onDidSkip: Event<SpotlightSkipReason>;
+    private _target;
+    private _options;
+    private _previousFocus;
+    private _scheduledLayout;
+    constructor(_container: HTMLElement, _resizeObserverCtor?: typeof ResizeObserver);
+    /** Show `content` spotlighting `target`. */
+    show(target: HTMLElement, content: ISpotlightContent, options?: ISpotlightShowOptions): void;
+    /** Recompute the hole and callout positions for the current target. */
+    layout(): void;
+    private _layoutBlocker;
+    private _layoutCallout;
+    private _centerCallout;
+    private _getPointerSide;
+    private _offsetCalloutForPointer;
+    private _layoutPointer;
+    private _clamp;
+    private _resolvePlacement;
+    private _renderContent;
+    private _onKeyDown;
+    private _trapFocus;
+    /**
+     * The focusable elements participating in the focus trap, in DOM order: the
+     * spotlighted target (when the step advances by pressing it), then any
+     * interactive content in the (possibly markdown) description, then the visible
+     * action buttons. Including the target keeps the spotlighted control
+     * keyboard-reachable, and querying the description keeps markdown links
+     * reachable despite `aria-modal`.
+     */
+    private _collectFocusable;
+    scheduleLayout(): void;
+    private _restoreFocus;
+    dispose(): void;
+}