gloomberb 0.7.5 → 0.8.0

package/src/components/command-bar/helpers.ts

@@ -1,112 +1,67 @@
-import type {
-  CommandDef,
-  PaneSettingField,
-  PaneTemplateDef,
-  WizardStep,
-} from "../../types/plugin";
+import type { CommandDef, PaneSettingField } from "../../types/plugin";
+import type { CommandBarRoute } from "./workflow/types";
+import type { CollectionKind, CollectionMembershipAction } from "./workflow/ops";
 
 export { slugifyName } from "../../utils/slugify";
-import type {
-  CommandBarFieldOption,
-  CommandBarFieldValue,
-  CommandBarRoute,
-  CommandBarWorkflowField,
-} from "./workflow-types";
-import type { CollectionKind, CollectionMembershipAction } from "./workflow-ops";
+export {
+  buildGeneratedTemplateField,
+  coerceFieldBoolean,
+  coerceFieldString,
+  coerceFieldValues,
+  getFirstVisibleFieldId,
+  getWorkflowFieldDescription,
+  getVisibleWorkflowFields,
+  isWorkflowTextField,
+  normalizeFieldOptions,
+  normalizeWizardFields,
+  summarizeWorkflowFieldValue,
+} from "./workflow/fields";
 
 export type RouteCommandId = "security-description" | "plugins" | "layout";
 export type CollectionCommandId = "add-watchlist" | "add-portfolio" | "remove-watchlist" | "remove-portfolio";
 
-export function summarizeError(error: unknown): Record<string, string> {
-  if (error instanceof Error) {
-    return {
-      name: error.name,
-      message: error.message,
-      stack: error.stack || "",
-    };
-  }
-  return { message: String(error) };
-}
-
 export function isRouteCommandId(commandId: string): commandId is RouteCommandId {
   return commandId === "security-description"
     || commandId === "plugins"
     || commandId === "layout";
 }
 
