@salt-ds/core 1.59.1 → 1.61.0

package/dist-types/tabs/internal/contexts/TabSlotRegistryContext.d.ts

@@ -0,0 +1,5 @@
+export interface TabSlotRegistryContextValue {
+    registerSlot: (slotId: string, element: HTMLDivElement | null) => void;
+}
+export declare const TabSlotRegistryContext: import("react").Context<TabSlotRegistryContextValue | null>;
+export declare function useTabSlotRegistry(): TabSlotRegistryContextValue | null;

package/dist-types/tabs/internal/contexts/TabsContext.d.ts

@@ -0,0 +1,43 @@
+import { type Dispatch, type MutableRefObject, type SetStateAction, type SyntheticEvent } from "react";
+import type { useCollection } from "../registry/useCollection";
+export interface Item {
+    id: string;
+    value: string;
+    element: HTMLElement | null;
+    location?: "hidden" | "main" | "overflow";
+    order?: number;
+}
+export interface RenderedTab {
+    host: HTMLDivElement;
+    id: string;
+    marker: HTMLElement | null;
+    root: HTMLElement | null;
+    trigger: HTMLButtonElement | null;
+    value: string;
+    width: number;
+}
+export type TabsRenderMode = "inline" | "portal";
+export interface TabsContextValue extends Omit<ReturnType<typeof useCollection>, "registerItem" | "updateItem"> {
+    renderMode: TabsRenderMode;
+    registerBootstrapTab: (value: string) => () => void;
+    setBootstrapTabReady: (value: string, ready: boolean) => void;
+    setBootstrapOverflowReady: (ready: boolean) => void;
+    registerTab: (item: Item) => () => void;
+    updateTab: (id: string, updates: Partial<Omit<Item, "id" | "value">>) => void;
+    registerRenderedTab: (tab: RenderedTab) => () => void;
+    updateRenderedTab: (value: string, updates: Partial<Omit<RenderedTab, "value">>) => void;
+    getRenderedTab: (value: string) => RenderedTab | undefined;
+    getRenderedTabOrder: (value: string) => number;
+    renderedTabs: RenderedTab[];
+    registerPanel: (id: string, value: string) => () => void;
+    getPanelId: (value: string) => string | undefined;
+    getTabId: (value: string) => string | undefined;
+    selected?: string;
+    setSelected: (event: SyntheticEvent | null, value: string, source?: "main" | "overflow") => void;
+    activeTab: MutableRefObject<Pick<Item, "id" | "value"> | undefined>;
+    selectionFromOverflowValueRef: MutableRefObject<string | null>;
+    menuOpen: boolean;
+    setMenuOpen: Dispatch<SetStateAction<boolean>>;
+}
+export declare const TabsContext: import("react").Context<TabsContextValue>;
+export declare function useTabs(): TabsContextValue;

package/dist-types/tabs/internal/hooks/useFocusWithRetry.d.ts

@@ -0,0 +1,9 @@
+interface UseFocusWithRetryArgs {
+    maxAttempts?: number;
+    targetWindow: Window | null | undefined;
+}
+export declare function useFocusWithRetry({ maxAttempts, targetWindow, }: UseFocusWithRetryArgs): {
+    cancelScheduledFocus: () => void;
+    focusElementWithRetry: (getElement: () => HTMLElement | null | undefined) => void;
+};
+export {};

package/dist-types/tabs/internal/hooks/useTabListRecovery.d.ts

@@ -0,0 +1,12 @@
+import { type MutableRefObject, type RefObject } from "react";
+interface UseTabListRecoveryArgs {
+    removalVersion: number;
+    targetWindow: Window | null | undefined;
+    tabstripRef: RefObject<HTMLDivElement | null>;
+    overflowListRef: RefObject<HTMLDivElement | null>;
+    handleTabRemoval: () => void;
+    pendingRemovalRecoveryRef: MutableRefObject<boolean>;
+    pendingRemovalRecoveryRetriesRef: MutableRefObject<number>;
+}
+export declare function useTabListRecovery({ removalVersion, targetWindow, tabstripRef, overflowListRef, handleTabRemoval, pendingRemovalRecoveryRef, pendingRemovalRecoveryRetriesRef, }: UseTabListRecoveryArgs): void;
+export {};

