@crewlethq/ui 0.45.0 → 0.46.0

package/dist/chunk-SQZEVWVC.js

@@ -0,0 +1,436 @@
+import { useReorder } from './chunk-XJ2QEBMM.js';
+import { FormField, Textarea } from './chunk-Z734SV4E.js';
+import { characterCountState, CharacterCount, countCharacters } from './chunk-XCUUI7E7.js';
+import { Kbd } from './chunk-SMBKXWML.js';
+import { announce } from './chunk-RSAQOKH3.js';
+import { Button } from './chunk-OG6CL3EB.js';
+import { isComposing } from './chunk-H5XTJ7GJ.js';
+import { IconButton } from './chunk-LACA4JGC.js';
+import { VisuallyHidden } from './chunk-BZFWDIV6.js';
+import { cx } from './chunk-ODEQTPFM.js';
+import './ListInput-DP2CSJ22.css';
+import { forwardRef, useState, useRef, useImperativeHandle, useLayoutEffect, useId } from 'react';
+import { PlusGlyph, GripVerticalGlyph, ArrowUpGlyph, ArrowDownGlyph, XGlyph } from '@crewlethq/icons/glyphs';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+function withDraft(value, draft) {
+  const text = (draft ?? "").trim();
+  return text === "" ? [...value] : [...value, text];
+}
+var minted = 0;
+var mint = () => `item-${minted += 1}`;
+var capitalized = (text) => text.charAt(0).toLocaleUpperCase() + text.slice(1);
+var ListInput = forwardRef(function ListInput2({
+  label,
+  itemName,
+  value,
+  onChange,
+  draft: ownedDraft,
+  onDraftChange,
+  hideLabel = false,
+  multiline = false,
+  helper,
+  helperOnFocus,
+  error,
+  placeholder,
+  disabled = false,
+  optional,
+  enterHint = true,
+  focusOnMount = false,
+  reorderByDrag = false,
+  maxItems,
+  maxLength,
+  undoRemove = false,
+  itemError,
+  fullMessage = (max) => `The list is full at ${max}. Remove one to add another.`,
+  addLabel = (name) => `Add ${name}`,
+  itemLabel = (name, position) => `${name} ${position}`,
+  newItemLabel = (name) => `New ${name}`,
+  moveUpLabel = (name, position) => `Move ${name} ${position} up`,
+  moveDownLabel = (name, position) => `Move ${name} ${position} down`,
+  removeLabel = (name, position) => `Remove ${name} ${position}`,
+  addedMessage = (name, position) => `Added ${name} ${position}`,
+  removedMessage = (name, position) => `Removed ${name} ${position}`,
+  movedMessage = (name, position, count) => `Moved ${name} to position ${position} of ${count}`,
+  removedNotice = (name, position) => `${name} ${position} removed.`,
+  undoLabel = "Undo",
+  dismissLabel = "Dismiss",
+  restoredMessage = (name, position) => `Restored ${name} ${position}`
+}, ref) {
+  const [heldDraft, setHeldDraft] = useState("");
+  const draft = ownedDraft ?? heldDraft;
+  const setDraft = (next) => {
+    if (ownedDraft === void 0) setHeldDraft(next);
+    onDraftChange?.(next);
+  };
+  const [removed, setRemoved] = useState(null);
+  const ids = useRef([]);
+  const emitted = useRef(null);
+  if (value !== emitted.current && value.length !== ids.current.length) {
+    ids.current = value.map(mint);
+    if (removed !== null) setRemoved(null);
+  }
+  const inputs = useRef(/* @__PURE__ */ new Map());
+  const ups = useRef(/* @__PURE__ */ new Map());
+  const downs = useRef(/* @__PURE__ */ new Map());
+  const addBox = useRef(null);
+  const undoButton = useRef(null);
+  const focusNext = useRef(null);
+  const focusField = (el) => {
+    if (!el) return;
+    el.focus();
+    el.setSelectionRange(el.value.length, el.value.length);
+  };
+  useImperativeHandle(ref, () => ({
+    focusItem: (index) => {
+      const id = ids.current[index];
+      if (id !== void 0) focusField(inputs.current.get(id));
+    },
+    focusNew: () => addBox.current?.focus()
+  }));
+  const focusAtMount = useRef(focusOnMount);
+  useLayoutEffect(() => {
+    if (focusAtMount.current) addBox.current?.focus();
+  }, []);
+  useLayoutEffect(() => {
+    const want = focusNext.current;
+    if (!want) return;
+    focusNext.current = null;
+    if (want.target === "add") {
+      addBox.current?.focus();
+      return;
+    }
+    if (want.target === "undo") {
+      undoButton.current?.focus();
+      return;
+    }
+    const up = ups.current.get(want.id);
+    const down = downs.current.get(want.id);
+    const box = inputs.current.get(want.id);
+    const order2 = want.target === "up" ? [up, down, box] : want.target === "down" ? [down, up, box] : [box];
+    order2.find((el) => el && !el.disabled)?.focus();
+  });
+  function emit(next, nextIds, said, leaving = null) {
+    ids.current = nextIds;
+    emitted.current = next;
+    setRemoved(leaving);
+    onChange(next);
+    if (said) announce(said);
+  }
+  const name = capitalized(itemName);
+  const count = value.length;
+  const listId = useId();
+  const full = maxItems !== void 0 && count >= maxItems;
+  const measured = (text) => countCharacters(text.trim());
+  const overLimit = (text) => maxLength !== void 0 && characterCountState(measured(text), maxLength) === "over";
+  const draftRefused = draft.trim() === "" || overLimit(draft);
+  const draftCount = maxLength !== void 0 && characterCountState(measured(draft), maxLength) !== "within";
+  const reorder = useReorder({
+    keys: ids.current,
+    nameOf: () => itemName,
+    onReorder: (nextIds) => {
+      const byId = new Map(ids.current.map((id, at) => [id, value[at]]));
+      emit(
+        nextIds.map((id) => byId.get(id)),
+        nextIds
+      );
+    },
+    labels: { moved: (_, position, total) => movedMessage(itemName, position, total) }
+  });
+  const drags = reorderByDrag && !disabled;
+  const order = drags ? reorder.order : ids.current;
+  function add() {
+    const text = draft.trim();
+    if (!text || disabled || full || overLimit(text)) return;
+    const id = mint();
+    const filled = maxItems !== void 0 && count + 1 >= maxItems;
+    emit(
+      [...value, text],
+      [...ids.current, id],
+      addedMessage(itemName, `${count + 1} of ${count + 1}`) + (filled ? `. ${fullMessage(maxItems)}` : "")
+    );
+    setDraft("");
+    focusNext.current = filled ? { id, target: "input" } : { id: "", target: "add" };
+  }
+  function move(index, by, target) {
+    const to = index + by;
+    if (disabled || to < 0 || to >= count) return;
+    const next = [...value];
+    const nextIds = [...ids.current];
+    [next[index], next[to]] = [next[to], next[index]];
+    [nextIds[index], nextIds[to]] = [nextIds[to], nextIds[index]];
+    focusNext.current = { id: nextIds[to], target };
+    emit(next, nextIds, movedMessage(itemName, to + 1, count));
+  }
+  const neighbourOf = (nextIds, index) => {
+    const neighbour = nextIds[index] ?? nextIds[index - 1];
+    return neighbour ? { id: neighbour, target: "input" } : { id: "", target: "add" };
+  };
+  function remove(index) {
+    if (disabled) return;
+    const next = value.filter((_, at) => at !== index);
+    const nextIds = ids.current.filter((_, at) => at !== index);
+    const leaving = undoRemove ? { id: ids.current[index], text: value[index], index } : null;
+    focusNext.current = leaving ? { id: "", target: "undo" } : neighbourOf(nextIds, index);
+    emit(next, nextIds, leaving ? void 0 : removedMessage(itemName, `${index + 1} of ${count}`), leaving);
+  }
+  function restore() {
+    if (!removed || disabled) return;
+    const at = Math.min(removed.index, count);
+    const next = [...value];
+    const nextIds = [...ids.current];
+    next.splice(at, 0, removed.text);
+    nextIds.splice(at, 0, removed.id);
+    focusNext.current = { id: removed.id, target: "input" };
+    emit(next, nextIds, restoredMessage(itemName, `${at + 1} of ${count + 1}`));
+  }
+  function dismiss() {
+    if (!removed) return;
+    focusNext.current = neighbourOf(ids.current, removed.index);
+    setRemoved(null);
+  }
+  const acts = (event) => event.key === "Enter" && !event.metaKey && !event.ctrlKey && !(multiline && event.shiftKey) && !isComposing(event);
+  function itemKeys(event, index) {
+    if (isComposing(event)) return;
+    if (event.altKey && (event.key === "ArrowUp" || event.key === "ArrowDown")) {
+      event.preventDefault();
+      move(index, event.key === "ArrowUp" ? -1 : 1, "input");
+      return;
+    }
+    if (!acts(event)) return;
+    event.preventDefault();
+    const next = ids.current[index + 1];
+    if (next) inputs.current.get(next)?.focus();
+    else addBox.current?.focus();
+  }
+  const control = (props) => (
+    /*
+     * ONE LINE THAT GROWS, never a fixed block of rows. A list of sentences
+     * read as a list wants each item on its own line; a two-row textarea per
+     * item made three of them 256px where the console draws 111, and the
+     * second row was empty in every one of them. `autoResize` starts at one
+     * line and takes as many as the sentence needs.
+     *
+     * AND A ONE-LINE ITEM WRAPS TOO. A one-line input scrolled a long
+     * policy sideways, so while it was edited only its tail could be read.
+     * Without `multiline` the field is a `singleLine` textarea: it wraps to
+     * be read whole and still holds one line, with no newline typed, pasted
+     * or dropped in.
+     */
+    /* @__PURE__ */ jsx(
+      Textarea,
+      {
+        rows: 1,
+        autoResize: true,
+        singleLine: !multiline,
+        "aria-label": props.label,
+        value: props.value,
+        placeholder: props.placeholder,
+        disabled,
+        spellCheck: true,
+        trailing: props.trailing,
+        error: props.invalid ?? false,
+        "aria-describedby": props.describedBy,
+        onChange: (event) => props.onChange(event.target.value),
+        onKeyDown: props.onKeyDown,
+        ref: props.ref
+      }
+    )
+  );
+  const addControl = /* @__PURE__ */ jsx(
+    IconButton,
+    {
+      size: "sm",
+      variant: "soft-brand",
+      label: addLabel(itemName),
+      icon: /* @__PURE__ */ jsx(PlusGlyph, {}),
+      disabled: disabled || full || draftRefused,
+      onClick: add
+    }
+  );
+  return /* @__PURE__ */ jsxs(
+    FormField,
+    {
+      as: "fieldset",
+      label: hideLabel ? /* @__PURE__ */ jsx(VisuallyHidden, { children: label }) : label,
+      optional,
+      helper,
+      helperOnFocus,
+      error,
+      className: "crewlet-list-input",
+      labelAction: hideLabel ? void 0 : addControl,
+      children: [
+        full ? (
+          /*
+           * A FULL LIST SAYS SO WHERE THE BOX WAS, rather than drawing a box
+           * that takes nothing. A disabled box is a control a reader reaches
+           * and cannot use with no word of why; the sentence is the why, and
+           * every item above it still edits, moves and goes.
+           */
+          /* @__PURE__ */ jsx("p", { className: "crewlet-list-input__full", children: fullMessage(maxItems) })
+        ) : /* @__PURE__ */ jsxs("div", { className: "crewlet-list-input__add", children: [
+          control({
+            label: newItemLabel(itemName),
+            value: draft,
+            placeholder,
+            invalid: overLimit(draft.trim()),
+            describedBy: draftCount ? `${listId}-draft-count` : void 0,
+            /*
+             * THE COUNT TAKES THE KEYCAP'S PLACE once the limit is near: both
+             * say what pressing Enter will do, and past the limit the answer
+             * is nothing, which the count says and the keycap would not.
+             */
+            trailing: draftCount ? /* @__PURE__ */ jsx(CharacterCount, { id: `${listId}-draft-count`, length: measured(draft), max: maxLength }) : enterHint ? /* @__PURE__ */ jsx(Kbd, { subtle: true, children: "Enter" }) : void 0,
+            onChange: setDraft,
+            onKeyDown: (event) => {
+              if (!acts(event)) return;
+              event.preventDefault();
+              add();
+            },
+            ref: (el) => {
+              addBox.current = el;
+            }
+          }),
+          hideLabel ? /* @__PURE__ */ jsx("span", { className: "crewlet-list-input__add-control", children: addControl }) : null
+        ] }),
+        count > 0 || removed !== null ? /* @__PURE__ */ jsx("ol", { className: "crewlet-list-input__items", ...drags ? reorder.containerProps : {}, children: withRemoved(
+          order.map((key) => {
+            const index = ids.current.indexOf(key);
+            const item = value[index] ?? "";
+            const position = `${index + 1} of ${count}`;
+            const length = maxLength === void 0 ? 0 : measured(item);
+            const counted = maxLength !== void 0 && characterCountState(length, maxLength) !== "within";
+            const refusal = itemError?.(index, item);
+            const refused = refusal !== void 0 && refusal !== null && refusal !== false && refusal !== "";
+            const countId = `${listId}-${key}-count`;
+            const errorId = `${listId}-${key}-error`;
+            const described = [counted ? countId : null, refused ? errorId : null].filter(Boolean).join(" ");
+            const { draggable, onDragStart, onDragEnd } = reorder.handleProps(key);
+            return /* @__PURE__ */ jsxs(
+              "li",
+              {
+                className: cx("crewlet-list-input__item", drags && "crewlet-list-input__item--draggable"),
+                ...drags ? reorder.itemProps(key) : {},
+                children: [
+                  drags ? /* @__PURE__ */ jsx(
+                    "span",
+                    {
+                      className: "crewlet-list-input__handle",
+                      "aria-hidden": "true",
+                      draggable,
+                      onDragStart,
+                      onDragEnd,
+                      children: /* @__PURE__ */ jsx(GripVerticalGlyph, { size: "sm" })
+                    }
+                  ) : null,
+                  /* @__PURE__ */ jsx("span", { className: "crewlet-list-input__index", "aria-hidden": "true", children: index + 1 }),
+                  /* @__PURE__ */ jsxs("span", { className: "crewlet-list-input__field", children: [
+                    control({
+                      label: itemLabel(name, position),
+                      value: item,
+                      invalid: refused || overLimit(item),
+                      describedBy: described || void 0,
+                      onChange: (next) => {
+                        const list = [...value];
+                        list[index] = next;
+                        emit(list, ids.current);
+                      },
+                      onKeyDown: (event) => itemKeys(event, index),
+                      ref: (el) => {
+                        if (el) inputs.current.set(key, el);
+                        else inputs.current.delete(key);
+                      }
+                    }),
+                    counted || refused ? /* @__PURE__ */ jsxs("span", { className: "crewlet-list-input__note", children: [
+                      refused ? /* @__PURE__ */ jsx("span", { id: errorId, className: "crewlet-list-input__error", children: refusal }) : /* @__PURE__ */ jsx("span", {}),
+                      counted ? /* @__PURE__ */ jsx(CharacterCount, { id: countId, length, max: maxLength }) : null
+                    ] }) : null
+                  ] }),
+                  /* @__PURE__ */ jsxs("span", { className: "crewlet-list-input__actions", children: [
+                    /* @__PURE__ */ jsxs("span", { className: "crewlet-list-input__move", children: [
+                      /* @__PURE__ */ jsx(
+                        IconButton,
+                        {
+                          size: "sm",
+                          label: moveUpLabel(itemName, position),
+                          icon: /* @__PURE__ */ jsx(ArrowUpGlyph, {}),
+                          disabled: disabled || index === 0,
+                          onClick: () => move(index, -1, "up"),
+                          ref: (el) => {
+                            if (el) ups.current.set(key, el);
+                            else ups.current.delete(key);
+                          }
+                        }
+                      ),
+                      /* @__PURE__ */ jsx(
+                        IconButton,
+                        {
+                          size: "sm",
+                          label: moveDownLabel(itemName, position),
+                          icon: /* @__PURE__ */ jsx(ArrowDownGlyph, {}),
+                          disabled: disabled || index === count - 1,
+                          onClick: () => move(index, 1, "down"),
+                          ref: (el) => {
+                            if (el) downs.current.set(key, el);
+                            else downs.current.delete(key);
+                          }
+                        }
+                      )
+                    ] }),
+                    /* @__PURE__ */ jsx(
+                      IconButton,
+                      {
+                        size: "sm",
+                        variant: "ghost-danger",
+                        label: removeLabel(itemName, position),
+                        icon: /* @__PURE__ */ jsx(XGlyph, {}),
+                        disabled,
+                        onClick: () => remove(index)
+                      }
+                    )
+                  ] })
+                ]
+              },
+              key
+            );
+          })
+        ) }) : null
+      ]
+    }
+  );
+  function withRemoved(rows) {
+    if (removed === null) return rows;
+    const noticeId = `${listId}-removed`;
+    const row = /* @__PURE__ */ jsxs("li", { className: "crewlet-list-input__removed", children: [
+      /* @__PURE__ */ jsx("span", { id: noticeId, className: "crewlet-list-input__removed-text", children: removedNotice(name, removed.index + 1) }),
+      /* @__PURE__ */ jsxs("span", { className: "crewlet-list-input__actions", children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            ref: undoButton,
+            size: "small",
+            variant: "ghost",
+            "aria-describedby": noticeId,
+            disabled,
+            onClick: restore,
+            children: undoLabel
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          IconButton,
+          {
+            size: "sm",
+            label: dismissLabel,
+            icon: /* @__PURE__ */ jsx(XGlyph, {}),
+            "aria-describedby": noticeId,
+            onClick: dismiss
+          }
+        )
+      ] })
+    ] }, `removed-${removed.id}`);
+    const at = Math.min(removed.index, rows.length);
+    return [...rows.slice(0, at), row, ...rows.slice(at)];
+  }
+});
+
+export { ListInput, withDraft };

