select machine

type LegacyHighlightEvent = {
  readonly type: typeof LEGACY_HIGHLIGHT_EVENT;
  readonly index: number;
};

type LegacyHighlightType = `ACT${"IVATE"}`;

declare function normalizedOptions(options: readonly OptionInput[]): readonly NormalizedOption[];

declare function normalizeOption(option: OptionInput): NormalizedOption;

type SelectChangeReason = "pointer" | "keyboard" | "programmatic";

type SelectCommand<TValue extends SelectItemValue = string> = CommandObject & {
  readonly type: "VALUE_CHANGE_REQUEST";
  readonly value: SelectCommandValue<TValue>;
  readonly reason: SelectChangeReason;
};

type SelectContext<TValue extends SelectItemValue = string> = {
  /** Caller-facing selection representation. */
  readonly value: SelectValue<TValue>;
  /** Normalized identity used by the machine for all selection operations. */
  readonly selectedIds: readonly string[];
  readonly valueKind: SelectionKind;
  /** Original options-list index; disabled options are skipped during movement. */
  readonly highlightedIndex: number;
  readonly mode: "controlled" | "uncontrolled";
};

export declare const SelectDiagnosticCodes: readonly DiagnosticCatalogueEntry[];

type SelectEvent<TValue extends SelectItemValue = string> = {
  readonly type: "TOGGLE";
} | {
  readonly type: "OPEN";
} | {
  readonly type: "CLOSE";
} | {
  readonly type: "MOVE";
  readonly direction: -1 | 1;
} | {
  readonly type: "SELECT";
  readonly value: TValue;
  readonly reason: SelectChangeReason;
} | {
  readonly type: "HIGHLIGHT";
  readonly index: number;
} | LegacyHighlightEvent | {
  readonly type: "HOME";
} | {
  readonly type: "END";
} | {
  readonly type: "TYPEAHEAD";
  readonly query: string;
} | {
  readonly type: "RESET";
};

type SelectInput<TValue extends SelectItemValue = string> = {
  readonly options: readonly SelectOptionInput<TValue>[];
  readonly selectionMode?: SelectSelectionMode;
  /** Controlled committed value. Defining it fixes controlled mode at first start. */
  readonly value?: SelectValue<TValue>;
  /** Uncontrolled initial committed value. */
  readonly defaultValue?: SelectValue<TValue>;
  readonly defaultOpen?: boolean;
  /** Versioned behavior: MOVE wraps past either end when true. Default false (legacy clamp). */
  readonly loop?: boolean;
};

type SelectItemValue = string;

export declare const selectMachine: SelectMachine;

type SelectMachine<TValue extends SelectItemValue = string> = Machine<SelectInput<TValue>, SelectStateValue, SelectContext<TValue>, SelectEvent<TValue>, SelectCommand<TValue>>;

interface SelectOption<TValue extends SelectItemValue = string> {
  readonly id?: string;
  readonly value: TValue;
  readonly label: string;
  readonly disabled?: boolean;
}

type SelectOptionInput<TValue extends SelectItemValue = string> = string | SelectOption<TValue>;

export declare const selectReplaySequence: readonly SelectEvent[];

type SelectSelection<TValue extends SelectItemValue = string> = string | SelectOption<TValue>;

type SelectSelectionMode = "single" | "multiple";

export declare const selectSelectors: {
  open: (snapshot: SelectSnapshot) => boolean;
  value: (snapshot: SelectSnapshot) => SelectValue<string>;
  selectedIds: (snapshot: SelectSnapshot) => readonly string[];
  highlightedIndex: (snapshot: SelectSnapshot) => number;
};

type SelectSnapshot<TValue extends SelectItemValue = string> = Snapshot<SelectStateValue, SelectContext<TValue>>;

type SelectStateValue = "open" | "closed";

type SelectValue<TValue extends SelectItemValue = string> = readonly SelectSelection<TValue>[];