package/dist-types/tabs/internal/hooks/useTabRemovalHandler.d.ts

@@ -0,0 +1,32 @@
+import { type MutableRefObject, type RefObject } from "react";
+import type { Item, TabsContextValue } from "../contexts/TabsContext";
+interface RemovedItem {
+    id: string;
+    value: string;
+    staleIndex?: number;
+}
+interface UseTabRemovalHandlerArgs {
+    activeTab: MutableRefObject<Pick<Item, "id" | "value"> | undefined>;
+    focusElementWithRetry: (getElement: () => HTMLElement | null | undefined) => void;
+    getFirst: TabsContextValue["getFirst"];
+    getIndex: TabsContextValue["getIndex"];
+    getLast: TabsContextValue["getLast"];
+    getRemovedItems: () => Map<string, RemovedItem>;
+    getRenderedTab: TabsContextValue["getRenderedTab"];
+    getSelectedTabElement: () => HTMLElement | null | undefined;
+    item: TabsContextValue["item"];
+    itemAt: TabsContextValue["itemAt"];
+    maxRetryAttempts: number;
+    menuOpen: boolean;
+    overflowButtonRef: RefObject<HTMLButtonElement | null>;
+    overflowListRef: RefObject<HTMLDivElement | null>;
+    pendingRemovalRecoveryRef: MutableRefObject<boolean>;
+    pendingRemovalRecoveryRetriesRef: MutableRefObject<number>;
+    removalRecoveryRafRef: MutableRefObject<number | null>;
+    selected?: string;
+    setSelected: TabsContextValue["setSelected"];
+    tabstripRef: RefObject<HTMLDivElement | null>;
+    targetWindow: Window | null | undefined;
+}
+export declare function useTabRemovalHandler({ activeTab, focusElementWithRetry, getFirst, getIndex, getLast, getRemovedItems, getRenderedTab, getSelectedTabElement, item, itemAt, maxRetryAttempts, menuOpen, overflowButtonRef, overflowListRef, pendingRemovalRecoveryRef, pendingRemovalRecoveryRetriesRef, removalRecoveryRafRef, selected, setSelected, tabstripRef, targetWindow, }: UseTabRemovalHandlerArgs): () => void;
+export {};

package/dist-types/tabs/internal/hooks/useTabSelectionFocus.d.ts

@@ -0,0 +1,15 @@
+import type { MutableRefObject } from "react";
+import type { TabsContextValue } from "../contexts/TabsContext";
+interface UseTabSelectionFocusArgs {
+    announce: (message: string, timeout?: number) => void;
+    focusElementWithRetry: (getElement: () => HTMLElement | null | undefined) => void;
+    getRenderedTab: TabsContextValue["getRenderedTab"];
+    getSelectedTabElement: () => HTMLElement | null | undefined;
+    menuOpen: boolean;
+    resolvedOverflowActiveValue: string | null;
+    selected?: string;
+    selectionFromOverflowValueRef: MutableRefObject<string | null>;
+    targetWindow: Window | null | undefined;
+}
+export declare function useTabSelectionFocus({ announce, focusElementWithRetry, getRenderedTab, getSelectedTabElement, menuOpen, resolvedOverflowActiveValue, selected, selectionFromOverflowValueRef, targetWindow, }: UseTabSelectionFocusArgs): void;
+export {};

package/dist-types/tabs/internal/overflow/TabOverflowList.d.ts

