@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/aquarium/browser/fish.d.ts

@@ -0,0 +1,68 @@
+/**
+ * VS Code logo "fish" used by the Agents window aquarium. Each fish is a small
+ * SVG element styled with `color:` so the silhouette inherits via `currentColor`,
+ * with animated body strips providing the swimming motion.
+ */
+/** The three VS Code release channel colors used as fish "species". */
+export declare enum FishSpecies {
+    Stable = "stable",
+    Insiders = "insiders",
+    Exploration = "exploration"
+}
+/** Pick a random species, weighted Stable > Insiders > Exploration. */
+export declare function pickRandomSpecies(): FishSpecies;
+/**
+ * Tear down the shared SVG defs container for the given document. Call when
+ * no fish are active in that document.
+ */
+export declare function disposeSharedFishDefs(targetDocument: Document): void;
+export interface IFishOptions {
+    readonly species: FishSpecies;
+    readonly size: number;
+    readonly positionX: number;
+    readonly positionY: number;
+    readonly velocityX: number;
+    readonly velocityY: number;
+}
+/**
+ * A swimming fish. Owns its DOM element and exposes mutable position/velocity
+ * for the aquarium's RAF loop to update.
+ */
+export declare class Fish {
+    readonly element: HTMLDivElement;
+    private readonly innerElement;
+    positionX: number;
+    positionY: number;
+    velocityX: number;
+    velocityY: number;
+    /** Current rendered size in px. Grows when the fish eats (see {@link grow}). */
+    size: number;
+    /** Timestamp until which this fish is in "panic" mode (faster, scattering). */
+    panicUntil: number;
+    /**
+     * The fish's preferred swim heading in radians. Drifts smoothly each frame
+     * via a small random delta — much less jittery than randomizing per-axis
+     * acceleration every frame.
+     */
+    wanderAngle: number;
+    /**
+     * Smoothed facing in [-1, 1] (1 = right, -1 = left). Eased toward
+     * sign(velocityX) each frame so direction changes look like a turn instead of
+     * a snap-flip.
+     */
+    private facing;
+    constructor(opts: IFishOptions, targetDocument: Document);
+    /**
+     * Write the current position/facing to the DOM.
+     *
+     * @param deltaSeconds seconds since last frame, used to ease facing toward
+     * velocity direction. Pass 0 for the initial paint.
+     */
+    applyTransform(deltaSeconds?: number): void;
+    /**
+     * Grow the fish by a multiplicative `factor`. Growth is intentionally
+     * unbounded — a fish that keeps eating keeps getting bigger. The element's
+     * footprint is updated so the body SVG (sized at 100%) scales with it.
+     */
+    grow(factor: number): void;
+}

package/vscode/src/vs/sessions/contrib/aquarium/browser/fish.js

