@tutti-os/workbench-launchpad 0.0.27

package/dist/index.js

@@ -0,0 +1,816 @@
+// src/WorkbenchLaunchpadOverlay.tsx
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import {
+  CloseIcon,
+  NavApplicationsFilledIcon,
+  SearchIcon
+} from "@tutti-os/ui-system";
+
+// src/launchpadModel.ts
+var workbenchLaunchpadDockActionId = "open-launchpad";
+var workbenchLaunchpadDockEntryId = "workspace-launchpad";
+var launchpadPreviewIconCount = 4;
+var launchpadMinColumns = 2;
+var launchpadMaxColumns = 7;
+var launchpadMinRows = 1;
+var launchpadMaxRows = 5;
+var launchpadTileWidth = 136;
+var launchpadTileHeight = 138;
+function buildWorkbenchLaunchpadItems(input) {
+  const nodeItems = (input.nodeDescriptors ?? []).map((node) => ({
+    disabledReason: node.disabledReason,
+    dockEntryId: node.dockEntryId,
+    iconUrl: node.iconUrl,
+    id: `node:${node.id}`,
+    kind: "node",
+    label: node.label,
+    launchEnabled: node.launchEnabled ?? true,
+    typeId: node.typeId
+  }));
+  const pinnedNodeItems = nodeItems.slice(0, 2);
+  const remainingNodeItems = nodeItems.slice(2);
+  return [
+    ...pinnedNodeItems,
+    ...(input.apps ?? []).map((app) => ({
+      appId: app.appId,
+      disabledReason: app.disabledReason,
+      iconUrl: app.iconUrl,
+      id: app.id ?? `app:${app.appId}`,
+      kind: "app",
+      label: app.label,
+      launchEnabled: app.launchEnabled
+    })),
+    ...remainingNodeItems,
+    ...(input.agentDescriptors ?? []).map((agent) => ({
+      action: agent.action,
+      actions: agent.actions,
+      comingSoon: agent.comingSoon,
+      disabledReason: agent.disabledReason,
+      iconUrl: agent.iconUrl,
+      id: agent.id ?? `agent:${agent.provider}`,
+      kind: "agent",
+      label: agent.label,
+      launchEnabled: agent.launchEnabled,
+      provider: agent.provider,
+      reason: agent.reason
+    }))
+  ];
+}
+function filterWorkbenchLaunchpadItems(items, query) {
+  const normalizedQuery = normalizeLaunchpadSearchText(query);
+  if (!normalizedQuery) {
+    return [...items];
+  }
+  return items.filter(
+    (item) => normalizeLaunchpadSearchText(item.label).includes(normalizedQuery)
+  );
+}
+function paginateWorkbenchLaunchpadItems(items, input) {
+  const pageSize = Math.max(1, Math.floor(input.pageSize));
+  const pageCount = Math.max(1, Math.ceil(items.length / pageSize));
+  const currentPage = clampInteger(input.page, 0, pageCount - 1);
+  const pageStart = currentPage * pageSize;
+  return {
+    currentPage,
+    pageCount,
+    pageItems: items.slice(pageStart, pageStart + pageSize)
+  };
+}
+function resolveWorkbenchLaunchpadGrid(input) {
+  const columns = clampInteger(
+    Math.floor(input.width / launchpadTileWidth),
+    launchpadMinColumns,
+    launchpadMaxColumns
+  );
+  const rows = clampInteger(
+    Math.floor(input.height / launchpadTileHeight),
+    launchpadMinRows,
+    launchpadMaxRows
+  );
+  return {
+    columns,
+    pageSize: Math.max(1, columns * rows),
+    rows
+  };
+}
+function resolveWorkbenchLaunchpadPreviewIconUrls(input) {
+  const icons = uniqueLaunchpadPreviewIconUrls([
+    ...input.appIcons ?? [],
+    ...input.nodeIconUrls ?? [],
+    ...input.agentIcons ?? []
+  ]).slice(0, launchpadPreviewIconCount);
+  while (icons.length < launchpadPreviewIconCount) {
+    icons.push(input.fallbackIconUrl);
+  }
+  return icons;
+}
+function uniqueLaunchpadPreviewIconUrls(iconUrls) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const iconUrl of iconUrls) {
+    const normalizedIconUrl = iconUrl?.trim();
+    if (!normalizedIconUrl || seen.has(normalizedIconUrl)) {
+      continue;
+    }
+    seen.add(normalizedIconUrl);
+    result.push(normalizedIconUrl);
+  }
+  return result;
+}
+function normalizeLaunchpadSearchText(value) {
+  return value.trim().toLocaleLowerCase();
+}
+function clampInteger(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.min(Math.max(Math.floor(value), min), max);
+}
+
+// src/launchpadWheelNavigation.ts
+var wheelDeltaLinePx = 16;
+var wheelDeltaPagePx = 360;
+var launchpadWheelNavigationThresholdPx = 64;
+var launchpadWheelNavigationCooldownMs = 420;
+var launchpadWheelHorizontalIntentRatio = 1.2;
+function createWorkbenchLaunchpadWheelNavigationState() {
+  return {
+    accumulatedDeltaX: 0,
+    lastNavigationAt: 0
+  };
+}
+function resolveWorkbenchLaunchpadWheelNavigation(input) {
+  if (input.pageCount <= 1) {
+    return {
+      nextPageIndex: null,
+      shouldPreventDefault: false,
+      state: createWorkbenchLaunchpadWheelNavigationState()
+    };
+  }
+  const delta = normalizeWorkbenchLaunchpadWheelDelta(input);
+  const absDeltaX = Math.abs(delta.x);
+  const absDeltaY = Math.abs(delta.y);
+  const isHorizontalIntent = absDeltaX > 0 && absDeltaX >= absDeltaY * launchpadWheelHorizontalIntentRatio;
+  if (!isHorizontalIntent) {
+    return {
+      nextPageIndex: null,
+      shouldPreventDefault: false,
+      state: {
+        accumulatedDeltaX: 0,
+        lastNavigationAt: input.state.lastNavigationAt
+      }
+    };
+  }
+  const direction = delta.x > 0 ? 1 : -1;
+  const previousDirection = input.state.accumulatedDeltaX > 0 ? 1 : -1;
+  const accumulatedDeltaX = input.state.accumulatedDeltaX !== 0 && previousDirection === direction ? input.state.accumulatedDeltaX + delta.x : delta.x;
+  if (input.timestamp - input.state.lastNavigationAt < launchpadWheelNavigationCooldownMs) {
+    return {
+      nextPageIndex: null,
+      shouldPreventDefault: true,
+      state: {
+        accumulatedDeltaX: 0,
+        lastNavigationAt: input.state.lastNavigationAt
+      }
+    };
+  }
+  if (Math.abs(accumulatedDeltaX) < launchpadWheelNavigationThresholdPx) {
+    return {
+      nextPageIndex: null,
+      shouldPreventDefault: true,
+      state: {
+        accumulatedDeltaX,
+        lastNavigationAt: input.state.lastNavigationAt
+      }
+    };
+  }
+  const nextPageIndex = input.currentPage + direction;
+  if (nextPageIndex < 0 || nextPageIndex >= input.pageCount) {
+    return {
+      nextPageIndex: null,
+      shouldPreventDefault: true,
+      state: {
+        accumulatedDeltaX: 0,
+        lastNavigationAt: input.timestamp
+      }
+    };
+  }
+  return {
+    nextPageIndex,
+    shouldPreventDefault: true,
+    state: {
+      accumulatedDeltaX: 0,
+      lastNavigationAt: input.timestamp
+    }
+  };
+}
+function normalizeWorkbenchLaunchpadWheelDelta(input) {
+  const unit = input.deltaMode === 1 ? wheelDeltaLinePx : input.deltaMode === 2 ? wheelDeltaPagePx : 1;
+  return {
+    x: input.deltaX * unit,
+    y: input.deltaY * unit
+  };
+}
+
+// src/WorkbenchLaunchpadOverlay.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var defaultLaunchpadGrid = {
+  columns: 5,
+  pageSize: 15,
+  rows: 3
+};
+var launchpadExitAnimationMs = 180;
+var launchpadHoverPanelViewportInsetPx = 16;
+function WorkbenchLaunchpadOverlay({
+  copy,
+  dockPlacement = "bottom",
+  getAgentActionLabel,
+  getAgentActionPending,
+  getAgentReason,
+  items,
+  onClose,
+  onLaunchItem,
+  onPageChange,
+  onRunAgentAction,
+  onSearch,
+  open
+}) {
+  const [query, setQuery] = useState("");
+  const [pageIndex, setPageIndex] = useState(0);
+  const [shouldRender, setShouldRender] = useState(open);
+  const searchInputRef = useRef(null);
+  const wheelNavigationRef = useRef(
+    createWorkbenchLaunchpadWheelNavigationState()
+  );
+  const { grid, ref: gridViewportRef } = useLaunchpadGridMetrics(open);
+  const isClosing = shouldRender && !open;
+  const filteredItems = useMemo(
+    () => filterWorkbenchLaunchpadItems(items, query),
+    [items, query]
+  );
+  const page = useMemo(
+    () => paginateWorkbenchLaunchpadItems(filteredItems, {
+      page: pageIndex,
+      pageSize: grid.pageSize
+    }),
+    [filteredItems, grid.pageSize, pageIndex]
+  );
+  useEffect(() => {
+    if (open) {
+      setShouldRender(true);
+      return void 0;
+    }
+    if (!shouldRender) {
+      return void 0;
+    }
+    const timeoutId = window.setTimeout(() => {
+      setShouldRender(false);
+    }, launchpadExitAnimationMs);
+    return () => {
+      window.clearTimeout(timeoutId);
+    };
+  }, [open, shouldRender]);
+  useEffect(() => {
+    if (!open) {
+      wheelNavigationRef.current = createWorkbenchLaunchpadWheelNavigationState();
+      return;
+    }
+    setQuery("");
+    setPageIndex(0);
+    window.setTimeout(() => searchInputRef.current?.focus(), 0);
+  }, [open]);
+  useEffect(() => {
+    setPageIndex(0);
+    wheelNavigationRef.current = createWorkbenchLaunchpadWheelNavigationState();
+  }, [query]);
+  useEffect(() => {
+    if (!open || !onSearch) {
+      return void 0;
+    }
+    const queryLength = query.trim().length;
+    if (queryLength === 0) {
+      return void 0;
+    }
+    const timeoutId = window.setTimeout(() => {
+      onSearch({
+        queryLength,
+        resultCount: filteredItems.length
+      });
+    }, 300);
+    return () => {
+      window.clearTimeout(timeoutId);
+    };
+  }, [filteredItems.length, onSearch, open, query]);
+  const changePage = useCallback(
+    (nextPageIndex) => {
+      setPageIndex((currentPageIndex) => {
+        const clampedPageIndex = Math.max(
+          0,
+          Math.min(nextPageIndex, page.pageCount - 1)
+        );
+        if (clampedPageIndex !== currentPageIndex) {
+          onPageChange?.({
+            pageIndex: clampedPageIndex,
+            totalPages: page.pageCount
+          });
+        }
+        return clampedPageIndex;
+      });
+    },
+    [onPageChange, page.pageCount]
+  );
+  useEffect(() => {
+    if (!open) {
+      return void 0;
+    }
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onClose();
+        return;
+      }
+      if (isTextInputTarget(event.target)) {
+        return;
+      }
+      if (event.key === "ArrowRight" && page.pageCount > 1) {
+        event.preventDefault();
+        changePage(page.currentPage + 1);
+        return;
+      }
+      if (event.key === "ArrowLeft" && page.pageCount > 1) {
+        event.preventDefault();
+        changePage(page.currentPage - 1);
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => {
+      window.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [changePage, onClose, open, page.currentPage, page.pageCount]);
+  const handleOverlayClick = useCallback(
+    (event) => {
+      if (isClosing || isLaunchpadInteractiveTarget(event.target)) {
+        return;
+      }
+      onClose();
+    },
+    [isClosing, onClose]
+  );
+  const handleOverlayWheel = useCallback(
+    (event) => {
+      if (!open || isClosing || isLaunchpadWheelIgnoredTarget(event.target)) {
+        return;
+      }
+      const result = resolveWorkbenchLaunchpadWheelNavigation({
+        currentPage: page.currentPage,
+        deltaMode: event.deltaMode,
+        deltaX: event.deltaX,
+        deltaY: event.deltaY,
+        pageCount: page.pageCount,
+        state: wheelNavigationRef.current,
+        timestamp: event.timeStamp
+      });
+      wheelNavigationRef.current = result.state;
+      if (result.shouldPreventDefault) {
+        event.preventDefault();
+      }
+      if (result.nextPageIndex !== null) {
+        changePage(result.nextPageIndex);
+      }
+    },
+    [changePage, isClosing, open, page.currentPage, page.pageCount]
+  );
+  if (!shouldRender) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "aria-label": copy.label,
+      "aria-modal": "false",
+      className: classNames(
+        "workspace-launchpad-overlay",
+        isClosing && "workspace-launchpad-overlay--closing"
+      ),
+      role: "dialog",
+      onClick: handleOverlayClick,
+      onWheel: handleOverlayWheel,
+      children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            "aria-hidden": "true",
+            className: "workspace-launchpad-overlay__dismiss",
+            tabIndex: -1,
+            type: "button",
+            onClick: onClose
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "workspace-launchpad-overlay__content",
+            "data-dock-placement": dockPlacement,
+            children: [
+              /* @__PURE__ */ jsx("div", { className: "workspace-launchpad-overlay__topbar", children: /* @__PURE__ */ jsxs("div", { className: "workspace-launchpad-search", children: [
+                /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    "aria-hidden": "true",
+                    className: "workspace-launchpad-search__icon",
+                    children: /* @__PURE__ */ jsx(SearchIcon, {})
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "input",
+                  {
+                    ref: searchInputRef,
+                    "aria-label": copy.searchPlaceholder,
+                    className: "workspace-launchpad-search__input",
+                    placeholder: copy.searchPlaceholder,
+                    type: "search",
+                    value: query,
+                    onChange: (event) => setQuery(event.target.value)
+                  }
+                ),
+                query ? /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    "aria-label": copy.clearSearch,
+                    className: "workspace-launchpad-search__clear",
+                    type: "button",
+                    onClick: (event) => {
+                      event.stopPropagation();
+                      setQuery("");
+                      searchInputRef.current?.focus();
+                    },
+                    onMouseDown: (event) => {
+                      event.preventDefault();
+                      event.stopPropagation();
+                    },
+                    children: /* @__PURE__ */ jsx(CloseIcon, {})
+                  }
+                ) : null
+              ] }) }),
+              /* @__PURE__ */ jsx(
+                "div",
+                {
+                  ref: gridViewportRef,
+                  className: "workspace-launchpad-grid-viewport",
+                  children: filteredItems.length === 0 ? /* @__PURE__ */ jsx("div", { className: "workspace-launchpad-empty", children: copy.empty }) : /* @__PURE__ */ jsx(
+                    "div",
+                    {
+                      className: "workspace-launchpad-grid",
+                      style: {
+                        gridTemplateColumns: `repeat(${grid.columns}, minmax(96px, 136px))`
+                      },
+                      children: page.pageItems.map((item, index) => /* @__PURE__ */ jsx(
+                        WorkbenchLaunchpadItemButton,
+                        {
+                          animationIndex: index,
+                          animationRisePx: 18 + index % grid.columns * 3,
+                          copy,
+                          getAgentActionLabel,
+                          getAgentReason,
+                          isAgentActionPending: getAgentActionPending,
+                          item,
+                          onLaunch: onLaunchItem,
+                          onRunAgentAction
+                        },
+                        item.id
+                      ))
+                    }
+                  )
+                }
+              ),
+              page.pageCount > 1 ? /* @__PURE__ */ jsx(
+                "div",
+                {
+                  "aria-label": copy.pages ?? "Pages",
+                  className: "workspace-launchpad-pages",
+                  children: Array.from({ length: page.pageCount }, (_, index) => /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      "aria-label": copy.pageDot?.({
+                        page: index + 1,
+                        pageCount: page.pageCount
+                      }) ?? `${index + 1} / ${page.pageCount}`,
+                      className: "workspace-launchpad-page-dot",
+                      "data-active": index === page.currentPage ? "true" : void 0,
+                      type: "button",
+                      onClick: () => changePage(index)
+                    },
+                    index
+                  ))
+                }
+              ) : /* @__PURE__ */ jsx("div", { "aria-hidden": "true", className: "workspace-launchpad-pages" })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function WorkbenchLaunchpadItemButton({
+  animationIndex,
+  animationRisePx,
+  copy,
+  getAgentActionLabel,
+  getAgentReason,
+  isAgentActionPending,
+  item,
+  onLaunch,
+  onRunAgentAction
+}) {
+  const disabledLabel = item.disabledReason === void 0 ? null : copy.unavailableItem?.({
+    reason: item.disabledReason,
+    title: item.label
+  }) ?? item.disabledReason;
+  const [hoverPanelOpen, setHoverPanelOpen] = useState(false);
+  const [hoverPanelShift, setHoverPanelShift] = useState(0);
+  const hoverPanelRef = useRef(null);
+  const hoverTimerRef = useRef(null);
+  const agentActions = item.kind === "agent" && !item.launchEnabled ? resolveLaunchpadAgentActions(item) : [];
+  const agentReason = item.kind === "agent" ? getAgentReason?.(item) ?? item.reason ?? null : null;
+  const showComingSoonTooltip = item.kind === "agent" && item.comingSoon === true && agentReason !== null;
+  const showAgentHoverPanel = item.kind === "agent" && item.comingSoon !== true && !item.launchEnabled && hoverPanelOpen && (agentActions.length > 0 || agentReason !== null);
+  const clearHoverTimer = useCallback(() => {
+    if (hoverTimerRef.current === null) {
+      return;
+    }
+    clearTimeout(hoverTimerRef.current);
+    hoverTimerRef.current = null;
+  }, []);
+  useEffect(
+    () => () => {
+      clearHoverTimer();
+    },
+    [clearHoverTimer]
+  );
+  useLayoutEffect(() => {
+    if (!showAgentHoverPanel || typeof window === "undefined") {
+      setHoverPanelShift(0);
+      return void 0;
+    }
+    const frameId = window.requestAnimationFrame(() => {
+      const panel = hoverPanelRef.current;
+      if (!panel) {
+        return;
+      }
+      const rect = panel.getBoundingClientRect();
+      const maxRight = window.innerWidth - launchpadHoverPanelViewportInsetPx;
+      const nextShift = rect.left < launchpadHoverPanelViewportInsetPx ? launchpadHoverPanelViewportInsetPx - rect.left : rect.right > maxRight ? maxRight - rect.right : 0;
+      setHoverPanelShift(
+        (current) => current === nextShift ? current : nextShift
+      );
+    });
+    return () => {
+      window.cancelAnimationFrame(frameId);
+    };
+  }, [agentActions.length, agentReason, showAgentHoverPanel]);
+  const handlePointerEnter = useCallback(() => {
+    if (item.kind !== "agent" || item.launchEnabled || item.comingSoon) {
+      return;
+    }
+    clearHoverTimer();
+    hoverTimerRef.current = setTimeout(() => {
+      hoverTimerRef.current = null;
+      setHoverPanelOpen(true);
+    }, 500);
+  }, [clearHoverTimer, item]);
+  const handlePointerLeave = useCallback(() => {
+    clearHoverTimer();
+    setHoverPanelOpen(false);
+  }, [clearHoverTimer]);
+  const animationStyle = {
+    "--workspace-launchpad-item-delay": `${Math.min(animationIndex, 24) * 28}ms`,
+    "--workspace-launchpad-item-rise": `${animationRisePx}px`
+  };
+  const itemNode = /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "workspace-launchpad-item-wrap",
+      style: animationStyle,
+      onPointerEnter: handlePointerEnter,
+      onPointerLeave: handlePointerLeave,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            "aria-label": disabledLabel ?? item.label,
+            className: classNames(
+              "workspace-launchpad-item",
+              !item.launchEnabled && "workspace-launchpad-item--disabled"
+            ),
+            disabled: !item.launchEnabled,
+            title: showComingSoonTooltip ? void 0 : disabledLabel ?? item.label,
+            type: "button",
+            onClick: () => onLaunch(item),
+            children: [
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  "aria-hidden": "true",
+                  className: "workspace-launchpad-item__icon",
+                  "data-workspace-app-icon": item.iconUrl ? "true" : void 0,
+                  children: item.iconUrl ? /* @__PURE__ */ jsx("img", { alt: "", draggable: false, src: item.iconUrl }) : /* @__PURE__ */ jsx(NavApplicationsFilledIcon, { className: "size-10" })
+                }
+              ),
+              /* @__PURE__ */ jsx("span", { className: "workspace-launchpad-item__label", children: item.label })
+            ]
+          }
+        ),
+        showAgentHoverPanel ? /* @__PURE__ */ jsxs(
+          "div",
+          {
+            ref: hoverPanelRef,
+            className: "desktop-dock__hover-panel workspace-launchpad-dock-hover-panel",
+            role: "group",
+            style: {
+              "--workspace-launchpad-hover-panel-shift": `${Math.round(
+                hoverPanelShift
+              )}px`
+            },
+            children: [
+              /* @__PURE__ */ jsx("div", { className: "desktop-dock__hover-panel-title", children: item.label }),
+              agentReason ? /* @__PURE__ */ jsx("div", { className: "desktop-dock__hover-panel-description", children: agentReason }) : null,
+              agentActions.length ? /* @__PURE__ */ jsx("div", { className: "desktop-dock__hover-actions", children: agentActions.map((action) => {
+                const isPending = isAgentActionPending?.(item, action.id) ?? false;
+                return /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    "aria-busy": isPending || void 0,
+                    className: "desktop-dock__hover-action",
+                    disabled: isPending,
+                    type: "button",
+                    onClick: (event) => {
+                      event.preventDefault();
+                      event.stopPropagation();
+                      if (isPending) {
+                        return;
+                      }
+                      onRunAgentAction?.(item, action.id);
+                    },
+                    children: resolveAgentActionLabel(
+                      isPending && action.id === "install" ? "installing" : action.id,
+                      copy,
+                      getAgentActionLabel
+                    )
+                  },
+                  action.id
+                );
+              }) }) : null
+            ]
+          }
+        ) : null
+      ]
+    }
+  );
+  return showComingSoonTooltip ? /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: "workspace-launchpad-tooltip-host",
+      title: agentReason ?? void 0,
+      children: itemNode
+    }
+  ) : itemNode;
+}
+function useLaunchpadGridMetrics(open) {
+  const ref = useRef(null);
+  const [grid, setGrid] = useState(defaultLaunchpadGrid);
+  useEffect(() => {
+    if (!open) {
+      return void 0;
+    }
+    const element = ref.current;
+    if (!element) {
+      return void 0;
+    }
+    const update = () => {
+      const rect = element.getBoundingClientRect();
+      setGrid(
+        resolveWorkbenchLaunchpadGrid({
+          height: rect.height,
+          width: rect.width
+        })
+      );
+    };
+    update();
+    const resizeObserver = new ResizeObserver(update);
+    resizeObserver.observe(element);
+    return () => {
+      resizeObserver.disconnect();
+    };
+  }, [open]);
+  return { grid, ref };
+}
+function resolveLaunchpadAgentActions(item) {
+  if (item.comingSoon) {
+    return [];
+  }
+  if (item.actions?.length) {
+    return item.actions;
+  }
+  if (item.action) {
+    return [{ id: item.action }];
+  }
+  return [];
+}
+function resolveAgentActionLabel(actionId, copy, getAgentActionLabel) {
+  if (getAgentActionLabel) {
+    return getAgentActionLabel(actionId);
+  }
+  switch (actionId) {
+    case "install":
+      return copy.installAction ?? actionId;
+    case "installing":
+      return copy.installingAction ?? copy.installAction ?? actionId;
+    case "sync":
+      return copy.syncAction ?? actionId;
+    default:
+      return copy.refreshAction ?? actionId;
+  }
+}
+function isTextInputTarget(target) {
+  return target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLElement && target.isContentEditable;
+}
+function isLaunchpadInteractiveTarget(target) {
+  return target instanceof HTMLElement && Boolean(
+    target.closest(
+      ".workspace-launchpad-overlay__topbar, .workspace-launchpad-search, .workspace-launchpad-item, .desktop-dock__hover-panel, .workspace-launchpad-pages"
+    )
+  );
+}
+function isLaunchpadWheelIgnoredTarget(target) {
+  return isTextInputTarget(target) || target instanceof HTMLElement && Boolean(
+    target.closest(
+      ".workspace-launchpad-overlay__topbar, .workspace-launchpad-search, .desktop-dock__hover-panel, .workspace-launchpad-pages"
+    )
+  );
+}
+function classNames(...values) {
+  return values.filter(Boolean).join(" ");
+}
+
+// src/workbenchLaunchpadDockEntry.ts
+import { createElement } from "react";
+function createWorkbenchLaunchpadDockIcon(input) {
+  return createElement(
+    "span",
+    {
+      "aria-hidden": "true",
+      className: "workspace-launchpad-dock-icon"
+    },
+    input.tileIconUrls.map(
+      (src, index) => createElement(
+        "span",
+        {
+          className: "workspace-launchpad-dock-icon__tile",
+          key: `${src}:${index}`
+        },
+        createElement("img", {
+          alt: "",
+          draggable: false,
+          src
+        })
+      )
+    )
+  );
+}
+function createWorkbenchLaunchpadDockEntry(input) {
+  return {
+    clickActionId: workbenchLaunchpadDockActionId,
+    icon: createWorkbenchLaunchpadDockIcon({
+      tileIconUrls: input.tileIconUrls
+    }),
+    id: workbenchLaunchpadDockEntryId,
+    label: input.label,
+    launchBehavior: "enabled",
+    order: input.order ?? 0,
+    sectionId: "launchpad",
+    typeId: workbenchLaunchpadDockEntryId,
+    visibility: "always"
+  };
+}
+export {
+  WorkbenchLaunchpadOverlay,
+  buildWorkbenchLaunchpadItems,
+  createWorkbenchLaunchpadDockEntry,
+  createWorkbenchLaunchpadDockIcon,
+  createWorkbenchLaunchpadWheelNavigationState,
+  filterWorkbenchLaunchpadItems,
+  paginateWorkbenchLaunchpadItems,
+  resolveWorkbenchLaunchpadGrid,
+  resolveWorkbenchLaunchpadPreviewIconUrls,
+  resolveWorkbenchLaunchpadWheelNavigation,
+  workbenchLaunchpadDockActionId,
+  workbenchLaunchpadDockEntryId
+};
+//# sourceMappingURL=index.js.map