@dxos/plugin-deck 0.7.5-main.9d2a38b → 0.7.5-main.e94eead

package/dist/lib/browser/chunk-O4RFYYQ6.mjs

@@ -0,0 +1,1114 @@
+import {
+  calculateOverscroll,
+  layoutAppliesTopbar,
+  useBreakpoints,
+  useHoistStatusbar
+} from "./chunk-KANJBSIX.mjs";
+import {
+  DeckCapabilities
+} from "./chunk-22AQ5IVX.mjs";
+import {
+  DeckAction,
+  NewPlankPositions,
+  OverscrollOptions,
+  SLUG_PATH_SEPARATOR,
+  getMode
+} from "./chunk-FT33W5CI.mjs";
+import {
+  DECK_PLUGIN
+} from "./chunk-N7TEPFVR.mjs";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Banner.tsx
+import React2 from "react";
+import { Surface } from "@dxos/app-framework";
+import { mx } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/SidebarButton.tsx
+import React from "react";
+import { useCapability } from "@dxos/app-framework";
+import { IconButton, useTranslation } from "@dxos/react-ui";
+var ToggleSidebarButton = ({ classNames, variant = "ghost" }) => {
+  const layoutContext = useCapability(DeckCapabilities.MutableDeckState);
+  const { t } = useTranslation(DECK_PLUGIN);
+  return /* @__PURE__ */ React.createElement(IconButton, {
+    variant,
+    iconOnly: true,
+    icon: "ph--sidebar--regular",
+    size: 4,
+    label: t("open navigation sidebar label"),
+    onClick: () => layoutContext.sidebarState = layoutContext.sidebarState === "expanded" ? "collapsed" : "expanded",
+    classNames
+  });
+};
+var CloseSidebarButton = () => {
+  const layoutContext = useCapability(DeckCapabilities.MutableDeckState);
+  const { t } = useTranslation(DECK_PLUGIN);
+  return /* @__PURE__ */ React.createElement(IconButton, {
+    variant: "ghost",
+    iconOnly: true,
+    icon: "ph--caret-line-left--regular",
+    size: 4,
+    label: t("close navigation sidebar label"),
+    onClick: () => layoutContext.sidebarState = "collapsed",
+    classNames: "rounded-none pli-1 dx-focus-ring-inset pie-[max(.5rem,env(safe-area-inset-left))]"
+  });
+};
+var ToggleComplementarySidebarButton = ({ inR0, classNames }) => {
+  const layoutContext = useCapability(DeckCapabilities.MutableDeckState);
+  const { t } = useTranslation(DECK_PLUGIN);
+  return /* @__PURE__ */ React.createElement(IconButton, {
+    iconOnly: true,
+    onClick: () => layoutContext.complementarySidebarState = layoutContext.complementarySidebarState === "expanded" ? "collapsed" : "expanded",
+    variant: "ghost",
+    label: t("open complementary sidebar label"),
+    classNames: [
+      "[&>svg]:-scale-x-100",
+      classNames
+    ],
+    icon: "ph--sidebar-simple--regular",
+    size: inR0 ? 5 : 4,
+    tooltipSide: inR0 ? "left" : void 0
+  });
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Banner.tsx
+var Banner = ({ variant, classNames }) => {
+  return /* @__PURE__ */ React2.createElement("header", {
+    className: mx("flex items-stretch relative plb-1 pis-1 pie-2", variant === "topbar" && "fixed inset-inline-0 block-start-[env(safe-area-inset-top)] bs-[--rail-size] border-be border-separator", classNames)
+  }, variant === "sidebar" ? /* @__PURE__ */ React2.createElement(CloseSidebarButton, null) : /* @__PURE__ */ React2.createElement(ToggleSidebarButton, null), /* @__PURE__ */ React2.createElement("span", {
+    className: "self-center grow mis-1"
+  }, "Composer"), variant === "topbar" && /* @__PURE__ */ React2.createElement("div", {
+    role: "none",
+    className: "absolute inset-0 pointer-events-none"
+  }, /* @__PURE__ */ React2.createElement("div", {
+    role: "none",
+    className: "grid bs-full pointer-fine:p-1 max-is-md mli-auto pointer-events-auto"
+  }, /* @__PURE__ */ React2.createElement(Surface, {
+    role: "search-input",
+    limit: 1
+  }))), /* @__PURE__ */ React2.createElement("span", {
+    role: "none",
+    className: "grow"
+  }), /* @__PURE__ */ React2.createElement(Surface, {
+    role: "header-end",
+    limit: 1
+  }), /* @__PURE__ */ React2.createElement(Surface, {
+    role: "notch-start",
+    limit: 1
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/DeckLayout.tsx
+import { untracked } from "@preact/signals-core";
+import React17, { useCallback as useCallback4, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef2, Fragment as Fragment3, useState as useState4 } from "react";
+import { LayoutAction as LayoutAction4, createIntent as createIntent4, Surface as Surface10, useCapability as useCapability5, useIntentDispatcher as useIntentDispatcher4, usePluginManager } from "@dxos/app-framework";
+import { AttentionCapabilities } from "@dxos/plugin-attention";
+import { AlertDialog, Dialog as NaturalDialog, Main as Main3, Popover as Popover2, useOnTransition, useMediaQuery } from "@dxos/react-ui";
+import { Stack, StackContext, DEFAULT_HORIZONTAL_SIZE } from "@dxos/react-ui-stack";
+import { mainPaddingTransitions } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ActiveNode.tsx
+import React3 from "react";
+import { Surface as Surface2, useAppGraph } from "@dxos/app-framework";
+import { useAttended } from "@dxos/react-ui-attention";
+
+// packages/plugins/plugin-deck/src/hooks/useNode.ts
+import { useEffect, useState } from "react";
+var useNode = (graph, id, timeout) => {
+  const [nodeState, setNodeState] = useState(id ? graph.findNode(id, false) : void 0);
+  useEffect(() => {
+    if (!id && nodeState) {
+      setNodeState(void 0);
+    }
+    if (nodeState?.id === id || !id) {
+      return;
+    }
+    const frame = requestAnimationFrame(async () => {
+      try {
+        const node = await graph.waitForNode(id, timeout);
+        if (node) {
+          setNodeState(node);
+        }
+      } catch {
+      }
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [
+    graph,
+    id,
+    timeout,
+    nodeState?.id
+  ]);
+  return nodeState;
+};
+
+// packages/plugins/plugin-deck/src/hooks/useNodeActionExpander.ts
+import { useEffect as useEffect2 } from "react";
+import { ACTION_GROUP_TYPE, ACTION_TYPE, getGraph } from "@dxos/plugin-graph";
+var expandNodeActions = async (node) => {
+  const graph = getGraph(node);
+  await graph.expand(node, "outbound", ACTION_GROUP_TYPE);
+  await graph.expand(node, "outbound", ACTION_TYPE);
+};
+var useNodeActionExpander = (node) => {
+  useEffect2(() => {
+    if (node) {
+      const frame = requestAnimationFrame(() => {
+        void expandNodeActions(node);
+      });
+      return () => cancelAnimationFrame(frame);
+    }
+  }, [
+    node
+  ]);
+};
+
+// packages/plugins/plugin-deck/src/hooks/useMainSize.ts
+import { useMainContext } from "@dxos/react-ui";
+var useMainSize = () => {
+  const { navigationSidebarState, complementarySidebarState } = useMainContext("DeckPluginPlank");
+  return {
+    "data-sidebar-inline-start-state": navigationSidebarState,
+    "data-sidebar-inline-end-state": complementarySidebarState
+  };
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ActiveNode.tsx
+var ActiveNode = () => {
+  const [id] = useAttended();
+  const { graph } = useAppGraph();
+  const activeNode = useNode(graph, id);
+  useNodeActionExpander(activeNode);
+  return /* @__PURE__ */ React3.createElement("div", {
+    role: "none",
+    className: "sr-only"
+  }, /* @__PURE__ */ React3.createElement(Surface2, {
+    role: "document-title",
+    data: {
+      subject: activeNode
+    },
+    limit: 1
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ComplementarySidebar.tsx
+import React8, { useCallback as useCallback2, useEffect as useEffect5, useMemo as useMemo2, useState as useState3, Fragment as Fragment2 } from "react";
+import { createIntent as createIntent2, LayoutAction as LayoutAction2, Surface as Surface4, useAppGraph as useAppGraph3, useCapabilities, useCapability as useCapability2, useIntentDispatcher as useIntentDispatcher2 } from "@dxos/app-framework";
+import { Main, useTranslation as useTranslation5, toLocalizedString as toLocalizedString2, IconButton as IconButton2, ScrollArea as NaturalScrollArea } from "@dxos/react-ui";
+import { useAttended as useAttended2 } from "@dxos/react-ui-attention";
+import { Tabs } from "@dxos/react-ui-tabs";
+import { byPosition } from "@dxos/util";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/PlankError.tsx
+import React7, { useEffect as useEffect4, useState as useState2 } from "react";
+import { useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { descriptionText, mx as mx3 } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/NodePlankHeading.tsx
+import React5, { Fragment, memo, useCallback, useEffect as useEffect3, useMemo } from "react";
+import { createIntent, LayoutAction, Surface as Surface3, useAppGraph as useAppGraph2, useIntentDispatcher } from "@dxos/app-framework";
+import { Icon as Icon2, Popover, toLocalizedString, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { StackItem } from "@dxos/react-ui-stack";
+import { TextTooltip } from "@dxos/react-ui-text-tooltip";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/PlankControls.tsx
+import React4, { forwardRef } from "react";
+import { Button, ButtonGroup, Icon, Tooltip, useTranslation as useTranslation2 } from "@dxos/react-ui";
+var PlankControl = ({ icon, label, ...props }) => {
+  return /* @__PURE__ */ React4.createElement(Tooltip.Root, null, /* @__PURE__ */ React4.createElement(Tooltip.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React4.createElement(Button, {
+    variant: "ghost",
+    ...props
+  }, /* @__PURE__ */ React4.createElement("span", {
+    className: "sr-only"
+  }, label), /* @__PURE__ */ React4.createElement(Icon, {
+    icon,
+    size: 5
+  }))), /* @__PURE__ */ React4.createElement(Tooltip.Portal, null, /* @__PURE__ */ React4.createElement(Tooltip.Content, {
+    side: "bottom"
+  }, label)));
+};
+var PlankControls = /* @__PURE__ */ forwardRef(({ onClick, variant = "default", capabilities: can, isSolo, pin, close = false, children, classNames, ...props }, forwardedRef) => {
+  const { t } = useTranslation2(DECK_PLUGIN);
+  const buttonClassNames = variant === "hide-disabled" ? "disabled:hidden pli-2 plb-3" : "pli-2 plb-3";
+  return /* @__PURE__ */ React4.createElement(ButtonGroup, {
+    ...props,
+    classNames: [
+      "app-no-drag",
+      classNames
+    ],
+    ref: forwardedRef
+  }, can.solo && /* @__PURE__ */ React4.createElement(PlankControl, {
+    label: isSolo ? t("show deck plank label") : t("show solo plank label"),
+    classNames: buttonClassNames,
+    onClick: () => onClick?.("solo"),
+    icon: isSolo ? "ph--corners-in--regular" : "ph--corners-out--regular"
+  }), !isSolo && can.solo && /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(PlankControl, {
+    label: t("increment start label"),
+    disabled: !can.incrementStart,
+    classNames: buttonClassNames,
+    onClick: () => onClick?.("increment-start"),
+    icon: "ph--caret-left--regular"
+  }), /* @__PURE__ */ React4.createElement(PlankControl, {
+    label: t("increment end label"),
+    disabled: !can.incrementEnd,
+    classNames: buttonClassNames,
+    onClick: () => onClick?.("increment-end"),
+    icon: "ph--caret-right--regular"
+  })), close && !isSolo && /* @__PURE__ */ React4.createElement(PlankControl, {
+    label: t(`${typeof close === "string" ? "minify" : "close"} label`),
+    classNames: buttonClassNames,
+    onClick: () => onClick?.("close"),
+    "data-testid": "plankHeading.close",
+    icon: close === "minify-start" ? "ph--caret-line-left--regular" : close === "minify-end" ? "ph--caret-line-right--regular" : "ph--x--regular"
+  }), children);
+});
+
+// packages/plugins/plugin-deck/src/components/fragments.ts
+import { mx as mx2 } from "@dxos/react-ui-theme";
+var soloInlinePadding = "pis-[calc(env(safe-area-inset-left)+.25rem)] pie-[calc(env(safe-area-inset-left)+.25rem)]";
+var sidebarToggleStyles = "bs-[--rail-item] is-[--rail-item] absolute block-end-2 z-[1] !bg-deck lg:hidden";
+var fixedSidebarToggleStyles = mx2(sidebarToggleStyles, "inline-start-2");
+var fixedComplementarySidebarToggleStyles = mx2(sidebarToggleStyles, "inline-end-2");
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/NodePlankHeading.tsx
+var NodePlankHeading = /* @__PURE__ */ memo(({ id, part, node, canIncrementStart, canIncrementEnd, popoverAnchorId, pending, actions = [] }) => {
+  const { t } = useTranslation3(DECK_PLUGIN);
+  const { graph } = useAppGraph2();
+  const breakpoint = useBreakpoints();
+  const icon = node?.properties?.icon ?? "ph--placeholder--regular";
+  const label = pending ? t("pending heading") : toLocalizedString(node?.properties?.label ?? [
+    "plank heading fallback label",
+    {
+      ns: DECK_PLUGIN
+    }
+  ], t);
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const ActionRoot = node && popoverAnchorId === `dxos.org/ui/${DECK_PLUGIN}/${node.id}` ? Popover.Anchor : Fragment;
+  useEffect3(() => {
+    const frame = requestAnimationFrame(() => {
+      node && graph.actions(node);
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [
+    node
+  ]);
+  const attendableId = id.split(SLUG_PATH_SEPARATOR).at(0);
+  const capabilities = useMemo(() => ({
+    solo: breakpoint !== "mobile" && (part === "solo" || part === "deck"),
+    incrementStart: canIncrementStart,
+    incrementEnd: canIncrementEnd
+  }), [
+    breakpoint,
+    part,
+    canIncrementStart,
+    canIncrementEnd
+  ]);
+  const sigilActions = useMemo(() => node && [
+    actions,
+    graph.actions(node)
+  ].filter((a) => a.length > 0), [
+    actions,
+    node,
+    graph
+  ]);
+  const handleAction = useCallback((action) => {
+    typeof action.data === "function" && action.data?.({
+      node: action,
+      caller: DECK_PLUGIN
+    });
+  }, []);
+  const handlePlankAction = useCallback((eventType) => {
+    if (eventType === "solo") {
+      return dispatch(createIntent(DeckAction.Adjust, {
+        type: eventType,
+        id
+      }));
+    } else if (eventType === "close") {
+      if (part === "complementary") {
+        return dispatch(createIntent(LayoutAction.UpdateComplementary, {
+          part: "complementary",
+          options: {
+            state: "collapsed"
+          }
+        }));
+      } else {
+        return dispatch(createIntent(LayoutAction.Close, {
+          part: "main",
+          subject: [
+            id
+          ],
+          options: {
+            state: false
+          }
+        }));
+      }
+    } else {
+      return dispatch(createIntent(DeckAction.Adjust, {
+        type: eventType,
+        id
+      }));
+    }
+  }, [
+    dispatch,
+    id,
+    part
+  ]);
+  return /* @__PURE__ */ React5.createElement(StackItem.Heading, {
+    classNames: [
+      "plb-1 border-be border-separator items-stretch gap-1 sticky inline-start-12 app-drag",
+      part === "solo" ? soloInlinePadding : "pli-1"
+    ]
+  }, /* @__PURE__ */ React5.createElement(ActionRoot, null, node && sigilActions ? /* @__PURE__ */ React5.createElement(StackItem.Sigil, {
+    icon,
+    related: part === "complementary",
+    attendableId,
+    triggerLabel: t("actions menu label"),
+    actions: sigilActions,
+    onAction: handleAction
+  }, /* @__PURE__ */ React5.createElement(Surface3, {
+    role: "menu-footer",
+    data: {
+      subject: node.data
+    }
+  })) : /* @__PURE__ */ React5.createElement(StackItem.SigilButton, null, /* @__PURE__ */ React5.createElement("span", {
+    className: "sr-only"
+  }, label), /* @__PURE__ */ React5.createElement(Icon2, {
+    icon,
+    size: 5
+  }))), /* @__PURE__ */ React5.createElement(TextTooltip, {
+    text: label,
+    onlyWhenTruncating: true
+  }, /* @__PURE__ */ React5.createElement(StackItem.HeadingLabel, {
+    attendableId,
+    related: part === "complementary",
+    ...pending && {
+      classNames: "text-description"
+    }
+  }, label)), node && part !== "complementary" && /* @__PURE__ */ React5.createElement(Surface3, {
+    role: "navbar-end",
+    data: {
+      subject: node.data
+    }
+  }), /* @__PURE__ */ React5.createElement(PlankControls, {
+    capabilities,
+    isSolo: part === "solo",
+    onClick: handlePlankAction,
+    close: part === "complementary" ? "minify-end" : true
+  }));
+});
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/PlankLoading.tsx
+import React6 from "react";
+var PlankLoading = () => {
+  return /* @__PURE__ */ React6.createElement("div", {
+    role: "none",
+    className: "grid place-items-center attention-surface"
+  });
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/PlankError.tsx
+var PlankContentError = ({ error }) => {
+  const { t } = useTranslation4(DECK_PLUGIN);
+  const errorString = error?.toString() ?? "";
+  return /* @__PURE__ */ React7.createElement("div", {
+    role: "none",
+    className: "overflow-auto p-8 attention-surface grid place-items-center"
+  }, /* @__PURE__ */ React7.createElement("p", {
+    role: "alert",
+    className: mx3(descriptionText, "break-words border border-dashed border-separator rounded-lg p-8", errorString.length < 256 && "text-lg")
+  }, error ? errorString : t("error fallback message")));
+};
+var PlankError = ({ id, part, node, error }) => {
+  const [timedOut, setTimedOut] = useState2(false);
+  useEffect4(() => {
+    setTimeout(() => setTimedOut(true), 5e3);
+  }, []);
+  return /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement(NodePlankHeading, {
+    id,
+    part,
+    node,
+    pending: !timedOut
+  }), timedOut ? /* @__PURE__ */ React7.createElement(PlankContentError, {
+    error
+  }) : /* @__PURE__ */ React7.createElement(PlankLoading, null));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ComplementarySidebar.tsx
+var ComplementarySidebar = ({ current }) => {
+  const { t } = useTranslation5(DECK_PLUGIN);
+  const { dispatchPromise: dispatch } = useIntentDispatcher2();
+  const layout = useCapability2(DeckCapabilities.MutableDeckState);
+  const attended = useAttended2();
+  const { graph } = useAppGraph3();
+  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] = useState3(activePanelId);
+  useEffect5(() => {
+    setInternalValue(activePanelId);
+  }, [
+    activePanelId
+  ]);
+  const handleTabClick = useCallback2((event) => {
+    const nextValue = event.currentTarget.getAttribute("data-value");
+    if (nextValue === activePanelId) {
+      layout.complementarySidebarState = layout.complementarySidebarState === "expanded" ? "collapsed" : "expanded";
+    } else {
+      setInternalValue(nextValue);
+      layout.complementarySidebarState = "expanded";
+      void dispatch(createIntent2(LayoutAction2.UpdateComplementary, {
+        part: "complementary",
+        subject: nextValue
+      }));
+    }
+  }, [
+    layout,
+    activePanelId,
+    dispatch
+  ]);
+  const data = useMemo2(() => node && {
+    id: node.id,
+    subject: node.data,
+    workspace: layout.activeDeck,
+    popoverAnchorId: layout.popoverAnchorId
+  }, [
+    node,
+    layout.popoverAnchorId
+  ]);
+  return /* @__PURE__ */ React8.createElement(Main.ComplementarySidebar, {
+    classNames: [
+      topbar && "block-start-[calc(env(safe-area-inset-top)+var(--rail-size))]",
+      hoistStatusbar && "block-end-[--statusbar-size]"
+    ]
+  }, /* @__PURE__ */ React8.createElement(Tabs.Root, {
+    orientation: "vertical",
+    verticalVariant: "stateless",
+    value: internalValue,
+    attendableId: attended[0],
+    classNames: "contents"
+  }, /* @__PURE__ */ React8.createElement("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"
+  }, /* @__PURE__ */ React8.createElement(Tabs.Tablist, {
+    classNames: "grid grid-cols-1 auto-rows-[--rail-action] p-1 gap-1 !overflow-y-auto"
+  }, availablePanels.map((panel) => /* @__PURE__ */ React8.createElement(Tabs.Tab, {
+    key: panel.id,
+    value: panel.id,
+    asChild: true
+  }, /* @__PURE__ */ React8.createElement(IconButton2, {
+    label: toLocalizedString2(panel.label, t),
+    icon: panel.icon,
+    size: 5,
+    iconOnly: true,
+    tooltipSide: "left",
+    "data-value": panel.id,
+    variant: activePanelId === panel.id ? layout.complementarySidebarState === "expanded" ? "primary" : "default" : "ghost",
+    onClick: handleTabClick
+  })))), !hoistStatusbar && /* @__PURE__ */ React8.createElement("div", {
+    role: "none",
+    className: "grid grid-cols-1 auto-rows-[--rail-item] p-1 overflow-y-auto"
+  }, /* @__PURE__ */ React8.createElement(Surface4, {
+    role: "status-bar--r0-footer",
+    limit: 1
+  })), /* @__PURE__ */ React8.createElement("div", {
+    role: "none",
+    className: "hidden lg:grid grid-cols-1 auto-rows-[--rail-action] p-1"
+  }, /* @__PURE__ */ React8.createElement(ToggleComplementarySidebarButton, null))), availablePanels.map((panel) => /* @__PURE__ */ React8.createElement(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"
+    }
+  }, /* @__PURE__ */ React8.createElement(ComplementarySidebarPanel, {
+    panel,
+    activePanelId,
+    data,
+    hoistStatusbar
+  })))));
+};
+var ScrollArea = ({ children }) => {
+  return /* @__PURE__ */ React8.createElement(NaturalScrollArea.Root, null, /* @__PURE__ */ React8.createElement(NaturalScrollArea.Viewport, null, children), /* @__PURE__ */ React8.createElement(NaturalScrollArea.Scrollbar, {
+    orientation: "vertical"
+  }, /* @__PURE__ */ React8.createElement(NaturalScrollArea.Thumb, null)));
+};
+var ComplementarySidebarPanel = ({ panel, activePanelId, data, hoistStatusbar }) => {
+  const { t } = useTranslation5(DECK_PLUGIN);
+  if (panel.id !== activePanelId || !data) {
+    return null;
+  }
+  const Wrapper = panel.fixed ? Fragment2 : ScrollArea;
+  return /* @__PURE__ */ React8.createElement(React8.Fragment, null, /* @__PURE__ */ React8.createElement("h2", {
+    className: "flex items-center pli-2 border-separator border-be font-medium"
+  }, toLocalizedString2(panel.label, t)), /* @__PURE__ */ React8.createElement(Wrapper, null, /* @__PURE__ */ React8.createElement(Surface4, {
+    role: `complementary--${activePanelId}`,
+    data,
+    fallback: PlankContentError,
+    placeholder: /* @__PURE__ */ React8.createElement(PlankLoading, null)
+  })), !hoistStatusbar && /* @__PURE__ */ React8.createElement("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)]"
+  }, /* @__PURE__ */ React8.createElement(Surface4, {
+    role: "status-bar--r1-footer",
+    limit: 1
+  })));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ContentEmpty.tsx
+import React9 from "react";
+import { Surface as Surface5 } from "@dxos/app-framework";
+var ContentEmpty = () => {
+  const breakpoint = useBreakpoints();
+  const topbar = layoutAppliesTopbar(breakpoint);
+  return /* @__PURE__ */ React9.createElement("div", {
+    role: "none",
+    className: "grid place-items-center p-8 relative bg-deck",
+    "data-testid": "layoutPlugin.firstRunMessage"
+  }, /* @__PURE__ */ React9.createElement(Surface5, {
+    role: "keyshortcuts"
+  }), !topbar && /* @__PURE__ */ React9.createElement(ToggleSidebarButton, {
+    variant: "default",
+    classNames: fixedSidebarToggleStyles
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Fullscreen.tsx
+import React11 from "react";
+import { Surface as Surface6, useAppGraph as useAppGraph4 } from "@dxos/app-framework";
+import { fixedInsetFlexLayout } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Fallback.tsx
+import React10 from "react";
+import { useTranslation as useTranslation6 } from "@dxos/react-ui";
+import { errorText, mx as mx4 } from "@dxos/react-ui-theme";
+var Fallback = () => {
+  const { t } = useTranslation6(DECK_PLUGIN);
+  return /* @__PURE__ */ React10.createElement("div", {
+    role: "none",
+    className: "min-bs-screen is-full flex items-center justify-center p-8"
+  }, /* @__PURE__ */ React10.createElement("p", {
+    role: "alert",
+    className: mx4(errorText, "border border-error-400/50 rounded-lg flex items-center justify-center p-8 font-normal text-lg")
+  }, t("plugin error message")));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/constants.ts
+var SURFACE_PREFIX = "surface:";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Fullscreen.tsx
+var Fullscreen = ({ id }) => {
+  const { graph } = useAppGraph4();
+  const fullScreenNode = useNode(graph, id);
+  return /* @__PURE__ */ React11.createElement("div", {
+    role: "none",
+    className: fixedInsetFlexLayout
+  }, /* @__PURE__ */ React11.createElement(Surface6, {
+    role: "main",
+    limit: 1,
+    fallback: Fallback,
+    data: {
+      subject: fullScreenNode?.data,
+      component: id?.startsWith(SURFACE_PREFIX) ? id.slice(SURFACE_PREFIX.length) : void 0
+    }
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Plank.tsx
+import React12, { memo as memo2, useCallback as useCallback3, useLayoutEffect, useMemo as useMemo3, useRef } from "react";
+import { createIntent as createIntent3, LayoutAction as LayoutAction3, Surface as Surface7, useCapability as useCapability3, useAppGraph as useAppGraph5, useIntentDispatcher as useIntentDispatcher3 } from "@dxos/app-framework";
+import { debounce } from "@dxos/async";
+import { useAttendableAttributes } from "@dxos/react-ui-attention";
+import { StackItem as StackItem2, railGridHorizontal } from "@dxos/react-ui-stack";
+import { mainIntrinsicSize, mx as mx5 } from "@dxos/react-ui-theme";
+var UNKNOWN_ID = "unknown_id";
+var Plank = /* @__PURE__ */ memo2(({ id = UNKNOWN_ID, part, path, order, active, layoutMode }) => {
+  const { dispatchPromise: dispatch } = useIntentDispatcher3();
+  const { deck, popoverAnchorId, scrollIntoView } = useCapability3(DeckCapabilities.DeckState);
+  const { graph } = useAppGraph5();
+  const node = useNode(graph, id);
+  const rootElement = useRef(null);
+  const canResize = layoutMode === "deck";
+  const Root = part === "solo" ? "article" : StackItem2.Root;
+  const attendableAttrs = useAttendableAttributes(id);
+  const index = active ? active.findIndex((entryId) => entryId === id) : 0;
+  const length = active?.length ?? 1;
+  const canIncrementStart = active && index !== void 0 && index > 0 && length !== void 0 && length > 1;
+  const canIncrementEnd = active && index !== void 0 && index < length - 1 && length !== void 0;
+  const key = id.split("+")[0];
+  const size = deck.plankSizing[key];
+  const setSize = useCallback3(debounce((nextSize) => {
+    return dispatch(createIntent3(DeckAction.UpdatePlankSize, {
+      id: key,
+      size: nextSize
+    }));
+  }, 200), [
+    dispatch,
+    key
+  ]);
+  const handleKeyDown = useCallback3((event) => {
+    if (event.target === event.currentTarget && event.key === "Escape") {
+      rootElement.current?.closest("main")?.focus();
+    }
+  }, []);
+  useLayoutEffect(() => {
+    if (scrollIntoView === id) {
+      const focusable = rootElement.current?.querySelector("button") || rootElement.current;
+      focusable?.focus({
+        preventScroll: true
+      });
+      layoutMode === "deck" && focusable?.scrollIntoView({
+        behavior: "smooth",
+        inline: "center"
+      });
+      void dispatch(createIntent3(LayoutAction3.ScrollIntoView, {
+        part: "current",
+        subject: void 0
+      }));
+    }
+  }, [
+    id,
+    scrollIntoView,
+    layoutMode
+  ]);
+  const isSolo = layoutMode === "solo" && part === "solo";
+  const isAttendable = isSolo || layoutMode === "deck" && part === "deck";
+  const sizeAttrs = useMainSize();
+  const data = useMemo3(() => node && {
+    subject: node.data,
+    path,
+    popoverAnchorId
+  }, [
+    node,
+    node?.data,
+    path,
+    popoverAnchorId
+  ]);
+  const placeholder = useMemo3(() => /* @__PURE__ */ React12.createElement(PlankLoading, null), []);
+  const className = mx5("attention-surface relative", isSolo && mainIntrinsicSize, isSolo && railGridHorizontal, isSolo ? "grid absolute inset-0" : "!border-separator border-li");
+  return /* @__PURE__ */ React12.createElement(Root, {
+    ref: rootElement,
+    "data-testid": "deck.plank",
+    tabIndex: 0,
+    ...part === "solo" ? {
+      ...sizeAttrs,
+      className
+    } : {
+      item: {
+        id
+      },
+      size,
+      onSizeChange: setSize,
+      classNames: className,
+      order,
+      role: "article"
+    },
+    ...isAttendable ? attendableAttrs : {},
+    onKeyDown: handleKeyDown
+  }, node ? /* @__PURE__ */ React12.createElement(React12.Fragment, null, /* @__PURE__ */ React12.createElement(NodePlankHeading, {
+    id,
+    part,
+    node,
+    canIncrementStart,
+    canIncrementEnd,
+    popoverAnchorId
+  }), /* @__PURE__ */ React12.createElement(Surface7, {
+    key: node.id,
+    role: "article",
+    data,
+    limit: 1,
+    fallback: PlankContentError,
+    placeholder
+  })) : /* @__PURE__ */ React12.createElement(PlankError, {
+    id,
+    part
+  }), canResize && /* @__PURE__ */ React12.createElement(StackItem2.ResizeHandle, null));
+});
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Sidebar.tsx
+import React13, { useMemo as useMemo4 } from "react";
+import { Surface as Surface8, useCapability as useCapability4 } from "@dxos/app-framework";
+import { Main as Main2 } from "@dxos/react-ui";
+var Sidebar = () => {
+  const { popoverAnchorId, activeDeck: current } = useCapability4(DeckCapabilities.DeckState);
+  const breakpoint = useBreakpoints();
+  const topbar = layoutAppliesTopbar(breakpoint);
+  const hoistStatusbar = useHoistStatusbar(breakpoint);
+  const navigationData = useMemo4(() => ({
+    popoverAnchorId,
+    topbar,
+    hoistStatusbar,
+    current
+  }), [
+    popoverAnchorId,
+    topbar,
+    hoistStatusbar,
+    current
+  ]);
+  return /* @__PURE__ */ React13.createElement(Main2.NavigationSidebar, {
+    classNames: [
+      "grid",
+      topbar && "block-start-[calc(env(safe-area-inset-top)+var(--rail-size))]",
+      hoistStatusbar && "block-end-[--statusbar-size]"
+    ]
+  }, /* @__PURE__ */ React13.createElement(Surface8, {
+    role: "navigation",
+    data: navigationData,
+    limit: 1
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/StatusBar.tsx
+import React14 from "react";
+import { Surface as Surface9 } from "@dxos/app-framework";
+import { useLandmarkMover } from "@dxos/react-ui";
+var StatusBar = ({ showHints }) => {
+  const mover = useLandmarkMover(void 0, "3");
+  return /* @__PURE__ */ React14.createElement("div", {
+    role: "contentinfo",
+    className: "fixed block-end-0 inset-inline-0 bs-[--statusbar-size] border-bs border-separator z-[2] flex text-description",
+    ...mover
+  }, showHints && /* @__PURE__ */ React14.createElement(Surface9, {
+    role: "hints",
+    limit: 1
+  }), /* @__PURE__ */ React14.createElement(Surface9, {
+    role: "status-bar",
+    limit: 1
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Toast.tsx
+import React15 from "react";
+import { Button as Button2, Icon as Icon3, Toast as NaturalToast, toLocalizedString as toLocalizedString3, useTranslation as useTranslation7 } from "@dxos/react-ui";
+var Toast = ({ id, title, description, icon, duration, actionLabel, actionAlt, closeLabel, onAction, onOpenChange }) => {
+  const { t } = useTranslation7(DECK_PLUGIN);
+  return /* @__PURE__ */ React15.createElement(NaturalToast.Root, {
+    "data-testid": id,
+    defaultOpen: true,
+    duration,
+    onOpenChange
+  }, /* @__PURE__ */ React15.createElement(NaturalToast.Body, null, /* @__PURE__ */ React15.createElement(NaturalToast.Title, {
+    classNames: "items-center"
+  }, icon && /* @__PURE__ */ React15.createElement(Icon3, {
+    icon,
+    size: 5,
+    classNames: "inline mr-1"
+  }), title && /* @__PURE__ */ React15.createElement("span", null, toLocalizedString3(title, t))), description && /* @__PURE__ */ React15.createElement(NaturalToast.Description, null, description && toLocalizedString3(description, t))), /* @__PURE__ */ React15.createElement(NaturalToast.Actions, null, onAction && actionAlt && actionLabel && /* @__PURE__ */ React15.createElement(NaturalToast.Action, {
+    altText: toLocalizedString3(actionAlt, t),
+    asChild: true
+  }, /* @__PURE__ */ React15.createElement(Button2, {
+    "data-testid": "toast.action",
+    variant: "primary",
+    onClick: () => onAction?.()
+  }, toLocalizedString3(actionLabel, t))), closeLabel && /* @__PURE__ */ React15.createElement(NaturalToast.Close, {
+    asChild: true
+  }, /* @__PURE__ */ React15.createElement(Button2, {
+    "data-testid": "toast.close"
+  }, toLocalizedString3(closeLabel, t)))));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Topbar.tsx
+import React16 from "react";
+var Topbar = () => {
+  return /* @__PURE__ */ React16.createElement(Banner, {
+    variant: "topbar"
+  });
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/DeckLayout.tsx
+var PlankSeparator = ({ index }) => index > 0 ? /* @__PURE__ */ React17.createElement("span", {
+  role: "separator",
+  className: "row-span-2 bg-deck is-4",
+  style: {
+    gridColumn: index * 2
+  }
+}) : null;
+var DeckLayout = ({ overscroll, showHints, onDismissToast }) => {
+  const { dispatchPromise: dispatch } = useIntentDispatcher4();
+  const context = useCapability5(DeckCapabilities.MutableDeckState);
+  const { sidebarState, complementarySidebarState, complementarySidebarPanel, dialogOpen, dialogContent, dialogBlockAlign, dialogType, popoverOpen, popoverContent, popoverAnchorId, deck, toasts } = context;
+  const { active, fullscreen, solo, plankSizing } = deck;
+  const breakpoint = useBreakpoints();
+  const topbar = layoutAppliesTopbar(breakpoint);
+  const hoistStatusbar = useHoistStatusbar(breakpoint);
+  const pluginManager = usePluginManager();
+  const scrollLeftRef = useRef2();
+  const deckRef = useRef2(null);
+  const [delayedPopoverVisibility, setDelayedPopoverVisibility] = useState4(false);
+  useEffect6(() => {
+    popoverOpen ? setTimeout(() => setDelayedPopoverVisibility(true), 40) : setDelayedPopoverVisibility(false);
+  }, [
+    popoverOpen
+  ]);
+  useEffect6(() => {
+    const attended = untracked(() => {
+      const attention = pluginManager.context.requestCapability(AttentionCapabilities.Attention);
+      return attention.current;
+    });
+    const firstId = solo ?? active[0];
+    if (attended.length === 0 && firstId) {
+      document.querySelector(`article[data-attendable-id="${firstId}"] button`)?.focus();
+    }
+  }, []);
+  const [isNotMobile] = useMediaQuery("md", {
+    ssr: false
+  });
+  const shouldRevert = useRef2(false);
+  useEffect6(() => {
+    if (!isNotMobile && getMode(deck) === "deck") {
+      const attended = untracked(() => {
+        const attention = pluginManager.context.requestCapability(AttentionCapabilities.Attention);
+        return attention.current;
+      });
+      shouldRevert.current = true;
+      void dispatch(createIntent4(LayoutAction4.SetLayoutMode, {
+        part: "mode",
+        subject: attended[0],
+        options: {
+          mode: "solo"
+        }
+      }));
+    } else if (isNotMobile && getMode(deck) === "solo" && shouldRevert.current) {
+      void dispatch(createIntent4(LayoutAction4.SetLayoutMode, {
+        part: "mode",
+        options: {
+          revert: true
+        }
+      }));
+    }
+  }, [
+    isNotMobile,
+    deck,
+    dispatch
+  ]);
+  const handleResize = useCallback4(() => {
+    scrollLeftRef.current = null;
+  }, []);
+  useEffect6(() => {
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, [
+    handleResize
+  ]);
+  const restoreScroll = useCallback4(() => {
+    if (deckRef.current && scrollLeftRef.current != null) {
+      deckRef.current.scrollLeft = scrollLeftRef.current;
+    }
+  }, []);
+  const layoutMode = getMode(deck);
+  useOnTransition(layoutMode, (mode) => mode !== "deck", "deck", restoreScroll);
+  const handleScroll = useCallback4((event) => {
+    if (!solo && event.currentTarget === event.target) {
+      scrollLeftRef.current = event.target.scrollLeft;
+    }
+  }, [
+    solo
+  ]);
+  const isEmpty = !solo && active.length === 0;
+  const padding = useMemo5(() => {
+    if (!solo && overscroll === "centering") {
+      return calculateOverscroll(active.length);
+    }
+    return {};
+  }, [
+    solo,
+    overscroll,
+    deck
+  ]);
+  const mainPosition = useMemo5(() => [
+    "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 Dialog = dialogType === "alert" ? AlertDialog : NaturalDialog;
+  const handlePopoverOpenChange = useCallback4((nextOpen) => {
+    if (nextOpen && popoverAnchorId) {
+      context.popoverOpen = true;
+    } else {
+      context.popoverOpen = false;
+      context.popoverAnchorId = void 0;
+      context.popoverSide = void 0;
+    }
+  }, [
+    context
+  ]);
+  const handlePopoverClose = useCallback4(() => handlePopoverOpenChange(false), [
+    handlePopoverOpenChange
+  ]);
+  return /* @__PURE__ */ React17.createElement(Popover2.Root, {
+    modal: true,
+    open: !!(popoverAnchorId && delayedPopoverVisibility),
+    onOpenChange: handlePopoverOpenChange
+  }, /* @__PURE__ */ React17.createElement(ActiveNode, null), fullscreen && /* @__PURE__ */ React17.createElement(Fullscreen, {
+    id: solo
+  }), !fullscreen && /* @__PURE__ */ React17.createElement(Main3.Root, {
+    navigationSidebarState: context.sidebarState,
+    onNavigationSidebarStateChange: (next) => context.sidebarState = next,
+    complementarySidebarState: context.complementarySidebarState,
+    onComplementarySidebarStateChange: (next) => context.complementarySidebarState = next
+  }, /* @__PURE__ */ React17.createElement(Sidebar, null), /* @__PURE__ */ React17.createElement(ComplementarySidebar, {
+    current: complementarySidebarPanel
+  }), /* @__PURE__ */ React17.createElement(Main3.Overlay, null), isEmpty && /* @__PURE__ */ React17.createElement(Main3.Content, {
+    bounce: true,
+    handlesFocus: true,
+    classNames: mainPosition
+  }, /* @__PURE__ */ React17.createElement(ContentEmpty, null)), !isEmpty && /* @__PURE__ */ React17.createElement(Main3.Content, {
+    bounce: true,
+    classNames: mainPosition,
+    handlesFocus: true,
+    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`
+    }
+  }, /* @__PURE__ */ React17.createElement("div", {
+    role: "none",
+    className: !solo ? "relative bg-deck overflow-hidden" : "sr-only",
+    ...solo && {
+      inert: ""
+    }
+  }, !topbar && /* @__PURE__ */ React17.createElement(ToggleSidebarButton, {
+    classNames: fixedSidebarToggleStyles
+  }), !topbar && /* @__PURE__ */ React17.createElement(ToggleComplementarySidebarButton, {
+    classNames: fixedComplementarySidebarToggleStyles
+  }), /* @__PURE__ */ React17.createElement(Stack, {
+    orientation: "horizontal",
+    size: "contain",
+    classNames: [
+      "absolute inset-block-0 -inset-inline-px",
+      mainPaddingTransitions
+    ],
+    onScroll: handleScroll,
+    itemsCount: 2 * (active.length ?? 0) - 1,
+    style: padding,
+    ref: deckRef
+  }, active.map((entryId, index) => /* @__PURE__ */ React17.createElement(Fragment3, {
+    key: entryId
+  }, /* @__PURE__ */ React17.createElement(PlankSeparator, {
+    index
+  }), /* @__PURE__ */ React17.createElement(Plank, {
+    id: entryId,
+    part: "deck",
+    order: index * 2 + 1,
+    active,
+    layoutMode
+  }))))), /* @__PURE__ */ React17.createElement("div", {
+    role: "none",
+    className: solo ? "relative bg-deck overflow-hidden" : "sr-only",
+    ...!solo && {
+      inert: ""
+    }
+  }, !topbar && /* @__PURE__ */ React17.createElement(ToggleSidebarButton, {
+    classNames: fixedSidebarToggleStyles
+  }), !topbar && /* @__PURE__ */ React17.createElement(ToggleComplementarySidebarButton, {
+    classNames: fixedComplementarySidebarToggleStyles
+  }), /* @__PURE__ */ React17.createElement(StackContext.Provider, {
+    value: {
+      size: "contain",
+      orientation: "horizontal",
+      rail: true
+    }
+  }, /* @__PURE__ */ React17.createElement(Plank, {
+    id: solo,
+    part: "solo",
+    layoutMode
+  })))), topbar && /* @__PURE__ */ React17.createElement(Topbar, null), hoistStatusbar && /* @__PURE__ */ React17.createElement(StatusBar, {
+    showHints
+  })), /* @__PURE__ */ React17.createElement(Popover2.Portal, null, /* @__PURE__ */ React17.createElement(Popover2.Content, {
+    side: context.popoverSide,
+    onEscapeKeyDown: handlePopoverClose
+  }, /* @__PURE__ */ React17.createElement(Popover2.Viewport, null, /* @__PURE__ */ React17.createElement(Surface10, {
+    role: "popover",
+    data: popoverContent,
+    limit: 1
+  })), /* @__PURE__ */ React17.createElement(Popover2.Arrow, null))), /* @__PURE__ */ React17.createElement(Dialog.Root, {
+    modal: dialogBlockAlign !== "end",
+    open: dialogOpen,
+    onOpenChange: (nextOpen) => context.dialogOpen = nextOpen
+  }, dialogBlockAlign === "end" ? /* @__PURE__ */ React17.createElement(Surface10, {
+    role: "dialog",
+    data: dialogContent,
+    limit: 1
+  }) : /* @__PURE__ */ React17.createElement(Dialog.Overlay, {
+    blockAlign: dialogBlockAlign
+  }, /* @__PURE__ */ React17.createElement(Surface10, {
+    role: "dialog",
+    data: dialogContent,
+    limit: 1
+  }))), toasts?.map((toast) => /* @__PURE__ */ React17.createElement(Toast, {
+    ...toast,
+    key: toast.id,
+    onOpenChange: (open) => {
+      if (!open) {
+        onDismissToast(toast.id);
+      }
+      return open;
+    }
+  })));
+};
+
+// packages/plugins/plugin-deck/src/components/LayoutSettings.tsx
+import React18 from "react";
+import { Input, Select, useTranslation as useTranslation8 } from "@dxos/react-ui";
+import { DeprecatedFormContainer, DeprecatedFormInput } from "@dxos/react-ui-form";
+var isSocket = !!globalThis.__args;
+var LayoutSettings = ({ settings }) => {
+  const { t } = useTranslation8(DECK_PLUGIN);
+  return /* @__PURE__ */ React18.createElement(DeprecatedFormContainer, null, /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+    label: t("select new plank positioning label")
+  }, /* @__PURE__ */ React18.createElement(Select.Root, {
+    value: settings.newPlankPositioning ?? "start",
+    onValueChange: (value) => settings.newPlankPositioning = value
+  }, /* @__PURE__ */ React18.createElement(Select.TriggerButton, {
+    placeholder: t("select new plank positioning placeholder")
+  }), /* @__PURE__ */ React18.createElement(Select.Portal, null, /* @__PURE__ */ React18.createElement(Select.Content, null, /* @__PURE__ */ React18.createElement(Select.Viewport, null, NewPlankPositions.map((position) => /* @__PURE__ */ React18.createElement(Select.Option, {
+    key: position,
+    value: position
+  }, t(`settings new plank position ${position} label`)))))))), /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+    label: t("settings overscroll label")
+  }, /* @__PURE__ */ React18.createElement(Select.Root, {
+    value: settings.overscroll ?? "none",
+    onValueChange: (value) => settings.overscroll = value
+  }, /* @__PURE__ */ React18.createElement(Select.TriggerButton, {
+    placeholder: t("select overscroll placeholder")
+  }), /* @__PURE__ */ React18.createElement(Select.Portal, null, /* @__PURE__ */ React18.createElement(Select.Content, null, /* @__PURE__ */ React18.createElement(Select.Viewport, null, OverscrollOptions.map((option) => /* @__PURE__ */ React18.createElement(Select.Option, {
+    key: option,
+    value: option
+  }, t(`settings overscroll ${option} label`)))))))), /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+    label: t("settings show hints label")
+  }, /* @__PURE__ */ React18.createElement(Input.Switch, {
+    checked: settings.showHints,
+    onCheckedChange: (checked) => settings.showHints = checked
+  })), !isSocket && /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+    label: t("settings native redirect label")
+  }, /* @__PURE__ */ React18.createElement(Input.Switch, {
+    checked: settings.enableNativeRedirect,
+    onCheckedChange: (checked) => settings.enableNativeRedirect = checked
+  })), /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+    label: t("settings enable ide-style statusbar label")
+  }, /* @__PURE__ */ React18.createElement(Input.Switch, {
+    checked: settings.enableIdeStyleStatusbar,
+    onCheckedChange: (checked) => settings.enableIdeStyleStatusbar = checked
+  })));
+};
+
+export {
+  Banner,
+  DeckLayout,
+  LayoutSettings
+};
+//# sourceMappingURL=chunk-O4RFYYQ6.mjs.map