@@ -0,0 +1,10 @@
+import { type ComponentPropsWithoutRef, type Dispatch, type Ref, type SetStateAction } from "react";
+interface TabOverflowListProps extends ComponentPropsWithoutRef<"button"> {
+    buttonRef?: Ref<HTMLButtonElement>;
+    hiddenValues: string[];
+    open: boolean;
+    setOpen: Dispatch<SetStateAction<boolean>>;
+    order: number;
+}
+export declare const TabOverflowList: import("react").ForwardRefExoticComponent<TabOverflowListProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist-types/tabs/internal/overflow/TabSlot.d.ts

@@ -0,0 +1,6 @@
+import { type ComponentPropsWithoutRef } from "react";
+export interface TabSlotProps extends ComponentPropsWithoutRef<"div"> {
+    slotId: string;
+    value: string;
+}
+export declare function TabSlot({ slotId, value, ...rest }: TabSlotProps): import("react/jsx-runtime").JSX.Element;

package/dist-types/tabs/internal/overflow/overflowMath.d.ts

@@ -0,0 +1,18 @@
+export declare const MIN_TRUSTED_TAB_WIDTH = 0.5;
+export interface MeasuredOverflowTab {
+    value: string;
+    width: number | null;
+}
+interface CalculateVisibleCountProps {
+    gap: number;
+    maxWidth: number;
+    overflowWidth: number;
+    pinnedValue?: string;
+    tabs: MeasuredOverflowTab[];
+}
+export declare function calculateVisibleCount({ gap, maxWidth: initialMaxWidth, overflowWidth, pinnedValue, tabs, }: CalculateVisibleCountProps): number | null;
+export declare function partitionVisibleValues(orderedValues: string[], visibleCount: number, pinnedValue?: string): {
+    visibleValues: string[];
+    hiddenValues: string[];
+};
+export {};

package/dist-types/tabs/internal/overflow/useOverflow.d.ts

@@ -0,0 +1,11 @@
+import { type RefObject } from "react";
+import type { RenderedTab } from "../contexts/TabsContext";
+interface UseOverflowProps {
+    container: RefObject<HTMLElement>;
+    selected?: string;
+    tabs: RenderedTab[];
+    overflowButton: RefObject<HTMLButtonElement>;
+    menuOpen: boolean;
+}
+export declare function useOverflow({ container, overflowButton, tabs, selected, menuOpen, }: UseOverflowProps): readonly [string[], string[], boolean];
+export {};

package/dist-types/tabs/internal/overflow/useOverflowLayoutState.d.ts

@@ -0,0 +1,13 @@
+import type { TabListLayoutContextValue } from "../contexts/TabListLayoutContext";
+interface UseOverflowLayoutStateArgs {
+    hiddenValues: string[];
+    menuOpen: boolean;
+    overflowMenuOpen: boolean;
+    visibleValues: string[];
+}
+interface UseOverflowLayoutStateResult {
+    resolvedOverflowActiveValue: string | null;
+    tabListLayoutContext: TabListLayoutContextValue;
+}
+export declare function useOverflowLayoutState({ hiddenValues, menuOpen, overflowMenuOpen, visibleValues, }: UseOverflowLayoutStateArgs): UseOverflowLayoutStateResult;
+export {};

package/dist-types/tabs/internal/overflow/useOverflowSelectionState.d.ts

@@ -0,0 +1,13 @@
+import { type Dispatch, type MutableRefObject, type SetStateAction, type SyntheticEvent } from "react";
+interface UseOverflowSelectionStateArgs {
+    commitSelection: (event: SyntheticEvent | null, value: string) => void;
+    menuOpen: boolean;
+    selected?: string;
+    setMenuOpen: Dispatch<SetStateAction<boolean>>;
+}
+interface UseOverflowSelectionStateResult {
+    selectionFromOverflowValueRef: MutableRefObject<string | null>;
+    setSelected: (event: SyntheticEvent | null, value: string, source?: "main" | "overflow") => void;
+}
+export declare function useOverflowSelectionState({ commitSelection, menuOpen, selected, setMenuOpen, }: UseOverflowSelectionStateArgs): UseOverflowSelectionStateResult;
+export {};

package/dist-types/tabs/internal/overflow/useRenderedTabWidth.d.ts