package/dist/{chunk-DL5ERIFF.js → chunk-SS4XCUUJ.js}

@@ -1,6 +1,6 @@
 import { Toolbar } from './chunk-NR4CPM4T.js';
-import { SegmentedControl } from './chunk-BF5WV7NM.js';
-import { tabId } from './chunk-KA75QPFM.js';
+import { SegmentedControl } from './chunk-6FVGSWLS.js';
+import { tabId } from './chunk-ILFEWRLG.js';
 import { IconButton } from './chunk-LACA4JGC.js';
 import { cx } from './chunk-ODEQTPFM.js';
 import './MarkdownEditor-WOKV7CLK.css';

package/dist/{chunk-GPIRKHGS.js → chunk-T7DXSFUX.js}

@@ -1,6 +1,6 @@
 import { Switch } from './chunk-A722MUNR.js';
 import { useReorder } from './chunk-XJ2QEBMM.js';
-import { Checkbox } from './chunk-EY7LACIR.js';
+import { Checkbox } from './chunk-RWET7W22.js';
 import { IconButton } from './chunk-LACA4JGC.js';
 import { VisuallyHidden } from './chunk-BZFWDIV6.js';
 import { cx } from './chunk-ODEQTPFM.js';

package/dist/{chunk-NZWX27J7.js → chunk-TDQ262TB.js}

