@dxos/plugin-deck 0.8.4-main.f9ba587 → 0.8.4-main.fffef41

package/src/capabilities/state.ts

@@ -8,17 +8,18 @@ import { live } from '@dxos/live-object';
 import { LocalStorageStore } from '@dxos/local-storage';
 import { type SidebarState } from '@dxos/react-ui';
 
+import { meta } from '../meta';
+import { type DeckPluginState, type DeckState, defaultDeck, getMode } from '../types';
+
 import { DeckCapabilities } from './capabilities';
-import { DECK_PLUGIN } from '../meta';
-import { getMode, type DeckPluginState, defaultDeck, type DeckState } from '../types';
 
 const boolean = /true|false/;
 
 // TODO(thure, 18 Feb 2025): Remove after the next release.
 
 const migrateSidebarStateDefaults = {
-  [`${DECK_PLUGIN}/complementary-sidebar-state`]: 'expanded',
-  [`${DECK_PLUGIN}/sidebar-state`]: 'collapsed',
+  [`${meta.id}/complementary-sidebar-state`]: 'expanded',
+  [`${meta.id}/sidebar-state`]: 'collapsed',
 };
 
 const migrateSidebarState = () => {
@@ -29,10 +30,13 @@ const migrateSidebarState = () => {
   });
 };
 
