@noya-app/noya-designsystem 0.1.45 → 0.1.46

package/src/components/List.tsx

@@ -0,0 +1,268 @@
+import {
+  forwardRefGeneric,
+  memoGeneric,
+  useFileDropTarget,
+} from "@noya-app/react-utils";
+import React, { useImperativeHandle, useRef, useState } from "react";
+import { cssVars } from "../theme";
+import { cx } from "../utils/classNames";
+import { updateSelection } from "../utils/selection";
+import { CollectionProps, CollectionRef } from "./Collection";
+import { ListView } from "./ListView";
+import { TreeView } from "./TreeView";
+
+const cssVarOverrides = {
+  "--icon-selected": cssVars.colors.primary,
+};
+
+const emptyArray: string[] = [];
+
+export const List = memoGeneric(
+  forwardRefGeneric(function List<T, M extends string = string>(
+    props: CollectionProps<T, M> & { ref?: React.ForwardedRef<CollectionRef> },
+    ref: React.ForwardedRef<CollectionRef>
+  ) {
+    const {
+      className,
+      items,
+      getId,
+      getName,
+      expandable,
+      getExpanded,
+      getRenamable,
+      getDepth,
+      setExpanded,
+      menuItems,
+      onSelectMenuItem,
+      onRename,
+      renderThumbnail,
+      renderAction,
+      renderDetail,
+      onSelectionChange,
+      itemRoleDescription = "clickable item",
+      detailPosition = "end",
+      size = "medium",
+      testHoveredId,
+      testRenamingId,
+      scrollable = false,
+      acceptsDrop,
+      onMoveItem,
+      onFilesDrop,
+      onDoubleClickItem,
+      renamable,
+      selectedIds = emptyArray,
+    } = props;
+
+    const [internalHoveredId, setHoveredId] = useState<string>();
+    const [internalRenamingId, setRenamingId] = useState<string>();
+
+    const hoveredId = internalHoveredId ?? testHoveredId;
+    const renamingId = testRenamingId ?? internalRenamingId;
+
+    const handleSelect = (itemId: string, event?: ListView.ClickInfo) => {
+      if (!onSelectionChange) return;
+
+      setRenamingId(undefined);
+      const newSelectedIds = updateSelection(
+        items.map(getId),
+        selectedIds,
+        itemId,
+        event
+      );
+      onSelectionChange(newSelectedIds, event);
+    };
+
+    const handleMenuAction = (action: M) => {
+      if (!onSelectMenuItem) return;
+
+      const selectedItems = items.filter((item) =>
+        selectedIds.includes(getId(item))
+      );
+      onSelectMenuItem(action, selectedItems);
+    };
+
+    const ViewComponent = expandable ? TreeView : ListView;
+
+    const fileDropTargetRef = useRef<HTMLDivElement>(null);
+    const { isDropTargetActive, dropTargetProps } = useFileDropTarget(
+      fileDropTargetRef,
+      onFilesDrop
+    );
+
+    useImperativeHandle(ref, () => ({
+      editName: (id: string) => {
+        setRenamingId(id);
+      },
+    }));
+
+    return (
+      <ViewComponent.Root
+        variant="bare"
+        className={cx(className, isDropTargetActive && "bg-primary-pastel")}
+        containerRef={fileDropTargetRef}
+        scrollable={scrollable}
+        data={items}
+        keyExtractor={getId}
+        role="listbox"
+        aria-orientation="vertical"
+        aria-multiselectable={true}
+        expandable={expandable}
+        sortable={expandable}
+        acceptsDrop={acceptsDrop}
+        onMoveItem={onMoveItem}
+        {...dropTargetProps}
+        renderItem={(
+          item: T,
+          _: number,
+          { isDragging }: { isDragging: boolean }
+        ) => {
+          const id = getId(item);
+          const isHovered = hoveredId === id && !isDragging;
+          const expanded = getExpanded?.(item);
+          const itemIsRenamable = getRenamable?.(item) ?? renamable;
+          const isSelected = selectedIds.includes(id);
+          const isRenaming = itemIsRenamable && onRename && renamingId === id;
+          const isTestingRenaming = testRenamingId === id;
+
+          const thumbnail = renderThumbnail?.(item, isSelected);
+          const action =
+            (isHovered || isSelected) &&
+            !isRenaming &&
+            renderAction?.(item, isSelected);
+          const end =
+            action ||
+            (detailPosition === "end" && renderDetail?.(item, isSelected));
+          const below =
+            detailPosition === "below" && renderDetail?.(item, isSelected);
+
+          return (
+            <ViewComponent.Row
+              id={id}
+              key={id}
+              role="option"
+              sortable={expandable}
+              aria-roledescription={itemRoleDescription}
+              aria-label={getName(item)}
+              aria-selected={isSelected}
+              className={cx("cursor-pointer p-1 rounded")}
+              backgroundColor={
+                isSelected ? cssVars.colors.primaryPastel : undefined
+              }
+              chevronClassName={cx(expandable && "relative left-2")}
+              style={cssVarOverrides as React.CSSProperties}
+              hovered={isHovered}
+              selected={isSelected}
+              expanded={expanded}
+              depth={getDepth?.(item)}
+              onHoverChange={(hovered: boolean) =>
+                setHoveredId(hovered ? id : undefined)
+              }
+              onPress={(e: ListView.ClickInfo) => {
+                handleSelect(id, e);
+              }}
+              onDoubleClick={() => {
+                onDoubleClickItem?.(id);
+              }}
+              onKeyDown={(e: React.KeyboardEvent) => {
+                if (e.key !== "Enter" && e.key !== " ") return;
+                e.preventDefault();
+                handleSelect(id, e);
+                if (e.key === "Enter") {
+                  setRenamingId(id);
+                }
+              }}
+              menuItems={menuItems}
+              onSelectMenuItem={handleMenuAction}
+              onContextMenu={() => {
+                if (!isSelected) {
+                  handleSelect(id, {
+                    shiftKey: false,
+                    altKey: false,
+                    metaKey: false,
+                    ctrlKey: false,
+                  });
+                }
+              }}
+              tabIndex={0}
+              onClickChevron={() => {
+                if (!expandable) return;
+                setExpanded?.(item, !expanded);
+              }}
+            >
+              <div className="flex flex-1 items-center px-2 gap-3">
+                {thumbnail && (
+                  <div
+                    className={cx(
+                      "rounded overflow-hidden flex-none flex items-center justify-center",
+                      size === "medium" ? "w-8 h-8" : "w-16 h-16",
+                      isSelected && "text-primary"
+                    )}
+                    style={{
+                      backgroundColor: isSelected
+                        ? cssVars.colors.primaryPastel
+                        : cssVars.colors.inputBackground,
+                    }}
+                    tabIndex={-1}
+                  >
+                    {thumbnail}
+                  </div>
+                )}
+                <div className="flex flex-col flex-1 w-0">
+                  <div className="flex items-center min-h-[27px] flex-1 gap-2">
+                    <div className="flex-1 w-0 flex items-center" tabIndex={-1}>
+                      {isRenaming ? (
+                        <ViewComponent.EditableRowTitle
+                          value={getName(item)}
+                          placeholder="Enter name"
+                          className="font-medium"
+                          autoFocus={!isTestingRenaming}
+                          onSubmitEditing={(value: string) => {
+                            if (value !== getName(item)) {
+                              onRename?.(item, value);
+                            }
+                            setRenamingId(undefined);
+                          }}
+                        />
+                      ) : (
+                        <ViewComponent.RowTitle
+                          className={cx(
+                            "font-medium",
+                            isSelected && "text-primary"
+                          )}
+                        >
+                          {getName(item)}
+                        </ViewComponent.RowTitle>
+                      )}
+                    </div>
+                    {end && (
+                      <div
+                        className={cx(
+                          "flex items-center gap-2",
+                          isSelected && "text-primary"
+                        )}
+                        tabIndex={-1}
+                      >
+                        {end}
+                      </div>
+                    )}
+                  </div>
+                  {below && (
+                    <div
+                      className={cx(
+                        "flex items-center",
+                        isSelected && "text-primary"
+                      )}
+                      tabIndex={-1}
+                    >
+                      {below}
+                    </div>
+                  )}
+                </div>
+              </div>
+            </ViewComponent.Row>
+          );
+        }}
+      />
+    );
+  })
+);

