@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

package/dist/main/services/views/overlay-panels-view.js

@@ -1,150 +1,299 @@
 import { WebContentsView } from 'electron';
-import path from 'path';
+import { createOverlayPanel } from '@dimina-kit/electron-deck/main';
 import { mainPreloadPath } from '../../utils/paths.js';
 import { applyNavigationHardening } from '../../windows/navigation-hardening.js';
 import * as layout from '../layout/index.js';
 import { HEADER_H } from '../../../shared/constants.js';
 import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
-import { destroyChildView } from './destroy-child-view.js';
+import { UpdateChannel } from '../../../shared/ipc-channels-overlays.js';
 export function createOverlayPanelsView(ctx, reconciler, deps) {
-    let settingsView = null;
-    let popoverView = null;
     function overlayHeaderHeight() {
         return HEADER_H + deps.getHostToolbarHeight();
     }
-    // settings/popover bounds are main-computed; publish them into overlayDesired
-    // and let the reconciler place them (they are top-tier layers, so a reorder
-    // keeps them above every base overlay — the old raiseTopOverlays is gone).
-    function applySettingsBounds() {
-        if (!settingsView || ctx.windows.mainWindow.isDestroyed())
-            return;
-        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        reconciler.setOverlayDesired(VIEW_ID.settings, {
-            viewId: VIEW_ID.settings,
-            placement: {
-                visible: true,
-                bounds: layout.computeSettingsBounds(w, h, overlayHeaderHeight()),
-            },
-            layer: VIEW_LAYER.settings,
-        });
-        reconciler.reconcileNow();
+    function overlayDesiredSetter(viewId, layer) {
+        return (bounds) => {
+            if (bounds === null) {
+                reconciler.deleteOverlayDesired(viewId);
+            }
+            else {
+                reconciler.setOverlayDesired(viewId, {
+                    viewId,
+                    placement: { visible: true, bounds },
+                    layer,
+                });
+            }
+            reconciler.reconcileNow();
+        };
     }
-    function applyPopoverBounds() {
-        if (!popoverView || ctx.windows.mainWindow.isDestroyed())
-            return;
-        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        reconciler.setOverlayDesired(VIEW_ID.popover, {
-            viewId: VIEW_ID.popover,
-            placement: {
-                visible: true,
-                bounds: layout.computePopoverBounds(w, h, overlayHeaderHeight()),
-            },
-            layer: VIEW_LAYER.popover,
-        });
-        reconciler.reconcileNow();
+    const settingsPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/settings/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.settings, VIEW_LAYER.settings),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.settings, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.settings, view),
+        readyMode: 'manual',
+    });
+    const popoverPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/popover/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.popover, VIEW_LAYER.popover),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.popover, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.popover, view),
+        pushData: (view, data) => ctx.notify.popoverInit(view, data),
+        readyMode: 'manual',
+    });
+    const tooltipPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/tooltip/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.tooltip, VIEW_LAYER.tooltip),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.tooltip, { getView }),
+        prepareView: (view) => {
+            const [width = 0, height = 0] = ctx.windows.mainWindow.getContentSize();
+            reconciler.prepareView(VIEW_ID.tooltip, view, {
+                x: 0,
+                y: 0,
+                width: Math.max(1, width),
+                height: Math.max(1, height),
+            });
+        },
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.tooltip, view),
+        pushData: (view, data) => ctx.notify.tooltipInit(view, data),
+        readyMode: 'manual',
+    });
+    /**
+     * Both devtools-owned dialog panels occupy the full main-window content
+     * rect (they render their own centered card + backdrop), so unlike
+     * settings/popover/tooltip they need no anchor-derived bounds computation —
+     * just the window's current content size, recomputed on every show/resize.
+     */
+    function fullWindowBounds() {
+        const [width = 0, height = 0] = ctx.windows.mainWindow.getContentSize();
+        return { x: 0, y: 0, width: Math.max(1, width), height: Math.max(1, height) };
     }
