@astryxdesign/core 0.1.2 → 0.1.3

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

@@ -14,7 +14,7 @@
 
 import {describe, it, expect} from 'vitest';
 import {derivedVarRegistry, getDerivedVars} from './derivedVarRegistry';
-import {readdirSync, readFileSync, existsSync} from 'fs';
+import {readdirSync, readFileSync} from 'fs';
 import {join} from 'path';
 
 const SRC_DIR = join(__dirname, '..');
@@ -129,8 +129,9 @@ function discoverComponents(): ComponentInfo[] {
 
   for (const dir of dirs) {
     const dirPath = join(SRC_DIR, dir);
+    const dirEntries = readdirSync(dirPath);
     // Find source files with component vars (.tsx and .ts, excluding tests/docs)
-    const sourceFiles = readdirSync(dirPath)
+    const sourceFiles = dirEntries
       .filter(
         f =>
           (f.endsWith('.tsx') || f.endsWith('.ts')) &&
@@ -150,11 +151,15 @@ function discoverComponents(): ComponentInfo[] {
       continue;
     }
 
-    // Only check component directories (those with a doc file)
-    const docPath = join(dirPath, `${dir}.doc.mjs`);
-    if (!existsSync(docPath)) {
+    // Only check component directories (those with a doc file named after the
+    // directory). Match against the on-disk listing rather than existsSync so
+    // the comparison is case-exact everywhere — on case-insensitive
+    // filesystems (macOS, Windows) existsSync('theme/theme.doc.mjs') matches
+    // theme/Theme.doc.mjs and pulls in a directory that CI never checks.
+    if (!dirEntries.includes(`${dir}.doc.mjs`)) {
       continue;
     }
+    const docPath = join(dirPath, `${dir}.doc.mjs`);
 
     let docVars: string[] = [];
     let docDerived: DerivedDocEntry[] = [];

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"useCalendarRovingTabindex.d.ts","sourceRoot":"","sources":["../../../src/Calendar/hooks/useCalendarRovingTabindex.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAC,KAAK,SAAS,EAAiB,MAAM,uBAAuB,CAAC;AACrE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,gCAAgC;IAC/C,2BAA2B;IAC3B,IAAI,EAAE,WAAW,EAAE,CAAC;IACpB,kCAAkC;IAClC,KAAK,EAAE,SAAS,CAAC;IACjB,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,cAAc,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,CAAC;IAC7C,uCAAuC;IACvC,YAAY,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C,2DAA2D;IAC3D,YAAY,EAAE,aAAa,GAAG,IAAI,CAAC;IACnC,mDAAmD;IACnD,UAAU,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC;CAC7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,gCAAgC,GACxC,+BAA+B,CA0CjC"}

package/dist/Calendar/hooks/useCalendarRovingTabindex.js

@@ -1,96 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-'use client';
-
-/**
- * @file useCalendarRovingTabindex.ts
- * @input Uses React useMemo, PlainDate utilities
- * @output Exports useCalendarRovingTabindex hook for accessible grid navigation
- * @position Calendar-specific hook; used by Calendar
- *
- * SYNC: When modified, update:
- * - /packages/core/src/Calendar/hooks/index.ts
- */
-import { useMemo } from 'react';
-import { plainDateToISO } from "../../utils/plainDate.js";
-
-/**
- * Configuration for calendar roving tabindex
- */
-
-/**
- * Return type for useCalendarRovingTabindex hook
- */
-
-/**
- * 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 function useCalendarRovingTabindex(options) {
-  const {
-    days,
-    today,
-    year,
-    month,
-    isDateDisabled,
-    selectedDate
-  } = options;
-
-  // Determine which day should be tabbable
-  const tabbableDate = useMemo(() => {
-    // Priority 1: Selected date if visible in this month and enabled
-    if (selectedDate) {
-      const isSelectedInMonth = selectedDate.year === year && selectedDate.month === month;
-      if (isSelectedInMonth && !isDateDisabled(selectedDate)) {
-        return plainDateToISO(selectedDate);
-      }
-    }
-
-    // Priority 2: Today if visible in this month and enabled
-    const isTodayInMonth = today.year === year && today.month === month;
-    if (isTodayInMonth && !isDateDisabled(today)) {
-      return plainDateToISO(today);
-    }
-
-    // Priority 3: First enabled day in this month
-    for (const day of days) {
-      if (!day.isOutside && !isDateDisabled(day.date)) {
-        return day.iso;
-      }
-    }
-    return null;
-  }, [days, today, year, month, isDateDisabled, selectedDate]);
-
-  // Check if a specific date is tabbable
-  const isTabbable = useMemo(() => {
-    return iso => {
-      return tabbableDate !== null && iso === tabbableDate;
-    };
-  }, [tabbableDate]);
-  return {
-    tabbableDate,
-    isTabbable
-  };
-}