@astryxdesign/core 0.1.1 → 0.1.2-canary.04e71b2

package/src/hooks/useTypeahead.ts

@@ -0,0 +1,183 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file useTypeahead.ts
+ * @input Uses React useCallback/useRef
+ * @output Exports useTypeahead hook for first-character (type-to-focus) search
+ * @position Core hook; adds APG typeahead to menus, listboxes, and other
+ *   collections. Composes with useListFocus/useGridFocus (or any collection)
+ *   via a caller-supplied getItemLabels + onMatch.
+ *
+ * SYNC: When modified, update:
+ * - /packages/core/src/hooks/index.ts
+ */
+
+import {useCallback, useRef} from 'react';
+
+export interface UseTypeaheadOptions {
+  /**
+   * Returns the current, in-DOM-order list of item labels to match against.
+   * An entry may be `null`/empty to mark a non-matchable slot (its index is
+   * preserved so it maps 1:1 to the caller's items).
+   */
+  getItemLabels: () => ReadonlyArray<string | null | undefined>;
+
+  /**
+   * Called with the index of the matched item so the caller can focus/select
+   * it (e.g. `useListFocus`'s `focusItem`).
+   */
+  onMatch: (index: number) => void;
+
+  /**
+   * The index to start searching from — typically the currently focused item,
+   * so repeated presses of the same letter cycle through matches. Defaults to
+   * -1 (search from the top).
+   */
+  getCurrentIndex?: () => number;
+
+  /**
+   * Milliseconds of inactivity after which the typed buffer resets.
+   * @default 750
+   */
+  resetMs?: number;
+
+  /**
+   * Whether an index should be skipped (e.g. disabled items).
+   */
+  isDisabled?: (index: number) => boolean;
+}
+
+export interface UseTypeaheadReturn {
+  /**
+   * Keydown handler. Call it (or let it fall through) from the collection's
+   * own key handler. Returns `true` when it handled a printable character (so
+   * the caller can `preventDefault`/stop further handling), `false` otherwise.
+   */
+  onKeyDown: (e: React.KeyboardEvent | KeyboardEvent) => boolean;
+  /** Clear the pending buffer (e.g. on close). */
+  reset: () => void;
+}
+
+/**
+ * Whether a key event represents a single printable character (a type-to-focus
+ * candidate) rather than a control/navigation key or a shortcut chord.
+ */
+function isPrintableCharacter(e: React.KeyboardEvent | KeyboardEvent): boolean {
+  return (
+    e.key.length === 1 &&
+    !e.ctrlKey &&
+    !e.metaKey &&
+    !e.altKey &&
+    // A lone space is used for activation in menus, not typeahead-from-empty.
+    e.key !== ' '
+  );
+}
+
+/**
+ * First-character ("type-ahead") search for a collection.
+ *
+ * Buffers printable keystrokes (resetting after `resetMs` of inactivity),
+ * matches items whose label starts with the buffer, and cycles from the
+ * current index — so pressing "s" repeatedly walks through the "s" items
+ * instead of sticking on the first. Space is reserved for activation and is
+ * only treated as typeahead while a buffer is already active.
+ *
+ * Additive and collection-agnostic: it does not move focus itself; the caller
+ * wires `onMatch` to its own focus/selection (e.g. `useListFocus.focusItem`).
+ *
+ * @example
+ * ```
+ * const {listRef, handleKeyDown, focusItem, getItems} = useListFocus(...);
+ * const typeahead = useTypeahead({
+ *   getItemLabels: () => getItems().map(el => el.textContent),
+ *   onMatch: focusItem,
+ *   getCurrentIndex: () => getItems().findIndex(el => el === document.activeElement),
+ * });
+ * const onKeyDown = (e) => { if (!typeahead.onKeyDown(e)) handleKeyDown(e); };
+ * ```
+ */
+export function useTypeahead(options: UseTypeaheadOptions): UseTypeaheadReturn {
+  const {
+    getItemLabels,
+    onMatch,
+    getCurrentIndex,
+    resetMs = 750,
+    isDisabled,
+  } = options;
+
+  const bufferRef = useRef('');
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | undefined>(
+    undefined,
+  );
+
+  const reset = useCallback(() => {
+    bufferRef.current = '';
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = undefined;
+    }
+  }, []);
+
+  const scheduleReset = useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    timeoutRef.current = setTimeout(() => {
+      bufferRef.current = '';
+      timeoutRef.current = undefined;
+    }, resetMs);
+  }, [resetMs]);
+
+  const onKeyDown = useCallback(
+    (e: React.KeyboardEvent | KeyboardEvent): boolean => {
+      // A bare Space with no active buffer is not typeahead (menus activate on
+      // Space); once the user is mid-typing, Space extends the query.
+      const isSpaceMidType = e.key === ' ' && bufferRef.current.length > 0;
+      if (!isPrintableCharacter(e) && !isSpaceMidType) {
+        return false;
+      }
+
+      const labels = getItemLabels();
+      if (labels.length === 0) {
+        return false;
+      }
+
+      // Pressing the SAME single character repeatedly cycles to the next match
+      // rather than filtering deeper (APG behavior).
+      const char = e.key.toLowerCase();
+      const isRepeatSameChar =
+        bufferRef.current.length > 0 &&
+        bufferRef.current.split('').every(c => c === char);
+      const nextBuffer = isRepeatSameChar ? char : bufferRef.current + char;
+      bufferRef.current = nextBuffer;
+      scheduleReset();
+
+      const start = getCurrentIndex?.() ?? -1;
+      const count = labels.length;
+      // When repeating a single char, start the search AFTER the current item
+      // so we advance; otherwise include the current item.
+      const offset = isRepeatSameChar ? 1 : 0;
+
+      for (let i = 0; i < count; i++) {
+        const index = (start + offset + i + count) % count;
+        if (isDisabled?.(index)) {
+          continue;
+        }
+        const label = labels[index];
+        if (
+          label != null &&
+          label.trim().toLowerCase().startsWith(nextBuffer)
+        ) {
+          onMatch(index);
+          return true;
+        }
+      }
+      return true;
+    },
+    [getItemLabels, onMatch, getCurrentIndex, scheduleReset, isDisabled],
+  );
+
+  return {onKeyDown, reset};
+}