+    const projectCreateDialogPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/project-create-dialog/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.projectCreateDialog, VIEW_LAYER.dialog),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.projectCreateDialog, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.projectCreateDialog, view),
+        pushData: (view, data) => ctx.notify.projectCreateInit(view, data),
+        readyMode: 'manual',
+    });
+    const updateDialogPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/update-dialog/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.updateDialog, VIEW_LAYER.dialog),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.updateDialog, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.updateDialog, view),
+        pushData: (view, data) => ctx.notify.updateAvailable(view, data),
+        readyMode: 'manual',
+    });
+    const devicePickerPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/device-picker/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.devicePicker, VIEW_LAYER.dialog),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.devicePicker, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.devicePicker, view),
+        pushData: (view, data) => ctx.notify.devicePickerInit(view, data),
+        readyMode: 'manual',
+    });
+    let tooltipRequestId = 0;
+    let activeTooltip = null;
     async function showSettings() {
-        if (!settingsView) {
-            settingsView = new WebContentsView({
-                webPreferences: {
-                    nodeIntegration: false,
-                    contextIsolation: true,
-                    sandbox: false,
-                    preload: mainPreloadPath,
-                },
-            });
-            // Overlay loads mainPreloadPath, so the same navigation rules as the
-            // main window apply — see navigation-hardening.ts.
-            applyNavigationHardening(settingsView.webContents, ctx.rendererDir);
-            // Transparent backing: the settings view now spans the whole content area
-            // (computeSettingsBounds) and its renderer paints a transparent backdrop +
-            // an opaque right-side panel, so the underlying editor/simulator show
-            // through and a backdrop click closes the overlay (mirrors the popover).
-            settingsView.setBackgroundColor('#00000000');
-            await settingsView.webContents.loadFile(path.join(ctx.rendererDir, 'entries/settings/index.html'));
-        }
-        applySettingsBounds();
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+        settingsPanel.show(undefined, layout.computeSettingsBounds(w, h, overlayHeaderHeight()));
+        await settingsPanel.whenReady();
     }
     function hideSettings() {
-        reconciler.deleteOverlayDesired(VIEW_ID.settings);
-        reconciler.reconcileNow();
+        settingsPanel.hide();
     }
     function showPopover(data) {
+        // Popover carries no state across opens (always fresh init data) — force a
+        // brand-new instance rather than reusing/repositioning a live one (and
+        // notify like any other close, via the shared hidePopover()).
         hidePopover();
-        const popover = new WebContentsView({
-            webPreferences: {
-                nodeIntegration: false,
-                contextIsolation: true,
-                sandbox: false,
-                preload: mainPreloadPath,
-            },
-        });
-        // Popover overlay loads mainPreloadPath — same navigation rules apply.
-        applyNavigationHardening(popover.webContents, ctx.rendererDir);
-        popoverView = popover;
-        popover.setBackgroundColor('#00000000');
-        applyPopoverBounds();
-        popover.webContents.once('did-finish-load', () => {
-            ctx.notify.popoverInit(popover, data);
-        });
-        popover.webContents.loadFile(path.join(ctx.rendererDir, 'entries/popover/index.html'));
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+        popoverPanel.show(data, layout.computePopoverBounds(w, h, overlayHeaderHeight()));
     }
     function hidePopover() {
-        if (!popoverView)
+        if (!popoverPanel.isPresent())
             return;
+        popoverPanel.destroy();
         reconciler.deleteOverlayDesired(VIEW_ID.popover);
-        // Destroy the WCV first (removeChildView + close), THEN reconcile: the detach
-        // op then finds the view already gone and does not double-removeChildView.
-        destroyChildView(ctx.windows.mainWindow, popoverView);
-        popoverView = null;
         reconciler.reconcileNow();
         ctx.notify.popoverClosed();
     }