@@ -0,0 +1,153 @@
+
+import { $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { VSCODE_LOGO_PATH } from './vscodeLogoPath.js';
+
+var FishSpecies;
+(function(FishSpecies) {
+    FishSpecies["Stable"] = "stable";
+    FishSpecies["Insiders"] = "insiders";
+    FishSpecies["Exploration"] = "exploration";
+})(FishSpecies || (FishSpecies = {}));
+const SPECIES_COLOR = {
+    [FishSpecies.Stable]: "#007ACC",
+    [FishSpecies.Insiders]: "#24bfa5",
+    [FishSpecies.Exploration]: "#E04F00"
+};
+function pickRandomSpecies() {
+    const roll = Math.random();
+    if (roll < 0.5) {
+        return FishSpecies.Stable;
+    }
+    if (roll < 0.8) {
+        return FishSpecies.Insiders;
+    }
+    return FishSpecies.Exploration;
+}
+function disposeSharedFishDefs(targetDocument) {
+    const container = sharedDefsByDocument.get(targetDocument);
+    if (container) {
+        container.remove();
+        sharedDefsByDocument.delete(targetDocument);
+    }
+}
+class Fish {
+    constructor(opts, targetDocument) {
+        this.panicUntil = 0;
+        this.facing = 1;
+        this.positionX = opts.positionX;
+        this.positionY = opts.positionY;
+        this.velocityX = opts.velocityX;
+        this.velocityY = opts.velocityY;
+        this.size = opts.size;
+        this.wanderAngle = Math.atan2(opts.velocityY, opts.velocityX);
+        this.element = $(".agents-aquarium-fish");
+        this.element.style.width = `${opts.size}px`;
+        this.element.style.height = `${opts.size}px`;
+        this.element.style.color = SPECIES_COLOR[opts.species];
+        this.innerElement = $(".agents-aquarium-fish-inner");
+        this.innerElement.appendChild(buildFishSvg(targetDocument));
+        this.element.appendChild(this.innerElement);
+        this.applyTransform();
+    }
+    applyTransform(deltaSeconds = 0) {
+        this.element.style.transform = `translate(${this.positionX.toFixed(2)}px, ${this.positionY.toFixed(2)}px)`;
+        const targetFacing = this.velocityX >= 0 ? 1 : -1;
+        if (deltaSeconds > 0) {
+            const easeFactor = 1 - Math.exp(-8 * deltaSeconds);
+            this.facing += (targetFacing - this.facing) * easeFactor;
+        } else {
+            this.facing = targetFacing;
+        }
+        const flipScaleX = Math.sign(this.facing) * Math.max(Math.abs(this.facing), 0.05);
+        this.innerElement.style.transform = `scaleX(${flipScaleX.toFixed(3)})`;
+    }
+    grow(factor) {
+        if (!isFinite(factor) || factor <= 0) {
+            return;
+        }
+        const newSize = this.size * factor;
+        const delta = newSize - this.size;
+        this.positionX -= delta / 2;
+        this.positionY -= delta / 2;
+        this.size = newSize;
+        this.element.style.transitionDelay = "0ms";
+        this.element.style.width = `${this.size}px`;
+        this.element.style.height = `${this.size}px`;
+        this.applyTransform();
+    }
+}
+const NUM_BODY_STRIPS = 8;
+const BODY_X_START = 5;
+const BODY_X_END = 90;
+const sharedDefsByDocument = ( new WeakMap());
+const SHARED_LOGO_SYMBOL_ID = "agents-aquarium-fish-logo";
+function ensureSharedDefs(targetDocument) {
+    if (( sharedDefsByDocument.has(targetDocument))) {
+        return;
+    }
+    const stripWidth = (BODY_X_END - BODY_X_START) / NUM_BODY_STRIPS;
+    const container = $.SVG("svg");
+    container.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+    container.setAttribute("width", "0");
+    container.setAttribute("height", "0");
+    container.setAttribute("aria-hidden", "true");
+    container.style.position = "absolute";
+    container.style.width = "0";
+    container.style.height = "0";
+    container.style.overflow = "hidden";
+    container.style.pointerEvents = "none";
+    container.appendChild(createVSCodeLogoSymbol());
+    const defs = $.SVG("defs");
+    for (let i = 0; i < NUM_BODY_STRIPS; i++) {
+        const clip = $.SVG("clipPath");
+        clip.setAttribute("id", `agents-aquarium-fish-clip-${i}`);
+        clip.setAttribute("clipPathUnits", "userSpaceOnUse");
+        const rect = $.SVG("rect");
+        rect.setAttribute("x", String(BODY_X_START + i * stripWidth));
+        rect.setAttribute("y", "-20");
+        rect.setAttribute("width", String(stripWidth + 0.8));
+        rect.setAttribute("height", "136");
+        clip.appendChild(rect);
+        defs.appendChild(clip);
+    }
+    container.appendChild(defs);
+    targetDocument.body.appendChild(container);
+    sharedDefsByDocument.set(targetDocument, container);
+}
+function createVSCodeLogoSymbol() {
+    const symbol = $.SVG("symbol");
+    symbol.setAttribute("id", SHARED_LOGO_SYMBOL_ID);
+    symbol.setAttribute("viewBox", "0 0 96 96");
+    symbol.setAttribute("overflow", "visible");
+    const logoPath = $.SVG("path");
+    logoPath.setAttribute("d", VSCODE_LOGO_PATH);
+    logoPath.setAttribute("fill", "currentColor");
+    logoPath.setAttribute("fill-rule", "evenodd");
+    symbol.appendChild(logoPath);
+    return symbol;
+}
+function buildFishSvg(targetDocument) {
+    ensureSharedDefs(targetDocument);
+    const svg = $.SVG("svg");
+    svg.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+    svg.setAttribute("focusable", "false");
+    svg.setAttribute("viewBox", "0 0 96 96");
+    svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+    svg.setAttribute("shape-rendering", "geometricPrecision");
+    const bodyGroup = $.SVG("g");
+    bodyGroup.setAttribute("class", "agents-aquarium-fish-body");
+    for (let i = 0; i < NUM_BODY_STRIPS; i++) {
+        const stripG = $.SVG("g");
+        stripG.setAttribute("class", "agents-aquarium-fish-strip");
+        stripG.style.setProperty("--agents-aquarium-strip-index", String(i));
+        const stripUse = $.SVG("use");
+        stripUse.setAttribute("href", `#${SHARED_LOGO_SYMBOL_ID}`);
+        stripUse.setAttribute("clip-path", `url(#agents-aquarium-fish-clip-${i})`);
+        stripG.appendChild(stripUse);
+        bodyGroup.appendChild(stripG);
+    }
+    svg.appendChild(bodyGroup);
+    return svg;
+}
+
+export { Fish, FishSpecies, disposeSharedFishDefs, pickRandomSpecies };

package/vscode/src/vs/sessions/contrib/aquarium/browser/fishFeedingStreak.d.ts

@@ -0,0 +1,58 @@
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+export type FishHungerState = "happy" | "neutral" | "sad" | "verySad";
+/** Result of recording a feed, describing how the streak changed. */
+export interface IFeedResult {
+    /** The streak count after this feed. */
+    readonly count: number;
+    /** True when this feed started a brand new streak (none was alive or revivable). */
+    readonly started: boolean;
+    /** True when this feed revived a previously-died streak. */
+    readonly revived: boolean;
+}
+/**
+ * Tracks how often the user feeds the aquarium fish as a persisted "streak".
+ *
+ * Feeding once on consecutive local calendar days grows the streak. Missing a
+ * full day kills it at local midnight, while parking the count for revival.
+ */
+export declare class FishFeedingStreak {
+    private readonly storageService;
+    private readonly now;
+    private readonly getCalendarDay;
+    constructor(storageService: IStorageService, now?: () => number, getCalendarDay?: (timestamp: number) => number);
+    private get lastFedAt();
+    private get lastFedDay();
+    private get rawCount();
+    /** The count of a previously-died streak that is available to revive (0 if none). */
+    get revivableCount(): number;
+    /** Whether the current streak was fed today or yesterday. */
+    get isAlive(): boolean;
+    private isAliveAt;
+    /** The current live streak count, or 0 when no streak is alive. */
+    get count(): number;
+    /** The fish mood for the current streak and local time of day. */
+    get hungerState(): FishHungerState;
+    /** Delay until the next local time boundary that can change {@link hungerState}. */
+    get millisecondsUntilHungerStateChange(): number | undefined;
+    /**
+     * Detect a streak that has aged out and park its count as revivable. Safe to
+     * call repeatedly. Returns the count that just died, or 0 if nothing died.
+     */
+    collectExpired(): number;
+    private collectExpiredAt;
+    /**
+     * Record that a fish was just fed. The count increases once per local
+     * calendar day, and a previously-died streak is restored to its parked count.
+     */
+    recordFeed(): IFeedResult;
+    private normalizePersistedState;
+    /**
+     * Force the streak into a specific state. Intended for development and
+     * demos only (see the "Simulate Fish Feeding Streak" command). When
+     * `alive` is true the streak is fed "now" so it counts as live; otherwise
+     * it is parked as a {@link revivableCount} died streak. A `count` of 0 (or
+     * less) clears all streak state.
+     */
+    simulate(count: number, alive: boolean): void;
+    private store;
+}

package/vscode/src/vs/sessions/contrib/aquarium/browser/fishFeedingStreak.js

@@ -0,0 +1,172 @@
+
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+
+const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+const HOURS_PER_HUNGER_STATE = 6;
+const STREAK_COUNT_KEY = "sessions.aquarium.streak.count";
+const STREAK_LAST_FED_KEY = "sessions.aquarium.streak.lastFedAt";
+const STREAK_LAST_FED_DAY_KEY = "sessions.aquarium.streak.lastFedDay";
+const STREAK_REVIVABLE_KEY = "sessions.aquarium.streak.revivable";
+function getLocalCalendarDay(timestamp) {
+    const date = ( new Date(timestamp));
+    return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) / MILLISECONDS_PER_DAY;
+}
+class FishFeedingStreak {
+    constructor(storageService, now = Date.now, getCalendarDay = getLocalCalendarDay) {
+        this.storageService = storageService;
+        this.now = now;
+        this.getCalendarDay = getCalendarDay;
+        this.normalizePersistedState();
+    }
+    get lastFedAt() {
+        return this.storageService.getNumber(STREAK_LAST_FED_KEY, StorageScope.APPLICATION, 0);
+    }
+    get lastFedDay() {
+        return this.storageService.getNumber(STREAK_LAST_FED_DAY_KEY, StorageScope.APPLICATION);
+    }
+    get rawCount() {
+        return this.storageService.getNumber(STREAK_COUNT_KEY, StorageScope.APPLICATION, 0);
+    }
+    get revivableCount() {
+        return this.storageService.getNumber(STREAK_REVIVABLE_KEY, StorageScope.APPLICATION, 0);
+    }
+    get isAlive() {
+        return this.isAliveAt(this.now());
+    }
+    isAliveAt(now) {
+        const lastFedDay = this.lastFedDay;
+        return this.rawCount > 0 && lastFedDay !== undefined && this.getCalendarDay(now) - lastFedDay <= 1;
+    }
+    get count() {
+        return this.isAlive ? this.rawCount : 0;
+    }
+    get hungerState() {
+        const count = this.rawCount;
+        if (count <= 0) {
+            return this.revivableCount > 0 ? "verySad" : "happy";
+        }
+        const now = this.now();
+        const lastFedDay = this.lastFedDay;
+        if (lastFedDay === undefined) {
+            return "happy";
+        }
+        const daysSinceFed = this.getCalendarDay(now) - lastFedDay;
+        if (daysSinceFed <= 0) {
+            return "happy";
+        }
+        if (daysSinceFed > 1) {
+            return "verySad";
+        }
+        const hour = ( new Date(now)).getHours();
+        if (hour < HOURS_PER_HUNGER_STATE) {
+            return "happy";
+        }
+        if (hour < HOURS_PER_HUNGER_STATE * 2) {
+            return "neutral";
+        }
+        if (hour < HOURS_PER_HUNGER_STATE * 3) {
+            return "sad";
+        }
+        return "verySad";
+    }
+    get millisecondsUntilHungerStateChange() {
+        const lastFedDay = this.lastFedDay;
+        if (this.rawCount <= 0 || lastFedDay === undefined) {
+            return undefined;
+        }
+        const now = this.now();
+        const daysSinceFed = this.getCalendarDay(now) - lastFedDay;
+        if (daysSinceFed < 0 || daysSinceFed > 1) {
+            return undefined;
+        }
+        const nextBoundary = ( new Date(now));
+        const nextHour = daysSinceFed === 0 ? 24 : (Math.floor(nextBoundary.getHours() / HOURS_PER_HUNGER_STATE) + 1) * HOURS_PER_HUNGER_STATE;
+        nextBoundary.setHours(nextHour, 0, 0, 0);
+        return Math.max(1, nextBoundary.getTime() - now);
+    }
+    collectExpired() {
+        return this.collectExpiredAt(this.now());
+    }
+    collectExpiredAt(now) {
+        const count = this.rawCount;
+        if (count > 0 && !this.isAliveAt(now)) {
+            const revivable = Math.max(this.revivableCount, count);
+            this.store(STREAK_REVIVABLE_KEY, revivable);
+            this.store(STREAK_COUNT_KEY, 0);
+            return count;
+        }
+        return 0;
+    }
+    recordFeed() {
+        const now = this.now();
+        const calendarDay = this.getCalendarDay(now);
+        this.collectExpiredAt(now);
+        const alive = this.isAliveAt(now);
+        const lastFedDay = this.lastFedDay;
+        const revivable = this.revivableCount;
+        let count;
+        let revived = false;
+        if (alive && lastFedDay !== undefined && calendarDay > lastFedDay) {
+            count = this.rawCount + 1;
+            this.store(STREAK_COUNT_KEY, count);
+        } else if (alive) {
+            count = this.rawCount;
+        } else if (revivable > 0) {
+            count = revivable;
+            revived = true;
+            this.store(STREAK_COUNT_KEY, count);
+        } else {
+            count = 1;
+            this.store(STREAK_COUNT_KEY, count);
+        }
+        this.store(STREAK_LAST_FED_KEY, now);
+        this.store(STREAK_LAST_FED_DAY_KEY, calendarDay);
+        if (revivable > 0) {
+            this.store(STREAK_REVIVABLE_KEY, 0);
+        }
+        return {
+            count,
+            started: !alive && !revived,
+            revived
+        };
+    }
+    normalizePersistedState() {
+        if (this.rawCount <= 0) {
+            return;
+        }
+        let lastFedAt = this.lastFedAt;
+        if (lastFedAt <= 0) {
+            lastFedAt = this.now();
+            this.store(STREAK_LAST_FED_KEY, lastFedAt);
+        }
+        if (this.lastFedDay === undefined) {
+            this.store(STREAK_LAST_FED_DAY_KEY, this.getCalendarDay(lastFedAt));
+        }
+    }
+    simulate(count, alive) {
+        if (count <= 0) {
+            this.store(STREAK_COUNT_KEY, 0);
+            this.store(STREAK_LAST_FED_KEY, 0);
+            this.storageService.remove(STREAK_LAST_FED_DAY_KEY, StorageScope.APPLICATION);
+            this.store(STREAK_REVIVABLE_KEY, 0);
+            return;
+        }
+        if (alive) {
+            const now = this.now();
+            this.store(STREAK_COUNT_KEY, count);
+            this.store(STREAK_LAST_FED_KEY, now);
+            this.store(STREAK_LAST_FED_DAY_KEY, this.getCalendarDay(now));
+            this.store(STREAK_REVIVABLE_KEY, 0);
+        } else {
+            this.store(STREAK_COUNT_KEY, 0);
+            this.store(STREAK_LAST_FED_KEY, 0);
+            this.storageService.remove(STREAK_LAST_FED_DAY_KEY, StorageScope.APPLICATION);
+            this.store(STREAK_REVIVABLE_KEY, count);
+        }
+    }
+    store(key, value) {
+        this.storageService.store(key, value, StorageScope.APPLICATION, StorageTarget.USER);
+    }
+}
+
+export { FishFeedingStreak };