@@ -1,19 +1,35 @@
 import { VisuallyHidden } from './chunk-BZFWDIV6.js';
 import { cx } from './chunk-ODEQTPFM.js';
-import './List-YHLIZFK4.css';
+import './List-XY445TKY.css';
 import { createContext, useContext, Children, isValidElement, cloneElement } from 'react';
 import { CircleAlertGlyph } from '@crewlethq/icons/glyphs';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
 var ListContext = createContext({ variant: "divided", templated: false });
-function List({ variant = "divided", template, className, style, children, ...rest }) {
+function List({
+  variant = "divided",
+  template,
+  density = "comfortable",
+  measure,
+  className,
+  style,
+  children,
+  ...rest
+}) {
   const Tag = variant === "numbered" || variant === "numbered-divided" ? "ol" : "ul";
   const templated = template !== void 0;
   return /* @__PURE__ */ jsx(ListContext.Provider, { value: { variant, templated }, children: /* @__PURE__ */ jsx(
     Tag,
     {
       ...rest,
-      className: cx("crewlet-list", `crewlet-list--${variant}`, templated && "crewlet-list--templated", className),
+      className: cx(
+        "crewlet-list",
+        `crewlet-list--${variant}`,
+        templated && "crewlet-list--templated",
+        density === "compact" && "crewlet-list--compact",
+        measure && `crewlet-list--measure-${measure}`,
+        className
+      ),
       style: templated ? { ...style, "--crewlet-list-template": template } : style,
       children
     }

package/dist/{chunk-5GNA4RKP.js → chunk-TGSIVB6H.js}

@@ -1,6 +1,6 @@
 import { useHeadingLevel, headingTag } from './chunk-PQADV6P6.js';
 import { cx } from './chunk-ODEQTPFM.js';
-import './CatalogTile-VPSLCKJE.css';
+import './CatalogTile-26XN7L2A.css';
 import { useId } from 'react';
 import { jsxs, jsx } from 'react/jsx-runtime';
 

package/dist/{chunk-UO5VJHWP.js → chunk-U4HOKU6P.js}

@@ -1,8 +1,8 @@
-import { SegmentedControl } from './chunk-BF5WV7NM.js';
+import { SegmentedControl } from './chunk-6FVGSWLS.js';
 import { Tooltip } from './chunk-I33UIUZD.js';
 import { ArtifactIcon } from './chunk-ILDNJHRU.js';
 import { isApplePlatform, Kbd } from './chunk-SMBKXWML.js';
-import { Menu } from './chunk-PCI7ZJ6Z.js';
+import { Menu } from './chunk-TMM32U7D.js';
 import { Button } from './chunk-OG6CL3EB.js';
 import { IconButton } from './chunk-LACA4JGC.js';
 import { returnFocus } from './chunk-NUZHC6MM.js';

package/dist/chunk-XCUUI7E7.js

@@ -0,0 +1,62 @@
+import { announce } from './chunk-RSAQOKH3.js';
+import { VisuallyHidden } from './chunk-BZFWDIV6.js';
+import { cx } from './chunk-ODEQTPFM.js';
+import './CharacterCount-S735DICR.css';
+import { useRef, useEffect } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function countCharacters(text) {
+  return Array.from(text).length;
+}
+var CHARACTER_COUNT_NEAR = 0.9;
+function characterCountState(length, max) {
+  if (length > max) return "over";
+  return length >= Math.ceil(max * CHARACTER_COUNT_NEAR) ? "near" : "within";
+}
+var characters = (n) => `${n} ${n === 1 ? "character" : "characters"}`;
+var CHARACTER_COUNT_LABELS = {
+  count: (length, max) => `${length} of ${characters(max)}`,
+  left: (left) => `${characters(left)} left`,
+  over: (over, max) => `${characters(over)} over the limit of ${max}`,
+  within: "Within the limit again"
+};
+function CharacterCount({
+  length,
+  max,
+  announce: says = true,
+  labels: overrides,
+  className,
+  ...rest
+}) {
+  const labels = { ...CHARACTER_COUNT_LABELS, ...overrides };
+  const state = characterCountState(length, max);
+  const was = useRef(state);
+  const sentence = useRef(labels);
+  sentence.current = labels;
+  useEffect(() => {
+    const before = was.current;
+    was.current = state;
+    if (!says || before === state) return;
+    const text = sentence.current;
+    if (state === "over") announce(text.over(length - max, max));
+    else if (state === "near" && before === "within") announce(text.left(max - length));
+    else if (before === "over") announce(text.within);
+  }, [state, says, length, max]);
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      ...rest,
+      className: cx("crewlet-character-count", `crewlet-character-count--${state}`, className),
+      children: [
+        /* @__PURE__ */ jsxs("span", { "aria-hidden": "true", children: [
+          length,
+          /* @__PURE__ */ jsx("span", { className: "crewlet-character-count__of", children: "/" }),
+          max
+        ] }),
+        /* @__PURE__ */ jsx(VisuallyHidden, { children: state === "over" ? labels.over(length - max, max) : labels.count(length, max) })
+      ]
+    }
+  );
+}
+
+export { CHARACTER_COUNT_LABELS, CHARACTER_COUNT_NEAR, CharacterCount, characterCountState, countCharacters };

package/dist/{chunk-ENHLVF6Q.js → chunk-XS2FJVMT.js}

@@ -1,4 +1,4 @@
-import { SegmentedControl } from './chunk-BF5WV7NM.js';
+import { SegmentedControl } from './chunk-6FVGSWLS.js';
 import { Button } from './chunk-OG6CL3EB.js';
 import { cx } from './chunk-ODEQTPFM.js';
 import './MergeConflicts-O44ESH4T.css';

package/dist/{chunk-FV6H7H5I.js → chunk-YBJVIY5E.js}

@@ -1,11 +1,11 @@
 import { Select } from './chunk-XQZ6EWOE.js';
 import { SHEET_LABELS, SHEET_COLUMN_TYPES, optionHue, retypeColumn } from './chunk-LFSIKGRQ.js';
-import { HueSwatch } from './chunk-QOP7QYUW.js';
+import { HueSwatch } from './chunk-34RMTXDZ.js';
 import { NODE_HUES, NODE_HUE_NAMES } from './chunk-AYKXMIOR.js';
-import { Checkbox } from './chunk-EY7LACIR.js';
-import { FormField, Input } from './chunk-ZI5G5RS7.js';
+import { Checkbox } from './chunk-RWET7W22.js';
+import { FormField, Input } from './chunk-Z734SV4E.js';
 import { Kbd } from './chunk-SMBKXWML.js';
-import { Menu } from './chunk-PCI7ZJ6Z.js';
+import { Menu } from './chunk-TMM32U7D.js';
 import { Button } from './chunk-OG6CL3EB.js';
 import { IconButton } from './chunk-LACA4JGC.js';
 import { VisuallyHidden } from './chunk-BZFWDIV6.js';

package/dist/{chunk-6MAQ2SVP.js → chunk-YR3ZURBM.js}

@@ -1,10 +1,10 @@
-import { Modal } from './chunk-FYINAYAJ.js';
+import { Modal } from './chunk-6AKG2VLR.js';
 import { useListbox, useHighlightRest } from './chunk-7KHM2FZH.js';
-import { Input } from './chunk-ZI5G5RS7.js';
+import { Input } from './chunk-Z734SV4E.js';
 import { Kbd } from './chunk-SMBKXWML.js';
 import { Count } from './chunk-BHHIIK3M.js';
-import { isComposing } from './chunk-H5XTJ7GJ.js';
 import { HIT_AREA_CLASS } from './chunk-2YTOOH3A.js';
+import { isComposing } from './chunk-H5XTJ7GJ.js';
 import { VisuallyHidden } from './chunk-BZFWDIV6.js';
 import { cx } from './chunk-ODEQTPFM.js';
 import './HitArea-QUOS6ZDJ.css';