@dxos/plugin-deck 0.7.5-labs.a279d8c → 0.7.5-labs.a8b535d

package/src/capabilities/url-handler.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes, createIntent, LayoutAction, type PluginsContext } from '@dxos/app-framework';
+import { scheduledEffect } from '@dxos/echo-signals/core';
+
+import { DeckCapabilities } from './capabilities';
+
+// TODO(wittjosiah): Cleanup the url handling. May justify introducing routing capabilities.
+export default async (context: PluginsContext) => {
+  const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher) ?? {};
+  const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+
+  const handleNavigation = async () => {
+    const pathname = window.location.pathname;
+    if (pathname === '/reset') {
+      state.activeDeck = 'default';
+      state.decks = {
+        default: {
+          initialized: false,
+          active: [],
+          inactive: [],
+          fullscreen: false,
+          solo: undefined,
+          plankSizing: {},
+        },
+      };
+      window.location.pathname = '/';
+      return;
+    }
+
+    const [_, nextDeck, nextSolo] = pathname.split('/');
+    if (nextDeck && nextDeck !== state.activeDeck) {
+      await dispatch(createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: nextDeck }));
+    }
+
+    if (nextSolo && nextSolo !== state.deck.solo) {
+      await dispatch(
+        createIntent(LayoutAction.SetLayoutMode, { part: 'mode', subject: nextSolo, options: { mode: 'solo' } }),
+      );
+    } else if (!nextSolo && state.deck.solo) {
+      await dispatch(createIntent(LayoutAction.SetLayoutMode, { part: 'mode', options: { mode: 'deck' } }));
+    }
+  };
+
+  await handleNavigation();
+  window.addEventListener('popstate', handleNavigation);
+
+  const unsubscribe = scheduledEffect(
+    () => ({ solo: state.deck.solo, activeDeck: state.activeDeck }),
+    ({ solo, activeDeck }) => {
+      const path = solo ? `/${activeDeck}/${solo}` : `/${activeDeck}`;
+      if (window.location.pathname !== path) {
+        // TODO(thure): In some browsers, this only preserves the most recent state change, even though this is not `history.replace`…
+        history.pushState(null, '', `${path}${window.location.search}`);
+      }
+    },
+  );
+
+  return contributes(Capabilities.Null, null, () => {
+    window.removeEventListener('popstate', handleNavigation);
+    unsubscribe();
+  });
+};

package/src/components/DeckLayout/ActiveNode.tsx

@@ -4,8 +4,7 @@
 
 import React from 'react';
 
-import { Surface } from '@dxos/app-framework';
-import { useGraph } from '@dxos/plugin-graph';
+import { Surface, useAppGraph } from '@dxos/app-framework';
 import { useAttended } from '@dxos/react-ui-attention';
 
 import { useNode, useNodeActionExpander } from '../../hooks';