-const DeckStateFactory = () => {
+/**
+ * @deprecated
+ */
+export const DeckStateFactory = () => {
   migrateSidebarState();
 
-  const state = new LocalStorageStore<DeckPluginState>(DECK_PLUGIN, {
+  const state = new LocalStorageStore<DeckPluginState>(meta.id, {
     sidebarState: 'expanded',
     complementarySidebarState: 'collapsed',
     complementarySidebarPanel: undefined,
@@ -68,6 +72,11 @@ const DeckStateFactory = () => {
     .prop({ key: 'activeDeck', type: LocalStorageStore.string() })
     .prop({ key: 'previousDeck', type: LocalStorageStore.string() });
 
+  // Don't allow fullscreen mode to be persisted to prevent getting stuck in it.
+  if (state.values.deck.fullscreen) {
+    state.values.deck.fullscreen = false;
+  }
+
   const layout = live<Capabilities.Layout>({
     get mode() {
       return getMode(state.values.deck);

package/src/capabilities/toolkit.ts

@@ -0,0 +1,66 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Tool from '@effect/ai/Tool';
+import * as Toolkit from '@effect/ai/Toolkit';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import {
+  Capabilities,
+  type Capability,
+  LayoutAction,
+  type PluginContext,
+  contributes,
+  createIntent,
+} from '@dxos/app-framework';
+import { GenericToolkit } from '@dxos/assistant';
+import { ArtifactId } from '@dxos/assistant';
+import { type SpaceId } from '@dxos/keys';
+import { trim } from '@dxos/util';
+
+import { DeckCapabilities } from './capabilities';
+
+const Toolkit$ = Toolkit.make(
+  Tool.make('open-item', {
+    description: trim`
+      Opens an item in the application.
+    `,
+    parameters: {
+      id: ArtifactId,
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+);
+
+export namespace DeckToolkit {
+  export const Toolkit = Toolkit$;
+
+  export const createLayer = (context: PluginContext) =>
+    Toolkit$.toLayer({
+      'open-item': ({ id }) =>
+        Effect.gen(function* () {
+          const state = context.getCapability(DeckCapabilities.DeckState);
+          const dxn = ArtifactId.toDXN(id, state.activeDeck as SpaceId).asEchoDXN();
+          if (!dxn) {
+            // TODO(wittjosiah): Support other variants.
+            throw new Error(`Invalid object ID: ${id}`);
+          }
+
+          // TODO(wittjosiah): Get capabilities via layers.
+          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+          yield* dispatch(
+            createIntent(LayoutAction.Open, {
+              subject: [`${dxn.spaceId!}:${dxn.echoId}`],
+              part: 'main',
+            }),
+          );
+        }).pipe(Effect.orDie),
+    });
+}
+
+export default (context: PluginContext): Capability<any>[] => [
+  contributes(Capabilities.Toolkit, GenericToolkit.make(DeckToolkit.Toolkit, DeckToolkit.createLayer(context))),
+];

package/src/capabilities/tools.ts

@@ -2,17 +2,20 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+// ISSUE(burdon): tools
+// @ts-nocheck
+
+import * as Schema from 'effect/Schema';
 
-import { createTool, ToolResult } from '@dxos/ai';
 import {
-  contributes,
-  createIntent,
   Capabilities,
   LayoutAction,
   type PromiseIntentDispatcher,
+  contributes,
+  createIntent,
 } from '@dxos/app-framework';
 import { invariant } from '@dxos/invariant';
+import { trim } from '@dxos/util';
 
 import { meta } from '../meta';
 import { DeckAction } from '../types';
@@ -30,9 +33,9 @@ export default () =>
   contributes(Capabilities.Tools, [
     createTool(meta.id, {
       name: 'show',
-      description: `
-        Show an item as a companion to an existing plank. This will make the item appear alongside the primary content.
-        When supplying IDs, they must be fully qualified like space:object.
+      description: trim`
+        Show an item as a companion to an existing plank. 
+        When supplying IDs, they must be fully qualified like this: space-key:object-id
       `,
       caption: 'Showing item...',
       // TODO(wittjosiah): Refactor Layout/Navigation/Deck actions so that they can be used directly.

package/src/capabilities/url-handler.ts

@@ -2,12 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, createIntent, LayoutAction, type PluginContext } from '@dxos/app-framework';
+import { Capabilities, LayoutAction, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
 import { scheduledEffect } from '@dxos/echo-signals/core';
 
-import { DeckCapabilities } from './capabilities';
 import { defaultDeck } from '../types';
 
+import { DeckCapabilities } from './capabilities';
+
 // TODO(wittjosiah): Cleanup the url handling. May justify introducing routing capabilities.
 export default async (context: PluginContext) => {
   const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);

package/src/components/DeckLayout/ActiveNode.tsx

@@ -4,7 +4,7 @@
 
 import React from 'react';
 
-import { Surface, useAppGraph } from '@dxos/app-framework';
+import { Surface, useAppGraph } from '@dxos/app-framework/react';
 import { useNode } from '@dxos/plugin-graph';
 import { useAttended } from '@dxos/react-ui-attention';
 

package/src/components/DeckLayout/Banner.tsx

@@ -4,15 +4,15 @@
 
 import React from 'react';
 
-import { Surface } from '@dxos/app-framework';
-import { useTranslation, type ThemedClassName } from '@dxos/react-ui';
+import { Surface } from '@dxos/app-framework/react';
+import { type ThemedClassName, useTranslation } from '@dxos/react-ui';
 import { mx } from '@dxos/react-ui-theme';
 
-import { DECK_PLUGIN } from '../../meta';
+import { meta } from '../../meta';
 import { CloseSidebarButton, ToggleSidebarButton } from '../Sidebar';
 
 export const Banner = ({ variant, classNames }: ThemedClassName<{ variant?: 'topbar' | 'sidebar' }>) => {
-  const { t } = useTranslation(DECK_PLUGIN);
+  const { t } = useTranslation(meta.id);
   return (
     <header
       className={mx(

package/src/components/DeckLayout/ContentEmpty.tsx

@@ -4,14 +4,14 @@
 
 import React from 'react';
 
-import { Surface, useCapability } from '@dxos/app-framework';
+import { Surface, useCapability } from '@dxos/app-framework/react';
 
 import { DeckCapabilities } from '../../capabilities';
 import { useBreakpoints } from '../../hooks';
 import { getMode } from '../../types';
 import { layoutAppliesTopbar } from '../../util';
-import { ToggleSidebarButton } from '../Sidebar';
 import { fixedSidebarToggleStyles } from '../fragments';
+import { ToggleSidebarButton } from '../Sidebar';
 
 export const ContentEmpty = () => {
   const breakpoint = useBreakpoints();

package/src/components/DeckLayout/DeckLayout.stories.tsx

@@ -0,0 +1,63 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+
+import { Events, IntentPlugin, SettingsPlugin, defineModule, definePlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AttentionPlugin } from '@dxos/plugin-attention';
+import { GraphPlugin } from '@dxos/plugin-graph';
+import { withTheme } from '@dxos/react-ui/testing';
+
+import { DeckStateFactory, LayoutIntentResolver } from '../../capabilities';
+import { meta as pluginMeta } from '../../meta';
+import { translations } from '../../translations';
+
+import { DeckLayout } from './DeckLayout';
+
+const meta = {
+  title: 'plugins/plugin-deck/DeckLayout',
+  component: DeckLayout,
+  render: (args) => <DeckLayout {...args} />,
+  decorators: [
+    withTheme,
+    withPluginManager({
+      plugins: [
+        AttentionPlugin(),
+        SettingsPlugin(),
+        IntentPlugin(),
+        GraphPlugin(),
+        definePlugin(
+          {
+            id: 'example.com/plutin/testing',
+            name: 'Testing',
+          },
+          () => [
+            defineModule({
+              id: `${pluginMeta.id}/module/deck-state`,
+              activatesOn: Events.AppGraphReady,
+              activate: () => DeckStateFactory(),
+            }),
+            defineModule({
+              id: `${pluginMeta.id}/module/layout-intent-resolver`,
+              activatesOn: Events.SetupIntentResolver,
+              activate: LayoutIntentResolver,
+            }),
+          ],
+        )(),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof DeckLayout>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/components/DeckLayout/DeckLayout.tsx

@@ -2,300 +2,31 @@
 // Copyright 2023 DXOS.org
 //
 
-import { untracked } from '@preact/signals-core';
-import React, { useCallback, useEffect, useMemo, useRef, type UIEvent, Fragment } from 'react';
+import React from 'react';
 
-import {
-  Capabilities,
-  LayoutAction,
-  createIntent,
-  useCapability,
-  useIntentDispatcher,
-  usePluginManager,
-} from '@dxos/app-framework';
-import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { Main, type MainProps, useMediaQuery, useOnTransition } from '@dxos/react-ui';
-import { Stack, StackContext, DEFAULT_HORIZONTAL_SIZE } from '@dxos/react-ui-stack';
-import { mainPaddingTransitions } from '@dxos/react-ui-theme';
+import { useCapability } from '@dxos/app-framework/react';
+
+import { DeckCapabilities } from '../../capabilities';
 
 import { ActiveNode } from './ActiveNode';
-import { ContentEmpty } from './ContentEmpty';
+import { DeckMain } from './DeckMain';
 import { Dialog } from './Dialog';
 import { PopoverContent, PopoverRoot } from './Popover';
-import { StatusBar } from './StatusBar';
-import { Toast } from './Toast';
-import { Topbar } from './Topbar';
-import { DeckCapabilities } from '../../capabilities';
-import { useBreakpoints, useHoistStatusbar } from '../../hooks';
-import { DECK_PLUGIN } from '../../meta';
-import { type DeckSettingsProps, getMode } from '../../types';
-import { calculateOverscroll, layoutAppliesTopbar } from '../../util';
-import { Plank } from '../Plank';
-import { ComplementarySidebar, Sidebar, ToggleComplementarySidebarButton, ToggleSidebarButton } from '../Sidebar';
-import { fixedComplementarySidebarToggleStyles, fixedSidebarToggleStyles } from '../fragments';
-
-export type DeckLayoutProps = {
-  onDismissToast: (id: string) => void;
-};
+import { Toaster, type ToasterProps } from './Toast';
 
-const PlankSeparator = ({ order }: { order: number }) =>
-  order > 0 ? <span role='separator' className='row-span-2 bg-deckSurface is-4' style={{ gridColumn: order }} /> : null;
+export type DeckLayoutProps = Pick<ToasterProps, 'onDismissToast'>;
 
 export const DeckLayout = ({ onDismissToast }: DeckLayoutProps) => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  const settings = useCapability(Capabilities.SettingsStore).getStore<DeckSettingsProps>(DECK_PLUGIN)!.value;
   const context = useCapability(DeckCapabilities.MutableDeckState);
-  const { sidebarState, complementarySidebarState, complementarySidebarPanel, deck, toasts } = context;
-  const { active, activeCompanions, fullscreen, solo, plankSizing } = deck;
-  const breakpoint = useBreakpoints();
-  const layoutMode = getMode(deck);
-  const topbar = layoutAppliesTopbar(breakpoint, layoutMode);
-  const hoistStatusbar = useHoistStatusbar(breakpoint, layoutMode);
-  const pluginManager = usePluginManager();
-
-  const scrollLeftRef = useRef<number | null>();
-  const deckRef = useRef<HTMLDivElement>(null);
-
-  // Ensure the first plank is attended when the deck is first rendered.
-  useEffect(() => {
-    // NOTE: Not `useAttended` so that the layout component is not re-rendered when the attended list changes.
-    const attended = untracked(() => {
-      const attention = pluginManager.context.getCapability(AttentionCapabilities.Attention);
-      return attention.current;
-    });
-    const firstId = solo ?? active[0];
-    if (attended.length === 0 && firstId) {
-      // TODO(wittjosiah): Focusing the type button is a workaround.
-      //   If the plank is directly focused on first load the focus ring appears.
-      document.querySelector<HTMLElement>(`article[data-attendable-id="${firstId}"] button`)?.focus();
-    }
-  }, []);
-
-  // Not using `breakpoint` to avoid firing when breakpoint changes between tablet and desktop.
-  // `ssr: false` to avoid using fallback values and flashing into solo mode on startup.
-  const [isNotMobile] = useMediaQuery('md', { ssr: false });
-  const shouldRevert = useRef(false);
-  useEffect(() => {
-    if (!isNotMobile && getMode(deck) === 'deck') {
-      // NOTE: Not `useAttended` so that the layout component is not re-rendered when the attended list changes.
-      const attended = untracked(() => {
-        const attention = pluginManager.context.getCapability(AttentionCapabilities.Attention);
-        return attention.current;
-      });
-
-      shouldRevert.current = true;
-      void dispatch(
-        createIntent(LayoutAction.SetLayoutMode, { part: 'mode', subject: attended[0], options: { mode: 'solo' } }),
-      );
-    } else if (isNotMobile && getMode(deck) === 'solo' && shouldRevert.current) {
-      void dispatch(createIntent(LayoutAction.SetLayoutMode, { part: 'mode', options: { revert: true } }));
-    }
-  }, [isNotMobile, deck, dispatch]);
-
-  // When deck is disabled in settings, set to solo mode if the current layout mode is deck.
-  // TODO(thure): Applying this as an effect should be avoided over emitting the intent only when the setting changes.
-  useEffect(() => {
-    if (!settings.enableDeck && layoutMode === 'deck') {
-      void dispatch(
-        createIntent(LayoutAction.SetLayoutMode, { part: 'mode', subject: active[0], options: { mode: 'solo' } }),
-      );
-    }
-  }, [settings.enableDeck, dispatch, active, layoutMode]);
-
-  /**
-   * Clear scroll restoration state if the window is resized
-   */
-  const handleResize = useCallback(() => {
-    scrollLeftRef.current = null;
-  }, []);
-
-  useEffect(() => {
-    window.addEventListener('resize', handleResize);
-    return () => window.removeEventListener('resize', handleResize);
-  }, [handleResize]);
-
-  const restoreScroll = useCallback(() => {
-    if (deckRef.current && scrollLeftRef.current != null) {
-      deckRef.current.scrollLeft = scrollLeftRef.current;
-    }
-  }, []);
-  useOnTransition(layoutMode, (mode) => mode !== 'deck', 'deck', restoreScroll);
-
-  /**
-   * Save scroll position as the user scrolls
-   */
-  const handleScroll = useCallback(
-    (event: UIEvent) => {
-      if (!solo && event.currentTarget === event.target) {
-        scrollLeftRef.current = (event.target as HTMLDivElement).scrollLeft;
-      }
-    },
-    [solo],
-  );
-
-  const isEmpty = !solo && active.length === 0;
-
-  const padding = useMemo(() => {
-    if (!solo && settings.overscroll === 'centering') {
-      return calculateOverscroll(active.length);
-    }
-    return {};
-  }, [solo, settings.overscroll, deck]);
-
-  const mainPosition = useMemo(
-    () => [
-      'grid !block-start-[env(safe-area-inset-top)]',
-      topbar && '!block-start-[calc(env(safe-area-inset-top)+var(--rail-size))]',
-      hoistStatusbar && 'lg:block-end-[--statusbar-size]',
-    ],
-    [topbar, hoistStatusbar],
-  );
-
-  const { order, itemsCount }: { order: Record<string, number>; itemsCount: number } = useMemo(() => {
-    return active.reduce(
-      (acc: { order: Record<string, number>; itemsCount: number }, entryId) => {
-        acc.order[entryId] = acc.itemsCount + 1;
-        acc.itemsCount += activeCompanions?.[entryId] ? 3 : 2;
-        return acc;
-      },
-      { order: {}, itemsCount: 0 },
-    );
-  }, [active, activeCompanions]);
+  const { toasts } = context;
 
   return (
     <PopoverRoot>
       <ActiveNode />
-
-      <Main.Root
-        navigationSidebarState={fullscreen ? 'closed' : context.sidebarState}
-        onNavigationSidebarStateChange={(next) => (context.sidebarState = next)}
-        complementarySidebarState={fullscreen ? 'closed' : context.complementarySidebarState}
-        onComplementarySidebarStateChange={(next) => (context.complementarySidebarState = next)}
-      >
-        {/* Left sidebar. */}
-        <Sidebar />
-
-        {/* Right sidebar. */}
-        <ComplementarySidebar current={complementarySidebarPanel} />
-
-        {/* Dialog overlay to dismiss dialogs. */}
-        <Main.Overlay />
-
-        {/* No content. */}
-        {isEmpty && (
-          <Main.Content bounce handlesFocus classNames={mainPosition}>
-            <ContentEmpty />
-          </Main.Content>
-        )}
-
-        {/* Solo/deck mode. */}
-        {!isEmpty && (
-          <Main.Content
-            bounce
-            handlesFocus
-            classNames={mainPosition}
-            style={
-              {
-                '--dx-main-sidebarWidth':
-                  sidebarState === 'expanded'
-                    ? 'var(--nav-sidebar-size)'
-                    : sidebarState === 'collapsed'
-                      ? 'var(--l0-size)'
-                      : '0',
-                '--dx-main-complementaryWidth':
-                  complementarySidebarState === 'expanded'
-                    ? 'var(--complementary-sidebar-size)'
-                    : complementarySidebarState === 'collapsed'
-                      ? 'var(--rail-size)'
-                      : '0',
-                '--dx-main-contentFirstWidth': `${plankSizing[active[0] ?? 'never'] ?? DEFAULT_HORIZONTAL_SIZE}rem`,
-                '--dx-main-contentLastWidth': `${plankSizing[active[(active.length ?? 1) - 1] ?? 'never'] ?? DEFAULT_HORIZONTAL_SIZE}rem`,
-              } as MainProps['style']
-            }
-          >
-            <div
-              role='none'
-              className={!solo ? 'relative bg-deckSurface overflow-hidden' : 'sr-only'}
-              {...(solo && { inert: '' })}
-            >
-              {!topbar && !fullscreen && <ToggleSidebarButton classNames={fixedSidebarToggleStyles} />}
-              {!topbar && !fullscreen && (
-                <ToggleComplementarySidebarButton classNames={fixedComplementarySidebarToggleStyles} />
-              )}
-              <Stack
-                ref={deckRef}
-                orientation='horizontal'
-                size='contain'
-                classNames={['absolute inset-block-0 -inset-inline-px', mainPaddingTransitions]}
-                itemsCount={itemsCount - 1}
-                style={padding}
-                onScroll={handleScroll}
-              >
-                {active.map((entryId) => (
-                  <Fragment key={entryId}>
-                    <PlankSeparator order={order[entryId] - 1} />
-                    <Plank
-                      id={entryId}
-                      companionId={activeCompanions?.[entryId]}
-                      part='deck'
-                      order={order[entryId]}
-                      active={active}
-                      layoutMode={layoutMode}
-                      settings={settings}
-                    />
-                  </Fragment>
-                ))}
-              </Stack>
-            </div>
-            <div
-              role='none'
-              className={solo ? 'relative bg-deckSurface overflow-hidden' : 'sr-only'}
-              {...(!solo && { inert: '' })}
-            >
-              {!topbar && !fullscreen && <ToggleSidebarButton classNames={fixedSidebarToggleStyles} />}
-              {!topbar && !fullscreen && (
-                <ToggleComplementarySidebarButton classNames={fixedComplementarySidebarToggleStyles} />
-              )}
-              <StackContext.Provider value={{ size: 'contain', orientation: 'horizontal', rail: true }}>
-                <Plank
-                  id={solo}
-                  companionId={solo ? activeCompanions?.[solo] : undefined}
-                  part='solo'
-                  layoutMode={layoutMode}
-                  settings={settings}
-                />
-              </StackContext.Provider>
-            </div>
-          </Main.Content>
-        )}
-
-        {/* Topbar. */}
-        {topbar && <Topbar />}
-
-        {/* Status bar. */}
-        {hoistStatusbar && <StatusBar showHints={settings.showHints} />}
-      </Main.Root>
-
-      {/* Global popovers. */}
+      <DeckMain />
       <PopoverContent />
-
-      {/* Global dialog. */}
       <Dialog />
-
-      {/* Global toasts. */}
-      {toasts?.map((toast) => (
-        <Toast
-          {...toast}
-          key={toast.id}
-          onOpenChange={(open) => {
-            if (!open) {
-              onDismissToast(toast.id);
-            }
-
-            return open;
-          }}
-        />
-      ))}
+      <Toaster toasts={toasts} onDismissToast={onDismissToast} />
     </PopoverRoot>
   );
 };