@dimina-kit/devtools 0.4.0-dev.20260803105710 → 0.4.0-dev.20260828092243

package/dist/main/services/notifications/renderer-notifier.js

@@ -1,4 +1,5 @@
-import { ProjectChannel, SessionChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
+import { ProjectChannel, SessionChannel, WindowChannel, WorkbenchSettingsChannel, EditorChannel, } from '../../../shared/ipc-channels.js';
+import { SettingsChannel, PopoverChannel, TooltipChannel, ProjectCreateChannel, UpdateChannel, ViewChannel, } from '../../../shared/ipc-channels-overlays.js';
 /** Safely resolve a WebContents, skipping destroyed / missing targets. */
 function liveWebContents(wc) {
     if (!wc)
@@ -45,15 +46,42 @@ export function createRendererNotifier(ctx) {
         hostToolbarHeightChanged(height) {
             sendToMain(ViewChannel.HostToolbarHeightChanged, height);
         },
+        hostSidebarWidthChanged(width) {
+            sendToMain(ViewChannel.HostSidebarWidthChanged, width);
+        },
+        hostSidebarCategorySelected(category) {
+            sendToMain(ViewChannel.HostSidebarCategorySelected, category);
+        },
         editorOpenFile(payload) {
             sendToMain(EditorChannel.OpenFile, payload);
         },
+        projectCreateSubmitted(payload) {
+            sendToMain(ProjectCreateChannel.Submitted, payload);
+        },
         popoverInit(popoverView, payload) {
             const wc = liveWebContents(popoverView.webContents);
             if (!wc)
                 return;
             wc.send(PopoverChannel.Init, payload);
         },
+        tooltipInit(tooltipView, payload) {
+            const wc = liveWebContents(tooltipView.webContents);
+            if (!wc)
+                return;
+            wc.send(TooltipChannel.Init, payload);
+        },
+        projectCreateInit(dialogView, payload) {
+            const wc = liveWebContents(dialogView.webContents);
+            if (!wc)
+                return;
+            wc.send(ProjectCreateChannel.Init, payload);
+        },
+        updateAvailable(dialogView, payload) {
+            const wc = liveWebContents(dialogView.webContents);
+            if (!wc)
+                return;
+            wc.send(UpdateChannel.Available, payload);
+        },
         settingsInit(payload) {
             const wc = liveWebContents(ctx.views.getSettingsWebContents());
             if (!wc)

package/dist/main/services/projects/project-repository.d.ts

@@ -1,9 +1,12 @@
-import type { CompileConfig } from '../../../shared/types.js';
+import type { CompileConfig, ProjectType } from '../../../shared/types.js';
+export type { ProjectType };
 export interface Project {
     name: string;
     path: string;
     lastOpened?: string | null;
     compileConfig?: CompileConfig;
+    /** Absent on projects added before mini-game support — treat as 'miniprogram'. */
+    type?: ProjectType;
 }
 export interface ProjectPages {
     pages: string[];

package/dist/main/services/projects/project-repository.js

@@ -4,6 +4,44 @@ import fs from 'fs';
 import { DEFAULT_SCENE } from '../../../shared/constants.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('projects');
+/**
+ * Merge project.config.json + project.private.config.json (private wins),
+ * mirroring `dimina/fe/packages/compiler/src/env.js`'s `storeInfo`.
+ */
+function readProjectConfig(dirPath) {
+    let merged = {};
+    for (const fileName of ['project.config.json', 'project.private.config.json']) {
+        const configPath = path.join(dirPath, fileName);
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            merged = { ...merged, ...JSON.parse(fs.readFileSync(configPath, 'utf-8')) };
+        }
+        catch (err) {
+            log.warn(`Failed to parse ${configPath}`, err);
+        }
+    }
+    return merged;
+}
+/**
+ * Mirrors `dimina/fe/packages/compiler/src/env.js`'s `detectRuntimeType` —
+ * an explicit `compileType` wins, else a mini-game is inferred from
+ * game.json + game.js/.ts with no app.json present.
+ */
+function detectRuntimeType(dirPath) {
+    const compileType = readProjectConfig(dirPath).compileType;
+    if (compileType === 'game')
+        return 'minigame';
+    if (compileType === 'miniprogram')
+        return 'miniprogram';
+    const hasMiniProgramConfig = fs.existsSync(path.join(dirPath, 'app.json'));
+    const hasMiniGameConfig = fs.existsSync(path.join(dirPath, 'game.json'));
+    const hasMiniGameEntry = ['game.js', 'game.ts']
+        .some((fileName) => fs.existsSync(path.join(dirPath, fileName)));
+    if (!hasMiniProgramConfig && hasMiniGameConfig && hasMiniGameEntry)
+        return 'minigame';
+    return 'miniprogram';
+}
 function getProjectsFile() {
     return path.join(app.getPath('userData'), 'dimina-projects.json');
 }
@@ -28,6 +66,12 @@ export function validateProjectDir(dirPath) {
     if (!fs.existsSync(dirPath)) {
         return `小程序目录不存在：${dirPath}`;
     }
+    if (detectRuntimeType(dirPath) === 'minigame') {
+        if (!fs.existsSync(path.join(dirPath, 'game.json'))) {
+            return '该目录缺少 game.json，请选择包含小游戏源码的目录';
+        }
+        return null;
+    }
     if (!fs.existsSync(path.join(dirPath, 'app.json'))) {
         const configPath = path.join(dirPath, 'project.config.json');
         if (fs.existsSync(configPath)) {
@@ -63,10 +107,11 @@ export function addProject(dirPath) {
     catch (err) {
         log.warn('Failed to read project name from config', err);
     }
-    const project = { name, path: dirPath, lastOpened: null };
+    const type = detectRuntimeType(dirPath);
+    const project = { name, path: dirPath, lastOpened: null, type };
     const idx = projects.findIndex((p) => p.path === dirPath);
     if (idx >= 0) {
-        projects[idx] = { ...projects[idx], name };
+        projects[idx] = { ...projects[idx], name, type };
     }
     else {
         projects.unshift(project);
@@ -88,13 +133,26 @@ export function updateLastOpened(dirPath) {
 export function getCompileConfig(dirPath) {
     const projects = load();
     const project = projects.find((p) => p.path === dirPath);
-    return (project?.compileConfig ?? {
-        startPage: '',
+    if (project?.compileConfig)
+        return project.compileConfig;
+    // Default startPage to the project's real entry page (mirrors
+    // getProjectPages: 'game' for mini-games, app.json's entryPagePath for
+    // mini-programs) rather than a mini-program-only literal — the simulator
+    // URL builders' own 'pages/index/index' fallback only fires when this is
+    // still empty (unreadable/malformed manifest).
+    return {
+        startPage: getProjectPages(dirPath).entryPagePath,
         scene: DEFAULT_SCENE,
         queryParams: [],
-    });
+    };
 }
 export function getProjectPages(dirPath) {
+    if (detectRuntimeType(dirPath) === 'minigame') {
+        // Mini-games have no page router — the compiler always emits a single
+        // synthetic 'game' entry (dimina/fe/packages/compiler/src/env.js
+        // storeAppConfig), mirrored here rather than reading a nonexistent app.json.
+        return { pages: ['game'], entryPagePath: 'game' };
+    }
     const appJsonPath = path.join(dirPath, 'app.json');
     try {
         const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));

package/dist/main/services/simulator-current-page/index.d.ts

@@ -6,9 +6,11 @@
  * page a nested render-host `<webview>`), not a renderer `<webview>` the main
  * window can observe — so in-app navigation (navigateTo / switchTab / back)
  * never reaches the renderer's `<webview>` did-navigate events. This service
- * taps the bridge's active-page signal and pushes the new route to the
- * main-window renderer (`SimulatorChannel.CurrentPage`), keeping the toolbar in
- * sync without polling.
+ * taps the bridge's active-page signal and pushes the route — page path plus
+ * its launch query, so the simulator's page-path bar shows params just like
+ * WeChat DevTools and a recompile can restore them — to the main-window
+ * renderer (`SimulatorChannel.CurrentPage`), keeping the toolbar in sync
+ * without polling.
  *
  * Inert on the default dimina-fe path (which derives the current page from the
  * simulator `<webview>`'s navigation events); app.ts gates the call on

package/dist/main/services/simulator-current-page/index.js

@@ -1,4 +1,5 @@
 import { SimulatorChannel } from '../../../shared/ipc-channels.js';
+import { encodePageSpec } from '../../../shared/simulator-route.js';
 import { DisposableRegistry } from '@dimina-kit/electron-deck/main';
 export function setupSimulatorCurrentPage(host, options) {
     const registry = new DisposableRegistry();
@@ -11,7 +12,13 @@ export function setupSimulatorCurrentPage(host, options) {
             return;
         if (host.isDestroyed())
             return;
-        host.send(SimulatorChannel.CurrentPage, ev.pagePath);
+        // Bridge queries are `Record<string, unknown>` (they may hold numbers from
+        // the URL); the route format wants strings. encodePageSpec re-encodes with
+        // `?k=v&…` so the renderer can decode it back into { pagePath, query }.
+        const query = {};
+        for (const [k, v] of Object.entries(ev.query ?? {}))
+            query[k] = String(v);
+        host.send(SimulatorChannel.CurrentPage, encodePageSpec({ pagePath: ev.pagePath, query }));
     });
     registry.add(off);
     return registry;

package/dist/main/services/update/update-manager.d.ts

@@ -1,9 +1,13 @@
-import { BrowserWindow } from 'electron';
 import type { UpdateChecker, UpdateInfo } from '../../../shared/types.js';
 import { type SenderPolicy } from '../../utils/ipc-registry.js';
 export interface UpdateManagerOptions {
     checker: UpdateChecker;
-    mainWindow: BrowserWindow;
+    /** Show the update-available overlay panel, fed the discovered update's info. */
+    showUpdatePanel: (info: UpdateInfo) => void;
+    /** Forward a download-progress tick into the (already-shown) update overlay. */
+    notifyDownloadProgress: (percent: number) => void;
+    /** Hide the update overlay panel — the renderer's close (any path) forwards here. */
+    hideUpdatePanel: () => void;
     /** Check interval in milliseconds. Default: 1 hour */
     checkInterval?: number;
     /** Delay before the first check after startup in ms. Default: 5000 */
@@ -20,7 +24,9 @@ export interface UpdateManagerOptions {
 }
 export declare class UpdateManager {
     private checker;
-    private mainWindow;
+    private showUpdatePanel;
+    private notifyDownloadProgress;
+    private hideUpdatePanel;
     private getCurrentVersion;
     private latestUpdate;
     private downloadedPath;
@@ -37,6 +43,14 @@ export declare class UpdateManager {
     private timer;
     private initialTimer;
     private ipc;
+    /**
+     * Set by `dispose()`. Clearing the timers only stops FUTURE ticks — an
+     * in-flight `checkAndNotify()` invocation (already past its `await
+     * this.check()`) has no timer left to cancel it, and would otherwise call
+     * `showUpdatePanel` after dispose has torn down the overlay panel that
+     * owns (e.g. `views.disposeAll()` destroying its WebContentsView).
+     */
+    private disposed;
     constructor(opts: UpdateManagerOptions);
     private registerIpc;
     check(): Promise<{

package/dist/main/services/update/update-manager.js

@@ -1,9 +1,11 @@
 import { app, shell } from 'electron';
-import { UpdateChannel } from '../../../shared/ipc-channels.js';
+import { UpdateChannel } from '../../../shared/ipc-channels-overlays.js';
 import { IpcRegistry } from '../../utils/ipc-registry.js';
 export class UpdateManager {
     checker;
-    mainWindow;
+    showUpdatePanel;
+    notifyDownloadProgress;
+    hideUpdatePanel;
     getCurrentVersion;
     latestUpdate = null;
     downloadedPath = null;
@@ -20,9 +22,19 @@ export class UpdateManager {
     timer = null;
     initialTimer = null;
     ipc;
+    /**
+     * Set by `dispose()`. Clearing the timers only stops FUTURE ticks — an
+     * in-flight `checkAndNotify()` invocation (already past its `await
+     * this.check()`) has no timer left to cancel it, and would otherwise call
+     * `showUpdatePanel` after dispose has torn down the overlay panel that
+     * owns (e.g. `views.disposeAll()` destroying its WebContentsView).
+     */
+    disposed = false;
     constructor(opts) {
         this.checker = opts.checker;
-        this.mainWindow = opts.mainWindow;
+        this.showUpdatePanel = opts.showUpdatePanel;
+        this.notifyDownloadProgress = opts.notifyDownloadProgress;
+        this.hideUpdatePanel = opts.hideUpdatePanel;
         this.getCurrentVersion = opts.getCurrentVersion ?? (() => app.getVersion());
         this.ipc = new IpcRegistry(opts.senderPolicy);
         this.registerIpc();
@@ -32,7 +44,8 @@ export class UpdateManager {
         this.ipc
             .handle(UpdateChannel.Check, async () => this.check())
             .handle(UpdateChannel.Download, async () => this.download())
-            .handle(UpdateChannel.Install, async () => this.install());
+            .handle(UpdateChannel.Install, async () => this.install())
+            .on(UpdateChannel.Close, () => this.hideUpdatePanel());
     }
     async check() {
         try {
@@ -69,7 +82,7 @@ export class UpdateManager {
         }
         try {
             const filePath = await this.checker.downloadUpdate(this.latestUpdate, (percent) => {
-                this.mainWindow.webContents.send(UpdateChannel.DownloadProgress, { percent });
+                this.notifyDownloadProgress(percent);
             });
             this.downloadedPath = filePath;
             return { success: true, filePath };
@@ -104,6 +117,7 @@ export class UpdateManager {
      * the timer clears + handler removals are scheduled synchronously.
      */
     dispose() {
+        this.disposed = true;
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;
@@ -120,12 +134,17 @@ export class UpdateManager {
     }
     async checkAndNotify() {
         const result = await this.check();
+        // dispose() only cancels the timers that SCHEDULE future ticks — a tick
+        // already in flight (past this await) has nothing left to cancel it, and
+        // must not call into a torn-down panel/registry after the fact.
+        if (this.disposed)
+            return;
         if (!result.hasUpdate || !result.info)
             return;
         if (this.hasNotified)
             return;
         this.hasNotified = true;
-        this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
+        this.showUpdatePanel(result.info);
     }
 }
 //# sourceMappingURL=update-manager.js.map

package/dist/main/services/views/clear-console-filter.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Clears the right-panel Console panel's text-filter box on a FRESH project
+ * open, together with the stale persisted keys behind it.
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────
+ * The Console filter text is a DevTools-owned setting that DevTools itself
+ * persists: it lives on the `devtools://` origin's localStorage, backed by the
+ * default session's on-disk storage (verified on disk:
+ * `~/Library/Application Support/Dimina DevTools/Local Storage/leveldb` holds a
+ * `console.textFilter` entry). An earlier implementation of the internal-log
+ * hiding wrote `-/^\[service\]/`-style negative filters straight into the box
+ * (see console-filter.ts's header for that history); that value still sits in
+ * localStorage and is restored on every project reopen / app restart. We do NOT
+ * fight DevTools' persistence mechanism here — instead, on each fresh project
+ * open we remove the stale keys and reset the visible box, so a project starts
+ * with the developer's own filter surface genuinely empty.
+ *
+ * ── When it runs ─────────────────────────────────────────────────────────
+ * Only the PROJECT-OPEN path arms this (see native-simulator-devtools-host.ts:
+ * `attach()` sets the flag; the injection consumes it once). Service-host pool
+ * swaps (hot-reload respawn) rebuild the front-end host too, but deliberately do
+ * NOT clear — the developer may legitimately have typed a filter during the
+ * session and a respawn must not drop in-flight work.
+ *
+ * ── Discipline (mirrors console-filter.ts) ────────────────────────────────
+ * In-realm bootstrap probe before touching `Console.ConsoleView.instance()` (an
+ * early construction transitively creates IssuesManager and permanently kills
+ * the front-end's own bootstrap — see frontend-bootstrap-gate.ts); bounded
+ * retry; silent degradation on any failure. The main process additionally holds
+ * this whole injection behind `whenFrontendBootstrapped`.
+ */
+/**
+ * Build the `executeJavaScript` source that clears the Console filter box.
+ *
+ * Two levers, belt-and-suspenders:
+ *   1. remove the stale persisted keys (`console.textFilter` — the on-disk
+ *      leftover we actually observed, and its kebab-case sibling) so a Console
+ *      view constructed after this script reads an empty setting;
+ *   2. reset the already-constructed panel's visible box via
+ *      `filter.textFilterUI.setValue('')`, which persists the empty value back
+ *      through the panel's own setting path.
+ */
+export declare function buildClearConsoleFilterScript(): string;
+//# sourceMappingURL=clear-console-filter.d.ts.map

package/dist/main/services/views/clear-console-filter.js

@@ -0,0 +1,86 @@
+/**
+ * Clears the right-panel Console panel's text-filter box on a FRESH project
+ * open, together with the stale persisted keys behind it.
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────
+ * The Console filter text is a DevTools-owned setting that DevTools itself
+ * persists: it lives on the `devtools://` origin's localStorage, backed by the
+ * default session's on-disk storage (verified on disk:
+ * `~/Library/Application Support/Dimina DevTools/Local Storage/leveldb` holds a
+ * `console.textFilter` entry). An earlier implementation of the internal-log
+ * hiding wrote `-/^\[service\]/`-style negative filters straight into the box
+ * (see console-filter.ts's header for that history); that value still sits in
+ * localStorage and is restored on every project reopen / app restart. We do NOT
+ * fight DevTools' persistence mechanism here — instead, on each fresh project
+ * open we remove the stale keys and reset the visible box, so a project starts
+ * with the developer's own filter surface genuinely empty.
+ *
+ * ── When it runs ─────────────────────────────────────────────────────────
+ * Only the PROJECT-OPEN path arms this (see native-simulator-devtools-host.ts:
+ * `attach()` sets the flag; the injection consumes it once). Service-host pool
+ * swaps (hot-reload respawn) rebuild the front-end host too, but deliberately do
+ * NOT clear — the developer may legitimately have typed a filter during the
+ * session and a respawn must not drop in-flight work.
+ *
+ * ── Discipline (mirrors console-filter.ts) ────────────────────────────────
+ * In-realm bootstrap probe before touching `Console.ConsoleView.instance()` (an
+ * early construction transitively creates IssuesManager and permanently kills
+ * the front-end's own bootstrap — see frontend-bootstrap-gate.ts); bounded
+ * retry; silent degradation on any failure. The main process additionally holds
+ * this whole injection behind `whenFrontendBootstrapped`.
+ */
+/**
+ * Build the `executeJavaScript` source that clears the Console filter box.
+ *
+ * Two levers, belt-and-suspenders:
+ *   1. remove the stale persisted keys (`console.textFilter` — the on-disk
+ *      leftover we actually observed, and its kebab-case sibling) so a Console
+ *      view constructed after this script reads an empty setting;
+ *   2. reset the already-constructed panel's visible box via
+ *      `filter.textFilterUI.setValue('')`, which persists the empty value back
+ *      through the panel's own setting path.
+ */
+export function buildClearConsoleFilterScript() {
+    return `(function(){
+    var attempts = 0;
+    var MAX = 100;
+    function bootstrapReady() {
+      try {
+        var eui = globalThis.EUI;
+        if (!eui || !eui.ShortcutRegistry || !eui.ShortcutRegistry.ShortcutRegistry) return false;
+        eui.ShortcutRegistry.ShortcutRegistry.instance();
+        return true;
+      } catch (_) { return false; }
+    }
+    function tryClear() {
+      attempts++;
+      var scheduleRetry = attempts < MAX;
+      if (!bootstrapReady()) {
+        if (scheduleRetry) { setTimeout(tryClear, 100); return; }
+        return;
+      }
+      try {
+        try { localStorage.removeItem('console.textFilter'); } catch(_) {}
+        try { localStorage.removeItem('console.text-filter'); } catch(_) {}
+        var ConsoleNS = globalThis.Console;
+        var view = ConsoleNS && ConsoleNS.ConsoleView ? ConsoleNS.ConsoleView.instance() : null;
+        var f = view ? view.filter : null;
+        var box = f && f.textFilterUI;
+        if (!box || typeof box.setValue !== 'function' || typeof box.value !== 'function') {
+          if (scheduleRetry) { setTimeout(tryClear, 100); return; }
+          return;
+        }
+        var current = box.value();
+        if (current) {
+          box.setValue('');
+          if (typeof f.updateCurrentFilter === 'function') f.updateCurrentFilter();
+          if (typeof f.onFilterChanged === 'function') f.onFilterChanged();
+        }
+      } catch(_) {
+        if (scheduleRetry) setTimeout(tryClear, 100);
+      }
+    }
+    tryClear();
+  })()`;
+}
+//# sourceMappingURL=clear-console-filter.js.map

package/dist/main/services/views/console-filter-test-fixtures.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Fakes shaped like the Chrome DevTools front-end objects
+ * `buildInternalLogHideScript()`'s generated source talks to, shared by
+ * console-filter.test.ts (what the hook does) and
+ * console-filter-degradation.test.ts (what happens when the panel is not there
+ * or the front-end API has moved).
+ *
+ * These are STUBS OF A FOREIGN API, not a second implementation: every test
+ * runs the real generated script string through `new Function`, so the fakes
+ * only have to expose the handful of members the script reaches for. What they
+ * cannot prove is that the real front-end still has those members — that is
+ * e2e/console-filter-live.spec.ts's job.
+ */
+import { type Mock } from 'vitest';
+export interface FakeViewMessage {
+    consoleMessage: () => {
+        messageText: string;
+    };
+}
+export type ShouldBeVisible = (this: unknown, viewMessage: FakeViewMessage) => boolean;
+export interface FakeConsoleFilterClass {
+    original: Mock<ShouldBeVisible>;
+    prototype: {
+        shouldBeVisible?: ShouldBeVisible;
+    };
+    newInstance: () => {
+        shouldBeVisible: ShouldBeVisible;
+    };
+}
+export interface FakeConsoleView {
+    view: {
+        filter: {
+            currentFilter: object;
+            textFilterUI: {
+                value: () => string;
+                setValue: Mock<(next: string) => void>;
+            };
+        };
+        onFilterChanged: Mock<() => void>;
+    };
+    setValue: Mock<(next: string) => void>;
+    onFilterChanged: Mock<() => void>;
+    filterText: () => string;
+}
+/** A ConsoleViewMessage stub exposing the single field the hook inspects. */
+export declare function createViewMessage(messageText: string): FakeViewMessage;
+/**
+ * A ConsoleFilter "class": one shared prototype carrying `shouldBeVisible`,
+ * plus a factory for further instances off that same prototype — what
+ * `ConsoleFilter.clone()` produces. `original` is the pre-existing
+ * implementation the hook must delegate to.
+ */
+export declare function createConsoleFilterClass(verdict?: boolean | ShouldBeVisible): FakeConsoleFilterClass;
+/** A ConsoleFilter whose prototype chain carries no `shouldBeVisible` at all. */
+export declare function createConsoleFilterClassWithoutHook(): {
+    prototype: Record<string, unknown>;
+    newInstance: () => object;
+};
+/** The ConsoleView surface the script reaches through: filter + refresh entry point. */
+export declare function createConsoleView(currentFilter: object, initialFilterText?: string): FakeConsoleView;
+/** A front end whose bootstrap has finished: the probe returns instead of throwing. */
+export declare function createReadyEui(): {
+    ShortcutRegistry: {
+        ShortcutRegistry: {
+            instance: () => {};
+        };
+    };
+};
+export declare function createGlobalThis(view: unknown): {
+    EUI: {
+        ShortcutRegistry: {
+            ShortcutRegistry: {
+                instance: () => {};
+            };
+        };
+    };
+    Console: {
+        ConsoleView: {
+            instance: () => unknown;
+        };
+    };
+};
+export declare function run(script: string, fakeGlobalThis: object): void;
+/**
+ * Collect `console.warn` output as plain strings for the whole test file.
+ *
+ * Reading `warnSpy.mock.calls` instead would hand every assertion an untyped
+ * `any[]`; the degradation tests care about WHICH warning was emitted, so the
+ * text has to survive into the assertion with its type intact.
+ */
+export declare function recordWarnings(): {
+    messages: string[];
+};
+//# sourceMappingURL=console-filter-test-fixtures.d.ts.map

package/dist/main/services/views/console-filter-test-fixtures.js

@@ -0,0 +1,82 @@
+/**
+ * Fakes shaped like the Chrome DevTools front-end objects
+ * `buildInternalLogHideScript()`'s generated source talks to, shared by
+ * console-filter.test.ts (what the hook does) and
+ * console-filter-degradation.test.ts (what happens when the panel is not there
+ * or the front-end API has moved).
+ *
+ * These are STUBS OF A FOREIGN API, not a second implementation: every test
+ * runs the real generated script string through `new Function`, so the fakes
+ * only have to expose the handful of members the script reaches for. What they
+ * cannot prove is that the real front-end still has those members — that is
+ * e2e/console-filter-live.spec.ts's job.
+ */
+import { vi } from 'vitest';
+/** A ConsoleViewMessage stub exposing the single field the hook inspects. */
+export function createViewMessage(messageText) {
+    return { consoleMessage: () => ({ messageText }) };
+}
+/**
+ * A ConsoleFilter "class": one shared prototype carrying `shouldBeVisible`,
+ * plus a factory for further instances off that same prototype — what
+ * `ConsoleFilter.clone()` produces. `original` is the pre-existing
+ * implementation the hook must delegate to.
+ */
+export function createConsoleFilterClass(verdict = true) {
+    const impl = typeof verdict === 'function' ? verdict : () => verdict;
+    const original = vi.fn(impl);
+    const prototype = { shouldBeVisible: original };
+    return {
+        original,
+        prototype,
+        newInstance: () => Object.create(prototype),
+    };
+}
+/** A ConsoleFilter whose prototype chain carries no `shouldBeVisible` at all. */
+export function createConsoleFilterClassWithoutHook() {
+    const prototype = Object.create(null);
+    return { prototype, newInstance: () => Object.create(prototype) };
+}
+/** The ConsoleView surface the script reaches through: filter + refresh entry point. */
+export function createConsoleView(currentFilter, initialFilterText = '') {
+    let filterText = initialFilterText;
+    const setValue = vi.fn((next) => { filterText = next; });
+    const onFilterChanged = vi.fn();
+    return {
+        view: {
+            filter: {
+                currentFilter,
+                textFilterUI: { value: () => filterText, setValue },
+            },
+            onFilterChanged,
+        },
+        setValue,
+        onFilterChanged,
+        filterText: () => filterText,
+    };
+}
+/** A front end whose bootstrap has finished: the probe returns instead of throwing. */
+export function createReadyEui() {
+    return { ShortcutRegistry: { ShortcutRegistry: { instance: () => ({}) } } };
+}
+export function createGlobalThis(view) {
+    return { EUI: createReadyEui(), Console: { ConsoleView: { instance: () => view } } };
+}
+export function run(script, fakeGlobalThis) {
+    new Function('globalThis', script)(fakeGlobalThis);
+}
+/**
+ * Collect `console.warn` output as plain strings for the whole test file.
+ *
+ * Reading `warnSpy.mock.calls` instead would hand every assertion an untyped
+ * `any[]`; the degradation tests care about WHICH warning was emitted, so the
+ * text has to survive into the assertion with its type intact.
+ */
+export function recordWarnings() {
+    const record = { messages: [] };
+    vi.spyOn(console, 'warn').mockImplementation((...args) => {
+        record.messages.push(args.map((arg) => String(arg)).join(' '));
+    });
+    return record;
+}
+//# sourceMappingURL=console-filter-test-fixtures.js.map