package/src/components/ListView.tsx

@@ -147,9 +147,10 @@ function ListViewEditableRowTitle({
     // the `onBlur` fires correctly.
     element.focus();
 
+    // must be a delay of 1ms or more to ensure any radix ui components have finished any focus behaviors
     setTimeout(() => {
       element.select();
-    }, 0);
+    }, 1);
   }, [autoFocus]);
 
   return (
@@ -1124,15 +1125,15 @@ export namespace ListView {
   export const DragIndicator = ListViewDragIndicatorElement;
   export const rowHeight = ROW_HEIGHT;
   export const sectionHeaderLabelHeight = SECTION_HEADER_LABEL_HEIGHT;
-  export const calculateHeight = (
-    items: number,
-    headerCount: number,
-    headerVariant: ListViewSectionHeaderVariant
-  ) => {
+  export const calculateHeight = ({
+    menuItemsCount,
+    sectionHeaderCount,
+  }: {
+    menuItemsCount: number;
+    sectionHeaderCount: number;
+  }) => {
     return (
-      items * rowHeight +
-      headerCount *
-        (headerVariant === "label" ? sectionHeaderLabelHeight : rowHeight)
+      menuItemsCount * rowHeight + sectionHeaderCount * sectionHeaderLabelHeight
     );
   };
   export const normalizeDestinationIndex = normalizeListDestinationIndex;

package/src/components/SearchCompletionMenu.tsx

@@ -1,13 +1,14 @@
 import {
   ComboboxMenu,
-  ComboboxOption,
   Divider,
   IScoredItem,
   InputField,
   ListView,
+  SelectableMenuItem,
   Small,
   fuzzyFilter,
   getNextIndex,
+  isSelectableMenuItem,
 } from "@noya-app/noya-designsystem";
 import { getCurrentPlatform, handleKeyboardEvent } from "@noya-app/noya-keymap";
 import React, {
@@ -32,10 +33,10 @@ export const SearchCompletionMenu = forwardRef(function SearchCompletionMenu(
     items,
     width = 200,
   }: {
-    onSelect: (item: ComboboxOption) => void;
-    onHover?: (item: ComboboxOption) => void;
+    onSelect: (item: SelectableMenuItem<string>) => void;
+    onHover?: (item: SelectableMenuItem<string>) => void;
     onClose: () => void;
-    items: ComboboxOption[];
+    items: SelectableMenuItem<string>[];
     width?: number;
   },
   forwardedRef: React.ForwardedRef<ISearchCompletionMenu>
@@ -56,12 +57,14 @@ export const SearchCompletionMenu = forwardRef(function SearchCompletionMenu(
   const results = useMemo(
     () =>
       fuzzyFilter({
-        items: items.map((item) => item.name),
+        items: items.map((item) =>
+          typeof item.title === "string" ? item.title : item.value
+        ),
         query: search,
       }).map((item) => ({
         ...item,
         ...items[item.index],
-      })) as (ComboboxOption & IScoredItem)[],
+      })) as (SelectableMenuItem<string> & IScoredItem)[],
     [items, search]
   );
 
@@ -96,7 +99,7 @@ export const SearchCompletionMenu = forwardRef(function SearchCompletionMenu(
   };
 
   const selectAndClose = useCallback(
-    (item: ComboboxOption) => {
+    (item: SelectableMenuItem<string>) => {
       onSelect(item);
       onClose();
     },
@@ -188,8 +191,9 @@ export const SearchCompletionMenu = forwardRef(function SearchCompletionMenu(
           items={results}
           selectedIndex={index}
           onSelectItem={(item) => {
-            if (item.type === "sectionHeader") return;
-            selectAndClose(item);
+            if (isSelectableMenuItem(item)) {
+              selectAndClose(item);
+            }
           }}
           onHoverIndex={setIndex}
         />

package/src/components/SegmentedControl.tsx

@@ -2,16 +2,16 @@ import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
 import React, {
   createContext,
   forwardRef,
-  memo,
   ReactNode,
   useCallback,
   useContext,
   useMemo,
 } from "react";
+import { memoGeneric } from "../../../noya-react-utils/src/utils/reactGenerics";
 import { useLabel } from "../hooks/useLabel";
 import { cx } from "../utils/classNames";
 import { renderIcon } from "./Icons";
-import { RegularMenuItem } from "./internal/Menu";
+import { SelectableMenuItem } from "./internal/Menu";
 import { Tooltip } from "./Tooltip";
 
 type SegmentedControlColorScheme = "primary" | "secondary";
@@ -43,7 +43,10 @@ export type SegmentedControlItemProps<T extends string> = {
   className?: string;
   style?: React.CSSProperties;
   tooltip?: ReactNode;
-} & Pick<RegularMenuItem<T>, "value" | "disabled" | "icon" | "role">;
+} & Pick<
+  SelectableMenuItem<T>,
+  "value" | "disabled" | "icon" | "role" | "title"
+>;
 
 const SegmentedControlItem = forwardRef(function SegmentedControlItem<
   T extends string,
@@ -104,7 +107,7 @@ const Separator = ({ transparent }: { transparent: boolean }) => (
   />
 );
 
-export const SegmentedControl = memo(function SegmentedControl<
+export const SegmentedControl = memoGeneric(function SegmentedControl<
   T extends string,
 >({
   id: idProp,

package/src/components/SelectMenu.tsx

@@ -14,9 +14,15 @@ import React, {
 } from "react";
 import { useLabel, useLabelPosition } from "../hooks/useLabel";
 import { cx } from "../utils/classNames";
+
 import { Button } from "./Button";
 import { renderIcon } from "./Icons";
-import { MenuItem, RegularMenuItem, styles } from "./internal/Menu";
+import {
+  isSelectableMenuItem,
+  MenuItem,
+  SelectableMenuItem,
+  styles,
+} from "./internal/Menu";
 import { MenuComponents, MenuViewport } from "./internal/MenuViewport";
 import { InsetLabel } from "./Label";
 
@@ -141,10 +147,8 @@ export const SelectMenu = memoGeneric(function SelectMenu<
   ...props
 }: Props<T>) {
   const selectedItem = items.find(
-    (item): item is RegularMenuItem<T> =>
-      item.type !== "separator" &&
-      item.type !== "sectionHeader" &&
-      item.value === value
+    (item): item is SelectableMenuItem<T> =>
+      isSelectableMenuItem(item) && item.value === value
   );
   const icon = selectedItem?.icon;
   const [internalOpen, setInternalOpen] = useState(open);

package/src/components/Toolbar.tsx

@@ -1,14 +1,15 @@
 import { DropdownChevronIcon } from "@noya-app/noya-icons";
 import { useKeyboardShortcuts } from "@noya-app/noya-keymap";
 import React from "react";
+
 import { BaseToolbar } from "./BaseToolbar";
 import { Button } from "./Button";
 import { DropdownMenu } from "./DropdownMenu";
 import { renderIcon } from "./Icons";
-import type { MenuItem } from "./internal/Menu";
 import {
   getKeyboardShortcutsForMenuItems,
-  SectionHeader,
+  isSelectableMenuItem,
+  MenuItem,
 } from "./internal/Menu";
 import { Spacer } from "./Spacer";
 
@@ -86,9 +87,9 @@ export function ToolbarMenu<T extends string>({
     <>
       {items.map((item, i) => {
         if (item.type === "separator") return null;
-        if (item.type === "sectionHeader") return <SectionHeader {...item} />;
+        if (item.type === "sectionHeader") return null;
 
-        if (!item.items) {
+        if (isSelectableMenuItem(item)) {
           return (
             <Button
               key={i}

package/src/components/TreeView.tsx

@@ -14,6 +14,7 @@ type TreeRowBaseProps = {
   expanded?: boolean;
   chevronClassName?: string;
   onClickChevron?: ({ altKey }: { altKey: boolean }) => void;
+  onDoubleClick?: () => void;
 };
 
 type TreeViewRowProps<MenuItemType extends string> =

package/src/components/WorkspaceLayout.tsx

@@ -73,17 +73,17 @@ export const WorkspaceLayout = forwardRef(function WorkspaceLayout(
     children,
     onChangeLayoutState,
     leftOptions: {
-      initialSize: leftInitialSize = 280,
       minSize: leftMinSize = 200,
       maxSize: leftMaxSize = 500,
+      initialSize: leftInitialSize = 280,
       resizable: leftResizable = true,
       style: leftStyle,
       className: leftClassName,
     } = {},
     rightOptions: {
-      initialSize: rightInitialSize = 280,
       minSize: rightMinSize = 200,
       maxSize: rightMaxSize = 500,
+      initialSize: rightInitialSize = 280,
       resizable: rightResizable = true,
       style: rightStyle,
       className: rightClassName,
@@ -99,8 +99,21 @@ export const WorkspaceLayout = forwardRef(function WorkspaceLayout(
       : (size / windowSize.width) * 100;
   }
 
-  const leftSidebarPercentage = getPercentage(leftInitialSize);
-  const rightSidebarPercentage = getPercentage(rightInitialSize);
+  function clampPercentage(
+    value: number,
+    min: number | undefined,
+    max: number | undefined
+  ) {
+    let result = value;
+    if (min !== undefined) {
+      result = Math.max(result, min);
+    }
+    if (max !== undefined) {
+      result = Math.min(result, max);
+    }
+    return result;
+  }
+
   const leftSidebarMinPercentage =
     leftMinSize !== undefined ? getPercentage(leftMinSize) : undefined;
   const rightSidebarMinPercentage =
@@ -110,6 +123,17 @@ export const WorkspaceLayout = forwardRef(function WorkspaceLayout(
   const rightSidebarMaxPercentage =
     rightMaxSize !== undefined ? getPercentage(rightMaxSize) : undefined;
 
+  const leftSidebarPercentage = clampPercentage(
+    getPercentage(leftInitialSize),
+    leftSidebarMinPercentage,
+    leftSidebarMaxPercentage
+  );
+  const rightSidebarPercentage = clampPercentage(
+    getPercentage(rightInitialSize),
+    rightSidebarMinPercentage,
+    rightSidebarMaxPercentage
+  );
+
   const panelGroupRef = useRef<ImperativePanelGroupHandle>(null);
   const leftSidebarRef = useRef<ImperativePanelHandle>(null);
   const rightSidebarRef = useRef<ImperativePanelHandle>(null);

package/src/components/internal/Menu.tsx

@@ -2,15 +2,12 @@ import { getShortcutDisplayParts } from "@noya-app/noya-keymap";
 import React, { memo, ReactNode } from "react";
 import { useDesignSystemConfiguration } from "../../contexts/DesignSystemConfiguration";
 import { cx } from "../../utils/classNames";
+import { IScoredItem } from "../../utils/fuzzyScorer";
 import withSeparatorElements from "../../utils/withSeparatorElements";
 import { IconName } from "../Icons";
 import { Spacer } from "../Spacer";
 import { textStyles } from "../Text";
 
-export type SeparatorItem = {
-  type: "separator";
-};
-
 // From electron
 export type MenuItemRole =
   | "undo"
@@ -61,35 +58,79 @@ export type MenuItemRole =
   | "moveTabToNewWindow"
   | "windowMenu";
 
-export type RegularMenuItem<T extends string> = {
-  value?: T;
-  title: ReactNode;
-  shortcut?: string;
+export type SeparatorItem = {
+  type: "separator";
+};
+
+type BaseMenuItem = {
   checked?: boolean;
   disabled?: boolean;
   icon?: Exclude<ReactNode, string> | IconName;
-  items?: MenuItem<T>[];
   role?: MenuItemRole;
-  type?: undefined;
   alwaysInclude?: boolean;
+  title: NonNullable<ReactNode>;
 };
 
 export type SectionHeaderMenuItem = {
   type: "sectionHeader";
   id: string;
-  title: string;
+  title: ReactNode;
   maxVisibleItems?: number;
   variant?: "normal" | "label";
 };
 
+export type SelectableMenuItem<T extends string> = BaseMenuItem & {
+  type?: undefined;
+  shortcut?: string;
+  value: T;
+};
+
+type SubMenuItem<T extends string> = BaseMenuItem & {
+  type: "submenu";
+  items: MenuItem<T>[];
+  id: string;
+};
+
+export type NonSelectableMenuItem<T extends string> =
+  | SeparatorItem
+  | SectionHeaderMenuItem
+  | SubMenuItem<T>;
+
 export type MenuItem<T extends string> =
   | SeparatorItem
-  | RegularMenuItem<T>
+  | SelectableMenuItem<T>
+  | SectionHeaderMenuItem
+  | SubMenuItem<T>;
+
+type ScoredSelectableMenuItem<T extends string> = SelectableMenuItem<T> &
+  IScoredItem;
+
+export type ScoredMenuItem<T extends string> =
+  | ScoredSelectableMenuItem<T>
   | SectionHeaderMenuItem;
 
 // Extract type T of RegularMenuItem<T> within MenuItem<T>
 export type ExtractMenuItemType<T> =
-  T extends RegularMenuItem<infer U> ? U : never;
+  T extends SelectableMenuItem<infer U> ? U : never;
+
+export const isSelectableMenuItem = <T extends string>(
+  item: MenuItem<T>
+): item is SelectableMenuItem<T> => {
+  return item.type === undefined;
+};
+
+export const isNonSelectableMenuItem = <T extends string>(
+  item: MenuItem<T>
+): item is NonSelectableMenuItem<T> => !isSelectableMenuItem(item);
+
+export const isMenuItemSectionHeader = (
+  item: MenuItem<string>
+): item is SectionHeaderMenuItem => item.type === "sectionHeader";
+
+export const isSelectableMenuItemWithScore = (
+  item: MenuItem<string>
+): item is ScoredSelectableMenuItem<string> =>
+  isSelectableMenuItem(item) && "index" in item && "score" in item;
 
 export const CHECKBOX_WIDTH = 16;
 export const CHECKBOX_RIGHT_INSET = 8;
@@ -132,7 +173,7 @@ function getKeyboardShortcuts<T extends string>(
   if (item.type === "separator") return [];
   if (item.type === "sectionHeader") return [];
 
-  if (item.items) return item.items.flatMap(getKeyboardShortcuts);
+  if (item.type === "submenu") return item.items.flatMap(getKeyboardShortcuts);
 
   if (item.disabled || !item.value || !item.shortcut) return [];