@codingame/monaco-vscode-api 37.1.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/welcomeOnboarding/common/onboardingTypes.d.ts

@@ -0,0 +1,81 @@
+import { IProductOnboardingTheme } from "../../../../base/common/product.js";
+/**
+ * Step identifiers for the onboarding walkthrough.
+ */
+export declare enum OnboardingStepId {
+    SignIn = "onboarding.signIn",
+    Personalize = "onboarding.personalize",
+    AiPreference = "onboarding.aiPreference"
+}
+/**
+ * Returns a localized title for each step.
+ */
+export declare function getOnboardingStepTitle(stepId: OnboardingStepId): string;
+/**
+ * Returns a localized subtitle for each step.
+ */
+export declare function getOnboardingStepSubtitle(stepId: OnboardingStepId): string;
+/**
+ * Ordered step IDs for the onboarding flow.
+ */
+export declare const ONBOARDING_STEPS: readonly OnboardingStepId[];
+/**
+ * Theme option for the onboarding personalization step.
+ * Sourced from product.json via `onboardingThemes`.
+ */
+export type IOnboardingThemeOption = IProductOnboardingTheme;
+/**
+ * AI collaboration preference for the AI style step.
+ */
+export declare enum AiCollaborationMode {
+    CodeFirst = "code-first",
+    Balanced = "balanced",
+    AgentForward = "agent-forward"
+}
+/**
+ * AI collaboration preference option.
+ */
+export interface IAiPreferenceOption {
+    readonly id: AiCollaborationMode;
+    readonly label: string;
+    readonly description: string;
+    readonly icon: string;
+}
+/**
+ * AI collaboration preference options shown in the AI style step.
+ */
+export declare const ONBOARDING_AI_PREFERENCE_OPTIONS: readonly IAiPreferenceOption[];
+/**
+ * Storage key for persisting onboarding completion state.
+ */
+export declare const ONBOARDING_STORAGE_KEY = "welcomeOnboarding.state";
+/**
+ * Regex matching a single-word GHE instance slug (e.g. "octocat").
+ * Only allows characters valid in DNS hostnames (letters, digits, hyphens).
+ */
+export declare const GHE_DOMAIN_REGEX: RegExp;
+/**
+ * Regex matching a full GHE instance URI (e.g. "https://octocat.ghe.com").
+ */
+export declare const GHE_FULL_URI_REGEX: RegExp;
+export declare enum GheParseResultKind {
+    Empty = "empty",
+    SingleWord = "singleWord",
+    FullUri = "fullUri",
+    Invalid = "invalid"
+}
+export type GheParseResult = {
+    readonly kind: GheParseResultKind.Empty;
+} | {
+    readonly kind: GheParseResultKind.SingleWord;
+    readonly resolvedUri: string;
+} | {
+    readonly kind: GheParseResultKind.FullUri;
+    readonly resolvedUri: string;
+} | {
+    readonly kind: GheParseResultKind.Invalid;
+};
+/**
+ * Parses a GHE instance input value and returns the result kind and resolved URI.
+ */
+export declare function parseGheInstanceInput(value: string): GheParseResult;

package/vscode/src/vs/workbench/contrib/welcomeOnboarding/common/onboardingTypes.js