@@ -13,7 +12,7 @@ import { useNode, useNodeActionExpander } from '../../hooks';
 // TODO(burdon): Factor out to effect in plugin set document title.
 export const ActiveNode = () => {
   const [id] = useAttended();
-  const { graph } = useGraph();
+  const { graph } = useAppGraph();
   const activeNode = useNode(graph, id);
   useNodeActionExpander(activeNode);
 

package/src/components/DeckLayout/ComplementarySidebar.tsx

@@ -2,111 +2,219 @@
 // Copyright 2024 DXOS.org
 //
 
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import React, {
+  type PropsWithChildren,
+  useCallback,
+  useEffect,
+  useMemo,
+  useState,
+  type MouseEvent,
+  Fragment,
+} from 'react';
 
-import { createIntent, NavigationAction, SLUG_PATH_SEPARATOR, Surface, useIntentDispatcher } from '@dxos/app-framework';
-import { useGraph } from '@dxos/plugin-graph';
-import { Main, ScrollArea, useTranslation, toLocalizedString } from '@dxos/react-ui';
+import {
+  createIntent,
+  LayoutAction,
+  Surface,
+  useAppGraph,
+  useCapabilities,
+  useCapability,
+  useIntentDispatcher,
+} from '@dxos/app-framework';
+import { Main, useTranslation, toLocalizedString, IconButton, ScrollArea as NaturalScrollArea } from '@dxos/react-ui';
 import { useAttended } from '@dxos/react-ui-attention';
-import { railGridHorizontal, StackContext, StackItem } from '@dxos/react-ui-stack';
 import { Tabs } from '@dxos/react-ui-tabs';
-import { mx } from '@dxos/react-ui-theme';
+import { byPosition } from '@dxos/util';
 
 import { PlankContentError } from './PlankError';
 import { PlankLoading } from './PlankLoading';
-import { CloseComplementarySidebarButton } from './SidebarButton';
-import { useNode, useNodeActionExpander } from '../../hooks';
+import { ToggleComplementarySidebarButton } from './SidebarButton';
+import { DeckCapabilities } from '../../capabilities';
+import { useNode } from '../../hooks';
 import { DECK_PLUGIN } from '../../meta';
 import { type Panel } from '../../types';
-import { useLayout } from '../LayoutContext';
+import { layoutAppliesTopbar, useBreakpoints, useHoistStatusbar } from '../../util';
 
 export type ComplementarySidebarProps = {
-  panels: Panel[];
   current?: string;
 };
 
-export const ComplementarySidebar = ({ panels, current }: ComplementarySidebarProps) => {
-  const { popoverAnchorId } = useLayout();
-  const attended = useAttended();
-  const panelIds = useMemo(() => panels.map((p) => p.id), [panels]);
-  const activePanelId = panelIds.find((p) => p === current) ?? panels[0].id;
-  const activeEntryId = attended[0] ? `${attended[0]}${SLUG_PATH_SEPARATOR}${activePanelId}` : undefined;
-  const { graph } = useGraph();
-  const node = useNode(graph, activeEntryId);
+export const ComplementarySidebar = ({ current }: ComplementarySidebarProps) => {
   const { t } = useTranslation(DECK_PLUGIN);
   const { dispatchPromise: dispatch } = useIntentDispatcher();
-  useNodeActionExpander(node);
+  const layout = useCapability(DeckCapabilities.MutableDeckState);
+  const attended = useAttended();
+  const { graph } = useAppGraph();
+  const node = useNode(graph, attended[0]);
+  const breakpoint = useBreakpoints();
+  const topbar = layoutAppliesTopbar(breakpoint);
+  const hoistStatusbar = useHoistStatusbar(breakpoint);
+
+  const panels = useCapabilities(DeckCapabilities.ComplementaryPanel);
+  const availablePanels = panels
+    .filter((panel) => {
+      if (!node || !panel.filter) {
+        return true;
+      }
 
+      return panel.filter(node);
+    })
+    .toSorted(byPosition);
+  const activePanelId = availablePanels.find((panel) => panel.id === current)?.id ?? availablePanels[0]?.id;
   const [internalValue, setInternalValue] = useState(activePanelId);
 
   useEffect(() => {
     setInternalValue(activePanelId);
   }, [activePanelId]);
 
-  const handleValueChange = useCallback(
-    (nextValue: string) => {
-      setInternalValue(nextValue);
-      void dispatch(createIntent(NavigationAction.Open, { activeParts: { complementary: nextValue } }));
+  const handleTabClick = useCallback(
+    (event: MouseEvent) => {
+      const nextValue = event.currentTarget.getAttribute('data-value') as string;
+      if (nextValue === activePanelId) {
+        layout.complementarySidebarState = layout.complementarySidebarState === 'expanded' ? 'collapsed' : 'expanded';
+      } else {
+        setInternalValue(nextValue);
+        layout.complementarySidebarState = 'expanded';
+        void dispatch(createIntent(LayoutAction.UpdateComplementary, { part: 'complementary', subject: nextValue }));
+      }
     },
-    [dispatch],
+    [layout, activePanelId, dispatch],
+  );
+
+  const data = useMemo(
+    () =>
+      node && {
+        id: node.id,
+        subject: node.data,
+        workspace: layout.activeDeck,
+        popoverAnchorId: layout.popoverAnchorId,
+      },
+    [node, layout.popoverAnchorId],
   );
 
   // TODO(burdon): Scroll area should be controlled by surface.
   return (
-    <Main.ComplementarySidebar classNames='lg:block-start-[calc(env(safe-area-inset-top)+var(--rail-size))]'>
-      <StackContext.Provider value={{ size: 'contain', orientation: 'horizontal', rail: true }}>
-        <div role='none' className={mx(railGridHorizontal, 'grid grid-cols-[100%] bs-full')}>
-          <Tabs.Root
-            orientation='horizontal'
-            value={internalValue}
-            onValueChange={handleValueChange}
-            attendableId={attended[0]}
-            classNames='contents'
-          >
-            <StackItem.Heading classNames='border-be border-separator grid grid-cols-[1fr_min-content] items-stretch'>
-              <ScrollArea.Root classNames='flex-1 min-is-0'>
-                <ScrollArea.Viewport>
-                  <Tabs.Tablist classNames='bs-[--rail-content] is-min items-stretch pis-[max(.5rem,env(safe-area-inset-left))] sm:pis-2'>
-                    {panels.map((panel) => (
-                      <Tabs.Tab key={panel.id} value={panel.id} classNames='!min-bs-0'>
-                        {toLocalizedString(panel.label, t)}
-                      </Tabs.Tab>
-                    ))}
-                  </Tabs.Tablist>
-                  <ScrollArea.Scrollbar orientation='horizontal'>
-                    <ScrollArea.Thumb />
-                  </ScrollArea.Scrollbar>
-                </ScrollArea.Viewport>
-              </ScrollArea.Root>
-              <CloseComplementarySidebarButton />
-            </StackItem.Heading>
-            <ScrollArea.Root>
-              <ScrollArea.Viewport>
-                {panels.map((panel) => (
-                  <Tabs.Tabpanel key={panel.id} value={panel.id} classNames='pbe-[env(safe-area-inset-bottom)]'>
-                    {panel.id === activePanelId && node && (
-                      <Surface
-                        key={activeEntryId}
-                        role={`complementary--${activePanelId}`}
-                        data={{
-                          id: activeEntryId,
-                          subject: node.properties.object ?? node.properties.space,
-                          popoverAnchorId,
-                        }}
-                        fallback={PlankContentError}
-                        placeholder={<PlankLoading />}
-                      />
-                    )}
-                  </Tabs.Tabpanel>
-                ))}
-                <ScrollArea.Scrollbar orientation='vertical'>
-                  <ScrollArea.Thumb />
-                </ScrollArea.Scrollbar>
-              </ScrollArea.Viewport>
-            </ScrollArea.Root>
-          </Tabs.Root>
+    <Main.ComplementarySidebar
+      classNames={[
+        topbar && 'block-start-[calc(env(safe-area-inset-top)+var(--rail-size))]',
+        hoistStatusbar && 'block-end-[--statusbar-size]',
+      ]}
+    >
+      <Tabs.Root
+        orientation='vertical'
+        verticalVariant='stateless'
+        value={internalValue}
+        attendableId={attended[0]}
+        classNames='contents'
+      >
+        <div
+          role='none'
+          className='absolute z-[1] inset-block-0 inline-end-0 !is-[--r0-size] pbs-[env(safe-area-inset-top)] pbe-[env(safe-area-inset-bottom)] border-is border-separator grid grid-cols-1 grid-rows-[1fr_min-content] bg-baseSurface contain-layout app-drag'
+        >
+          <Tabs.Tablist classNames='grid grid-cols-1 auto-rows-[--rail-action] p-1 gap-1 !overflow-y-auto'>
+            {availablePanels.map((panel) => (
+              <Tabs.Tab key={panel.id} value={panel.id} asChild>
+                <IconButton
+                  label={toLocalizedString(panel.label, t)}
+                  icon={panel.icon}
+                  size={5}
+                  iconOnly
+                  tooltipSide='left'
+                  data-value={panel.id}
+                  variant={
+                    activePanelId === panel.id
+                      ? layout.complementarySidebarState === 'expanded'
+                        ? 'primary'
+                        : 'default'
+                      : 'ghost'
+                  }
+                  onClick={handleTabClick}
+                />
+              </Tabs.Tab>
+            ))}
+          </Tabs.Tablist>
+          {!hoistStatusbar && (
+            <div role='none' className='grid grid-cols-1 auto-rows-[--rail-item] p-1 overflow-y-auto'>
+              <Surface role='status-bar--r0-footer' limit={1} />
+            </div>
+          )}
+          <div role='none' className='hidden lg:grid grid-cols-1 auto-rows-[--rail-action] p-1'>
+            <ToggleComplementarySidebarButton />
+          </div>
         </div>
-      </StackContext.Provider>
+        {availablePanels.map((panel) => (
+          <Tabs.Tabpanel
+            key={panel.id}
+            value={panel.id}
+            classNames='absolute data-[state="inactive"]:-z-[1] inset-block-0 inline-start-0 is-[calc(100%-var(--r0-size))] lg:is-[--r1-size] grid grid-cols-1 grid-rows-[var(--rail-size)_1fr_min-content] pbs-[env(safe-area-inset-top)]'
+            {...(layout.complementarySidebarState !== 'expanded' && { inert: 'true' })}
+          >
+            <ComplementarySidebarPanel
+              panel={panel}
+              activePanelId={activePanelId}
+              data={data}
+              hoistStatusbar={hoistStatusbar}
+            />
+          </Tabs.Tabpanel>
+        ))}
+      </Tabs.Root>
     </Main.ComplementarySidebar>
   );
 };
+
+type ComplementarySidebarPanelProps = {
+  panel: Panel;
+  activePanelId: string;
+  data?: {
+    id: string;
+    subject: any;
+    workspace: string;
+    popoverAnchorId?: string;
+  };
+  hoistStatusbar: boolean;
+};
+
+const ScrollArea = ({ children }: PropsWithChildren) => {
+  return (
+    <NaturalScrollArea.Root>
+      <NaturalScrollArea.Viewport>{children}</NaturalScrollArea.Viewport>
+      <NaturalScrollArea.Scrollbar orientation='vertical'>
+        <NaturalScrollArea.Thumb />
+      </NaturalScrollArea.Scrollbar>
+    </NaturalScrollArea.Root>
+  );
+};
+
+const ComplementarySidebarPanel = ({ panel, activePanelId, data, hoistStatusbar }: ComplementarySidebarPanelProps) => {
+  const { t } = useTranslation(DECK_PLUGIN);
+
+  if (panel.id !== activePanelId || !data) {
+    return null;
+  }
+
+  const Wrapper = panel.fixed ? Fragment : ScrollArea;
+
+  return (
+    <>
+      <h2 className='flex items-center pli-2 border-separator border-be font-medium'>
+        {toLocalizedString(panel.label, t)}
+      </h2>
+      <Wrapper>
+        <Surface
+          role={`complementary--${activePanelId}`}
+          data={data}
+          fallback={PlankContentError}
+          placeholder={<PlankLoading />}
+        />
+      </Wrapper>
+      {!hoistStatusbar && (
+        <div
+          role='contentinfo'
+          className='flex flex-wrap justify-center items-center border-bs border-separator pbs-1 pbe-[max(env(safe-area-inset-bottom),0.25rem)]'
+        >
+          <Surface role='status-bar--r1-footer' limit={1} />
+        </div>
+      )}
+    </>
+  );
+};

package/src/components/DeckLayout/ContentEmpty.tsx

@@ -5,25 +5,22 @@
 import React from 'react';
 
 import { Surface } from '@dxos/app-framework';
-import { mx } from '@dxos/react-ui-theme';
 
 import { ToggleSidebarButton } from './SidebarButton';
-import { soloInlinePadding } from '../fragments';
+import { layoutAppliesTopbar, useBreakpoints } from '../../util';
+import { fixedSidebarToggleStyles } from '../fragments';
 
 export const ContentEmpty = () => {
+  const breakpoint = useBreakpoints();
+  const topbar = layoutAppliesTopbar(breakpoint);
   return (
     <div
       role='none'
-      className='min-bs-screen is-dvw sm:is-full p-8 grid grid-rows-[var(--rail-size)_1fr] lg:grid-rows-1'
+      className='grid place-items-center p-8 relative bg-deck'
       data-testid='layoutPlugin.firstRunMessage'
     >
-      <div role='toolbar' className={mx(soloInlinePadding, 'bs-[--rail-action] flex items-stretch lg:hidden')}>
-        <ToggleSidebarButton />
-        <span role='none' className='grow' />
-      </div>
-      <div role='none' className='grid place-items-center'>
-        <Surface role='keyshortcuts' />
-      </div>
+      <Surface role='keyshortcuts' />
+      {!topbar && <ToggleSidebarButton variant='default' classNames={fixedSidebarToggleStyles} />}
     </div>
   );
 };