@dxos/plugin-sheet 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/src/components/SheetToolbar/SheetToolbar.tsx

@@ -2,43 +2,46 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
-import React, { type PropsWithChildren, useMemo } from 'react';
+import { Atom, type Registry, RegistryContext } from '@effect-atom/atom-react';
+import React, { type PropsWithChildren, useContext, useMemo } from 'react';
 
-import { useAppGraph } from '@dxos/app-framework';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
 import { type CompleteCellRange } from '@dxos/compute';
-import { type ThemedClassName } from '@dxos/react-ui';
 import {
   type ActionGraphProps,
-  MenuProvider,
-  ToolbarMenu,
+  Menu,
+  type MenuRootProps,
   createGapSeparator,
-  rxFromSignal,
   useMenuActions,
 } from '@dxos/react-ui-menu';
 
 import { type SheetModel } from '../../model';
-import { useSheetContext } from '../SheetContext';
+import { useSheetContext } from '../SheetRoot';
 
 import { createAlign, useAlignState } from './align';
 import { createStyle, useStyleState } from './style';
-import { type ToolbarState, useToolbarState } from './useToolbarState';
+import { type ToolbarStateAtom, useToolbarState } from './useToolbarState';
 
-//
-// Root
-//
-
-export type SheetToolbarProps = ThemedClassName<PropsWithChildren<{ id: string }>>;
+type ToolbarActionsContext = {
+  model: SheetModel;
+  stateAtom: ToolbarStateAtom;
+  registry: Registry.Registry;
+  cursorFallbackRange?: CompleteCellRange;
+  customActions?: Atom.Atom<ActionGraphProps>;
+};
 