@@ -0,0 +1,97 @@
+
+import { localize } from '../../../../nls.js';
+
+var OnboardingStepId;
+(function(OnboardingStepId) {
+    OnboardingStepId["SignIn"] = "onboarding.signIn";
+    OnboardingStepId["Personalize"] = "onboarding.personalize";
+    OnboardingStepId["AiPreference"] = "onboarding.aiPreference";
+})(OnboardingStepId || (OnboardingStepId = {}));
+function getOnboardingStepTitle(stepId) {
+    switch (stepId) {
+    case OnboardingStepId.SignIn:
+        return localize(19089, "Sign In");
+    case OnboardingStepId.Personalize:
+        return localize(19090, "Make It Yours");
+    case OnboardingStepId.AiPreference:
+        return localize(19091, "Your AI Style");
+    }
+}
+function getOnboardingStepSubtitle(stepId) {
+    switch (stepId) {
+    case OnboardingStepId.SignIn:
+        return localize(19092, "Sync settings, unlock AI features, and connect to GitHub");
+    case OnboardingStepId.Personalize:
+        return localize(19093, "Choose your theme and keyboard mapping");
+    case OnboardingStepId.AiPreference:
+        return localize(19094, "Choose how much AI collaboration fits your workflow");
+    }
+}
+const ONBOARDING_STEPS = [OnboardingStepId.SignIn, OnboardingStepId.Personalize];
+var AiCollaborationMode;
+(function(AiCollaborationMode) {
+    AiCollaborationMode["CodeFirst"] = "code-first";
+    AiCollaborationMode["Balanced"] = "balanced";
+    AiCollaborationMode["AgentForward"] = "agent-forward";
+})(AiCollaborationMode || (AiCollaborationMode = {}));
+const ONBOARDING_AI_PREFERENCE_OPTIONS = [{
+    id: AiCollaborationMode.CodeFirst,
+    label: ( localize(19095, "I Write the Code")),
+    description: ( localize(
+        19096,
+        "AI assists with suggestions and answers questions when you ask. You stay in control of every edit."
+    )),
+    icon: "edit"
+}, {
+    id: AiCollaborationMode.Balanced,
+    label: ( localize(19097, "Side by Side")),
+    description: ( localize(
+        19098,
+        "Inline suggestions plus a chat panel for deeper collaboration. A balance of writing and delegating."
+    )),
+    icon: "layoutSidebarRight"
+}, {
+    id: AiCollaborationMode.AgentForward,
+    label: ( localize(19099, "AI Takes the Lead")),
+    description: ( localize(
+        19100,
+        "Let the agent drive — describe what you want and review the result. Great for scaffolding and exploration."
+    )),
+    icon: "copilot"
+}];
+const ONBOARDING_STORAGE_KEY = "welcomeOnboarding.state";
+const GHE_DOMAIN_REGEX = /^[a-zA-Z0-9-]+$/;
+const GHE_FULL_URI_REGEX = /^(https:\/\/)?([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.ghe\.com\/?$/;
+var GheParseResultKind;
+(function(GheParseResultKind) {
+    GheParseResultKind["Empty"] = "empty";
+    GheParseResultKind["SingleWord"] = "singleWord";
+    GheParseResultKind["FullUri"] = "fullUri";
+    GheParseResultKind["Invalid"] = "invalid";
+})(GheParseResultKind || (GheParseResultKind = {}));
+function parseGheInstanceInput(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return {
+            kind: GheParseResultKind.Empty
+        };
+    }
+    if (GHE_DOMAIN_REGEX.test(trimmed)) {
+        return {
+            kind: GheParseResultKind.SingleWord,
+            resolvedUri: `https://${trimmed}.ghe.com`
+        };
+    }
+    if (GHE_FULL_URI_REGEX.test(trimmed)) {
+        const resolvedUri = trimmed.toLowerCase().startsWith("https://") ? trimmed : `https://${trimmed}`;
+        return {
+            kind: GheParseResultKind.FullUri,
+            resolvedUri
+        };
+    }
+    return {
+        kind: GheParseResultKind.Invalid
+    };
+}
+
+export { AiCollaborationMode, GHE_DOMAIN_REGEX, GHE_FULL_URI_REGEX, GheParseResultKind, ONBOARDING_AI_PREFERENCE_OPTIONS, ONBOARDING_STEPS, ONBOARDING_STORAGE_KEY, OnboardingStepId, getOnboardingStepSubtitle, getOnboardingStepTitle, parseGheInstanceInput };

package/vscode/src/vs/workbench/services/extensions/common/extHostCustomers.d.ts

@@ -0,0 +1,32 @@
+import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { BrandedService, IConstructorSignature } from "../../../../platform/instantiation/common/instantiation.js";
+import { ExtensionHostKind } from "./extensionHostKind.js";
+import { IExtensionHostProxy } from "./extensionHostProxy.js";
+import { IInternalExtensionService } from "./extensions.js";
+import { IRPCProtocol, ProxyIdentifier } from "./proxyIdentifier.js";
+export interface IExtHostContext extends IRPCProtocol {
+    readonly remoteAuthority: string | null;
+    readonly extensionHostKind: ExtensionHostKind;
+}
+export interface IInternalExtHostContext extends IExtHostContext {
+    readonly internalExtensionService: IInternalExtensionService;
+    _setExtensionHostProxy(extensionHostProxy: IExtensionHostProxy): void;
+    _setAllMainProxyIdentifiers(mainProxyIdentifiers: ProxyIdentifier<unknown>[]): void;
+}
+export type IExtHostNamedCustomer<T extends IDisposable> = [
+    ProxyIdentifier<T>,
+    IExtHostCustomerCtor<T>
+];
+export type IExtHostCustomerCtor<T extends IDisposable> = IConstructorSignature<T, [
+    IExtHostContext
+]>;
+export declare function extHostNamedCustomer<T extends IDisposable>(id: ProxyIdentifier<T>): <Services extends BrandedService[]>(ctor: {
+    new (context: IExtHostContext, ...services: Services): T;
+}) => void;
+export declare function extHostCustomer<T extends IDisposable, Services extends BrandedService[]>(ctor: {
+    new (context: IExtHostContext, ...services: Services): T;
+}): void;
+export declare namespace ExtHostCustomersRegistry {
+    function getNamedCustomers(): IExtHostNamedCustomer<IDisposable>[];
+    function getCustomers(): IExtHostCustomerCtor<IDisposable>[];
+}

package/vscode/src/vs/workbench/services/extensions/common/extHostCustomers.js

@@ -0,0 +1,45 @@
+
+
+function extHostNamedCustomer(id) {
+    return function(ctor) {
+        ExtHostCustomersRegistryImpl.INSTANCE.registerNamedCustomer(id, ctor);
+    };
+}
+function extHostCustomer(ctor) {
+    ExtHostCustomersRegistryImpl.INSTANCE.registerCustomer(ctor);
+}
+var ExtHostCustomersRegistry;
+(function(ExtHostCustomersRegistry) {
+    function getNamedCustomers() {
+        return ExtHostCustomersRegistryImpl.INSTANCE.getNamedCustomers();
+    }
+    ExtHostCustomersRegistry.getNamedCustomers = getNamedCustomers;
+    function getCustomers() {
+        return ExtHostCustomersRegistryImpl.INSTANCE.getCustomers();
+    }
+    ExtHostCustomersRegistry.getCustomers = getCustomers;
+})(ExtHostCustomersRegistry || (ExtHostCustomersRegistry = {}));
+class ExtHostCustomersRegistryImpl {
+    static {
+        this.INSTANCE = ( new ExtHostCustomersRegistryImpl());
+    }
+    constructor() {
+        this._namedCustomers = [];
+        this._customers = [];
+    }
+    registerNamedCustomer(id, ctor) {
+        const entry = [id, ctor];
+        this._namedCustomers.push(entry);
+    }
+    getNamedCustomers() {
+        return this._namedCustomers;
+    }
+    registerCustomer(ctor) {
+        this._customers.push(ctor);
+    }
+    getCustomers() {
+        return this._customers;
+    }
+}
+
+export { ExtHostCustomersRegistry, extHostCustomer, extHostNamedCustomer };

package/vscode/src/vs/platform/agentHost/common/agentHostEnablementService.d.ts

@@ -1,7 +0,0 @@
-import { RawContextKey } from "../../contextkey/common/contextkey.js";
-/** Context key set by {@link IAgentHostEnablementService}. Use in `when` clauses to gate Agent Host UI. */
-export declare const AGENT_HOST_ENABLED_CONTEXT_KEY: RawContextKey<boolean>;
-/** Hidden setting that gates the current-harness indicator for existing Agent Host sessions in the main VS Code window. */
-export declare const AgentHostExistingSessionHarnessPickerEnabledSettingId = "chat.editor.agentHost.existingSessionHarnessPicker.enabled";
-/** Effective setting or experiment value for the existing-session harness indicator in the main VS Code window. */
-export declare const AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY: RawContextKey<boolean>;

package/vscode/src/vs/platform/agentHost/common/agentHostEnablementService.js

@@ -1,92 +0,0 @@
-
-import { PolicyCategory } from '../../../base/common/policy.js';
-import { localize } from '../../../nls.js';
-import { Extensions } from '../../configuration/common/configurationRegistry.js';
-import { RawContextKey } from '../../contextkey/common/contextkey.js';
-import { Registry } from '../../registry/common/platform.js';
-
-const AGENT_HOST_ENABLED_CONTEXT_KEY = ( new RawContextKey("agentHostEnabled", false, {
-    type: "boolean",
-    description: ( localize(
-        1866,
-        "Whether Agent Host features are available and AI features are enabled in this window."
-    ))
-}));
-const AgentHostExistingSessionHarnessPickerEnabledSettingId = "chat.editor.agentHost.existingSessionHarnessPicker.enabled";
-const AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY = ( new RawContextKey("agentHostExistingSessionHarnessPickerEnabled", false, {
-    type: "boolean",
-    description: ( localize(
-        1867,
-        "Whether existing Agent Host sessions in the main VS Code window show the current harness as a disabled picker."
-    ))
-}));
-const configurationRegistry = ( Registry.as(Extensions.Configuration));
-configurationRegistry.registerConfiguration({
-    id: "chatAgentHost",
-    title: ( localize(1868, "Chat Agent Host")),
-    type: "object",
-    properties: {
-        "chat.editor.preferCopilotHarness": {
-            type: "boolean",
-            description: ( localize(
-                1869,
-                "When enabled, uses the Agent Host Copilot SDK whenever the local harness would otherwise be selected for a new editor chat session. Claude and Codex selections are unaffected."
-            )),
-            default: false,
-            tags: ["experimental"],
-            experiment: {
-                mode: "startup"
-            },
-            policy: {
-                name: "ChatEditorPreferCopilotHarness",
-                category: PolicyCategory.InteractiveSession,
-                minimumVersion: "1.134",
-                localization: {
-                    description: {
-                        key: "chat.editor.preferCopilotHarness.policy",
-                        value: ( localize(
-                            1870,
-                            "Configure whether VS Code uses the Agent Host Copilot SDK instead of the local harness for new editor chat sessions."
-                        ))
-                    }
-                }
-            }
-        },
-        "chat.defaultToCopilotHarness": {
-            type: "boolean",
-            description: ( localize(
-                1871,
-                "When enabled, new editor and panel chat sessions default to the Agent Host Copilot SDK instead of the local harness."
-            )),
-            default: false,
-            tags: ["experimental"],
-            experiment: {
-                mode: "startup"
-            }
-        },
-        "chat.editor.localAgent.enabled": {
-            type: "boolean",
-            description: ( localize(
-                1872,
-                "When enabled, shows the VS Code local chat harness in the chat picker. This setting is ignored in virtual workspaces, where the local chat harness is always available."
-            )),
-            default: true,
-            tags: ["experimental"],
-            experiment: {
-                mode: "startup"
-            }
-        },
-        [AgentHostExistingSessionHarnessPickerEnabledSettingId]: {
-            type: "boolean",
-            description: ( localize(
-                1873,
-                "When enabled, existing Agent Host sessions in the main VS Code window show the current harness as a disabled picker."
-            )),
-            default: false,
-            included: false,
-            tags: ["experimental"]
-        }
-    }
-});
-
-export { AGENT_HOST_ENABLED_CONTEXT_KEY, AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY, AgentHostExistingSessionHarnessPickerEnabledSettingId };

package/vscode/src/vs/platform/layout/browser/zIndexRegistry.d.ts

@@ -1,12 +0,0 @@
-export declare enum ZIndex {
-    Base = 0,
-    Sash = 35,
-    SuggestWidget = 40,
-    Hover = 50,
-    DragImage = 1000,
-    MenubarMenuItemsHolder = 2000,// quick-input-widget
-    ContextView = 2500,
-    ModalDialog = 2600,
-    PaneDropOverlay = 10000
-}
-export declare function registerZIndex(relativeLayer: ZIndex, z: number, name: string): string;

package/vscode/src/vs/platform/layout/browser/zIndexRegistry.js

@@ -1,64 +0,0 @@
-
-import { clearNode } from '../../../base/browser/dom.js';
-import { createStyleSheet, createCSSRule } from '../../../base/browser/domStylesheets.js';
-import { RunOnceScheduler } from '../../../base/common/async.js';
-
-var ZIndex;
-(function(ZIndex) {
-    ZIndex[ZIndex["Base"] = 0] = "Base";
-    ZIndex[ZIndex["Sash"] = 35] = "Sash";
-    ZIndex[ZIndex["SuggestWidget"] = 40] = "SuggestWidget";
-    ZIndex[ZIndex["Hover"] = 50] = "Hover";
-    ZIndex[ZIndex["DragImage"] = 1000] = "DragImage";
-    ZIndex[ZIndex["MenubarMenuItemsHolder"] = 2000] = "MenubarMenuItemsHolder";
-    ZIndex[ZIndex["ContextView"] = 2500] = "ContextView";
-    ZIndex[ZIndex["ModalDialog"] = 2600] = "ModalDialog";
-    ZIndex[ZIndex["PaneDropOverlay"] = 10000] = "PaneDropOverlay";
-})(ZIndex || (ZIndex = {}));
-const ZIndexValues = ( ( Object.keys(ZIndex)).filter(key => !isNaN(Number(key))).map(key => Number(key))).sort((a, b) => b - a);
-function findBase(z) {
-    for (const zi of ZIndexValues) {
-        if (z >= zi) {
-            return zi;
-        }
-    }
-    return -1;
-}
-class ZIndexRegistry {
-    constructor() {
-        this.styleSheet = createStyleSheet();
-        this.zIndexMap = ( new Map());
-        this.scheduler = ( new RunOnceScheduler(() => this.updateStyleElement(), 200));
-    }
-    registerZIndex(relativeLayer, z, name) {
-        if (this.zIndexMap.get(name)) {
-            throw ( new Error(`z-index with name ${name} has already been registered.`));
-        }
-        const proposedZValue = relativeLayer + z;
-        if (findBase(proposedZValue) !== relativeLayer) {
-            throw ( new Error(
-                `Relative layer: ${relativeLayer} + z-index: ${z} exceeds next layer ${proposedZValue}.`
-            ));
-        }
-        this.zIndexMap.set(name, proposedZValue);
-        this.scheduler.schedule();
-        return this.getVarName(name);
-    }
-    getVarName(name) {
-        return `--z-index-${name}`;
-    }
-    updateStyleElement() {
-        clearNode(this.styleSheet);
-        let ruleBuilder = "";
-        this.zIndexMap.forEach((zIndex, name) => {
-            ruleBuilder += `${this.getVarName(name)}: ${zIndex};\n`;
-        });
-        createCSSRule(":root, :host", ruleBuilder, this.styleSheet);
-    }
-}
-const zIndexRegistry = ( new ZIndexRegistry());
-function registerZIndex(relativeLayer, z, name) {
-    return zIndexRegistry.registerZIndex(relativeLayer, z, name);
-}
-
-export { ZIndex, registerZIndex };