+    function prepareTooltip() {
+        tooltipPanel.prepare();
+    }
+    function showTooltip(data) {
+        const requestId = ++tooltipRequestId;
+        activeTooltip = { requestId, anchor: data.anchor };
+        const [contentWidth = 0] = ctx.windows.mainWindow.getContentSize();
+        tooltipPanel.show({
+            requestId,
+            text: data.text,
+            maxWidth: layout.computeTooltipMaxWidth(contentWidth),
+        }, null);
+    }
+    function hideTooltip() {
+        activeTooltip = null;
+        tooltipPanel.hide();
+    }
+    function showProjectCreateDialog(data) {
+        projectCreateDialogPanel.show(data, fullWindowBounds());
+    }
+    function hideProjectCreateDialog() {
+        projectCreateDialogPanel.hide();
+    }
+    function showUpdateDialog(data) {
+        updateDialogPanel.show(data, fullWindowBounds());
+    }
+    function hideUpdateDialog() {
+        updateDialogPanel.hide();
+    }
+    function showDevicePicker(data) {
+        devicePickerPanel.show(data, fullWindowBounds());
+    }
+    function hideDevicePicker() {
+        devicePickerPanel.hide();
+    }
+    function notifyUpdateDownloadProgress(percent) {
+        const wc = updateDialogPanel.getWebContents();
+        if (!wc)
+            return;
+        wc.send(UpdateChannel.DownloadProgress, { percent });
+    }
+    function markOverlayReady(webContentsId) {
+        settingsPanel.markReady(webContentsId);
+        popoverPanel.markReady(webContentsId);
+        tooltipPanel.markReady(webContentsId);
+        projectCreateDialogPanel.markReady(webContentsId);
+        updateDialogPanel.markReady(webContentsId);
+        devicePickerPanel.markReady(webContentsId);
+    }
+    function applyTooltipMeasurement(webContentsId, measurement) {
+        const active = activeTooltip;
+        if (!active || active.requestId !== measurement.requestId)
+            return;
+        if (tooltipPanel.getWebContentsId() !== webContentsId)
+            return;
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+        tooltipPanel.reposition(layout.computeTooltipBounds(active.anchor, w, h, measurement));
+    }
     function reapplyPresentOverlays() {
-        if (reconciler.hasOverlayDesired(VIEW_ID.settings))
-            applySettingsBounds();
-        if (reconciler.hasOverlayDesired(VIEW_ID.popover))
-            applyPopoverBounds();
+        // Fire-and-forget re-trigger — a crash between this call and the panel
+        // becoming ready now rejects whenReady() (see overlay-panel.ts teardown);
+        // handleViewBroken() already logs it, nothing more to do here.
+        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) {
+            showSettings().catch(() => { });
+        }
+        if (popoverPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.popover)) {
+            const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+            popoverPanel.reposition(layout.computePopoverBounds(w, h, overlayHeaderHeight()));
+        }
+        if (projectCreateDialogPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.projectCreateDialog)) {
+            projectCreateDialogPanel.reposition(fullWindowBounds());
+        }
+        if (updateDialogPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.updateDialog)) {
+            updateDialogPanel.reposition(fullWindowBounds());
+        }
+        if (devicePickerPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.devicePicker)) {
+            devicePickerPanel.reposition(fullWindowBounds());
+        }
     }
     function applySettingsBoundsIfPresent() {
-        if (reconciler.hasOverlayDesired(VIEW_ID.settings))
-            applySettingsBounds();
+        // See reapplyPresentOverlays() above for why this swallows a rejection.
+        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) {
+            showSettings().catch(() => { });
+        }
     }
     function destroySettings() {
-        destroyChildView(ctx.windows.mainWindow, settingsView);
-        settingsView = null;
+        activeTooltip = null;
+        settingsPanel.destroy();
+        tooltipPanel.destroy();
+    }
+    function destroyDialogs() {
+        projectCreateDialogPanel.destroy();
+        updateDialogPanel.destroy();
+        devicePickerPanel.destroy();
     }
-    reconciler.registerView(VIEW_ID.settings, { getView: () => settingsView });
-    reconciler.registerView(VIEW_ID.popover, { getView: () => popoverView });
     return {
         showSettings,
         hideSettings,
         showPopover,
         hidePopover,
+        prepareTooltip,
+        showTooltip,
+        hideTooltip,
+        markOverlayReady,
+        applyTooltipMeasurement,
+        showProjectCreateDialog,
+        hideProjectCreateDialog,
+        showUpdateDialog,
+        hideUpdateDialog,
+        notifyUpdateDownloadProgress,
+        showDevicePicker,
+        hideDevicePicker,
         reapplyPresentOverlays,
         applySettingsBoundsIfPresent,
         destroySettings,
-        getSettingsWebContents: () => {
-            if (!settingsView)
-                return null;
-            if (settingsView.webContents.isDestroyed())
-                return null;
-            return settingsView.webContents;
-        },
-        getSettingsWebContentsId: () => {
-            if (!settingsView)
-                return null;
-            if (settingsView.webContents.isDestroyed())
-                return null;
-            return settingsView.webContents.id;
-        },
-        getPopoverWebContentsId: () => {
-            if (!popoverView)
-                return null;
-            if (popoverView.webContents.isDestroyed())
-                return null;
-            return popoverView.webContents.id;
-        },
+        destroyDialogs,
+        getSettingsWebContents: () => settingsPanel.getWebContents(),
+        getSettingsWebContentsId: () => settingsPanel.getWebContentsId(),
+        getPopoverWebContentsId: () => popoverPanel.getWebContentsId(),
+        getTooltipWebContentsId: () => tooltipPanel.getWebContentsId(),
+        getProjectCreateDialogWebContentsId: () => projectCreateDialogPanel.getWebContentsId(),
+        getUpdateDialogWebContentsId: () => updateDialogPanel.getWebContentsId(),
+        getDevicePickerWebContentsId: () => devicePickerPanel.getWebContentsId(),
     };
 }
 //# sourceMappingURL=overlay-panels-view.js.map