-export function normalizeFieldOptions(
-  options: Array<{ label: string; value: string; description?: string }> | undefined,
-): CommandBarFieldOption[] {
-  return (options ?? []).map((option) => ({
-    label: option.label,
-    value: option.value,
-    description: option.description,
-  }));
-}
-
-export function getVisibleWorkflowFields(
-  fields: CommandBarWorkflowField[],
-  values: Record<string, CommandBarFieldValue>,
-): CommandBarWorkflowField[] {
-  return fields.filter((field) => {
-    if (!field.dependsOn || field.dependsOn.length === 0) return true;
-    return field.dependsOn.every((dependency) => String(values[dependency.key] ?? "") === dependency.value);
-  });
+export function routeCommandIdToScreen(commandId: RouteCommandId): "ticker-search" | "plugins" | "layout" {
+  switch (commandId) {
+    case "security-description":
+      return "ticker-search";
+    case "plugins":
+      return "plugins";
+    case "layout":
+      return "layout";
+  }
 }
 
-export function coerceFieldString(value: CommandBarFieldValue | undefined): string {
-  return typeof value === "string" ? value : "";
+export function isRootParsedCommand(commandId: string): boolean {
+  return commandId === "security-description"
+    || commandId === "add-watchlist"
+    || commandId === "add-portfolio"
+    || commandId === "remove-watchlist"
+    || commandId === "remove-portfolio";
 }
 
-export function coerceFieldBoolean(value: CommandBarFieldValue | undefined): boolean {
-  return value === true;
+export function isCollectionCommand(commandId: string): commandId is CollectionCommandId {
+  return commandId === "add-watchlist"
+    || commandId === "add-portfolio"
+    || commandId === "remove-watchlist"
+    || commandId === "remove-portfolio";
 }
 
-export function coerceFieldValues(value: CommandBarFieldValue | undefined): string[] {
-  return Array.isArray(value)
-    ? value.filter((entry): entry is string => typeof entry === "string")
-    : [];
+export function getCollectionCommandKind(commandId: CollectionCommandId): CollectionKind {
+  return commandId === "add-watchlist" || commandId === "remove-watchlist" ? "watchlist" : "portfolio";
 }
 
-function fieldOptionLabel(field: CommandBarWorkflowField, value: string): string {
-  if (field.type !== "select" && field.type !== "multi-select" && field.type !== "ordered-multi-select") {
-    return value;
-  }
-  return field.options.find((option) => option.value === value)?.label ?? value;
+export function getCollectionCommandAction(commandId: CollectionCommandId): CollectionMembershipAction {
+  return commandId === "add-watchlist" || commandId === "add-portfolio" ? "add" : "remove";
 }
 
-export function summarizeWorkflowFieldValue(
-  field: CommandBarWorkflowField,
-  value: CommandBarFieldValue | undefined,
-): string {
-  switch (field.type) {
-    case "toggle":
-      return coerceFieldBoolean(value) ? "On" : "Off";
-    case "text":
-    case "password":
-    case "number": {
-      const next = coerceFieldString(value).trim();
-      return next.length > 0 ? next : "Unset";
-    }
-    case "textarea": {
-      const next = coerceFieldString(value).replace(/\s+/g, " ").trim();
-      return next.length > 0 ? next : "Unset";
-    }
-    case "select": {
-      const selected = coerceFieldString(value);
-      return selected ? fieldOptionLabel(field, selected) : "Choose…";
-    }
-    case "multi-select":
-    case "ordered-multi-select": {
-      const selected = coerceFieldValues(value);
-      if (selected.length === 0) return "None";
-      const labels = selected.map((entry) => fieldOptionLabel(field, entry)).slice(0, 3);
-      const suffix = selected.length > 3 ? ` +${selected.length - 3}` : "";
-      return `${labels.join(", ")}${suffix}`;
-    }
-    default:
-      return "";
-  }
+export function getCollectionCommandVerb(action: CollectionMembershipAction): string {
+  return action === "add" ? "Add" : "Remove";
 }
 
 export function summarizePaneSettingValue(field: PaneSettingField, value: unknown): string {
@@ -136,166 +91,6 @@ export function summarizePaneSettingValue(field: PaneSettingField, value: unknow
   }
 }
 
-export function toggleSelectedValue(currentValues: string[], value: string): string[] {
-  return currentValues.includes(value)
-    ? currentValues.filter((entry) => entry !== value)
-    : [...currentValues, value];
-}
-
-export function moveSelectedValue(
-  field: { options: CommandBarFieldOption[] },
-  currentValues: string[],
-  selectedOption: string,
-  direction: "up" | "down",
-): string[] {
-  if (!currentValues.includes(selectedOption)) return currentValues;
-
-  const optionValueSet = new Set(field.options.map((option) => option.value));
-  const ordered = currentValues.filter((value) => optionValueSet.has(value));
-  const index = ordered.indexOf(selectedOption);
-  if (index < 0) return currentValues;
-
-  const targetIndex = direction === "up"
-    ? Math.max(0, index - 1)
-    : Math.min(ordered.length - 1, index + 1);
-  if (targetIndex === index) return currentValues;
-
-  const next = [...ordered];
-  const [entry] = next.splice(index, 1);
-  next.splice(targetIndex, 0, entry!);
-  const unknownValues = currentValues.filter((value) => !optionValueSet.has(value));
-  return [...next, ...unknownValues];
-}
-
-export function normalizeWizardFields(steps: WizardStep[]): {
-  fields: CommandBarWorkflowField[];
-  description: string[];
-  initialValues: Record<string, CommandBarFieldValue>;
-  pendingLabel?: string;
-  successLabel?: string;
-} {
-  const fields: CommandBarWorkflowField[] = [];
-  const description: string[] = [];
-  const initialValues: Record<string, CommandBarFieldValue> = {};
-  let pendingLabel: string | undefined;
-  let successLabel: string | undefined;
-
-  for (const step of steps) {
-    if (step.type === "info") {
-      if (step.key.startsWith("_validate")) {
-        pendingLabel = step.body?.[0] || step.label;
-        successLabel = step.body?.[1];
-      } else if (step.body) {
-        description.push(...step.body);
-      }
-      continue;
-    }
-
-    const type = step.type === "password"
-      ? "password"
-      : step.type === "number"
-        ? "number"
-        : step.type === "textarea"
-          ? "textarea"
-        : step.type === "select"
-          ? "select"
-          : "text";
-    if (type === "select") {
-      fields.push({
-        id: step.key,
-        label: step.label,
-        type,
-        options: normalizeFieldOptions(step.options),
-        placeholder: step.placeholder,
-        description: step.body?.[0],
-        required: true,
-        dependsOn: step.dependsOn ? [{ key: step.dependsOn.key, value: step.dependsOn.value }] : undefined,
-      });
-      if (step.defaultValue) {
-        initialValues[step.key] = step.defaultValue;
-      } else if (step.options?.[0]?.value) {
-        initialValues[step.key] = step.options[0].value;
-      }
-      continue;
-    }
-
-    fields.push({
-      id: step.key,
-      label: step.label,
-      type,
-      placeholder: step.placeholder,
-      description: step.body?.[0],
-      required: true,
-      dependsOn: step.dependsOn ? [{ key: step.dependsOn.key, value: step.dependsOn.value }] : undefined,
-    });
-    if (step.defaultValue) {
-      initialValues[step.key] = step.defaultValue;
-    }
-  }
-
-  return { fields, description, initialValues, pendingLabel, successLabel };
-}
-
-export function routeCommandIdToScreen(commandId: RouteCommandId): "ticker-search" | "plugins" | "layout" {
-  switch (commandId) {
-    case "security-description":
-      return "ticker-search";
-    case "plugins":
-      return "plugins";
-    case "layout":
-      return "layout";
-  }
-}
-
-export function getFirstVisibleFieldId(
-  fields: CommandBarWorkflowField[],
-  values: Record<string, CommandBarFieldValue>,
-): string | null {
-  return getVisibleWorkflowFields(fields, values)[0]?.id ?? null;
-}
-
-export function isWorkflowTextField(field: CommandBarWorkflowField | undefined): boolean {
-  return field?.type === "text"
-    || field?.type === "password"
-    || field?.type === "number"
-    || field?.type === "textarea";
-}
-
-export function buildGeneratedTemplateField(
-  template: PaneTemplateDef,
-  activeTicker: string | null,
-): {
-  field: CommandBarWorkflowField | null;
-  initialValue: CommandBarFieldValue | undefined;
-} {
-  const placeholder = template.shortcut?.argPlaceholder;
-  if (placeholder === "ticker") {
-    return {
-      field: {
-        id: "ticker",
-        label: "Ticker",
-        type: "text",
-        required: true,
-        placeholder: activeTicker || "MSFT",
-      },
-      initialValue: activeTicker ?? "",
-    };
-  }
-  if (placeholder === "tickers") {
-    return {
-      field: {
-        id: "tickers",
-        label: "Tickers",
-        type: "text",
-        required: true,
-        placeholder: "AAPL, MSFT, NVDA",
-      },
-      initialValue: "",
-    };
-  }
-  return { field: null, initialValue: undefined };
-}
-
 export function getScreenFooterLeft(route: CommandBarRoute | null): string {
   if (!route) return "up/down move  enter select";
   switch (route.kind) {
@@ -335,31 +130,15 @@ export function getScreenFooterRight(route: CommandBarRoute | null): string {
   return "backspace/esc back";
 }
 
-export function isRootParsedCommand(commandId: string): boolean {
-  return commandId === "security-description"
-    || commandId === "add-watchlist"
-    || commandId === "add-portfolio"
-    || commandId === "remove-watchlist"
-    || commandId === "remove-portfolio";
-}
-
-export function isCollectionCommand(commandId: string): commandId is CollectionCommandId {
-  return commandId === "add-watchlist"
-    || commandId === "add-portfolio"
-    || commandId === "remove-watchlist"
-    || commandId === "remove-portfolio";
-}
-
-export function getCollectionCommandKind(commandId: CollectionCommandId): CollectionKind {
-  return commandId === "add-watchlist" || commandId === "remove-watchlist" ? "watchlist" : "portfolio";
-}
-
-export function getCollectionCommandAction(commandId: CollectionCommandId): CollectionMembershipAction {
-  return commandId === "add-watchlist" || commandId === "add-portfolio" ? "add" : "remove";
-}
-
-export function getCollectionCommandVerb(action: CollectionMembershipAction): string {
-  return action === "add" ? "Add" : "Remove";
+export function summarizeError(error: unknown): Record<string, string> {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack || "",
+    };
+  }
+  return { message: String(error) };
 }
 
 export function looksDestructiveCommand(

package/src/components/command-bar/keyboard-handlers.ts

@@ -0,0 +1,306 @@
+import type { KeyEventLike } from "../../react/input";
+import { isPlainBackspace } from "../../utils/back-navigation";
+import { openNativeSelect, type NativeSelectElement } from "../ui/native-select";
+import {
+  coerceFieldBoolean,
+  getVisibleWorkflowFields,
+  isWorkflowTextField,
+} from "./helpers";
+import type { ListScreenState } from "./list/model";
+import type { ThemePickerHandle } from "./theme-picker";
+import type {
+  CommandBarFieldValue,
+  CommandBarRoute,
+  CommandBarWorkflowField,
+  CommandBarWorkflowRoute,
+} from "./workflow/types";
+
+export type RefLike<T> = { current: T };
+
+export function consumeShortcutEvent(event: KeyEventLike): void {
+  event.stopPropagation();
+  event.preventDefault();
+}
+
+export function isMoveUpShortcut(event: KeyEventLike): boolean {
+  return event.name === "up" || (event.ctrl && event.name === "p");
+}
+
+export function isMoveDownShortcut(event: KeyEventLike): boolean {
+  return event.name === "down" || (event.ctrl && event.name === "n");
+}
+
+export function isCommitShortcut(event: KeyEventLike): boolean {
+  return event.name === "return" || event.name === "enter";
+}
+
+export function handleConfirmRouteShortcut({
+  confirmCurrentRoute,
+  currentRoute,
+  event,
+  popRoute,
+}: {
+  confirmCurrentRoute: () => void | Promise<void>;
+  currentRoute: CommandBarRoute | null;
+  event: KeyEventLike;
+  popRoute: () => void;
+}): boolean {
+  if (currentRoute?.kind !== "confirm") return false;
+
+  if (isPlainBackspace(event)) {
+    consumeShortcutEvent(event);
+    popRoute();
+    return true;
+  }
+  if (isCommitShortcut(event) || event.name === "y") {
+    consumeShortcutEvent(event);
+    void confirmCurrentRoute();
+    return true;
+  }
+  if (event.name === "n") {
+    consumeShortcutEvent(event);
+    popRoute();
+  }
+  return true;
+}
+
+export function handleRouteBackShortcut({
+  currentRoute,
+  event,
+  popRoute,
+}: {
+  currentRoute: CommandBarRoute | null;
+  event: KeyEventLike;
+  popRoute: () => void;
+}): boolean {
+  if (
+    currentRoute
+    && (currentRoute.kind === "mode"
+      || currentRoute.kind === "picker"
+      || currentRoute.kind === "pane-settings")
+    && isPlainBackspace(event)
+    && currentRoute.query.length === 0
+  ) {
+    consumeShortcutEvent(event);
+    popRoute();
+    return true;
+  }
+  return false;
+}
+
+export function handleWorkflowRouteShortcut({
+  currentRoute,
+  event,
+  getWorkflowFieldStringValue,
+  moveWorkflowFocus,
+  nativePaneChrome,
+  openWorkflowFieldPicker,
+  popRoute,
+  submitWorkflowRoute,
+  updateWorkflowValue,
+  workflowNativeSelectRefs,
+}: {
+  currentRoute: CommandBarRoute | null;
+  event: KeyEventLike;
+  getWorkflowFieldStringValue: (
+    field: CommandBarWorkflowField,
+    value: CommandBarFieldValue | undefined,
+  ) => string;
+  moveWorkflowFocus: (delta: number) => void;
+  nativePaneChrome: boolean;
+  openWorkflowFieldPicker: (
+    route: CommandBarWorkflowRoute,
+    field: CommandBarWorkflowField,
+  ) => void;
+  popRoute: () => void;
+  submitWorkflowRoute: (route: CommandBarWorkflowRoute) => void | Promise<void>;
+  updateWorkflowValue: (fieldId: string, value: CommandBarFieldValue) => void;
+  workflowNativeSelectRefs: RefLike<Map<string, NativeSelectElement>>;
+}): boolean {
+  if (currentRoute?.kind !== "workflow") return false;
+
+  const visibleFields = getVisibleWorkflowFields(currentRoute.fields, currentRoute.values);
+  const activeField = visibleFields.find((field) => field.id === currentRoute.activeFieldId) ?? visibleFields[0];
+  const activeTextarea = activeField?.type === "textarea";
+
+  if (isPlainBackspace(event)) {
+    const activeValue = activeField
+      ? getWorkflowFieldStringValue(activeField, currentRoute.values[activeField.id])
+      : "";
+    if (!activeField || !isWorkflowTextField(activeField) || activeValue.length === 0) {
+      consumeShortcutEvent(event);
+      popRoute();
+      return true;
+    }
+  }
+
+  if (event.name === "tab") {
+    consumeShortcutEvent(event);
+    moveWorkflowFocus(event.shift ? -1 : 1);
+    return true;
+  }
+
+  if (activeTextarea && event.ctrl && event.name === "s") {
+    consumeShortcutEvent(event);
+    void submitWorkflowRoute(currentRoute);
+    return true;
+  }
+
+  if (activeTextarea && (event.name === "up" || event.name === "down" || (event.ctrl && (event.name === "p" || event.name === "n")))) {
+    return true;
+  }
+
+  if (isMoveUpShortcut(event)) {
+    consumeShortcutEvent(event);
+    moveWorkflowFocus(-1);
+    return true;
+  }
+
+  if (isMoveDownShortcut(event)) {
+    consumeShortcutEvent(event);
+    moveWorkflowFocus(1);
+    return true;
+  }
+
+  if (event.name === "space" && activeField?.type === "toggle") {
+    consumeShortcutEvent(event);
+    updateWorkflowValue(activeField.id, !coerceFieldBoolean(currentRoute.values[activeField.id]));
+    return true;
+  }
+
+  if (
+    isCommitShortcut(event)
+    || (nativePaneChrome && event.name === "space" && activeField?.type === "select")
+  ) {
+    if (!activeField) return true;
+    if (activeField.type === "select" || activeField.type === "multi-select" || activeField.type === "ordered-multi-select" || activeField.type === "toggle") {
+      consumeShortcutEvent(event);
+      if (nativePaneChrome && activeField.type === "select") {
+        openNativeSelect(workflowNativeSelectRefs.current.get(activeField.id));
+        return true;
+      }
+      openWorkflowFieldPicker(currentRoute, activeField);
+      return true;
+    }
+  }
+
+  return true;
+}
+
+export function handlePickerRouteShortcut({
+  activateListSelection,
+  commitMultiSelectPicker,
+  currentRoute,
+  event,
+  handleMultiSelectMove,
+  handleMultiSelectToggle,
+  moveListSelection,
+  visibleListStateRef,
+}: {
+  activateListSelection: (options?: { secondary?: boolean }) => void;
+  commitMultiSelectPicker: () => void;
+  currentRoute: CommandBarRoute | null;
+  event: KeyEventLike;
+  handleMultiSelectMove: (direction: "up" | "down") => void;
+  handleMultiSelectToggle: (optionId: string) => void;
+  moveListSelection: (delta: number) => void;
+  visibleListStateRef: RefLike<ListScreenState | null>;
+}): boolean {
+  if (currentRoute?.kind !== "picker") return false;
+
+  if (isMoveUpShortcut(event)) {
+    consumeShortcutEvent(event);
+    moveListSelection(-1);
+    return true;
+  }
+  if (isMoveDownShortcut(event)) {
+    consumeShortcutEvent(event);
+    moveListSelection(1);
+    return true;
+  }
+  if (currentRoute.pickerId === "field-multi-select" && (event.name === "space" || event.sequence === " ")) {
+    consumeShortcutEvent(event);
+    const listState = visibleListStateRef.current;
+    const selected = listState?.results[listState.selectedIdx];
+    if (selected) handleMultiSelectToggle(selected.id);
+    return true;
+  }
+  if (currentRoute.pickerId === "field-multi-select" && event.name === "[") {
+    consumeShortcutEvent(event);
+    handleMultiSelectMove("up");
+    return true;
+  }
+  if (currentRoute.pickerId === "field-multi-select" && event.name === "]") {
+    consumeShortcutEvent(event);
+    handleMultiSelectMove("down");
+    return true;
+  }
+  if (isCommitShortcut(event)) {
+    consumeShortcutEvent(event);
+    if (currentRoute.pickerId === "field-multi-select") {
+      commitMultiSelectPicker();
+      return true;
+    }
+    activateListSelection();
+  }
+  return true;
+}
+
+export function handlePaneSettingsRouteShortcut({
+  activateListSelection,
+  currentRoute,
+  event,
+  moveListSelection,
+}: {
+  activateListSelection: (options?: { secondary?: boolean }) => void;
+  currentRoute: CommandBarRoute | null;
+  event: KeyEventLike;
+  moveListSelection: (delta: number) => void;
+}): boolean {
+  if (currentRoute?.kind !== "pane-settings") return false;
+
+  if (isMoveUpShortcut(event)) {
+    consumeShortcutEvent(event);
+    moveListSelection(-1);
+    return true;
+  }
+  if (isMoveDownShortcut(event)) {
+    consumeShortcutEvent(event);
+    moveListSelection(1);
+    return true;
+  }
+  if (isCommitShortcut(event) || event.name === "space") {
+    consumeShortcutEvent(event);
+    activateListSelection();
+  }
+  return true;
+}
+
+export function handleThemePickerShortcut({
+  event,
+  themePickerActive,
+  themePickerRef,
+}: {
+  event: KeyEventLike;
+  themePickerActive: boolean;
+  themePickerRef: RefLike<ThemePickerHandle | null>;
+}): boolean {
+  if (!themePickerActive) return false;
+
+  if (isMoveUpShortcut(event)) {
+    consumeShortcutEvent(event);
+    themePickerRef.current?.move(-1);
+    return true;
+  }
+  if (isMoveDownShortcut(event)) {
+    consumeShortcutEvent(event);
+    themePickerRef.current?.move(1);
+    return true;
+  }
+  if (isCommitShortcut(event)) {
+    consumeShortcutEvent(event);
+    themePickerRef.current?.commit();
+    return true;
+  }
+  return false;
+}