@@ -0,0 +1,12 @@
+import { type RefObject } from "react";
+import type { TabsContextValue, TabsRenderMode } from "../contexts/TabsContext";
+interface UseRenderedTabWidthProps {
+    hostElement: HTMLDivElement | null;
+    renderMode: TabsRenderMode;
+    tabRootRef: RefObject<HTMLDivElement>;
+    targetWindow: Window | null | undefined;
+    updateRenderedTab: TabsContextValue["updateRenderedTab"];
+    value: string;
+}
+export declare function useRenderedTabWidth({ hostElement, renderMode, tabRootRef, targetWindow, updateRenderedTab, value, }: UseRenderedTabWidthProps): void;
+export {};

package/dist-types/tabs/internal/overflow/widthMeasurement.d.ts

@@ -0,0 +1,5 @@
+export declare function getMeasuredWidth(element: HTMLElement | null | undefined): number;
+export declare function getIntrinsicMeasuredWidth(element: HTMLElement | null | undefined): number;
+export declare function getGapValue(styles: CSSStyleDeclaration): number;
+export declare function seedWidthMap(elements: HTMLElement[]): Map<HTMLElement, number>;
+export declare function updateWidthMap(widths: Map<HTMLElement, number>, element: HTMLElement, nextWidth: number, epsilon?: number): boolean;

package/dist-types/tabs/internal/registry/useCollection.d.ts

@@ -0,0 +1,30 @@
+export interface Item {
+    id: string;
+    element?: HTMLElement | null;
+    value: string;
+    location?: "hidden" | "main" | "overflow";
+    order?: number;
+    stale?: boolean;
+}
+interface StaleItem extends Item {
+    staleIndex?: number;
+}
+interface UseCollectionProps {
+    targetWindow: Window | null | undefined;
+    wrap: boolean;
+}
+export declare function useCollection({ wrap, targetWindow }: UseCollectionProps): {
+    registerItem: (item: Item) => () => void;
+    item: (id?: string | null) => Item | null;
+    getNext: (current: string) => Item | null;
+    getPrevious: (current: string) => Item | null;
+    getFirst: () => Item | null;
+    getLast: () => Item | null;
+    getIndex: (current: string) => number;
+    itemAt: (index: number) => Item | null;
+    updateItem: (id: string, updates: Partial<Omit<Item, "id" | "value">>) => void;
+    getRemovedItems: () => Map<string, StaleItem>;
+    removalVersion: number;
+    sortItems: () => void;
+};
+export {};

package/dist-types/tabs/internal/registry/useRenderedTabsRegistry.d.ts

@@ -0,0 +1,12 @@
+import type { RenderedTab, TabsRenderMode } from "../contexts/TabsContext";
+export declare function useRenderedTabsRegistry(): {
+    renderMode: TabsRenderMode;
+    registerBootstrapTab: (tabValue: string) => () => void;
+    setBootstrapTabReady: (tabValue: string, ready: boolean) => void;
+    setBootstrapOverflowReady: (ready: boolean) => void;
+    registerRenderedTab: (tab: RenderedTab) => () => void;
+    updateRenderedTab: (value: string, updates: Partial<Omit<RenderedTab, "value">>) => void;
+    getRenderedTab: (value: string) => RenderedTab | undefined;
+    getRenderedTabOrder: (value: string) => number;
+    renderedTabs: RenderedTab[];
+};

package/dist-types/tabs/internal/utils/domUtils.d.ts

@@ -0,0 +1 @@
+export declare function isHTMLElement(node: unknown): node is HTMLElement;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salt-ds/core",
-  "version": "1.59.1",
+  "version": "1.61.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -22,6 +22,8 @@
     "@salt-ds/styles": "0.3.0",
     "@salt-ds/window": "0.1.1",
     "clsx": "^2.0.0",
+    "dom-accessibility-api": "^0.7.1",
+    "tabbable": "^6.0.0",
     "use-sync-external-store": "^1.5.0"
   },
   "peerDependencies": {