@dxos/plugin-sheet 0.7.5-main.9d26e3a → 0.7.5-main.e9bb01b

package/src/components/SheetToolbar/comment.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect, useMemo } from 'react';
+
+import { RefArray } from '@dxos/live-object';
+import { createMenuAction } from '@dxos/react-ui-menu';
+
+import { SHEET_PLUGIN } from '../../meta';
+import { commentKey, type CommentKey, type CommentValue, rangeToIndex } from '../../types';
+import { useSheetContext } from '../SheetContext';
+
+export type CommentAction = { key: CommentKey; value: CommentValue; cellContent?: string };
+
+export type CommentState = { commentEnabled: 'comment' | 'no cursor' | 'selection overlaps existing comment' };
+
+export const useCommentState = (state: Partial<CommentState>) => {
+  const { cursorFallbackRange, model } = useSheetContext();
+
+  // TODO(thure): Can this O(n) call be memoized?
+  const overlapsCommentAnchor = useMemo(
+    () =>
+      RefArray.allResolvedTargets(model.sheet.threads ?? [])
+        .filter((thread) => thread.status !== 'resolved')
+        .some((thread) => {
+          if (!cursorFallbackRange) {
+            return false;
+          }
+          return rangeToIndex(model.sheet, cursorFallbackRange) === thread.anchor;
+        }),
+    [cursorFallbackRange, model.sheet],
+  );
+
+  useEffect(() => {
+    state.commentEnabled = !cursorFallbackRange
+      ? 'no cursor'
+      : overlapsCommentAnchor
+        ? 'selection overlaps existing comment'
+        : 'comment';
+  }, [overlapsCommentAnchor, cursorFallbackRange]);
+};
+
+const createCommentAction = (state: Partial<CommentState>) =>
+  createMenuAction<Pick<CommentAction, 'key'>>('comment', {
+    key: commentKey,
+    testId: 'editor.toolbar.comment',
+    icon: 'ph--chat-text--regular',
+    label: [`${state.commentEnabled} label`, { ns: SHEET_PLUGIN }],
+    disabled: state.commentEnabled !== 'comment',
+  });
+
+export const createComment = (state: Partial<CommentState>) => ({
+  nodes: [createCommentAction(state)],
+  edges: [{ source: 'root', target: 'comment' }],
+});

package/src/components/{Toolbar → SheetToolbar}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './Toolbar';
+export * from './SheetToolbar';

package/src/components/SheetToolbar/style.ts

@@ -0,0 +1,72 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect } from 'react';
+
+import { inRange } from '@dxos/compute';
+import { createMenuAction, createMenuItemGroup, type ToolbarMenuActionGroupProperties } from '@dxos/react-ui-menu';
+
+import { SHEET_PLUGIN } from '../../meta';
+import { rangeFromIndex, type StyleKey, type StyleValue } from '../../types';
+import { useSheetContext } from '../SheetContext';
+
+export type StyleState = Partial<Record<StyleValue, boolean>>;
+
+export type StyleAction = { key: StyleKey; value: StyleValue };
+
+const styles: Record<StyleValue, string> = {
+  highlight: 'ph--highlighter--regular',
+  softwrap: 'ph--paragraph--regular',
+};
+
+export const useStyleState = (state: StyleState) => {
+  const { cursorFallbackRange, model } = useSheetContext();
+
+  useEffect(() => {
+    state.highlight = false;
+    state.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;
+        });
+    }
+  }, [cursorFallbackRange, model.sheet]);
+};
+
+const createStyleGroup = (state: StyleState) => {
+  return createMenuItemGroup('style', {
+    variant: 'toggleGroup',
+    selectCardinality: 'multiple',
+    value: Object.keys(styles)
+      .filter((key) => !!state[key as StyleValue])
+      .map((styleValue) => `style--${styleValue}`),
+  } as ToolbarMenuActionGroupProperties);
+};
+
+const createStyleActions = (state: StyleState) =>
+  Object.entries(styles).map(([styleValue, icon]) => {
+    return createMenuAction<StyleAction>(`style--${styleValue}`, {
+      key: 'style',
+      value: styleValue as StyleValue,
+      icon,
+      label: [`range value ${styleValue} label`, { ns: SHEET_PLUGIN }],
+      checked: !!state[styleValue as StyleValue],
+    });
+  });
+
+export const createStyle = (state: StyleState) => {
+  const styleGroupAction = createStyleGroup(state);
+  const styleActions = createStyleActions(state);
+  return {
+    nodes: [styleGroupAction, ...styleActions],
+    edges: [
+      { source: 'root', target: 'style' },
+      ...styleActions.map(({ id }) => ({ source: styleGroupAction.id, target: id })),
+    ],
+  };
+};