package/dist/main/services/views/placement-reconciler.d.ts

@@ -12,8 +12,6 @@ import type { ViewManagerContext } from './view-manager.js';
 export interface ViewSlot {
     /** The live WebContentsView for this slot, or null when not yet created. */
     getView(): WebContentsView | null;
-    /** Record whether the view is currently added to the contentView. */
-    setAdded?(added: boolean): void;
     /**
      * When true, force the desired placement to hidden — the view-creation site
      * has not produced the WCV yet, so the reconciler must never record an attach
@@ -21,12 +19,6 @@ export interface ViewSlot {
      * to re-open the gate.
      */
     gateHidden?(): boolean;
-    /**
-     * Run before the generic attach. Return true when the slot fully handled the
-     * attach itself (e.g. a lazy async load that adds the view on completion), so
-     * the reconciler must NOT addChildView here.
-     */
-    beforeAttach?(): boolean;
     /** Lazily create the view on attach (host-toolbar); used instead of getView. */
     ensureView?(): WebContentsView | null;
     /** Domain-specific setBounds (simulator zoom rides here). */
@@ -44,8 +36,10 @@ export interface ViewSlot {
  * settings/popover are main-owned and live in `overlayDesired`. Any change
  * merges the two, runs the pure reconcile core, and applies the ordered ops
  * through `viewTarget`. `epochCounter` is a single monotonic tick — main is the
- * only (serial) reconcile caller, so the core's stale guard passes by
- * construction; `rendererGeneration` still drives the reset on renderer restart.
+ * only (serial) reconcile caller, so the core's stale-epoch guard passes by
+ * construction; `rendererGeneration` is the high-water mark that drives both
+ * the reset on a genuinely newer generation and the hard rejection of a
+ * snapshot from behind it (see `setPlacementSnapshot`).
  */
 export interface PlacementReconciler {
     registerView(viewId: string, slot: ViewSlot): void;
@@ -55,19 +49,25 @@ export interface PlacementReconciler {
      * truth for every managed native view's bounds/visibility/z-order.
      */
     setPlacementSnapshot(snapshot: PlacementSnapshot<DevtoolsExtra>): void;
-    /**
-     * Forget a view's reconciled mount state so the NEXT rebuilt view is treated
-     * as a fresh attach. Required wherever a view instance is replaced/destroyed
-     * via a manual removeChildView that bypasses the reconciler (otherwise the
-     * level-triggered core still records the old instance as attached and never
-     * emits the attach op for the replacement — a sticky invisible view).
-     */
-    forgetActual(viewId: string): void;
+    /** Size a detached view for renderer-side intrinsic measurement. */
+    prepareView(viewId: string, view: WebContentsView, bounds: layout.Bounds): void;
+    /** Detach and close one concrete view instance through the native-tree owner. */
+    destroyView(viewId: string, view: WebContentsView | null): void;
     setBaseDesired(viewId: string, desired: DesiredView<DevtoolsExtra>): void;
     deleteBaseDesired(viewId: string): void;
     setOverlayDesired(viewId: string, desired: DesiredView<DevtoolsExtra>): void;
     deleteOverlayDesired(viewId: string): void;
     hasOverlayDesired(viewId: string): boolean;
+    /**
+     * Hand out a fresh generation seed for a renderer bootstrap (see
+     * renderer-placement-generation.ts). Strictly exceeds both the current
+     * high-water mark (`rendererGeneration`, which a full renderer reload does
+     * NOT reset — this reconciler lives in the long-lived main process) and
+     * every previously allocated seed, so a reload that races ahead of its own
+     * previous session's accepted snapshots can never be handed a value that
+     * `setPlacementSnapshot` would reject as stale.
+     */
+    allocateGeneration(): number;
 }
 export declare function createPlacementReconciler(ctx: ViewManagerContext): PlacementReconciler;
 //# sourceMappingURL=placement-reconciler.d.ts.map