-const createToolbarActions = (
-  model: SheetModel,
-  state: ToolbarState,
-  cursorFallbackRange?: CompleteCellRange,
-  customActions?: Rx.Rx<ActionGraphProps>,
-): Rx.Rx<ActionGraphProps> => {
-  return Rx.make((get) => {
-    const align = get(rxFromSignal(() => createAlign(model, state, cursorFallbackRange)));
-    const style = get(rxFromSignal(() => createStyle(model, state, cursorFallbackRange)));
+const createToolbarActions = ({
+  model,
+  stateAtom,
+  registry,
+  cursorFallbackRange,
+  customActions,
+}: ToolbarActionsContext): Atom.Atom<ActionGraphProps> => {
+  return Atom.make((get) => {
+    const state = get(stateAtom);
+    const context = { model, state, stateAtom, registry, cursorFallbackRange };
+    const align = createAlign(context);
+    const style = createStyle(context);
     const gap = createGapSeparator();
 
     const graph: ActionGraphProps = {
@@ -56,30 +59,37 @@ const createToolbarActions = (
   });
 };
 
-export const SheetToolbar = ({ id, classNames }: SheetToolbarProps) => {
+export type SheetToolbarProps = { id: string } & Partial<MenuRootProps> &
+  PropsWithChildren<{ id: string } & Partial<MenuRootProps>>;
+
+export const SheetToolbar = ({ id, ...props }: SheetToolbarProps) => {
   const { model, cursorFallbackRange } = useSheetContext();
-  const state = useToolbarState({});
-  useAlignState(state);
-  useStyleState(state);
+  const stateAtom = useToolbarState({});
+  const registry = useContext(RegistryContext);
+  useAlignState(stateAtom);
+  useStyleState(stateAtom);
 
   const { graph } = useAppGraph();
   const customActions = useMemo(() => {
-    return Rx.make((get) => {
+    return Atom.make((get) => {
       const actions = get(graph.actions(id));
       const nodes = actions.filter((action) => action.properties.disposition === 'toolbar');
-      return { nodes, edges: nodes.map((node) => ({ source: 'root', target: node.id })) };
+      return {
+        nodes,
+        edges: nodes.map((node) => ({ source: 'root', target: node.id, relation: 'child' })),
+      };
     });
-  }, [graph]);
+  }, [graph, id]);
 
   const actionsCreator = useMemo(
-    () => createToolbarActions(model, state, cursorFallbackRange, customActions),
-    [model, state, cursorFallbackRange, customActions],
+    () => createToolbarActions({ model, stateAtom, registry, cursorFallbackRange, customActions }),
+    [model, stateAtom, registry, cursorFallbackRange, customActions],
   );
   const menu = useMenuActions(actionsCreator);
 
   return (
-    <MenuProvider {...menu} attendableId={id}>
-      <ToolbarMenu classNames={classNames} />
-    </MenuProvider>
+    <Menu.Root {...props} {...menu} attendableId={id}>
+      <Menu.Toolbar />
+    </Menu.Root>
   );
 };

package/src/components/SheetToolbar/align.ts

@@ -2,17 +2,24 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useEffect } from 'react';
+import { type Registry, RegistryContext } from '@effect-atom/atom-react';
+import { useContext, useEffect } from 'react';
 
 import { type CompleteCellRange, inRange } from '@dxos/compute';
-import { type ToolbarMenuActionGroupProperties, createMenuAction, createMenuItemGroup } from '@dxos/react-ui-menu';
+import { Obj } from '@dxos/echo';
+import {
+  type ActionGraphProps,
+  type ToolbarMenuActionGroupProperties,
+  createMenuAction,
+  createMenuItemGroup,
+} from '@dxos/react-ui-menu';
 
 import { meta } from '../../meta';
 import { type SheetModel } from '../../model';
 import { type AlignKey, type AlignValue, alignKey, rangeFromIndex, rangeToIndex } from '../../types';
-import { useSheetContext } from '../SheetContext';
+import { useSheetContext } from '../SheetRoot';
 
-import { type ToolbarState } from './useToolbarState';
+import { type ToolbarState, type ToolbarStateAtom } from './useToolbarState';
 
 export type AlignAction = { key: AlignKey; value: AlignValue };
 
@@ -24,18 +31,21 @@ const aligns: Record<AlignValue, string> = {
   end: 'ph--text-align-right--regular',
 };
 
-export const useAlignState = (state: Partial<AlignState>) => {
+export const useAlignState = (stateAtom: ToolbarStateAtom) => {
+  const registry = useContext(RegistryContext);
   const { cursor, model } = useSheetContext();
   useEffect(() => {
     // TODO(thure): Can this O(n) call be memoized?
-    state[alignKey] = (
+    const alignValue = (
       cursor
         ? model.sheet.ranges?.findLast(
             ({ range, key }) => key === alignKey && inRange(rangeFromIndex(model.sheet, range), cursor),
           )?.value
         : undefined
     ) as AlignValue | undefined;
-  }, [cursor, model.sheet]);
+    const prev = registry.get(stateAtom);
+    registry.set(stateAtom, { ...prev, [alignKey]: alignValue });
+  }, [cursor, model.sheet, registry, stateAtom]);
 };
 
 const createAlignGroupAction = (value?: AlignValue) =>
@@ -46,7 +56,15 @@ const createAlignGroupAction = (value?: AlignValue) =>
     value: `${alignKey}--${value}`,
   } as ToolbarMenuActionGroupProperties);
 
-const createAlignActions = (model: SheetModel, state: ToolbarState, cursorFallbackRange?: CompleteCellRange) =>
+type AlignActionsContext = {
+  model: SheetModel;
+  state: ToolbarState;
+  stateAtom: ToolbarStateAtom;
+  registry: Registry.Registry;
+  cursorFallbackRange?: CompleteCellRange;
+};
+
+const createAlignActions = ({ model, state, stateAtom, registry, cursorFallbackRange }: AlignActionsContext) =>
   Object.entries(aligns).map(([alignValue, icon]) => {
     return createMenuAction<AlignAction>(
       `${alignKey}--${alignValue}`,
@@ -64,15 +82,22 @@ const createAlignActions = (model: SheetModel, state: ToolbarState, cursorFallba
           key: alignKey,
           value: alignValue as AlignValue,
         };
+        const currentState = registry.get(stateAtom);
         if (index < 0) {
-          model.sheet.ranges?.push(nextRangeEntity);
-          state[alignKey] = nextRangeEntity.value;
+          Obj.change(model.sheet, (obj) => {
+            obj.ranges?.push(nextRangeEntity);
+          });
+          registry.set(stateAtom, { ...currentState, [alignKey]: nextRangeEntity.value });
         } else if (model.sheet.ranges![index].value === nextRangeEntity.value) {
-          model.sheet.ranges?.splice(index, 1);
-          state[alignKey] = undefined;
+          Obj.change(model.sheet, (obj) => {
+            obj.ranges?.splice(index, 1);
+          });
+          registry.set(stateAtom, { ...currentState, [alignKey]: undefined });
         } else {
-          model.sheet.ranges?.splice(index, 1, nextRangeEntity);
-          state[alignKey] = nextRangeEntity.value;
+          Obj.change(model.sheet, (obj) => {
+            obj.ranges?.splice(index, 1, nextRangeEntity);
+          });
+          registry.set(stateAtom, { ...currentState, [alignKey]: nextRangeEntity.value });
         }
       },
       {
@@ -86,14 +111,14 @@ const createAlignActions = (model: SheetModel, state: ToolbarState, cursorFallba
     );
   });
 
-export const createAlign = (model: SheetModel, state: ToolbarState, cursorFallbackRange?: CompleteCellRange) => {
-  const alignGroup = createAlignGroupAction(state[alignKey]);
-  const alignActions = createAlignActions(model, state, cursorFallbackRange);
+export const createAlign = (context: AlignActionsContext): ActionGraphProps => {
+  const alignGroup = createAlignGroupAction(context.state[alignKey]);
+  const alignActions = createAlignActions(context);
   return {
     nodes: [alignGroup, ...alignActions],
     edges: [
-      { source: 'root', target: 'align' },
-      ...alignActions.map(({ id }) => ({ source: alignGroup.id, target: id })),
+      { source: 'root', target: 'align', relation: 'child' },
+      ...alignActions.map(({ id }) => ({ source: alignGroup.id, target: id, relation: 'child' })),
     ],
   };
 };

package/src/components/SheetToolbar/style.ts

@@ -2,15 +2,24 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useEffect } from 'react';
+import { type Registry, RegistryContext } from '@effect-atom/atom-react';
+import { useContext, useEffect } from 'react';
 
 import { type CompleteCellRange, inRange } from '@dxos/compute';
-import { type ToolbarMenuActionGroupProperties, createMenuAction, createMenuItemGroup } from '@dxos/react-ui-menu';
+import { Obj } from '@dxos/echo';
+import {
+  type ActionGraphProps,
+  type ToolbarMenuActionGroupProperties,
+  createMenuAction,
+  createMenuItemGroup,
+} from '@dxos/react-ui-menu';
 
 import { meta } from '../../meta';
 import { type SheetModel } from '../../model';
 import { type StyleKey, type StyleValue, rangeFromIndex, rangeToIndex } from '../../types';
-import { useSheetContext } from '../SheetContext';
+import { useSheetContext } from '../SheetRoot';
+
+import { type ToolbarState, type ToolbarStateAtom } from './useToolbarState';
 
 export type StyleState = Partial<Record<StyleValue, boolean>>;
 
@@ -21,22 +30,30 @@ const styles: Record<StyleValue, string> = {
   softwrap: 'ph--paragraph--regular',
 };
 
-export const useStyleState = (state: StyleState) => {
+export const useStyleState = (stateAtom: ToolbarStateAtom) => {
+  const registry = useContext(RegistryContext);
   const { cursorFallbackRange, model } = useSheetContext();
 
   useEffect(() => {
-    state.highlight = false;
-    state.softwrap = false;
+    let highlight = false;
+    let softwrap = false;
     if (cursorFallbackRange && model.sheet.ranges) {
       model.sheet.ranges
         .filter(
           ({ range, key }) => key === 'style' && inRange(rangeFromIndex(model.sheet, range), cursorFallbackRange.from),
         )
         .forEach(({ value }) => {
-          state[value as StyleValue] = true;
+          if (value === 'highlight') {
+            highlight = true;
+          }
+          if (value === 'softwrap') {
+            softwrap = true;
+          }
         });
     }
-  }, [cursorFallbackRange, model.sheet]);
+    const prev = registry.get(stateAtom);
+    registry.set(stateAtom, { ...prev, highlight, softwrap });
+  }, [cursorFallbackRange, model.sheet, registry, stateAtom]);
 };
 
 const createStyleGroup = (state: StyleState) => {
@@ -49,7 +66,15 @@ const createStyleGroup = (state: StyleState) => {
   } as ToolbarMenuActionGroupProperties);
 };
 
-const createStyleActions = (model: SheetModel, state: StyleState, cursorFallbackRange?: CompleteCellRange) =>
+type StyleActionsContext = {
+  model: SheetModel;
+  state: ToolbarState;
+  stateAtom: ToolbarStateAtom;
+  registry: Registry.Registry;
+  cursorFallbackRange?: CompleteCellRange;
+};
+
+const createStyleActions = ({ model, state, stateAtom, registry, cursorFallbackRange }: StyleActionsContext) =>
   Object.entries(styles).map(([styleValue, icon]) => {
     return createMenuAction<StyleAction>(
       `style--${styleValue}`,
@@ -67,6 +92,7 @@ const createStyleActions = (model: SheetModel, state: StyleState, cursorFallback
           key: 'style',
           value: styleValue as StyleValue,
         };
+        const currentState = registry.get(stateAtom);
         if (
           model.sheet.ranges
             .filter(
@@ -77,12 +103,16 @@ const createStyleActions = (model: SheetModel, state: StyleState, cursorFallback
         ) {
           // this value should be unset
           if (index >= 0) {
-            model.sheet.ranges?.splice(index, 1);
+            Obj.change(model.sheet, (obj) => {
+              obj.ranges?.splice(index, 1);
+            });
           }
-          state[nextRangeEntity.value] = false;
+          registry.set(stateAtom, { ...currentState, [nextRangeEntity.value]: false });
         } else {
-          model.sheet.ranges?.push(nextRangeEntity);
-          state[nextRangeEntity.value] = true;
+          Obj.change(model.sheet, (obj) => {
+            obj.ranges?.push(nextRangeEntity);
+          });
+          registry.set(stateAtom, { ...currentState, [nextRangeEntity.value]: true });
         }
       },
       {
@@ -95,14 +125,14 @@ const createStyleActions = (model: SheetModel, state: StyleState, cursorFallback
     );
   });
 
-export const createStyle = (model: SheetModel, state: StyleState, cursorFallbackRange?: CompleteCellRange) => {
-  const styleGroupAction = createStyleGroup(state);
-  const styleActions = createStyleActions(model, state, cursorFallbackRange);
+export const createStyle = (context: StyleActionsContext): ActionGraphProps => {
+  const styleGroupAction = createStyleGroup(context.state);
+  const styleActions = createStyleActions(context);
   return {
     nodes: [styleGroupAction, ...styleActions],
     edges: [
-      { source: 'root', target: 'style' },
-      ...styleActions.map(({ id }) => ({ source: styleGroupAction.id, target: id })),
+      { source: 'root', target: 'style', relation: 'child' },
+      ...styleActions.map(({ id }) => ({ source: styleGroupAction.id, target: id, relation: 'child' })),
     ],
   };
 };

package/src/components/SheetToolbar/useToolbarState.ts

@@ -2,15 +2,32 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useMemo } from 'react';
-
-import { live } from '@dxos/live-object';
+import { Atom, type Registry, RegistryContext, useAtomValue } from '@effect-atom/atom-react';
+import { useContext, useMemo } from 'react';
 
 import { type AlignState } from './align';
 import { type StyleState } from './style';
 
 export type ToolbarState = Partial<StyleState & AlignState>;
+export type ToolbarStateAtom = Atom.Writable<ToolbarState>;
+
+/**
+ * Creates a reactive toolbar state Atom.
+ */
+export const useToolbarState = (initialState: ToolbarState = {}): ToolbarStateAtom => {
+  return useMemo(() => Atom.make<ToolbarState>(initialState).pipe(Atom.keepAlive), []);
+};
+
+/**
+ * Hook to read the current toolbar state value.
+ */
+export const useToolbarStateValue = (stateAtom: ToolbarStateAtom): ToolbarState => {
+  return useAtomValue(stateAtom);
+};
 
-export const useToolbarState = (initialState: ToolbarState = {}) => {
-  return useMemo(() => live<ToolbarState>(initialState), []);
+/**
+ * Hook to get the registry for updating toolbar state.
+ */
+export const useToolbarStateRegistry = (): Registry.Registry => {
+  return useContext(RegistryContext);
 };

package/src/components/index.ts

@@ -2,11 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-import { lazy } from 'react';
-
 export * from './ComputeGraph';
-export * from './GridSheet';
-export * from './RangeList';
-export * from './SheetContext';
-
-export const SheetContainer = lazy(() => import('./SheetContainer'));
+export * from './Sheet';

package/src/{components → containers}/RangeList/RangeList.tsx

@@ -6,38 +6,43 @@ import * as Schema from 'effect/Schema';
 import React, { useCallback } from 'react';
 
 import { rangeToA1Notation } from '@dxos/compute';
-import { Callout, useTranslation } from '@dxos/react-ui';
+import { Obj } from '@dxos/echo';
+import { Input, Message, useTranslation } from '@dxos/react-ui';
 import { List } from '@dxos/react-ui-list';
-import { ghostHover } from '@dxos/react-ui-theme';
+import { ghostHover } from '@dxos/ui-theme';
 
 import { meta } from '../../meta';
 import { rangeFromIndex } from '../../types';
-import { Range, type SheetType } from '../../types';
+import { Sheet } from '../../types';
 
 export type RangeListProps = {
-  sheet: SheetType;
+  sheet: Sheet.Sheet;
 };
 
 export const RangeList = ({ sheet }: RangeListProps) => {
   const { t } = useTranslation(meta.id);
   // TODO(thure): Implement similar to comments, #8121
-  const handleSelectRange = (range: Range) => {};
+  const handleSelectRange = (range: Sheet.Range) => {};
   const handleDeleteRange = useCallback(
-    (range: Range) => {
+    (range: Sheet.Range) => {
       const index = sheet.ranges.findIndex((sheetRange) => sheetRange === range);
-      sheet.ranges.splice(index, 1);
+      Obj.change(sheet, (obj) => {
+        obj.ranges.splice(index, 1);
+      });
     },
     [sheet],
   );
   return (
     <>
-      <h2 className='mbs-cardSpacingBlock mbe-labelSpacingBlock text-sm font-semibold'>{t('range list heading')}</h2>
+      <Input.Root>
+        <Input.Label>{t('range list heading')}</Input.Label>
+      </Input.Root>
       {sheet.ranges.length < 1 ? (
-        <Callout.Root>
-          <Callout.Title>{t('no ranges message')}</Callout.Title>
-        </Callout.Root>
+        <Message.Root>
+          <Message.Title>{t('no ranges message')}</Message.Title>
+        </Message.Root>
       ) : (
-        <List.Root<Range> items={sheet.ranges} isItem={Schema.is(Range)}>
+        <List.Root<Sheet.Range> items={sheet.ranges} isItem={Schema.is(Sheet.Range)}>
           {({ items: ranges }) =>
             ranges.map((range, i) => (
               <List.Item key={i} item={range} classNames={['p-2', ghostHover]}>

package/src/containers/RangeList/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { RangeList } from './RangeList';
+
+export default RangeList;

package/src/containers/SheetContainer/SheetContainer.stories.tsx

@@ -0,0 +1,94 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Meta } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React, { useContext } from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Obj } from '@dxos/echo';
+import { OperationResolver } from '@dxos/operation';
+import { corePlugins } from '@dxos/plugin-testing';
+import { useSpace } from '@dxos/react-client/echo';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { AttendableContainer } from '@dxos/react-ui-attention';
+
+import { ComputeGraphContext, useComputeGraph } from '../../components';
+import { createTestCells, useTestSheet, withComputeGraphDecorator } from '../../testing';
+import { translations } from '../../translations';
+import { Sheet, SheetOperation } from '../../types';
+import RangeList from '../RangeList';
+
+import { SheetContainer } from './SheetContainer';
+
+const meta = {
+  title: 'plugins/plugin-sheet/containers/SheetContainer',
+  component: SheetContainer,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'fullscreen' }),
+    withClientProvider({ types: [Sheet.Sheet], createSpace: true }),
+    withComputeGraphDecorator(),
+    withPluginManager({
+      plugins: [...corePlugins()],
+      capabilities: [
+        Capability.contributes(Capabilities.OperationResolver, [
+          OperationResolver.make({
+            operation: SheetOperation.DropAxis,
+            handler: ({ model, axis, axisIndex }) =>
+              Effect.sync(() => {
+                model[axis === 'col' ? 'dropColumn' : 'dropRow'](axisIndex);
+                return { axis, axisIndex, index: 0, axisMeta: null, values: [] };
+              }),
+          }),
+        ]),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof SheetContainer>;
+
+export default meta;
+
+export const Default = () => {
+  const space = useSpace();
+  const graph = useComputeGraph(space);
+  const { registry } = useContext(ComputeGraphContext) ?? {};
+  const sheet = useTestSheet(space, graph, { cells: createTestCells() });
+  if (!sheet || !space || !registry) {
+    return null;
+  }
+
+  return (
+    <AttendableContainer id={Obj.getDXN(sheet).toString()} classNames='contents'>
+      <SheetContainer role='article' space={space} subject={sheet} registry={registry} ignoreAttention />
+    </AttendableContainer>
+  );
+};
+
+export const Spec = () => {
+  const space = useSpace();
+  const graph = useComputeGraph(space);
+  const { registry } = useContext(ComputeGraphContext) ?? {};
+  const sheet = useTestSheet(space, graph, { cells: { A1: { value: 'Ready' } } });
+  if (!sheet || !space || !registry) {
+    return null;
+  }
+
+  return (
+    <AttendableContainer id={Obj.getDXN(sheet).toString()} classNames='contents'>
+      <div role='none' className='w-full grid grid-cols-[1fr_20rem]'>
+        <SheetContainer role='article' space={space} subject={sheet} registry={registry} ignoreAttention />
+        <div role='none' data-testid='grid.range-list'>
+          <RangeList sheet={sheet} />
+        </div>
+      </div>
+    </AttendableContainer>
+  );
+};

package/src/containers/SheetContainer/SheetContainer.tsx

@@ -0,0 +1,57 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { type ComputeGraphRegistry } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { type Space } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+
+import { ComputeGraphContextProvider, Sheet, useComputeGraph } from '../../components';
+import { type Sheet as SheetType } from '../../types';
+
+export type SheetContainerProps = SurfaceComponentProps<
+  SheetType.Sheet,
+  {
+    space: Space;
+    registry: ComputeGraphRegistry;
+    ignoreAttention?: boolean;
+  }
+>;
+
+export const SheetContainer = ({ registry, ...props }: SheetContainerProps) => (
+  <ComputeGraphContextProvider registry={registry}>
+    <SheetContainerInner {...props} />
+  </ComputeGraphContextProvider>
+);
+
+const SheetContainerInner = ({
+  role,
+  subject: sheet,
+  space,
+  ignoreAttention,
+}: Omit<SheetContainerProps, 'registry'>) => {
+  const graph = useComputeGraph(space);
+  if (!graph) {
+    return null;
+  }
+
+  return (
+    <Sheet.Root graph={graph} sheet={sheet} ignoreAttention={ignoreAttention}>
+      <Panel.Root classNames={role === 'section' && 'aspect-aquare'}>
+        <Panel.Toolbar asChild>
+          <Sheet.Toolbar id={Obj.getDXN(sheet).toString()} />
+        </Panel.Toolbar>
+        <Panel.Content asChild>
+          <Sheet.Content />
+        </Panel.Content>
+        <Panel.Statusbar asChild>
+          <Sheet.Statusbar />
+        </Panel.Statusbar>
+      </Panel.Root>
+    </Sheet.Root>
+  );
+};

package/src/{components → containers}/SheetContainer/index.ts

@@ -1,5 +1,5 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2023 DXOS.org
 //
 
 import { SheetContainer } from './SheetContainer';

package/src/containers/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export const RangeList: ComponentType<any> = lazy(() => import('./RangeList'));
+export const SheetContainer: ComponentType<any> = lazy(() => import('./SheetContainer'));