@lotics/ui 2.3.1 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/ui",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "type": "module",
   "exports": {
     "./tokens": "./src/tokens.ts",
@@ -55,6 +55,7 @@
     "./button": "./src/button.tsx",
     "./checkbox": "./src/checkbox.tsx",
     "./combobox": "./src/combobox.tsx",
+    "./composer": "./src/composer.tsx",
     "./portal": "./src/portal.tsx",
     "./popover_nav": "./src/popover_nav.tsx",
     "./popover": "./src/popover.tsx",

package/src/combobox.tsx

@@ -389,7 +389,7 @@ export function Combobox<T extends string = string, D = unknown>(props: Combobox
                       selected={!multi && !isCustom && single?.value === opt.value}
                       disabled={opt.disabled}
                       onPress={() => handleSelect(i)}
-                      onHoverIn={() => setActiveIndex(i)}
+                      onHoverIn={() => setActiveIndex(i, false)}
                     />
                   );
                 })

package/src/composer.tsx

@@ -0,0 +1,231 @@
+import React, { type ReactNode, type Ref, useCallback, useState } from "react";
+import { View, TextInput as RNTextInput, ScrollView, StyleSheet, type TextInputProps } from "react-native";
+import { Button } from "./button";
+import { colors } from "./colors";
+import { fontFamilyRegular, getInputTextStyle } from "./text_utils";
+import { useAutoGrowHeight } from "./use_auto_grow_height";
+
+/**
+ * The pure composer *chrome* — a bordered, auto-growing multiline text input
+ * with Enter-to-send, a send/stop button, and a footer. Everything domain- or
+ * Lotics-specific is injected: labels (no i18n), and `pills` / `files` /
+ * `children` slots the consumer fills (the product's chat wraps this and fills
+ * them with skill/knowledge pills + an upload grid; a custom-code app fills
+ * `files` with its own attachment region, or leaves it empty).
+ *
+ * Pure by the package contract: no i18n, no domain types, no upload machinery.
+ * Compose those above it.
+ */
+export interface ComposerProps {
+  onSend: (text: string) => void;
+  onStop?: () => void;
+  disabled?: boolean;
+  /** Override the default "block on empty text" send-disable (e.g. allow send with attachments only). */
+  sendDisabled?: boolean;
+  placeholder?: string;
+  autoFocus?: boolean;
+  testID?: string;
+  /** Control text externally; omit to let the composer manage its own state. */
+  value?: string;
+  onChangeText?: (text: string) => void;
+  /** Extra TextInput props (ref, onKeyPress, …). `onKeyPress` runs before the
+   *  built-in Enter-to-send and can `preventDefault()` to suppress it. */
+  textInputProps?: Partial<TextInputProps> & { ref?: Ref<RNTextInput> };
+
+  // Slots, rendered top-to-bottom above the input:
+  /** A row of context pills (skills, mentions, …). */
+  pills?: ReactNode;
+  /** An attachment region (an upload grid, a thumbnail row, …). */
+  files?: ReactNode;
+  /** Arbitrary content between the slots and the input. */
+  children?: ReactNode;
+  /** Footer left — typically an attach / actions button. */
+  actionsButton?: ReactNode;
+  /** Footer right, before the send button — e.g. a model picker. */
+  footerRight?: ReactNode;
+
+  /** Accessible/tooltip label for the send button. */
+  sendLabel?: string;
+  /** Accessible/tooltip label for the stop button (shown while `disabled` + `onStop`). */
+  stopLabel?: string;
+}
+
+export function Composer(props: ComposerProps) {
+  const {
+    onSend,
+    onStop,
+    disabled,
+    sendDisabled,
+    placeholder,
+    autoFocus,
+    testID,
+    textInputProps,
+    pills,
+    files,
+    children,
+    actionsButton,
+    footerRight,
+    sendLabel = "Send",
+    stopLabel = "Stop",
+  } = props;
+
+  const [internalText, setInternalText] = useState("");
+  const isControlled = props.value !== undefined;
+  const text = isControlled ? props.value! : internalText;
+  const setText = isControlled ? (props.onChangeText ?? setInternalText) : setInternalText;
+
+  const [focused, setFocused] = useState(false);
+  const { containerHeight, scrollEnabled, inputRef, measure, onContentSizeChange } = useAutoGrowHeight({ maxLines: 12 });
+  const emptyText = text.trim().length === 0;
+
+  const { ref: externalRef, ...spreadInputProps } = textInputProps ?? {};
+  const mergedInputRef = useCallback(
+    (node: RNTextInput | null) => {
+      inputRef(node);
+      if (typeof externalRef === "function") (externalRef as (node: RNTextInput | null) => void)(node);
+      else if (externalRef) (externalRef as React.MutableRefObject<RNTextInput | null>).current = node;
+    },
+    [inputRef, externalRef],
+  );
+
+  const effectiveSendDisabled = sendDisabled !== undefined ? sendDisabled : emptyText;
+
+  const handleSend = useCallback(() => {
+    if (disabled || effectiveSendDisabled) return;
+    onSend(text);
+    setText("");
+    requestAnimationFrame(measure);
+  }, [disabled, effectiveSendDisabled, onSend, text, setText, measure]);
+
+  const handleChangeText = useCallback(
+    (t: string) => {
+      setText(t);
+      measure();
+    },
+    [setText, measure],
+  );
+
+  const handleKeyPress = useCallback(
+    (e: unknown) => {
+      // The consumer's handler runs first and may suppress send (e.g. to remove
+      // a pill on Backspace, or run a mention selection on Enter).
+      if (spreadInputProps.onKeyPress) {
+        (spreadInputProps.onKeyPress as (e: unknown) => void)(e);
+      }
+      const webEvent = e as { key: string; shiftKey: boolean; preventDefault: () => void; defaultPrevented?: boolean };
+      if (webEvent.defaultPrevented) return;
+      if (webEvent.key === "Enter" && !webEvent.shiftKey) {
+        webEvent.preventDefault();
+        handleSend();
+      }
+    },
+    [handleSend, spreadInputProps],
+  );
+
+  const hasContentAboveInput = pills != null || files != null || children != null;
+
+  return (
+    <View testID={testID} style={[styles.container, focused && styles.focused]}>
+      <View style={[styles.inputContainer, hasContentAboveInput && styles.inputContainerWithContent]}>
+        {pills != null && <View style={styles.pillRow}>{pills}</View>}
+        {files != null && (
+          <ScrollView horizontal showsHorizontalScrollIndicator={false} contentContainerStyle={{ gap: 8 }}>
+            {files}
+          </ScrollView>
+        )}
+        {children}
+        <View style={{ justifyContent: "center" }}>
+          <View style={{ height: containerHeight }}>
+            <RNTextInput
+              ref={mergedInputRef}
+              autoFocus={autoFocus}
+              onChangeText={handleChangeText}
+              onSubmitEditing={handleSend}
+              placeholder={placeholder}
+              placeholderTextColor={colors.zinc[500]}
+              value={text}
+              onFocus={() => setFocused(true)}
+              onBlur={() => setFocused(false)}
+              multiline
+              scrollEnabled={scrollEnabled}
+              onContentSizeChange={onContentSizeChange}
+              {...spreadInputProps}
+              onKeyPress={handleKeyPress}
+              style={[
+                styles.textInput,
+                getInputTextStyle(),
+                { outlineStyle: "none" },
+                !scrollEnabled && { overflow: "hidden" as const },
+                spreadInputProps?.style,
+              ]}
+            />
+          </View>
+        </View>
+      </View>
+
+      <View style={styles.footer}>
+        <View style={styles.footerLeft}>{actionsButton}</View>
+        <View style={styles.footerRight}>
+          {footerRight}
+          {disabled && onStop ? (
+            <Button onPress={onStop} color="primary" icon="square" tooltip={stopLabel} />
+          ) : (
+            <Button
+              onPress={handleSend}
+              color="primary"
+              disabled={disabled || effectiveSendDisabled}
+              icon="arrow-up"
+              tooltip={sendLabel}
+            />
+          )}
+        </View>
+      </View>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    padding: 8,
+    borderRadius: 16,
+    borderWidth: 2,
+    borderColor: colors.border,
+    backgroundColor: colors.background,
+  },
+  focused: {
+    borderColor: colors.black,
+  },
+  footer: {
+    flex: 1,
+    flexDirection: "row",
+    gap: 8,
+    justifyContent: "space-between",
+    zIndex: 1,
+    paddingTop: 8,
+  },
+  footerLeft: {
+    flexDirection: "row",
+    gap: 8,
+  },
+  footerRight: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 8,
+  },
+  inputContainer: {
+    padding: 4,
+  },
+  inputContainerWithContent: {
+    gap: 8,
+  },
+  pillRow: {
+    flexDirection: "row",
+    flexWrap: "wrap",
+    gap: 4,
+  },
+  textInput: {
+    flex: 1,
+    fontFamily: fontFamilyRegular,
+    letterSpacing: -0.4,
+  },
+});

