@codingame/monaco-vscode-welcome-service-override 34.1.1 → 35.0.0

package/index.js

@@ -1,14 +1,18 @@
 
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { IOnboardingScenarioService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService.service';
+import { OnboardingScenarioService } from './vscode/src/vs/workbench/contrib/onboarding/browser/onboardingService.js';
 import { IOnboardingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/welcomeOnboarding/common/onboardingService.service';
 import { OnboardingVariationA } from './vscode/src/vs/workbench/contrib/welcomeOnboarding/browser/onboardingVariationA.js';
-import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import './vscode/src/vs/workbench/contrib/onboarding/browser/onboarding.contribution.js';
 import './vscode/src/vs/workbench/contrib/welcomeViews/common/viewsWelcome.contribution.js';
 import './vscode/src/vs/workbench/contrib/welcomeViews/common/newFile.contribution.js';
 import './vscode/src/vs/workbench/contrib/welcomeOnboarding/browser/welcomeOnboarding.contribution.js';
 
 function getServiceOverride() {
     return {
-        [IOnboardingService.toString()]: new SyncDescriptor(OnboardingVariationA, [], true)
+        [IOnboardingService.toString()]: new SyncDescriptor(OnboardingVariationA, [], true),
+        [IOnboardingScenarioService.toString()]: new SyncDescriptor(OnboardingScenarioService, [], true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-welcome-service-override",
-  "version": "34.1.1",
+  "version": "35.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - welcome service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "34.1.1"
+    "@codingame/monaco-vscode-api": "35.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/workbench/contrib/onboarding/browser/media/onboardingTarget.css

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.onboarding-target-pulse {
+	animation: onboarding-target-pulse 1.4s ease-out infinite;
+	outline: var(--vscode-strokeThickness) solid var(--vscode-focusBorder);
+	outline-offset: 2px;
+}
+
+@media (prefers-reduced-motion: reduce) {
+	.onboarding-target-pulse {
+		animation: none;
+	}
+}
+
+@keyframes onboarding-target-pulse {
+	0% {
+		box-shadow: 0 0 0 0 var(--vscode-focusBorder);
+	}
+	70% {
+		box-shadow: 0 0 0 6px transparent;
+	}
+	100% {
+		box-shadow: 0 0 0 0 transparent;
+	}
+}

package/vscode/src/vs/workbench/contrib/onboarding/browser/media/spotlight.css

@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* Spotlight overlay: dim everything, cut a highlight hole, anchor a callout. */
+
+.spotlight-overlay {
+	position: fixed;
+	inset: 0;
+	pointer-events: none;
+	/* Above dialogs (2575) so the onboarding spotlight wins over modal chrome. */
+	z-index: 2600;
+}
+
+/* Full-screen click blocker. Transparent; swallows interaction outside the hole. */
+.spotlight-blocker {
+	position: fixed;
+	inset: 0;
+	pointer-events: auto;
+}
+
+/*
+ * The highlight hole. The huge spread box-shadow paints the dim everywhere
+ * *outside* this element, while the inset ring highlights the target. Purely
+ * visual: it never intercepts pointer events.
+ */
+.spotlight-hole {
+	position: fixed;
+	border-radius: var(--vscode-cornerRadius-medium);
+	pointer-events: none;
+	/*
+	 * The dim color matches the modal scrim (.monaco-dialog-modal-block.dimmed)
+	 * and the native window-controls dim (windowImpl.ts dimColor, 0.5 black) so
+	 * the spotlight, the dimmed app and the OS-drawn controls read as one layer.
+	 */
+	box-shadow:
+		0 0 0 9999px rgba(0, 0, 0, 0.5),
+		0 0 0 2px var(--vscode-focusBorder) inset;
+	transition: top 0.2s ease, left 0.2s ease, width 0.2s ease, height 0.2s ease;
+}
+
+.spotlight-callout-pointer {
+	position: fixed;
+	box-sizing: border-box;
+	width: var(--vscode-spacing-size100);
+	height: var(--vscode-spacing-size100);
+	z-index: 1;
+	pointer-events: none;
+}
+
+.spotlight-callout-pointer::after {
+	content: '';
+	position: absolute;
+	inset: 0;
+	background: var(--vscode-editorWidget-background);
+	border-right: var(--vscode-strokeThickness) solid var(--vscode-widget-border, transparent);
+	border-bottom: var(--vscode-strokeThickness) solid var(--vscode-widget-border, transparent);
+}
+
+.spotlight-callout-pointer.top::after {
+	transform: rotate(225deg);
+}
+
+.spotlight-callout-pointer.right::after {
+	transform: rotate(315deg);
+}
+
+.spotlight-callout-pointer.bottom::after {
+	transform: rotate(45deg);
+}
+
+.spotlight-callout-pointer.left::after {
+	transform: rotate(135deg);
+}
+
+.spotlight-callout {
+	position: fixed;
+	box-sizing: border-box;
+	z-index: 0;
+	width: 320px;
+	max-width: calc(100vw - var(--vscode-spacing-size320));
+	padding: var(--vscode-spacing-size160);
+	background: var(--vscode-editorWidget-background);
+	color: var(--vscode-editorWidget-foreground);
+	border: var(--vscode-strokeThickness) solid var(--vscode-widget-border, transparent);
+	border-radius: var(--vscode-cornerRadius-large);
+	box-shadow: 0 2px 8px var(--vscode-widget-shadow, rgba(0, 0, 0, 0.36));
+	pointer-events: auto;
+}
+
+.spotlight-callout:focus,
+.spotlight-callout:focus-visible {
+	outline: none;
+}
+
+.spotlight-callout-title {
+	margin: 0 0 var(--vscode-spacing-size80) 0;
+	font-size: var(--vscode-bodyFontSize);
+	font-weight: 600;
+}
+
+.spotlight-callout-description {
+	margin: 0;
+	font-size: var(--vscode-bodyFontSize);
+	line-height: 1.4;
+	color: var(--vscode-descriptionForeground);
+}
+
+.spotlight-callout-description p {
+	margin: 0 0 var(--vscode-spacing-size80) 0;
+}
+
+.spotlight-callout-description p:last-child {
+	margin-bottom: 0;
+}
+
+.spotlight-callout-footer {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: var(--vscode-spacing-size120);
+	margin-top: var(--vscode-spacing-size160);
+}
+
+.spotlight-callout-counter {
+	font-size: var(--vscode-bodyFontSize-small);
+	color: var(--vscode-descriptionForeground);
+}
+
+.spotlight-callout-actions {
+	display: flex;
+	flex-wrap: wrap;
+	gap: var(--vscode-spacing-size80);
+}
+
+.spotlight-callout-actions .monaco-button {
+	width: fit-content;
+	white-space: nowrap;
+}
+
+/* Respect reduced-motion: drop the animated hole transition. */
+@media (prefers-reduced-motion: reduce) {
+	.spotlight-hole {
+		transition: none;
+	}
+}

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

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

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

@@ -0,0 +1,107 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { workbenchConfigurationNodeBase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/configuration';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { onboardingPresentationRegistry } from '../common/onboardingPresentation.js';
+import { onboardingScenarioRegistry } from '../common/onboardingRegistry.js';
+import { ONBOARDING_DEVELOPER_MODE_CONFIG, ONBOARDING_ENABLED_CONFIG } from '../common/onboardingScenarioService.js';
+import { IOnboardingScenarioService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService.service';
+import './onboardingService.js';
+import { SpotlightPresentation } from './spotlight/spotlightPresentation.js';
+
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+function buildDeveloperModeConfigurationNode() {
+    const properties = {};
+    const defaultValue = {};
+    for (const id of ( onboardingScenarioRegistry.getScenarios().map(scenario => scenario.id)).sort()) {
+        properties[id] = {
+            type: "boolean",
+            default: false
+        };
+        defaultValue[id] = false;
+    }
+    return {
+        ...workbenchConfigurationNodeBase,
+        properties: {
+            [ONBOARDING_DEVELOPER_MODE_CONFIG]: {
+                type: "object",
+                default: defaultValue,
+                properties,
+                additionalProperties: {
+                    type: "boolean"
+                },
+                tags: ["experimental"],
+                description: ( localize(
+                    12885,
+                    "Map of onboarding scenario/tour id to whether developer mode is enabled for it. When enabled for a scenario, that onboarding tour ignores usage-based eligibility checks (such as how many sessions you have started), previously persisted shown state, and any linked experiment (so it is shown even if the experiment is not running or you are in the control group). It does not override the {0} setting. The tour is still shown at most once per window session, so reload the window to show it again.",
+                    `\`#${ONBOARDING_ENABLED_CONFIG}#\``
+                ))
+            }
+        }
+    };
+}
+let developerModeConfigurationNode = buildDeveloperModeConfigurationNode();
+configurationRegistry.registerConfiguration({
+    ...workbenchConfigurationNodeBase,
+    properties: {
+        [ONBOARDING_ENABLED_CONFIG]: {
+            type: "boolean",
+            default: true,
+            description: ( localize(
+                12886,
+                "When enabled, onboarding tours and hints may appear automatically to highlight features. Disabling this does not affect tours you start manually."
+            ))
+        }
+    }
+});
+configurationRegistry.registerConfiguration(developerModeConfigurationNode);
+function refreshDeveloperModeConfiguration() {
+    const next = buildDeveloperModeConfigurationNode();
+    configurationRegistry.updateConfigurations({
+        add: [next],
+        remove: [developerModeConfigurationNode]
+    });
+    developerModeConfigurationNode = next;
+}
+let OnboardingContribution = class OnboardingContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.onboarding";
+    }
+    constructor(onboardingService, instantiationService) {
+        super();
+        refreshDeveloperModeConfiguration();
+        this._register(
+            onboardingScenarioRegistry.onDidChange(() => refreshDeveloperModeConfiguration())
+        );
+        const spotlight = this._register(instantiationService.createInstance(SpotlightPresentation));
+        this._register(onboardingPresentationRegistry.register(spotlight));
+        onboardingService.start();
+    }
+};
+OnboardingContribution = ( __decorate([( __param(0, IOnboardingScenarioService)), ( __param(1, IInstantiationService))], OnboardingContribution));
+registerWorkbenchContribution2(
+    OnboardingContribution.ID,
+    OnboardingContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "workbench.action.onboarding.resetShownState",
+            title: ( localize2(12887, "Reset Onboarding Shown State")),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(accessor) {
+        accessor.get(IOnboardingScenarioService).resetAll();
+    }
+});

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

@@ -0,0 +1,122 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { 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 { IOnboardingScenario, OnboardingOutcome } from "../common/onboardingScenario.js";
+import { IOnboardingScenarioService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService.service";
+export declare class OnboardingScenarioService extends Disposable implements IOnboardingScenarioService {
+    private readonly storageService;
+    private readonly contextKeyService;
+    private readonly configurationService;
+    private readonly lifecycleService;
+    private readonly assignmentService;
+    private readonly telemetryService;
+    readonly _serviceBrand: undefined;
+    private static readonly MEMENTO_ID;
+    /**
+     * Storage key for the set of assignment-context identifiers whose telemetry gate has been
+     * opened (the user reached the onboarding moment). Persisted so the identifier keeps
+     * flowing across reloads/relaunches until the experiment is stopped.
+     */
+    private static readonly OPENED_IDS_STORAGE_KEY;
+    private readonly _memento;
+    private readonly _state;
+    /** Listeners for `observable` triggers, rebuilt whenever the registry changes. */
+    private readonly _triggerListeners;
+    /** Scenario ids currently queued or running (prevents double-scheduling). */
+    private readonly _pending;
+    private readonly _queue;
+    /** Deferreds for scenarios that have been dequeued and are currently running, keyed by id. */
+    private readonly _inflight;
+    private _pumping;
+    /** Abort signal for the scenario currently running. */
+    private _activeAbort;
+    /** Resolved experiment treatment state, keyed by scenario id. */
+    private readonly _experimentStates;
+    /**
+     * Assignment-context ids whose telemetry gate is open. While an onboarding id is *not* in
+     * this set, the eagerly-registered filter excludes it from telemetry (see the prefix
+     * constant). The set is seeded from storage and grows as users reach the onboarding moment.
+     */
+    private readonly _openedAssignmentContextIds;
+    private readonly _onDidChangeOpenedIds;
+    private _started;
+    private _stopped;
+    private readonly _shownSinceStart;
+    constructor(storageService: IStorageService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, lifecycleService: ILifecycleService, assignmentService: IWorkbenchAssignmentService, telemetryService: ITelemetryService);
+    private _stop;
+    start(): void;
+    getScenarios(): readonly IOnboardingScenario[];
+    runScenario(id: string): Promise<OnboardingOutcome>;
+    hasBeenShown(id: string): boolean;
+    reset(id: string): void;
+    resetAll(): void;
+    /**
+     * The master switch for *automatic* onboarding. When `onboarding.enabled` is
+     * explicitly `false`, no scenario ever runs automatically (developer mode does
+     * NOT override this — see {@link _evaluate}). Any other value (including unset)
+     * is treated as enabled. On-demand {@link runScenario} is intentionally exempt
+     * from this switch.
+     */
+    private get _enabled();
+    private _isDeveloperMode;
+    /**
+     * Re-evaluate every scenario and enqueue any that are eligible to run
+     * automatically. Idempotent: already shown / queued scenarios are skipped.
+     *
+     * The automatic eligibility rules are:
+     * 1. If `onboarding.enabled` is `false`, nothing runs automatically — this
+     *    method returns immediately, and developer mode does NOT override it.
+     * 2. If a scenario declares an `experiment`, it only runs when the experiment
+     *    is active AND the user is in the treatment arm (see below) — OR when
+     *    developer mode is enabled for that scenario, which bypasses the experiment
+     *    gate so the tour can be previewed locally.
+     * 3. If a scenario has no `experiment`, it runs for every user that meets its
+     *    `when`/trigger criteria (the typical state once an experiment has graduated
+     *    and the tour is rolled out to everyone).
+     *
+     * For an experiment-active scenario, reaching eligibility *is* the "would-show"
+     * moment: the telemetry gate is opened for the experiment's assignment-context id
+     * (in both arms), and then only the treatment arm is enqueued to actually show the
+     * tour. Control opens the gate but renders nothing and is not marked as shown.
+     *
+     * Developer mode is the exception: it shows the tour unconditionally and never
+     * opens the telemetry gate, so a local preview can never affect the experiment
+     * scorecard regardless of which arm the developer happens to be assigned to.
+     */
+    private _evaluate;
+    private _isAutoEligible;
+    private _enqueue;
+    private _pump;
+    private _doPump;
+    private _runPresentation;
+    /** Emit per-tour telemetry. Only called when a tour was actually shown. */
+    private _reportOutcome;
+    private _registerTriggerListeners;
+    /**
+     * Resolve the two experiment treatment flags for each scenario that declares an experiment.
+     * The experiment is only active when both resolve: the boolean to a boolean and the id to a
+     * non-empty string that starts with {@link ONBOARDING_ASSIGNMENT_CONTEXT_PREFIX}. Resolved
+     * once per scenario; re-evaluation is triggered when an experiment becomes active.
+     */
+    private _resolveExperiments;
+    private _loadOpenedIds;
+    /**
+     * Open the telemetry gate for an assignment-context id: from now on (and after reload) the
+     * id is no longer filtered out, so every event carries it. Idempotent.
+     */
+    private _openGate;
+    /**
+     * The key under which a scenario's once-per-user "shown" state is stored.
+     * Scenarios may opt into a shared {@link IOnboardingScenario.seenKey} so that
+     * variations of the same onboarding are gated together; otherwise the
+     * scenario id is used.
+     */
+    private _seenKey;
+    private _hasBeenShownKey;
+    private _markShown;
+    private _recordOutcome;
+}