package/src/components/SheetToolbar/useToolbarAction.ts

@@ -0,0 +1,87 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCallback } from 'react';
+
+import { createIntent, useIntentDispatcher } from '@dxos/app-framework';
+import { inRange } from '@dxos/compute';
+import { ThreadAction } from '@dxos/plugin-thread/types';
+import type { MenuAction, MenuActionHandler } from '@dxos/react-ui-menu';
+
+import { type AlignAction } from './align';
+import { type CommentAction } from './comment';
+import { type StyleAction } from './style';
+import { type ToolbarState } from './useToolbarState';
+import { completeCellRangeToThreadCursor } from '../../integrations';
+import { alignKey, rangeFromIndex, rangeToIndex } from '../../types';
+import { useSheetContext } from '../SheetContext';
+
+export type ToolbarAction = StyleAction | AlignAction | CommentAction;
+
+export const useToolbarAction = (state: ToolbarState) => {
+  const { model, cursorFallbackRange, cursor } = useSheetContext();
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+
+  // TODO(Zan): Externalize the toolbar action handler. E.g., Toolbar/keys should both fire events.
+  return useCallback(
+    (action: MenuAction<ToolbarAction>) => {
+      const { key, value } = action.properties;
+      if (cursorFallbackRange) {
+        const index =
+          model.sheet.ranges?.findIndex(
+            (range) => range.key === key && inRange(rangeFromIndex(model.sheet, range.range), cursorFallbackRange.from),
+          ) ?? -1;
+        const nextRangeEntity = {
+          range: rangeToIndex(model.sheet, cursorFallbackRange),
+          key,
+          value,
+        };
+        switch (key) {
+          case 'alignment':
+            if (index < 0) {
+              model.sheet.ranges?.push(nextRangeEntity);
+              state[alignKey] = value;
+            } else if (model.sheet.ranges![index].value === value) {
+              model.sheet.ranges?.splice(index, 1);
+              state[alignKey] = undefined;
+            } else {
+              model.sheet.ranges?.splice(index, 1, nextRangeEntity);
+              state[alignKey] = value;
+            }
+            break;
+          case 'style':
+            if (
+              model.sheet.ranges
+                .filter(
+                  ({ range, key: rangeKey }) =>
+                    rangeKey === 'style' && inRange(rangeFromIndex(model.sheet, range), cursorFallbackRange.from),
+                )
+                .some(({ value: rangeValue }) => rangeValue === value)
+            ) {
+              // this value should be unset
+              if (index >= 0) {
+                model.sheet.ranges?.splice(index, 1);
+              }
+              state[value] = false;
+            } else {
+              model.sheet.ranges?.push(nextRangeEntity);
+              state[value] = true;
+            }
+            break;
+          case 'comment': {
+            const cellContent = model.getCellText(cursorFallbackRange.from);
+            void dispatch(
+              createIntent(ThreadAction.Create, {
+                cursor: completeCellRangeToThreadCursor(cursorFallbackRange),
+                name: cellContent,
+                subject: model.sheet,
+              }),
+            );
+          }
+        }
+      }
+    },
+    [model.sheet, cursorFallbackRange, cursor, dispatch],
+  ) as MenuActionHandler;
+};

package/src/components/SheetToolbar/useToolbarState.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { create } from '@dxos/live-object';
+
+import { type AlignState } from './align';
+import { type CommentState } from './comment';
+import { type StyleState } from './style';
+
+export type ToolbarState = Partial<StyleState & AlignState & CommentState>;
+
+export const useToolbarState = (initialState: ToolbarState = {}) => {
+  return useMemo(() => create<ToolbarState>(initialState), []);
+};

package/src/components/index.ts

@@ -8,6 +8,5 @@ export * from './ComputeGraph';
 export * from './GridSheet';
 export * from './RangeList';
 export * from './SheetContext';
-export * from './SheetObjectSettings';
 
 export const SheetContainer = lazy(() => import('./SheetContainer'));

package/src/index.ts

@@ -2,9 +2,6 @@
 // Copyright 2023 DXOS.org
 //
 