package/src/use_list_keyboard_nav.test.ts

@@ -103,4 +103,11 @@ describe("useListKeyboardNav", () => {
     act(() => void view.result.current.handleKey("ArrowDown"));
     expect(onActiveChange).toHaveBeenCalledWith(1);
   });
+
+  it("setActiveIndex moves the active row but skips onActiveChange when scrollIntoView is false (mouse hover)", () => {
+    const { view, onActiveChange } = setup();
+    act(() => view.result.current.setActiveIndex(2, false));
+    expect(view.result.current.activeIndex).toBe(2);
+    expect(onActiveChange).not.toHaveBeenCalled();
+  });
 });

package/src/use_list_keyboard_nav.ts

@@ -17,7 +17,10 @@ export interface ListKeyboardNav {
   /** The virtually-focused row. The list stays visually highlighted here while
    *  DOM focus remains on the controlling input (ARIA `aria-activedescendant`). */
   activeIndex: number;
-  setActiveIndex: (index: number) => void;
+  /** Set the active row. `scrollIntoView` defaults to true (keyboard nav); pass
+   *  false on mouse hover so it doesn't scroll the row into view — the cursor is
+   *  already on it, and scrolling would slide a different row under the cursor. */
+  setActiveIndex: (index: number, scrollIntoView?: boolean) => void;
   /** Feed a key from the controlling input's `onKeyPress`. Returns true when it
    *  handled the key, so the caller can `preventDefault()`. */
   handleKey: (key: string) => boolean;
@@ -34,9 +37,13 @@ export function useListKeyboardNav(opts: ListKeyboardNavOptions): ListKeyboardNa
   const [activeIndex, setActiveIndexState] = useState(0);
 
   const setActiveIndex = useCallback(
-    (index: number) => {
+    (index: number, scrollIntoView = true) => {
       setActiveIndexState(index);
-      onActiveChange?.(index);
+      // Only scroll for keyboard nav. Mouse hover sets the active row without
+      // scrolling — the cursor is already on it, and scrolling it into view
+      // would slide a different row under the cursor → onHoverIn → scroll →
+      // runaway loop.
+      if (scrollIntoView) onActiveChange?.(index);
     },
     [onActiveChange],
   );