package/src/index.ts

@@ -42,6 +42,7 @@ export * from './Collapsible';
 export * from './RadioList';
 export * from './Resizable';
 export * from './Divider';
+export * from './VisuallyHidden';
 export * from './EmptyState';
 export * from './Lightbox';
 export * from './Link';

package/src/theme/derivedVarRegistry.test.ts

@@ -64,6 +64,10 @@ const STRUCTURAL_VARS = new Set([
   '--indicator-color',
   '--indicator-width',
   '--table-resize-height',
+  // sticky-columns plugin: opaque backdrop (overridable) + the row overlay it
+  // replays on pinned cells. Structural/runtime, not themeable design tokens.
+  '--table-sticky-background',
+  '--table-row-overlay',
   '--separator-display',
   '--astryx-section-padding',
 ]);

package/src/theme/generateThemeRules.test.ts

@@ -101,7 +101,9 @@ describe('generateThemeRules', () => {
 
   it('includes .astryx-heading.level-* rules for all 6 levels', () => {
     for (let level = 1; level <= 6; level++) {
-      const rule = rules.find(r => r.includes(`.astryx-heading.level-${level}`));
+      const rule = rules.find(r =>
+        r.includes(`.astryx-heading.level-${level}`),
+      );
       expect(rule).toBeDefined();
       expect(rule).toContain('font-family');
       expect(rule).toContain(`var(--text-heading-${level}-size)`);
@@ -137,9 +139,7 @@ describe('generateThemeRules', () => {
     });
     const pseudoRules = generateThemeRules(pseudoTheme);
     expect(
-      pseudoRules.some(rule =>
-        rule.includes('.astryx-button:hover'),
-      ),
+      pseudoRules.some(rule => rule.includes('.astryx-button:hover')),
     ).toBe(true);
   });
 
@@ -186,7 +186,8 @@ describe('generateThemeRules', () => {
     expect(rules.some(r => r.includes('.astryx-text.secondary'))).toBe(true);
     expect(rules.some(r => r.includes('.astryx-heading.primary'))).toBe(true);
     expect(rules.some(r => r.includes('.astryx-heading.disabled'))).toBe(true);
-    expect(rules.some(r => r.includes('.astryx-text.active'))).toBe(true);
+    expect(rules.some(r => r.includes('.astryx-text.active'))).toBe(false);
+    expect(rules.some(r => r.includes('.astryx-text.accent'))).toBe(true);
   });
 
   // --- Consistency ---
@@ -194,9 +195,7 @@ describe('generateThemeRules', () => {
   it('generateThemeCSS returns prose and component blocks with @scope', () => {
     const {prose, component} = generateThemeCSS(theme);
     const combined = prose + component;
-    expect(combined).toContain(
-      '@scope ([data-astryx-theme="default"])',
-    );
+    expect(combined).toContain('@scope ([data-astryx-theme="default"])');
     expect(combined).toContain('to ([data-astryx-theme])');
     // Every rule from generateThemeRules should appear in one of the blocks
     for (const rule of rules) {

package/src/theme/generateThemeRules.ts

@@ -472,7 +472,7 @@ function generateColorOverrides(
     secondary: 'var(--color-text-secondary)',
     disabled: 'var(--color-text-disabled)',
     placeholder: 'var(--color-text-secondary)',
-    active: 'var(--color-accent)',
+    accent: 'var(--color-text-accent)',
   };
 
   const touchesText = 'text' in components;

package/src/theme/syntax/SyntaxTheme.tsx

@@ -8,7 +8,7 @@
  * @output SyntaxTheme provider, useSyntaxTheme hook
  * @position Provider component; wraps code surfaces to apply syntax coloring
  *
- * @see https://github.com/facebookexperimental/xds/issues/1148
+ * @see https://github.com/facebook/astryx/issues/1148
  */
 
 import React, {createContext, use, useMemo} from 'react';

package/src/theme/syntax/defineSyntaxTheme.ts

@@ -1,6 +1,6 @@
 // Copyright (c) Meta Platforms, Inc. and affiliates.
 
-"use strict";
+'use strict';
 
 /**
  * @file defineSyntaxTheme.ts
@@ -8,7 +8,7 @@
  * @output defineSyntaxTheme, SyntaxTheme, syntaxThemeStyle
  * @position Syntax theme definition API; consumed by presets, SyntaxTheme, defineTheme
  *
- * @see https://github.com/facebookexperimental/xds/issues/1148
+ * @see https://github.com/facebook/astryx/issues/1148
  */
 
 import {syntaxTokenDefaults, type SyntaxTokenName} from './tokens';
@@ -41,7 +41,10 @@ export type SyntaxThemeTokenKey =
 export type SyntaxTokenValue = string | [light: string, dark: string];
 
 /** Token map for defineSyntaxTheme input — values can be strings or tuples. */
-export type SyntaxThemeTokenInput = Record<SyntaxThemeTokenKey, SyntaxTokenValue>;
+export type SyntaxThemeTokenInput = Record<
+  SyntaxThemeTokenKey,
+  SyntaxTokenValue
+>;
 
 /** Resolved token map — all values are CSS strings (tuples resolved to light-dark()). */
 export type SyntaxThemeTokenMap = Record<SyntaxThemeTokenKey, string>;
@@ -73,8 +76,9 @@ function toCSSProperty(key: SyntaxThemeTokenKey): SyntaxTokenName {
 }
 
 /** All valid human-readable token keys, derived from the defaults. */
-export const ALL_SYNTAX_KEYS: SyntaxThemeTokenKey[] = Object.keys(syntaxTokenDefaults)
-  .map(k => k.replace(CSS_PREFIX, '') as SyntaxThemeTokenKey);
+export const ALL_SYNTAX_KEYS: SyntaxThemeTokenKey[] = Object.keys(
+  syntaxTokenDefaults,
+).map(k => k.replace(CSS_PREFIX, '') as SyntaxThemeTokenKey);
 
 // =============================================================================
 // Helpers
@@ -130,12 +134,17 @@ export function resolveSyntaxTokenForMode(
  *   },
  * });
  */
-export function defineSyntaxTheme(input: SyntaxThemeInput): SyntaxThemeDefinition {
+export function defineSyntaxTheme(
+  input: SyntaxThemeInput,
+): SyntaxThemeDefinition {
   const missing = ALL_SYNTAX_KEYS.filter(key => !(key in input.tokens));
   if (missing.length > 0) {
     console.warn(
-      '[Astryx] defineSyntaxTheme("' + input.name + '"): missing tokens: ' +
-        missing.join(', ') + '. All 14 syntax tokens are required.',
+      '[Astryx] defineSyntaxTheme("' +
+        input.name +
+        '"): missing tokens: ' +
+        missing.join(', ') +
+        '. All 14 syntax tokens are required.',
     );
   }
 
@@ -169,7 +178,7 @@ export function syntaxThemeStyle(
 
 /** Convert a syntax theme to CSS declarations (no selector wrapper). */
 export function syntaxThemeToCSS(theme: SyntaxThemeDefinition): string {
-  return ALL_SYNTAX_KEYS
-    .map(key => toCSSProperty(key) + ': ' + theme.tokens[key] + ';')
-    .join('\n  ');
+  return ALL_SYNTAX_KEYS.map(
+    key => toCSSProperty(key) + ': ' + theme.tokens[key] + ';',
+  ).join('\n  ');
 }

package/src/theme/syntax/presets.ts

@@ -8,10 +8,13 @@
  * All original themes are MIT licensed. Only color values are extracted.
  * See THIRD_PARTY_LICENSES.md for full attribution.
  *
- * @see https://github.com/facebookexperimental/xds/issues/1148
+ * @see https://github.com/facebook/astryx/issues/1148
  */
 
-import {defineSyntaxTheme, type SyntaxThemeDefinition} from './defineSyntaxTheme';
+import {
+  defineSyntaxTheme,
+  type SyntaxThemeDefinition,
+} from './defineSyntaxTheme';
 
 /** One Dark Pro (Binaryify) — MIT */
 export const oneDarkPro: SyntaxThemeDefinition = defineSyntaxTheme({

package/src/theme/syntax/tokens.ts

@@ -16,7 +16,7 @@
  * 14-token architecture validated against 11 community code themes.
  * All themes map cleanly to these 14 slots.
  *
- * @see https://github.com/facebookexperimental/xds/issues/1148
+ * @see https://github.com/facebook/astryx/issues/1148
  */
 
 export const syntaxTokenDefaults = {

package/src/theme/types.ts

@@ -162,7 +162,7 @@ export type TextColor =
   | 'secondary'
   | 'disabled'
   | 'placeholder'
-  | 'active'
+  | 'accent'
   | 'inherit';
 
 /**

package/src/utils/dateTypes.test.ts

@@ -0,0 +1,40 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file dateTypes.test.ts
+ * @input Uses vitest
+ * @output Test suite for date type helpers
+ * @position Tests for dateTypes.ts (normalizeDayOfWeek)
+ *
+ * SYNC: When dateTypes.ts changes, update tests accordingly
+ */
+
+import {describe, it, expect} from 'vitest';
+import {normalizeDayOfWeek} from './dateTypes';
+
+describe('normalizeDayOfWeek', () => {
+  it('passes numeric days through unchanged', () => {
+    expect(normalizeDayOfWeek(0)).toBe(0);
+    expect(normalizeDayOfWeek(1)).toBe(1);
+    expect(normalizeDayOfWeek(6)).toBe(6);
+  });
+
+  it('maps three-letter day names to their index', () => {
+    expect(normalizeDayOfWeek('sun')).toBe(0);
+    expect(normalizeDayOfWeek('mon')).toBe(1);
+    expect(normalizeDayOfWeek('tue')).toBe(2);
+    expect(normalizeDayOfWeek('wed')).toBe(3);
+    expect(normalizeDayOfWeek('thu')).toBe(4);
+    expect(normalizeDayOfWeek('fri')).toBe(5);
+    expect(normalizeDayOfWeek('sat')).toBe(6);
+  });
+
+  it('is case-insensitive for day names', () => {
+    expect(normalizeDayOfWeek('MON' as 'mon')).toBe(1);
+    expect(normalizeDayOfWeek('Sat' as 'sat')).toBe(6);
+  });
+
+  it('falls back to 0 (Sunday) for an unrecognized name', () => {
+    expect(normalizeDayOfWeek('xyz' as 'mon')).toBe(0);
+  });
+});

package/src/utils/dateTypes.ts

@@ -17,6 +17,46 @@ export type ISODateString =
 /** Day of week: 0 = Sunday through 6 = Saturday */
 export type DayOfWeek = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 
+/**
+ * Three-letter lowercase weekday name, 'sun' through 'sat'.
+ * A more self-documenting alternative to the numeric {@link DayOfWeek}.
+ */
+export type DayOfWeekName =
+  | 'sun'
+  | 'mon'
+  | 'tue'
+  | 'wed'
+  | 'thu'
+  | 'fri'
+  | 'sat';
+
+/** Weekday names indexed by {@link DayOfWeek} (0 = Sunday). */
+const WEEKDAY_NAMES: ReadonlyArray<DayOfWeekName> = [
+  'sun',
+  'mon',
+  'tue',
+  'wed',
+  'thu',
+  'fri',
+  'sat',
+];
+
+/**
+ * Normalize a weekday to its numeric {@link DayOfWeek}. Accepts either a
+ * number (0–6) or a three-letter day name ('sun'–'sat', case-insensitive),
+ * so APIs like `weekStartsOn` can take whichever is more readable at the
+ * call site. Unrecognized values fall back to 0 (Sunday).
+ */
+export function normalizeDayOfWeek(
+  value: DayOfWeek | DayOfWeekName,
+): DayOfWeek {
+  if (typeof value === 'number') {
+    return value;
+  }
+  const index = WEEKDAY_NAMES.indexOf(value.toLowerCase() as DayOfWeekName);
+  return index === -1 ? 0 : (index as DayOfWeek);
+}
+
 /** Immutable date record with 1-based month. */
 export interface PlainDate {
   readonly year: number;

package/src/utils/index.ts

@@ -68,7 +68,16 @@ export {getKey, type Key, type KeyFallback} from './getKey';
 
 export {mergeProps} from './mergeProps';
 export {mergeRefs} from './mergeRefs';
+export {themeProps, themeDataAttributes} from './themeProps';
+export type {
+  ClassValue,
+  ClassProps,
+  ThemeDataAttributes,
+  ThemeProps,
+} from './themeProps';
 export {groupItems, getItemGroup} from './groupItems';
 export type {ItemGroup} from './groupItems';
 export {observeResize, unobserveResize} from './sharedResizeObserver';
 export {isRenderable} from './isRenderable';
+export {getInputARIA} from './inputAria';
+export type {InputARIA, InputARIAInputGroup} from './inputAria';

package/src/utils/inputAria.test.ts

@@ -0,0 +1,39 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, expect, it} from 'vitest';
+import {getInputARIA} from './inputAria';
+
+describe('getInputARIA', () => {
+  it('keeps standalone input labeling native while composing descriptions', () => {
+    expect(
+      getInputARIA('input-label', ['input-help', undefined, 'input-error']),
+    ).toEqual({
+      ariaLabelledBy: undefined,
+      ariaDescribedBy: 'input-help input-error',
+    });
+  });
+
+  it('composes InputGroup context before input labels and descriptions', () => {
+    expect(
+      getInputARIA('input-label', ['input-help'], {
+        labelID: 'group-label',
+        describedByIDs: 'group-help group-error',
+      }),
+    ).toEqual({
+      ariaLabelledBy: 'group-label input-label',
+      ariaDescribedBy: 'group-help group-error input-help',
+    });
+  });
+
+  it('deduplicates repeated IDs', () => {
+    expect(
+      getInputARIA('group-label', ['shared', 'input-help'], {
+        labelID: 'group-label',
+        describedByIDs: 'shared group-error',
+      }),
+    ).toEqual({
+      ariaLabelledBy: 'group-label',
+      ariaDescribedBy: 'shared group-error input-help',
+    });
+  });
+});

package/src/utils/inputAria.ts

@@ -0,0 +1,58 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file inputAria.ts
+ * @input Receives input label/description IDs and optional InputGroup context
+ * @output Exports helpers for consistent input ARIA composition
+ * @position Internal utility; used by inputs that compose labels/descriptions
+ */
+
+export interface InputARIAInputGroup {
+  /** ID of the visible InputGroup label. */
+  labelID: string;
+  /** Space-separated IDs for InputGroup description/status text. */
+  describedByIDs?: string;
+}
+
+export interface InputARIA {
+  /** Value for aria-labelledby on the input. */
+  ariaLabelledBy?: string;
+  /** Value for aria-describedby on the input. */
+  ariaDescribedBy?: string;
+}
+
+type AriaID = string | null | undefined | false;
+
+function joinAriaIDs(...values: AriaID[]): string | undefined {
+  const ids = values
+    .flatMap(value =>
+      typeof value === 'string' ? value.trim().split(/\s+/) : [],
+    )
+    .filter(Boolean);
+
+  if (ids.length === 0) {
+    return undefined;
+  }
+
+  return Array.from(new Set(ids)).join(' ');
+}
+
+/**
+ * Builds ARIA label/description wiring for an input.
+ *
+ * Standalone inputs keep their normal native label association. Grouped inputs
+ * are named by the visible InputGroup label plus their own input label, and
+ * inherit group description/status text in addition to input-local text.
+ */
+export function getInputARIA(
+  labelID: string,
+  describedByIDs: AriaID[] = [],
+  inputGroup?: InputARIAInputGroup | null,
+): InputARIA {
+  return {
+    ariaLabelledBy: inputGroup
+      ? joinAriaIDs(inputGroup.labelID, labelID)
+      : undefined,
+    ariaDescribedBy: joinAriaIDs(inputGroup?.describedByIDs, ...describedByIDs),
+  };
+}

package/src/utils/timeParser.test.ts

@@ -144,11 +144,21 @@ describe('parseTimeInput', () => {
     expect(parseTimeInput('12pm')).toBe('12:00');
   });
 
+  it('parses dotted meridiems (a.m./p.m.)', () => {
+    expect(parseTimeInput('2:30 p.m.')).toBe('14:30');
+    expect(parseTimeInput('2:30 P.M.')).toBe('14:30');
+    expect(parseTimeInput('2:30 p.m')).toBe('14:30');
+    expect(parseTimeInput('12 a.m.')).toBe('00:00');
+    expect(parseTimeInput('12 p.m.')).toBe('12:00');
+    expect(parseTimeInput('2 p.m.')).toBe('14:00');
+  });
+
   it('returns null for invalid input', () => {
     expect(parseTimeInput('')).toBeNull();
     expect(parseTimeInput('abc')).toBeNull();
     expect(parseTimeInput('25:00')).toBeNull();
     expect(parseTimeInput('13:00 PM')).toBeNull(); // 13 is invalid in 12h format
+    expect(parseTimeInput('13:00 p.m.')).toBeNull(); // dotted variant rejected too
   });
 });
 

package/src/utils/timeParser.ts

@@ -164,10 +164,13 @@ export function parseTimeInput(
 
   const trimmed = input.trim().toLowerCase();
 
-  // Check for AM/PM
-  const hasMeridiem = /[ap]m?\s*$/i.test(trimmed);
+  // Check for AM/PM. hasMeridiem is derived from isPM/isAM so the detection
+  // can never drift from them: it previously used its own regex without the
+  // optional dots, so dotted meridiems ("2:30 p.m.") skipped the 12h -> 24h
+  // conversion and parsed 12 hours off.
   const isPM = /p\.?m?\.?\s*$/i.test(trimmed);
   const isAM = /a\.?m?\.?\s*$/i.test(trimmed);
+  const hasMeridiem = isPM || isAM;
 
   // Remove AM/PM suffix
   const timeStr = trimmed.replace(/\s*[ap]\.?m?\.?\s*$/i, '').trim();

package/dist/Calendar/hooks/useCalendarRovingTabindex.d.ts

@@ -1,57 +0,0 @@
-import type { ISODateString } from '../../utils/dateTypes';
-import { type PlainDate } from '../../utils/plainDate';
-import type { CalendarDay } from './useCalendarDays';
-/**
- * Configuration for calendar roving tabindex
- */
-export interface UseCalendarRovingTabindexOptions {
-    /** All days in the grid */
-    days: CalendarDay[];
-    /** Today's date as a PlainDate */
-    today: PlainDate;
-    /** The year being displayed */
-    year: number;
-    /** The month being displayed (1-based: 1 = January, 12 = December) */
-    month: number;
-    /** Function to check if a date is disabled */
-    isDateDisabled: (date: PlainDate) => boolean;
-    /** Currently selected date (if any) */
-    selectedDate?: PlainDate | null;
-}
-/**
- * Return type for useCalendarRovingTabindex hook
- */
-export interface UseCalendarRovingTabindexReturn {
-    /** The ISO date string of the tabbable element, or null */
-    tabbableDate: ISODateString | null;
-    /** Check if a specific date is the tabbable one */
-    isTabbable: (iso: ISODateString) => boolean;
-}
-/**
- * Hook for managing roving tabindex in calendar grids.
- *
- * Implements the WAI-ARIA roving tabindex pattern where only one element
- * in a group has tabindex="0" while others have tabindex="-1".
- *
- * Priority for tabbable element:
- * 1. Today if visible in the current month and enabled
- * 2. First enabled day in the month
- *
- * @example
- * ```
- * const {tabbableDate, isTabbable} = useCalendarRovingTabindex({
- *   days,
- *   today: {year: 2026, month: 1, day: 20},
- *   year: 2026,
- *   month: 1, // January (1-based)
- *   isDateDisabled,
- * });
- *
- * // In day rendering:
- * <button tabIndex={isTabbable(day.iso) ? 0 : -1}>
- *   {day.dayNumber}
- * </button>
- * ```
- */
-export declare function useCalendarRovingTabindex(options: UseCalendarRovingTabindexOptions): UseCalendarRovingTabindexReturn;
-//# sourceMappingURL=useCalendarRovingTabindex.d.ts.map