-import { SheetPlugin } from './SheetPlugin';
-
-export * from './types';
+export { SheetCapabilities } from './capabilities';
+export * from './meta';
 export * from './SheetPlugin';
-
-export default SheetPlugin;

package/src/integrations/thread-ranges.ts

@@ -8,14 +8,15 @@ import {
   createIntent,
   createResolver,
   LayoutAction,
-  useIntentDispatcher,
   useIntentResolver,
+  useIntentDispatcher,
 } from '@dxos/app-framework';
 import { debounce } from '@dxos/async';
 import { type CellAddress, type CompleteCellRange, inRange } from '@dxos/compute';
+import { S } from '@dxos/echo-schema';
 import { ThreadAction } from '@dxos/plugin-thread/types';
 import { fullyQualifiedId } from '@dxos/react-client/echo';
-import { type DxGridElement, type DxGridPosition } from '@dxos/react-ui-grid';
+import { type DxGridElement, type DxGridPosition, type GridContentProps } from '@dxos/react-ui-grid';
 
 import { useSheetContext } from '../components';
 import { SHEET_PLUGIN } from '../meta';
@@ -41,19 +42,29 @@ export const useUpdateFocusedCellOnThreadSelection = (grid: DxGridElement | null
   const { model, setActiveRefs } = useSheetContext();
   const scrollIntoViewResolver = useMemo(
     () =>
-      createResolver(
-        LayoutAction.ScrollIntoView,
-        ({ cursor, ref }) => {
+      createResolver({
+        intent: LayoutAction.ScrollIntoView,
+        position: 'hoist',
+        filter: (
+          data,
+        ): data is {
+          part: 'current';
+          subject: string;
+          options: { cursor: string; ref: GridContentProps['activeRefs'] };
+        } => {
+          if (!S.is(LayoutAction.ScrollIntoView.fields.input)(data)) {
+            return false;
+          }
+
+          return data.subject === fullyQualifiedId(model.sheet) && !!data.options?.cursor;
+        },
+        resolve: ({ options: { cursor, ref } }) => {
           setActiveRefs(ref);
           // TODO(Zan): Everywhere we refer to the cursor in a thread context should change to `anchor`.
           const range = parseThreadAnchorAsCellRange(cursor!);
           range && grid?.setFocus({ ...range.to, plane: 'grid' }, true);
         },
-        {
-          disposition: 'hoist',
-          filter: (data) => data.id === fullyQualifiedId(model.sheet) && !!data.cursor,
-        },
-      ),
+      }),
     [model.sheet, setActiveRefs],
   );
 

package/src/meta.ts

@@ -6,10 +6,11 @@ import { type PluginMeta } from '@dxos/app-framework';
 
 export const SHEET_PLUGIN = 'dxos.org/plugin/sheet';
 
-export default {
+export const meta = {
   id: SHEET_PLUGIN,
   name: 'Sheet',
-  description: 'A simple spreadsheet plugin.',
+  description: `Sheets in Composer are simple spreadsheets which allow you to leverage custom functions inside of cell grids. Leverage more than 400 pre-built formulas like Sum, Average, Count, Max, Min along with many others. You can also deploy your own custom functions using the Scripts plugin. `,
   icon: 'ph--grid-nine--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-sheet',
+  screenshots: ['https://dxos.network/plugin-details-sheet-dark.png'],
 } satisfies PluginMeta;

package/src/types/sheet-range-types.ts

@@ -8,7 +8,7 @@ import { type SheetType } from '../types';
 
 export const alignKey = 'alignment';
 export type AlignKey = typeof alignKey;
-export type AlignValue = 'start' | 'center' | 'end' | 'unset';
+export type AlignValue = 'start' | 'center' | 'end';
 
 export const commentKey = 'comment';
 export type CommentKey = typeof commentKey;

package/src/types/types.ts

@@ -2,38 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import type {
-  IntentResolverProvides,
-  MetadataRecordsProvides,
-  SurfaceProvides,
-  TranslationsProvides,
-} from '@dxos/app-framework';
 import { S } from '@dxos/echo-schema';
-import { type MarkdownExtensionProvides } from '@dxos/plugin-markdown';
-import { type SchemaProvides } from '@dxos/plugin-space';
 
 import { type CellValue, RowColumnMeta, SheetType } from './schema';
 import { SHEET_PLUGIN } from '../meta';
 import { SheetModel } from '../model';
 
-// TODO(Zan): Move this to the plugin-space plugin or another common location
-// when we implement comments in sheets.
-// This is currently duplicated in a few places.
-type ThreadProvides<T> = {
-  thread: {
-    predicate: (obj: any) => obj is T;
-    createSort: (obj: T) => (anchorA: string | undefined, anchorB: string | undefined) => number;
-  };
-};
-
-export type SheetPluginProvides = SurfaceProvides &
-  IntentResolverProvides &
-  MarkdownExtensionProvides &
-  MetadataRecordsProvides &
-  TranslationsProvides &
-  SchemaProvides &
-  ThreadProvides<SheetType>;
-
 export type SheetSize = {
   rows: number;
   columns: number;

package/dist/lib/browser/SheetContainer-S4NCLUYL.mjs

@@ -1,290 +0,0 @@
-import {
-  GridSheet,
-  SheetProvider,
-  completeCellRangeToThreadCursor,
-  useComputeGraph,
-  useSheetContext
-} from "./chunk-A374JPWV.mjs";
-import {
-  alignKey,
-  mapFormulaIndicesToRefs,
-  rangeFromIndex,
-  rangeToIndex,
-  styleKey
-} from "./chunk-Q4XS4YWF.mjs";
-import {
-  SHEET_PLUGIN
-} from "./chunk-RABELMEQ.mjs";
-
-// packages/plugins/plugin-sheet/src/components/SheetContainer/SheetContainer.tsx
-import React3 from "react";
-import { StackItem } from "@dxos/react-ui-stack";
-
-// packages/plugins/plugin-sheet/src/components/FunctionEditor/FunctionEditor.tsx
-import React from "react";
-import { addressToA1Notation, isFormula, rangeToA1Notation } from "@dxos/compute";
-import { Icon } from "@dxos/react-ui";
-var FunctionEditor = () => {
-  const { model, cursor, range } = useSheetContext();
-  let value;
-  let formula = false;
-  if (cursor) {
-    value = model.getCellValue(cursor);
-    if (isFormula(value)) {
-      value = model.graph.mapFunctionBindingFromId(mapFormulaIndicesToRefs(model.sheet, value));
-      formula = true;
-    } else if (value != null) {
-      value = String(value);
-    }
-  }
-  return /* @__PURE__ */ React.createElement("div", {
-    className: "flex shrink-0 justify-between items-center px-4 py-1 text-sm attention-surface border-bs !border-separator"
-  }, /* @__PURE__ */ React.createElement("div", {
-    className: "flex gap-4 items-center"
-  }, /* @__PURE__ */ React.createElement("div", {
-    className: "flex w-16 items-center font-mono"
-  }, range && rangeToA1Notation(range) || cursor && addressToA1Notation(cursor)), /* @__PURE__ */ React.createElement("div", {
-    className: "flex gap-2 items-center"
-  }, /* @__PURE__ */ React.createElement(Icon, {
-    icon: "ph--function--regular",
-    classNames: [
-      "text-greenText",
-      formula ? "visible" : "invisible"
-    ]
-  }), /* @__PURE__ */ React.createElement("span", {
-    className: "font-mono"
-  }, value))));
-};
-
-// packages/plugins/plugin-sheet/src/components/Toolbar/Toolbar.tsx
-import { createContext } from "@radix-ui/react-context";
-import React2, { useCallback } from "react";
-import { createIntent, useIntentDispatcher } from "@dxos/app-framework";
-import { inRange } from "@dxos/compute";
-import { RefArray } from "@dxos/live-object";
-import { ThreadAction } from "@dxos/plugin-thread/types";
-import { Icon as Icon2, Toolbar as NaturalToolbar, Tooltip, useTranslation } from "@dxos/react-ui";
-import { useAttention } from "@dxos/react-ui-attention";
-var buttonStyles = "min-bs-0 p-2";
-var tooltipProps = {
-  side: "bottom"
-};
-var ToolbarSeparator = () => /* @__PURE__ */ React2.createElement("div", {
-  role: "separator",
-  className: "grow"
-});
-var ToolbarItem = ({ itemType, icon, children, ...props }) => {
-  const Invoker = itemType === "toggleGroupItem" ? NaturalToolbar.ToggleGroupItem : itemType === "toggle" ? NaturalToolbar.Toggle : NaturalToolbar.Button;
-  return /* @__PURE__ */ React2.createElement(Tooltip.Root, null, /* @__PURE__ */ React2.createElement(Tooltip.Trigger, {
-    asChild: true
-  }, /* @__PURE__ */ React2.createElement(Invoker, {
-    variant: "ghost",
-    ...props,
-    classNames: buttonStyles
-  }, /* @__PURE__ */ React2.createElement(Icon2, {
-    icon,
-    size: 5
-  }), /* @__PURE__ */ React2.createElement("span", {
-    className: "sr-only"
-  }, children))), /* @__PURE__ */ React2.createElement(Tooltip.Portal, null, /* @__PURE__ */ React2.createElement(Tooltip.Content, tooltipProps, children, /* @__PURE__ */ React2.createElement(Tooltip.Arrow, null))));
-};
-var [ToolbarContextProvider, useToolbarContext] = createContext("Toolbar");
-var ToolbarRoot = ({ children, role, classNames }) => {
-  const { id, model, cursorFallbackRange, cursor } = useSheetContext();
-  const { hasAttention } = useAttention(id);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  const handleAction = useCallback((action) => {
-    switch (action.key) {
-      case "alignment":
-        if (cursorFallbackRange) {
-          const index = model.sheet.ranges?.findIndex((range) => range.key === action.key && inRange(rangeFromIndex(model.sheet, range.range), cursorFallbackRange.from)) ?? -1;
-          const nextRangeEntity = {
-            range: rangeToIndex(model.sheet, cursorFallbackRange),
-            key: action.key,
-            value: action.value
-          };
-          if (index < 0) {
-            model.sheet.ranges?.push(nextRangeEntity);
-          } else if (model.sheet.ranges[index].value === action.value) {
-            model.sheet.ranges?.splice(index, 1);
-          } else {
-            model.sheet.ranges?.splice(index, 1, nextRangeEntity);
-          }
-        }
-        break;
-      case "style":
-        if (action.unset) {
-          const index = model.sheet.ranges?.findIndex((range) => range.key === action.key && cursorFallbackRange && inRange(rangeFromIndex(model.sheet, range.range), cursorFallbackRange.from));
-          if (index >= 0) {
-            model.sheet.ranges?.splice(index, 1);
-          }
-        } else if (cursorFallbackRange) {
-          model.sheet.ranges?.push({
-            range: rangeToIndex(model.sheet, cursorFallbackRange),
-            key: action.key,
-            value: action.value
-          });
-        }
-        break;
-      case "comment": {
-        if (cursorFallbackRange) {
-          void dispatch(createIntent(ThreadAction.Create, {
-            cursor: completeCellRangeToThreadCursor(cursorFallbackRange),
-            name: action.cellContent,
-            subject: model.sheet
-          }));
-        }
-      }
-    }
-  }, [
-    model.sheet,
-    cursorFallbackRange,
-    cursor,
-    dispatch
-  ]);
-  return /* @__PURE__ */ React2.createElement(ToolbarContextProvider, {
-    onAction: handleAction
-  }, /* @__PURE__ */ React2.createElement(NaturalToolbar.Root, {
-    classNames: [
-      "pli-0.5 attention-surface",
-      !hasAttention && "opacity-20",
-      classNames
-    ]
-  }, children));
-};
-var alignmentOptions = [
-  {
-    value: "start",
-    icon: "ph--text-align-left--regular"
-  },
-  {
-    value: "center",
-    icon: "ph--text-align-center--regular"
-  },
-  {
-    value: "end",
-    icon: "ph--text-align-right--regular"
-  }
-];
-var Alignment = () => {
-  const { cursor, model } = useSheetContext();
-  const { onAction } = useToolbarContext("Alignment");
-  const { t } = useTranslation(SHEET_PLUGIN);
-  const value = cursor ? model.sheet.ranges?.findLast(({ range, key }) => key === alignKey && inRange(rangeFromIndex(model.sheet, range), cursor))?.value : void 0;
-  return /* @__PURE__ */ React2.createElement(NaturalToolbar.ToggleGroup, {
-    type: "single",
-    value: (
-      // TODO(thure): providing `undefined` leaves the last item active which was active rather than showing none.
-      value ?? "never"
-    ),
-    onValueChange: (value2) => onAction?.({
-      key: alignKey,
-      value: value2
-    })
-  }, alignmentOptions.map(({ value: value2, icon }) => /* @__PURE__ */ React2.createElement(ToolbarItem, {
-    itemType: "toggleGroupItem",
-    key: value2,
-    value: value2,
-    icon,
-    "data-testid": `grid.toolbar.${alignKey}.${value2}`
-  }, t("toolbar action label", {
-    key: t(`range key ${alignKey} label`),
-    value: t(`range value ${value2} label`)
-  }))));
-};
-var styleOptions = [
-  {
-    value: "highlight",
-    icon: "ph--highlighter--regular"
-  },
-  {
-    value: "softwrap",
-    icon: "ph--paragraph--regular"
-  }
-];
-var Styles = () => {
-  const { cursorFallbackRange, model } = useSheetContext();
-  const { onAction } = useToolbarContext("Styles");
-  const { t } = useTranslation(SHEET_PLUGIN);
-  const activeValues = cursorFallbackRange ? model.sheet.ranges?.filter(({ range, key }) => key === "style" && inRange(rangeFromIndex(model.sheet, range), cursorFallbackRange.from)).reduce((acc, { value }) => {
-    acc.add(value);
-    return acc;
-  }, /* @__PURE__ */ new Set()) : void 0;
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, styleOptions.map(({ value, icon }) => /* @__PURE__ */ React2.createElement(ToolbarItem, {
-    itemType: "toggle",
-    key: value,
-    pressed: activeValues?.has(value),
-    onPressedChange: (nextPressed) => {
-      onAction?.({
-        key: "style",
-        value,
-        unset: !nextPressed
-      });
-    },
-    icon
-  }, t("toolbar action label", {
-    key: t(`range key ${styleKey} label`),
-    value: t(`range value ${value} label`)
-  }))));
-};
-var Actions = () => {
-  const { onAction } = useToolbarContext("Actions");
-  const { cursorFallbackRange, cursor, model } = useSheetContext();
-  const { t } = useTranslation(SHEET_PLUGIN);
-  const overlapsCommentAnchor = RefArray.allResolvedTargets(model.sheet.threads ?? []).filter((thread) => thread.status !== "resolved").some((thread) => {
-    if (!cursorFallbackRange) {
-      return false;
-    }
-    return rangeToIndex(model.sheet, cursorFallbackRange) === thread.anchor;
-  });
-  const tooltipLabelKey = !cursor ? "no cursor label" : overlapsCommentAnchor ? "selection overlaps existing comment label" : "comment label";
-  return /* @__PURE__ */ React2.createElement(ToolbarItem, {
-    itemType: "button",
-    value: "comment",
-    icon: "ph--chat-text--regular",
-    "data-testid": "editor.toolbar.comment",
-    onClick: () => {
-      if (!cursorFallbackRange) {
-        return;
-      }
-      return onAction?.({
-        key: "comment",
-        value: rangeToIndex(model.sheet, cursorFallbackRange),
-        cellContent: model.getCellText(cursorFallbackRange.from)
-      });
-    },
-    disabled: !cursorFallbackRange || overlapsCommentAnchor
-  }, t(tooltipLabelKey));
-};
-var Toolbar = {
-  Root: ToolbarRoot,
-  Separator: ToolbarSeparator,
-  Alignment,
-  Styles,
-  Actions
-};
-
-// packages/plugins/plugin-sheet/src/components/SheetContainer/SheetContainer.tsx
-var SheetContainer = ({ space, sheet, role, ignoreAttention }) => {
-  const graph = useComputeGraph(space);
-  return graph ? /* @__PURE__ */ React3.createElement(SheetProvider, {
-    sheet,
-    graph,
-    ignoreAttention
-  }, /* @__PURE__ */ React3.createElement(StackItem.Content, {
-    toolbar: true,
-    statusbar: true,
-    ...role === "section" && {
-      classNames: "aspect-video"
-    }
-  }, /* @__PURE__ */ React3.createElement(Toolbar.Root, {
-    role
-  }, /* @__PURE__ */ React3.createElement(Toolbar.Styles, null), /* @__PURE__ */ React3.createElement(Toolbar.Alignment, null), /* @__PURE__ */ React3.createElement(Toolbar.Separator, null), /* @__PURE__ */ React3.createElement(Toolbar.Actions, null)), /* @__PURE__ */ React3.createElement(GridSheet, null), /* @__PURE__ */ React3.createElement(FunctionEditor, null))) : null;
-};
-
-// packages/plugins/plugin-sheet/src/components/SheetContainer/index.ts
-var SheetContainer_default = SheetContainer;
-export {
-  SheetContainer_default as default
-};
-//# sourceMappingURL=SheetContainer-S4NCLUYL.mjs.map