@forgeax/interface 0.4.1

package/dist/package/node/components/DockShell/chatDockAnimation.js

@@ -0,0 +1,101 @@
+export const CHAT_DOCK_ANIMATION_FALLBACK_MS = 300;
+/**
+ * F1's closed → open path must commit the prepared zero-width phase before it
+ * clears the collapsed store flag. Otherwise ChatDock renders one frame at its
+ * full persisted width while the dockview panel is still absent.
+ */
+export function prepareClosedChatOpen(state, actions) {
+    if (!state.atHome)
+        actions.moveHome();
+    actions.markForReopen();
+    actions.prepareExpand();
+    if (state.collapsed)
+        actions.uncollapse();
+}
+const browserScheduler = {
+    setTimeout: (callback, delayMs) => window.setTimeout(callback, delayMs),
+    clearTimeout: (handle) => window.clearTimeout(handle),
+};
+/**
+ * Owns the cancellable part of the ChatDock width transition. DOM preparation
+ * stays in DockRegion (it must run after React commits), while this controller
+ * guarantees that a stale transitionend/fallback can never close a panel that
+ * has already been expanded again.
+ */
+export function createChatDockAnimationController(callbacks, scheduler = browserScheduler, fallbackMs = CHAT_DOCK_ANIMATION_FALLBACK_MS) {
+    let phase = 'idle';
+    let fallback = null;
+    let disposed = false;
+    const clearFallback = () => {
+        if (fallback === null)
+            return;
+        scheduler.clearTimeout(fallback);
+        fallback = null;
+    };
+    const publish = (next) => {
+        phase = next;
+        if (!disposed)
+            callbacks.onPhaseChange(next);
+    };
+    const settleCollapse = () => {
+        if (disposed || phase !== 'collapsing')
+            return;
+        clearFallback();
+        if (callbacks.shouldFinishCollapse())
+            callbacks.onCollapse();
+        publish('idle');
+    };
+    const settleExpand = () => {
+        if (disposed || phase !== 'expanding')
+            return;
+        clearFallback();
+        publish('idle');
+    };
+    const schedule = (settle) => {
+        clearFallback();
+        fallback = scheduler.setTimeout(settle, fallbackMs);
+    };
+    return {
+        getPhase: () => phase,
+        activate: () => {
+            disposed = false;
+        },
+        collapse: () => {
+            if (disposed)
+                return;
+            clearFallback();
+            publish('collapsing');
+            schedule(settleCollapse);
+        },
+        prepareExpand: () => {
+            if (disposed)
+                return;
+            clearFallback();
+            publish('preparing-expand');
+        },
+        startExpand: () => {
+            if (disposed)
+                return;
+            clearFallback();
+            publish('expanding');
+            schedule(settleExpand);
+        },
+        transitionEnd: () => {
+            if (phase === 'collapsing')
+                settleCollapse();
+            else if (phase === 'expanding')
+                settleExpand();
+        },
+        cancel: () => {
+            if (disposed)
+                return;
+            clearFallback();
+            publish('idle');
+        },
+        dispose: () => {
+            clearFallback();
+            disposed = true;
+            phase = 'idle';
+        },
+    };
+}

package/dist/package/node/components/DockShell/chatDockFullscreen.js

@@ -0,0 +1,22 @@
+export function handleFullscreenChatToggle(fullscreen, toggleChatpanel) {
+    if (!fullscreen)
+        return false;
+    toggleChatpanel();
+    return true;
+}
+export function isFullscreenChatRestoreOwner({ chatWasOpen, chatHome, region, }) {
+    // The physical panel identifies its owner while open. When it was already
+    // closed, the configured home region owns any explicit fullscreen toggle.
+    return chatWasOpen || chatHome === region;
+}
+export function resolveFullscreenChatRestoreIntent({ ownsChat, chatpanelCollapsed, }) {
+    if (!ownsChat)
+        return null;
+    return {
+        chatWasOpen: !chatpanelCollapsed,
+        hiddenByToggle: chatpanelCollapsed,
+    };
+}
+export function shouldRestoreFullscreenChat({ chatWasOpen, chatpanelCollapsed, }) {
+    return chatWasOpen && !chatpanelCollapsed;
+}

package/dist/package/node/components/DockShell/chatDockLayout.js

@@ -0,0 +1,11 @@
+/**
+ * Dockview must be laid out against its own flex item. The ChatDock inner shell
+ * also contains SessionTabStrip, so measuring either the outer column or the
+ * inner shell overstates Dockview's height by the tab-strip height.
+ */
+export function readChatDockviewLayoutSize(inner) {
+    const dockview = inner?.querySelector('.fx-dockshell');
+    if (!dockview || dockview.clientWidth <= 0 || dockview.clientHeight <= 0)
+        return null;
+    return { width: dockview.clientWidth, height: dockview.clientHeight };
+}

package/dist/package/node/components/DockShell/compact-empty-dock-groups.js

@@ -0,0 +1,28 @@
+/** Remove grid/floating groups that lost all panels (e.g. after UE lift/drop). */
+export function compactEmptyDockGroups(api) {
+    const empty = api.groups.filter((group) => group.panels.length === 0
+        && (group.api.location.type === 'grid' || group.api.location.type === 'floating'));
+    for (const group of empty) {
+        try {
+            api.removeGroup(group);
+        }
+        catch {
+            // Group may already be mid-disposal from dockview's own move path.
+        }
+    }
+    return empty.length;
+}
+export function relayoutDockContainer(api, container) {
+    if (!container)
+        return;
+    const width = container.clientWidth;
+    const height = container.clientHeight;
+    if (width <= 0 || height <= 0)
+        return;
+    try {
+        api.layout?.(width, height, true);
+    }
+    catch {
+        // noop — region may be unmounting.
+    }
+}

package/dist/package/node/components/DockShell/crossInstanceDrop.js

@@ -0,0 +1 @@
+export { handleCrossInstanceDrop, } from '@forgeax/app-shell/dock';

package/dist/package/node/components/DockShell/dockResetEpoch.js

@@ -0,0 +1,13 @@
+// Monotonic epoch for `app.dock.reset`.
+//
+// Callers (layout menu, onboarding tour) may fire reset before a DockRegion has
+// subscribed to `dock:reset` or before dockview `onReady` has set `api`. Bumping
+// this epoch at request time lets each region apply the reset exactly once when
+// it becomes ready — no timers, no localStorage poking.
+let epoch = 0;
+export function bumpDockResetEpoch() {
+    epoch += 1;
+}
+export function getDockResetEpoch() {
+    return epoch;
+}

package/dist/package/node/components/DockShell/dockTitle.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslation } from '../../i18n/index.js';
+const DOCK_TITLE_STATE = 'data-fx-dock-title-state';
+export function setDockTitleHidden(group, hidden) {
+    const element = group;
+    element.dataset.fxDockTitleState = hidden ? 'hidden' : 'visible';
+}
+/**
+ * Resolve the effective title-bar state for a group. An explicit state wins;
+ * otherwise a panel's declarative single-tab preference is the default.
+ */
+export function isDockTitleHidden(group) {
+    const state = group.getAttribute(DOCK_TITLE_STATE);
+    if (state === 'hidden')
+        return true;
+    if (state === 'visible')
+        return false;
+    return group.querySelector('[data-dock-single-tab="hideTitle"]') !== null;
+}
+function closestDockGroup(target) {
+    return target.closest('.dv-groupview, .groupview');
+}
+/** Restore affordance rendered in every dock panel body. CSS only reveals it
+ * for a single-panel group whose title bar is currently hidden. */
+export function DockTitleRestoreButton() {
+    const { t } = useTranslation();
+    return (_jsx("button", { type: "button", className: "fx-dock-title-restore", "data-testid": "dock-title-restore", "aria-label": t('dockShell.showPanelTitle'), title: t('dockShell.showPanelTitle'), onClick: (event) => {
+            const group = closestDockGroup(event.currentTarget);
+            if (group)
+                setDockTitleHidden(group, false);
+        } }));
+}
+/** Keep the restore affordance outside the panel's layout flow. */
+export function withDockTitleRestore(render) {
+    return () => (_jsxs(_Fragment, { children: [render(), _jsx(DockTitleRestoreButton, {})] }));
+}

package/dist/package/node/components/DockShell/dockviewRegistry.js

@@ -0,0 +1 @@
+export { getDockRegions, getDockviewApi, registerDockRegion, registerDockviewApi, } from '@forgeax/app-shell/dock';