Tu/Outlook_Addin_LLM
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
Outlook_Addin_LLM/node_modules/tabster/dist/index.d.ts

1357 lines
57 KiB
TypeScript
Raw Permalink Normal View History

First version with simple frontend and Compose Email by AI
2024-11-29 21:36:41 +01:00
/*!
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
declare const TABSTER_ATTRIBUTE_NAME: "data-tabster";
declare const TABSTER_DUMMY_INPUT_ATTRIBUTE_NAME: "data-tabster-dummy";
declare const FOCUSABLE_SELECTOR: string;
declare const AsyncFocusSources$1: {
readonly EscapeGroupper: 1;
readonly Restorer: 2;
readonly Deloser: 3;
};
declare const ObservedElementAccessibilities$1: {
readonly Any: 0;
readonly Accessible: 1;
readonly Focusable: 2;
};
declare const RestoreFocusOrders$1: {
readonly History: 0;
readonly DeloserDefault: 1;
readonly RootDefault: 2;
readonly DeloserFirst: 3;
readonly RootFirst: 4;
};
declare const DeloserStrategies$1: {
/**
* If the focus is lost, the focus will be restored automatically using all available focus history.
* This is the default strategy.
*/
readonly Auto: 0;
/**
* If the focus is lost from this Deloser instance, the focus will not be restored automatically.
* The application might listen to the event and restore the focus manually.
* But if it is lost from another Deloser instance, the history of this Deloser could be used finding
* the element to focus.
*/
readonly Manual: 1;
};
declare const Visibilities$1: {
readonly Invisible: 0;
readonly PartiallyVisible: 1;
readonly Visible: 2;
};
declare const RestorerTypes$1: {
readonly Source: 0;
readonly Target: 1;
};
declare const MoverDirections$1: {
readonly Both: 0;
readonly Vertical: 1;
readonly Horizontal: 2;
readonly Grid: 3;
readonly GridLinear: 4;
};
declare const MoverKeys$1: {
readonly ArrowUp: 1;
readonly ArrowDown: 2;
readonly ArrowLeft: 3;
readonly ArrowRight: 4;
readonly PageUp: 5;
readonly PageDown: 6;
readonly Home: 7;
readonly End: 8;
};
declare const GroupperTabbabilities$1: {
readonly Unlimited: 0;
readonly Limited: 1;
readonly LimitedTrapFocus: 2;
};
declare const GroupperMoveFocusActions$1: {
readonly Enter: 1;
readonly Escape: 2;
};
declare const SysDummyInputsPositions$1: {
readonly Auto: 0;
readonly Inside: 1;
readonly Outside: 2;
};
/*!
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
interface HTMLElementWithTabsterFlags extends HTMLElement {
__tabsterElementFlags?: {
/**
* @deprecated This option is added to support interop between Fluent UI V9 and Fluent UI V8.
* Once Fluent UI V8 is not supported anymore, this option should be removed.
*/
noDirectAriaHidden?: boolean;
};
}
interface TabsterDOMAttribute {
[TABSTER_ATTRIBUTE_NAME]: string | undefined;
}
interface TabsterCoreProps {
autoRoot?: RootProps;
/**
* Allows all tab key presses under the tabster root to be controlled by tabster
* @default true
*/
controlTab?: boolean;
/**
* When controlTab is false, Root doesn't have dummy inputs by default.
* This option allows to enable dummy inputs on Root.
*/
rootDummyInputs?: boolean;
/**
* A callback that will be called for the uncontrolled areas when Tabster wants
* to know is the uncontrolled element wants complete control (for example it
* is trapping focus) and Tabster should not interfere with handling Tab.
* If the callback returns undefined, then the default behaviour is to return
* the uncontrolled.completely value from the element. If the callback returns
* non-undefined value, the callback's value will dominate the element's
* uncontrolled.completely value.
*/
checkUncontrolledCompletely?: (element: HTMLElement, completely: boolean) => boolean | undefined;
/**
* @deprecated use checkUncontrolledCompletely.
*/
checkUncontrolledTrappingFocus?: (element: HTMLElement) => boolean;
/**
* Custom getter for parent elements. Defaults to the default .parentElement call
* Currently only used to detect tabster contexts
*/
getParent?(el: Node): Node | null;
/**
* Ability to redefine all DOM API calls used by Tabster. For example, for
* ShadowDOM support.
*/
DOMAPI?: Partial<DOMAPI>;
}
interface DOMAPI {
createMutationObserver: (callback: MutationCallback) => MutationObserver;
createTreeWalker(doc: Document, root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
getParentNode(node: Node | null | undefined): ParentNode | null;
getParentElement(element: HTMLElement | null | undefined): HTMLElement | null;
nodeContains(parent: Node | null | undefined, child: Node | null | undefined): boolean;
getActiveElement(doc: Document): Element | null;
querySelector(element: ParentNode, selector: string): Element | null;
querySelectorAll(element: ParentNode, selector: string): Element[];
getElementById(doc: Document, id: string): HTMLElement | null;
getFirstChild(node: Node | null | undefined): ChildNode | null;
getLastChild(node: Node | null | undefined): ChildNode | null;
getNextSibling(node: Node | null | undefined): ChildNode | null;
getPreviousSibling(node: Node | null | undefined): ChildNode | null;
getFirstElementChild(element: Element | null | undefined): Element | null;
getLastElementChild(element: Element | null | undefined): Element | null;
getNextElementSibling(element: Element | null | undefined): Element | null;
getPreviousElementSibling(element: Element | null | undefined): Element | null;
appendChild(parent: Node, child: Node): Node;
insertBefore(parent: Node, child: Node, referenceChild: Node | null): Node;
getSelection(ref: Node): Selection | null;
getElementsByName(referenceElement: HTMLElement, name: string): NodeListOf<HTMLElement>;
}
type GetTabster = () => TabsterCore;
type GetWindow = () => Window;
type SubscribableCallback<A, B = undefined> = (val: A, detail: B) => void;
interface Disposable {
}
interface Subscribable<A, B = undefined> {
subscribe(callback: SubscribableCallback<A, B>): void;
unsubscribe(callback: SubscribableCallback<A, B>): void;
}
interface KeyboardNavigationState extends Subscribable<boolean>, Disposable {
isNavigatingWithKeyboard(): boolean;
setNavigatingWithKeyboard(isNavigatingWithKeyboard: boolean): void;
}
interface FocusedElementDetail {
relatedTarget?: HTMLElement;
isFocusedProgrammatically?: boolean;
modalizerId?: string;
}
type AsyncFocusSources = typeof AsyncFocusSources$1;
type AsyncFocusSource = AsyncFocusSources[keyof AsyncFocusSources];
interface FocusedElementState extends Subscribable<HTMLElement | undefined, FocusedElementDetail>, Disposable {
getFocusedElement(): HTMLElement | undefined;
getLastFocusedElement(): HTMLElement | undefined;
focus(element: HTMLElement, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): boolean;
focusDefault(container: HTMLElement): boolean;
focusFirst(props: FindFirstProps): boolean;
focusLast(props: FindFirstProps): boolean;
resetFocus(container: HTMLElement): boolean;
}
interface WeakHTMLElement<D = undefined> {
get(): HTMLElement | undefined;
getData(): D | undefined;
}
interface TabsterPart<P> {
readonly id: string;
getElement(): HTMLElement | undefined;
getProps(): P;
setProps(props: P): void;
}
interface TabsterPartWithFindNextTabbable {
findNextTabbable(current?: HTMLElement, reference?: HTMLElement, isBackward?: boolean, ignoreAccessibility?: boolean): NextTabbable | null;
}
interface TabsterPartWithAcceptElement {
acceptElement(element: HTMLElement, state: FocusableAcceptElementState): number | undefined;
}
interface ObservedElementProps {
names: string[];
details?: any;
}
interface ObservedElementDetails extends ObservedElementProps {
accessibility?: ObservedElementAccessibility;
}
type ObservedElementAccessibilities = typeof ObservedElementAccessibilities$1;
type ObservedElementAccessibility = ObservedElementAccessibilities[keyof ObservedElementAccessibilities];
interface ObservedElementAsyncRequest<T> {
result: Promise<T>;
cancel(): void;
}
interface ObservedElementAPIInternal {
}
interface ObservedElementAPI extends Subscribable<HTMLElement, ObservedElementDetails>, Disposable, ObservedElementAPIInternal {
getElement(observedName: string, accessibility?: ObservedElementAccessibility): HTMLElement | null;
waitElement(observedName: string, timeout: number, accessibility?: ObservedElementAccessibility): ObservedElementAsyncRequest<HTMLElement | null>;
requestFocus(observedName: string, timeout: number): ObservedElementAsyncRequest<boolean>;
}
interface CrossOriginElement {
readonly uid: string;
readonly ownerId: string;
readonly id?: string;
readonly rootId?: string;
readonly observedName?: string;
readonly observedDetails?: string;
focus(noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
}
interface CrossOriginSentTo {
[id: string]: true;
}
interface CrossOriginTransactionTypes {
Bootstrap: 1;
FocusElement: 2;
State: 3;
GetElement: 4;
RestoreFocusInDeloser: 5;
Ping: 6;
}
type CrossOriginTransactionType = CrossOriginTransactionTypes[keyof CrossOriginTransactionTypes];
interface CrossOriginTransactionData<I, O> {
transaction: string;
type: CrossOriginTransactionType;
isResponse: boolean;
timestamp: number;
owner: string;
sentto: CrossOriginSentTo;
timeout?: number;
target?: string;
beginData?: I;
endData?: O;
}
type CrossOriginTransactionSend = (data: CrossOriginTransactionData<any, any>) => void;
interface CrossOriginMessage {
data: CrossOriginTransactionData<any, any>;
send: CrossOriginTransactionSend;
}
interface CrossOriginFocusedElementState extends Subscribable<CrossOriginElement | undefined, FocusedElementDetail>, Disposable {
focus(element: CrossOriginElement, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
focusById(elementId: string, rootId?: string, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
focusByObservedName(observedName: string, timeout?: number, rootId?: string, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
}
interface CrossOriginObservedElementState extends Subscribable<CrossOriginElement, ObservedElementProps>, Disposable {
getElement(observedName: string, accessibility?: ObservedElementAccessibility): Promise<CrossOriginElement | null>;
waitElement(observedName: string, timeout: number, accessibility?: ObservedElementAccessibility): Promise<CrossOriginElement | null>;
requestFocus(observedName: string, timeout: number): Promise<boolean>;
}
interface CrossOriginAPI {
focusedElement: CrossOriginFocusedElementState;
observedElement: CrossOriginObservedElementState;
setup(sendUp?: CrossOriginTransactionSend | null): (msg: CrossOriginMessage) => void;
isSetUp(): boolean;
dispose(): void;
}
interface OutlineProps {
areaClass: string;
outlineClass: string;
outlineColor: string;
outlineWidth: number;
zIndex: number;
}
interface OutlinedElementProps {
isIgnored?: boolean;
}
interface OutlineAPI extends Disposable {
setup(props?: Partial<OutlineProps>): void;
}
interface DeloserElementActions {
focusDefault: () => boolean;
focusFirst: () => boolean;
resetFocus: () => boolean;
clearHistory: (preserveExisting?: boolean) => void;
setSnapshot: (index: number) => void;
isActive: () => boolean;
}
type RestoreFocusOrders = typeof RestoreFocusOrders$1;
type RestoreFocusOrder = RestoreFocusOrders[keyof RestoreFocusOrders];
type DeloserStrategies = typeof DeloserStrategies$1;
type DeloserStrategy = DeloserStrategies[keyof DeloserStrategies];
interface DeloserProps {
restoreFocusOrder?: RestoreFocusOrder;
noSelectorCheck?: boolean;
strategy?: DeloserStrategy;
}
interface Deloser extends TabsterPart<DeloserProps> {
readonly uid: string;
readonly strategy: DeloserStrategy;
dispose(): void;
isActive(): boolean;
setActive(active: boolean): void;
getActions(): DeloserElementActions;
setSnapshot(index: number): void;
focusFirst(): boolean;
unshift(element: HTMLElement): void;
focusDefault(): boolean;
resetFocus(): boolean;
findAvailable(): HTMLElement | null;
clearHistory(preserveExisting?: boolean): void;
customFocusLostHandler(element: HTMLElement): boolean;
}
type DeloserConstructor = (element: HTMLElement, props: DeloserProps) => Deloser;
interface DeloserInterfaceInternal {
}
interface DeloserAPI extends DeloserInterfaceInternal, Disposable {
getActions(element: HTMLElement): DeloserElementActions | undefined;
pause(): void;
resume(restore?: boolean): void;
}
interface FocusableProps {
isDefault?: boolean;
isIgnored?: boolean;
/**
* Do not determine an element's focusability based on aria-disabled.
*/
ignoreAriaDisabled?: boolean;
/**
* Exclude element (and all subelements) from Mover navigation.
*/
excludeFromMover?: boolean;
/**
* Prevents tabster from handling the keydown event
*/
ignoreKeydown?: {
Tab?: boolean;
Escape?: boolean;
Enter?: boolean;
ArrowUp?: boolean;
ArrowDown?: boolean;
ArrowLeft?: boolean;
ArrowRight?: boolean;
PageUp?: boolean;
PageDown?: boolean;
Home?: boolean;
End?: boolean;
};
}
interface RadioButtonGroup {
name: string;
buttons: Set<HTMLInputElement>;
checked?: HTMLInputElement;
}
interface FocusableAcceptElementState {
container: HTMLElement;
modalizerUserId?: string;
currentCtx?: TabsterContext;
from: HTMLElement;
fromCtx?: TabsterContext;
isBackward?: boolean;
found?: boolean;
foundElement?: HTMLElement;
foundBackward?: HTMLElement;
rejectElementsFrom?: HTMLElement;
uncontrolled?: HTMLElement;
acceptCondition: (el: HTMLElement) => boolean;
hasCustomCondition?: boolean;
includeProgrammaticallyFocusable?: boolean;
ignoreAccessibility?: boolean;
cachedGrouppers: {
[id: string]: {
isActive: boolean | undefined;
first?: HTMLElement | null;
};
};
cachedRadioGroups: {
[name: string]: RadioButtonGroup;
};
isFindAll?: boolean;
/**
* A flag that indicates that some focusable elements were skipped
* during the search and the found element is not the one the browser
* would normally focus if the user pressed Tab.
*/
skippedFocusable?: boolean;
}
interface FindFocusableProps {
/**
* The container used for the search.
*/
container: HTMLElement;
/**
* The elemet to start from.
*/
currentElement?: HTMLElement;
/**
* See `referenceElement` of GetTabsterContextOptions for description.
*/
referenceElement?: HTMLElement;
/**
* Includes elements that can be focused programmatically.
*/
includeProgrammaticallyFocusable?: boolean;
/**
* Ignore accessibility check.
*/
ignoreAccessibility?: boolean;
/**
* Take active modalizer into account when searching for elements
* (the elements out of active modalizer will not be returned).
*/
useActiveModalizer?: boolean;
/**
* Search withing the specified modality, null for everything outside of modalizers, string within
* a specific id, undefined for search within the current application state.
*/
modalizerId?: string | null;
/**
* If true, find previous element instead of the next one.
*/
isBackward?: boolean;
/**
* @param el element visited.
* @returns if an element should be accepted.
*/
acceptCondition?(el: HTMLElement): boolean;
/**
* A callback that will be called for every focusable element found during findAll().
* If false is returned from this callback, the search will stop.
*/
onElement?: FindElementCallback;
}
interface FindFocusableOutputProps {
/**
* An output parameter. Will be true after the findNext/findPrev() call if some focusable
* elements were skipped during the search and the result element not immediately next
* focusable after the currentElement.
*/
outOfDOMOrder?: boolean;
/**
* An output parameter. Will be true if the found element is uncontrolled.
*/
uncontrolled?: HTMLElement | null;
}
type FindFirstProps = Pick<FindFocusableProps, "container" | "modalizerId" | "includeProgrammaticallyFocusable" | "useActiveModalizer" | "ignoreAccessibility">;
type FindNextProps = Pick<FindFocusableProps, "currentElement" | "referenceElement" | "container" | "modalizerId" | "includeProgrammaticallyFocusable" | "useActiveModalizer" | "ignoreAccessibility">;
type FindDefaultProps = Pick<FindFocusableProps, "container" | "modalizerId" | "includeProgrammaticallyFocusable" | "useActiveModalizer" | "ignoreAccessibility">;
type FindAllProps = Pick<FindFocusableProps, "container" | "modalizerId" | "currentElement" | "isBackward" | "includeProgrammaticallyFocusable" | "useActiveModalizer" | "acceptCondition" | "ignoreAccessibility" | "onElement">;
/**
* A callback that is called for every found element during search. Returning false stops search.
*/
type FindElementCallback = (element: HTMLElement) => boolean;
interface FocusableAPI extends Disposable {
getProps(element: HTMLElement): FocusableProps;
isFocusable(element: HTMLElement, includeProgrammaticallyFocusable?: boolean, noVisibleCheck?: boolean, noAccessibleCheck?: boolean): boolean;
isVisible(element: HTMLElement): boolean;
isAccessible(element: HTMLElement): boolean;
findFirst(options: FindFirstProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
findLast(options: FindFirstProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
findNext(options: FindNextProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
findPrev(options: FindNextProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
findDefault(options: FindDefaultProps, out?: FindFocusableOutputProps): HTMLElement | null;
/**
* @returns All focusables in a given context that satisfy an given condition
*/
findAll(options: FindAllProps): HTMLElement[];
findElement(options: FindFocusableProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
}
interface DummyInputManager {
moveOut: (backwards: boolean) => void;
moveOutWithDefaultAction: (backwards: boolean, relatedEvent: KeyboardEvent) => void;
}
type Visibilities = typeof Visibilities$1;
type Visibility = Visibilities[keyof Visibilities];
interface MoverElementState {
isCurrent: boolean | undefined;
visibility: Visibility;
}
type RestorerTypes = typeof RestorerTypes$1;
type RestorerType = RestorerTypes[keyof RestorerTypes];
type MoverDirections = typeof MoverDirections$1;
type MoverDirection = MoverDirections[keyof MoverDirections];
interface NextTabbable {
element: HTMLElement | null | undefined;
uncontrolled?: HTMLElement | null;
outOfDOMOrder?: boolean;
}
interface MoverProps {
direction?: MoverDirection;
memorizeCurrent?: boolean;
tabbable?: boolean;
/**
* Whether to allow cyclic navigation in the mover
* Can only be applied if navigationType is MoverKeys.Arrows
*
* @defaultValue false
*/
cyclic?: boolean;
/**
* In case we need a rich state of the elements inside a Mover,
* we can track it. It takes extra resourses and might affect
* performance when a Mover has many elements inside, so make sure
* you use this prop when it is really needed.
*/
trackState?: boolean;
/**
* When set to Visibility.Visible or Visibility.PartiallyVisible,
* uses the visibility part of the trackState prop to be able to
* go to first/last visible element (instead of first/last focusable
* element in DOM) when tabbing from outside of the mover.
*/
visibilityAware?: Visibility;
/**
* When true, Mover will try to locate a focusable with Focusable.isDefault
* property as a prioritized element to focus. True by default.
*/
hasDefault?: boolean;
/**
* A value between 0 and 1 that specifies the tolerance allowed
* when testing for visibility.
*
* @example
* an element of height 100px has 10px that are above the viewport
* hidden by scroll. This element is a valid visible element to focus.
*
* @default 0.8
*/
visibilityTolerance?: number;
}
interface Mover extends TabsterPart<MoverProps>, TabsterPartWithFindNextTabbable, TabsterPartWithAcceptElement {
readonly id: string;
readonly dummyManager: DummyInputManager | undefined;
readonly visibilityTolerance: NonNullable<MoverProps["visibilityTolerance"]>;
dispose(): void;
setCurrent(element: HTMLElement | undefined): void;
getCurrent(): HTMLElement | null;
getState(element: HTMLElement): MoverElementState | undefined;
}
type MoverConstructor = (tabster: TabsterCore, element: HTMLElement, props: MoverProps) => Mover;
interface MoverAPIInternal {
}
type MoverKeys = typeof MoverKeys$1;
type MoverKey = MoverKeys[keyof MoverKeys];
interface MoverAPI extends MoverAPIInternal, Disposable {
}
type GroupperTabbabilities = typeof GroupperTabbabilities$1;
type GroupperTabbability = GroupperTabbabilities[keyof GroupperTabbabilities];
interface GroupperProps {
tabbability?: GroupperTabbability;
delegated?: boolean;
}
interface Groupper extends TabsterPart<GroupperProps>, TabsterPartWithFindNextTabbable, TabsterPartWithAcceptElement {
readonly id: string;
readonly dummyManager: DummyInputManager | undefined;
dispose(): void;
makeTabbable(isUnlimited: boolean): void;
isActive(noIfFirstIsFocused?: boolean): boolean | undefined;
setFirst(element: HTMLElement | undefined): void;
getFirst(orContainer: boolean): HTMLElement | undefined;
}
type GroupperConstructor = (tabster: TabsterCore, element: HTMLElement, props: GroupperProps) => Groupper;
type GroupperMoveFocusActions = typeof GroupperMoveFocusActions$1;
type GroupperMoveFocusAction = GroupperMoveFocusActions[keyof GroupperMoveFocusActions];
interface GroupperAPI extends GroupperAPIInternal, Disposable {
}
interface GroupperAPIInternal {
}
interface GroupperAPIInternal {
forgetCurrentGrouppers(): void;
}
interface ModalizerProps {
id: string;
isOthersAccessible?: boolean;
isAlwaysAccessible?: boolean;
isNoFocusFirst?: boolean;
isNoFocusDefault?: boolean;
/** A focus trap variant, keeps focus inside the modal when tabbing */
isTrapped?: boolean;
}
interface Modalizer extends TabsterPart<ModalizerProps>, TabsterPartWithFindNextTabbable {
readonly userId: string;
readonly dummyManager: DummyInputManager | undefined;
/**
* @returns - Whether the element is inside the modalizer
*/
contains(element: HTMLElement): boolean;
dispose(): void;
isActive(): boolean;
makeActive(isActive: boolean): void;
focused(noIncrement?: boolean): number;
}
type ModalizerConstructor = (tabster: TabsterCore, element: HTMLElement, props: ModalizerProps) => Modalizer;
interface RootProps {
restoreFocusOrder?: RestoreFocusOrder;
}
interface Root extends TabsterPart<RootProps> {
readonly uid: string;
dispose(): void;
moveOutWithDefaultAction(backwards: boolean, relatedEvent: KeyboardEvent): void;
}
type RootConstructor = (tabster: TabsterCore, element: HTMLElement, props: RootProps) => Root;
type SysDummyInputsPositions = typeof SysDummyInputsPositions$1;
type SysDummyInputsPosition = SysDummyInputsPositions[keyof SysDummyInputsPositions];
/**
* Ability to fine-tune Tabster internal behaviour in rare cases of need.
* Normally, should not be used. A deep understanding of the intention and the effect
* is required.
*/
interface SysProps {
/**
* Force dummy input position outside or inside of the element.
* By default (when undefined), the position is determined dynamically
* (for example inside for <li> elements and outside for <table> elements,
* plus a default Groupper/Mover/Modalizer implementation position).
* Setting to true will force the dummy inputs to be always outside of the element,
* setting to false will force the dummy inputs to be always inside.
*/
dummyInputsPosition?: SysDummyInputsPosition;
}
interface GetTabsterContextOptions {
/**
* Should visit **all** element ancestors to verify if `dir='rtl'` is set
*/
checkRtl?: boolean;
/**
* The element to start computing the context from. Useful when dealing
* with nested structures. For example, if we have an element inside a groupper
* inside another groupper, the `groupper` prop in this element's contexts will
* be the inner groupper, but when we pass the inner groupper's parent element
* as `referenceElement`, the context groupper will be the outer one. Having
* this option simplifies searching for the next tabbable element in the
* environment of nested movers and grouppers.
*/
referenceElement?: HTMLElement;
}
type TabsterContextMoverGroupper = {
isMover: true;
mover: Mover;
} | {
isMover: false;
groupper: Groupper;
};
interface TabsterContext {
root: Root;
modalizer?: Modalizer;
groupper?: Groupper;
mover?: Mover;
groupperBeforeMover?: boolean;
modalizerInGroupper?: Groupper;
/**
* Whether `dir='rtl'` is set on an ancestor
*/
rtl?: boolean;
excludedFromMover?: boolean;
uncontrolled?: HTMLElement | null;
ignoreKeydown: (e: KeyboardEvent) => boolean;
}
interface RootAPIInternal {
}
interface RootAPI extends Disposable, RootAPIInternal {
}
interface UncontrolledAPI {
isUncontrolledCompletely(element: HTMLElement, completely: boolean): boolean;
}
interface ModalizerAPIInternal extends TabsterPartWithAcceptElement {
}
interface ModalizerAPI extends ModalizerAPIInternal, Disposable {
/**
* Activates a Modalizer and focuses the first or default element within
*
* @param elementFromModalizer An element that belongs to a Modalizer
* @param noFocusFirst Do not focus on the first element in the Modalizer
* @param noFocusDefault Do not focus the default element in the Modalizre
*/
focus(elementFromModalizer: HTMLElement, noFocusFirst?: boolean, noFocusDefault?: boolean): boolean;
}
interface RestorerAPIInternal {
}
interface RestorerAPI extends RestorerAPIInternal, Disposable {
}
interface Restorer extends Disposable, TabsterPart<RestorerProps> {
}
/**
* A signature for the accessibleCheck callback from getModalizer().
* It is called when active Modalizer sets aria-hidden on elements outsidef of it.
*
* @param element The element that is about to receive aria-hidden.
* @param activeModalizerElements The container elements of the active modalizer.
* @returns true if the element should remain accessible and should not receive
* aria-hidden.
*/
type ModalizerElementAccessibleCheck = (element: HTMLElement, activeModalizerElements?: HTMLElement[]) => boolean;
interface UncontrolledProps {
completely?: boolean;
}
interface DeloserOnElement {
deloser: Deloser;
}
interface RootOnElement {
root: Root;
}
interface ModalizerOnElement {
modalizer: Modalizer;
}
interface RestorerOnElement {
restorer: Restorer;
}
interface FocusableOnElement {
focusable: FocusableProps;
}
interface MoverOnElement {
mover: Mover;
}
interface GroupperOnElement {
groupper: Groupper;
}
interface UncontrolledOnElement {
uncontrolled: UncontrolledProps;
}
interface ObservedOnElement {
observed: ObservedElementProps;
}
interface OutlineOnElement {
outline: OutlinedElementProps;
}
interface SysOnElement {
sys: SysProps;
}
interface RestorerProps {
type: RestorerType;
}
type TabsterAttributeProps = Partial<{
deloser: DeloserProps;
root: RootProps;
uncontrolled: UncontrolledProps;
modalizer: ModalizerProps;
focusable: FocusableProps;
groupper: GroupperProps;
mover: MoverProps;
observed: ObservedElementProps;
outline: OutlinedElementProps;
sys: SysProps;
restorer: RestorerProps;
}>;
interface TabsterAttributeOnElement {
string: string;
object: TabsterAttributeProps;
}
interface TabsterAugmentedAttributes {
[name: string]: string | null;
}
type TabsterOnElement = Partial<RootOnElement & DeloserOnElement & ModalizerOnElement & FocusableOnElement & MoverOnElement & GroupperOnElement & ObservedOnElement & OutlineOnElement & UncontrolledOnElement & SysOnElement & RestorerOnElement>;
interface OutlineElements {
container: HTMLDivElement;
left: HTMLDivElement;
top: HTMLDivElement;
right: HTMLDivElement;
bottom: HTMLDivElement;
}
interface TabsterElementStorageEntry {
tabster?: TabsterOnElement;
attr?: TabsterAttributeOnElement;
aug?: TabsterAugmentedAttributes;
}
interface TabsterElementStorage {
[uid: string]: TabsterElementStorageEntry;
}
type DisposeFunc = () => void;
interface InternalAPI {
stopObserver(): void;
resumeObserver(syncState: boolean): void;
}
interface DummyInputObserver {
add(dummy: HTMLElement, callback: () => void): void;
remove(dummy: HTMLElement): void;
dispose(): void;
domChanged?(parent: HTMLElement): void;
updatePositions(compute: (scrollTopLeftCache: Map<HTMLElement, {
scrollTop: number;
scrollLeft: number;
} | null>) => () => void): void;
}
interface TabsterCoreInternal {
}
interface Tabster {
keyboardNavigation: KeyboardNavigationState;
focusedElement: FocusedElementState;
focusable: FocusableAPI;
root: RootAPI;
uncontrolled: UncontrolledAPI;
}
interface TabsterCore extends Pick<TabsterCoreProps, "controlTab" | "rootDummyInputs">, Disposable, TabsterCoreInternal, Omit<Tabster, "core"> {
}
interface TabsterCompat {
attributeTransform?: <P>(old: P) => TabsterAttributeProps;
}
type Types_d_HTMLElementWithTabsterFlags = HTMLElementWithTabsterFlags;
type Types_d_TabsterDOMAttribute = TabsterDOMAttribute;
type Types_d_TabsterCoreProps = TabsterCoreProps;
type Types_d_DOMAPI = DOMAPI;
type Types_d_GetTabster = GetTabster;
type Types_d_GetWindow = GetWindow;
type Types_d_SubscribableCallback<A, B = undefined> = SubscribableCallback<A, B>;
type Types_d_Disposable = Disposable;
type Types_d_Subscribable<A, B = undefined> = Subscribable<A, B>;
type Types_d_KeyboardNavigationState = KeyboardNavigationState;
type Types_d_FocusedElementDetail = FocusedElementDetail;
type Types_d_AsyncFocusSources = AsyncFocusSources;
type Types_d_AsyncFocusSource = AsyncFocusSource;
type Types_d_FocusedElementState = FocusedElementState;
type Types_d_WeakHTMLElement<D = undefined> = WeakHTMLElement<D>;
type Types_d_TabsterPart<P> = TabsterPart<P>;
type Types_d_TabsterPartWithFindNextTabbable = TabsterPartWithFindNextTabbable;
type Types_d_TabsterPartWithAcceptElement = TabsterPartWithAcceptElement;
type Types_d_ObservedElementProps = ObservedElementProps;
type Types_d_ObservedElementDetails = ObservedElementDetails;
type Types_d_ObservedElementAccessibilities = ObservedElementAccessibilities;
type Types_d_ObservedElementAccessibility = ObservedElementAccessibility;
type Types_d_ObservedElementAsyncRequest<T> = ObservedElementAsyncRequest<T>;
type Types_d_ObservedElementAPI = ObservedElementAPI;
type Types_d_CrossOriginElement = CrossOriginElement;
type Types_d_CrossOriginSentTo = CrossOriginSentTo;
type Types_d_CrossOriginTransactionTypes = CrossOriginTransactionTypes;
type Types_d_CrossOriginTransactionType = CrossOriginTransactionType;
type Types_d_CrossOriginTransactionData<I, O> = CrossOriginTransactionData<I, O>;
type Types_d_CrossOriginTransactionSend = CrossOriginTransactionSend;
type Types_d_CrossOriginMessage = CrossOriginMessage;
type Types_d_CrossOriginFocusedElementState = CrossOriginFocusedElementState;
type Types_d_CrossOriginObservedElementState = CrossOriginObservedElementState;
type Types_d_CrossOriginAPI = CrossOriginAPI;
type Types_d_OutlineProps = OutlineProps;
type Types_d_OutlinedElementProps = OutlinedElementProps;
type Types_d_OutlineAPI = OutlineAPI;
type Types_d_DeloserElementActions = DeloserElementActions;
type Types_d_RestoreFocusOrders = RestoreFocusOrders;
type Types_d_RestoreFocusOrder = RestoreFocusOrder;
type Types_d_DeloserStrategies = DeloserStrategies;
type Types_d_DeloserStrategy = DeloserStrategy;
type Types_d_DeloserProps = DeloserProps;
type Types_d_Deloser = Deloser;
type Types_d_DeloserConstructor = DeloserConstructor;
type Types_d_DeloserAPI = DeloserAPI;
type Types_d_FocusableProps = FocusableProps;
type Types_d_RadioButtonGroup = RadioButtonGroup;
type Types_d_FocusableAcceptElementState = FocusableAcceptElementState;
type Types_d_FindFocusableProps = FindFocusableProps;
type Types_d_FindFocusableOutputProps = FindFocusableOutputProps;
type Types_d_FindFirstProps = FindFirstProps;
type Types_d_FindNextProps = FindNextProps;
type Types_d_FindDefaultProps = FindDefaultProps;
type Types_d_FindAllProps = FindAllProps;
type Types_d_FindElementCallback = FindElementCallback;
type Types_d_FocusableAPI = FocusableAPI;
type Types_d_DummyInputManager = DummyInputManager;
type Types_d_Visibilities = Visibilities;
type Types_d_Visibility = Visibility;
type Types_d_MoverElementState = MoverElementState;
type Types_d_RestorerTypes = RestorerTypes;
type Types_d_RestorerType = RestorerType;
type Types_d_MoverDirections = MoverDirections;
type Types_d_MoverDirection = MoverDirection;
type Types_d_NextTabbable = NextTabbable;
type Types_d_MoverProps = MoverProps;
type Types_d_Mover = Mover;
type Types_d_MoverConstructor = MoverConstructor;
type Types_d_MoverKeys = MoverKeys;
type Types_d_MoverKey = MoverKey;
type Types_d_MoverAPI = MoverAPI;
type Types_d_GroupperTabbabilities = GroupperTabbabilities;
type Types_d_GroupperTabbability = GroupperTabbability;
type Types_d_GroupperProps = GroupperProps;
type Types_d_Groupper = Groupper;
type Types_d_GroupperConstructor = GroupperConstructor;
type Types_d_GroupperAPIInternal = GroupperAPIInternal;
type Types_d_GroupperMoveFocusActions = GroupperMoveFocusActions;
type Types_d_GroupperMoveFocusAction = GroupperMoveFocusAction;
type Types_d_GroupperAPI = GroupperAPI;
type Types_d_ModalizerProps = ModalizerProps;
type Types_d_Modalizer = Modalizer;
type Types_d_ModalizerConstructor = ModalizerConstructor;
type Types_d_RootProps = RootProps;
type Types_d_Root = Root;
type Types_d_RootConstructor = RootConstructor;
type Types_d_SysDummyInputsPositions = SysDummyInputsPositions;
type Types_d_SysDummyInputsPosition = SysDummyInputsPosition;
type Types_d_SysProps = SysProps;
type Types_d_GetTabsterContextOptions = GetTabsterContextOptions;
type Types_d_TabsterContextMoverGroupper = TabsterContextMoverGroupper;
type Types_d_TabsterContext = TabsterContext;
type Types_d_RootAPI = RootAPI;
type Types_d_UncontrolledAPI = UncontrolledAPI;
type Types_d_ModalizerAPI = ModalizerAPI;
type Types_d_RestorerAPI = RestorerAPI;
type Types_d_Restorer = Restorer;
type Types_d_ModalizerElementAccessibleCheck = ModalizerElementAccessibleCheck;
type Types_d_UncontrolledProps = UncontrolledProps;
type Types_d_DeloserOnElement = DeloserOnElement;
type Types_d_RootOnElement = RootOnElement;
type Types_d_ModalizerOnElement = ModalizerOnElement;
type Types_d_RestorerOnElement = RestorerOnElement;
type Types_d_FocusableOnElement = FocusableOnElement;
type Types_d_MoverOnElement = MoverOnElement;
type Types_d_GroupperOnElement = GroupperOnElement;
type Types_d_UncontrolledOnElement = UncontrolledOnElement;
type Types_d_ObservedOnElement = ObservedOnElement;
type Types_d_OutlineOnElement = OutlineOnElement;
type Types_d_SysOnElement = SysOnElement;
type Types_d_RestorerProps = RestorerProps;
type Types_d_TabsterAttributeProps = TabsterAttributeProps;
type Types_d_TabsterAttributeOnElement = TabsterAttributeOnElement;
type Types_d_TabsterAugmentedAttributes = TabsterAugmentedAttributes;
type Types_d_TabsterOnElement = TabsterOnElement;
type Types_d_OutlineElements = OutlineElements;
type Types_d_TabsterElementStorageEntry = TabsterElementStorageEntry;
type Types_d_TabsterElementStorage = TabsterElementStorage;
type Types_d_DisposeFunc = DisposeFunc;
type Types_d_InternalAPI = InternalAPI;
type Types_d_DummyInputObserver = DummyInputObserver;
type Types_d_Tabster = Tabster;
type Types_d_TabsterCore = TabsterCore;
type Types_d_TabsterCompat = TabsterCompat;
declare namespace Types_d {
export {
Types_d_HTMLElementWithTabsterFlags as HTMLElementWithTabsterFlags,
Types_d_TabsterDOMAttribute as TabsterDOMAttribute,
Types_d_TabsterCoreProps as TabsterCoreProps,
Types_d_DOMAPI as DOMAPI,
Types_d_GetTabster as GetTabster,
Types_d_GetWindow as GetWindow,
Types_d_SubscribableCallback as SubscribableCallback,
Types_d_Disposable as Disposable,
Types_d_Subscribable as Subscribable,
Types_d_KeyboardNavigationState as KeyboardNavigationState,
Types_d_FocusedElementDetail as FocusedElementDetail,
Types_d_AsyncFocusSources as AsyncFocusSources,
Types_d_AsyncFocusSource as AsyncFocusSource,
Types_d_FocusedElementState as FocusedElementState,
Types_d_WeakHTMLElement as WeakHTMLElement,
Types_d_TabsterPart as TabsterPart,
Types_d_TabsterPartWithFindNextTabbable as TabsterPartWithFindNextTabbable,
Types_d_TabsterPartWithAcceptElement as TabsterPartWithAcceptElement,
Types_d_ObservedElementProps as ObservedElementProps,
Types_d_ObservedElementDetails as ObservedElementDetails,
Types_d_ObservedElementAccessibilities as ObservedElementAccessibilities,
Types_d_ObservedElementAccessibility as ObservedElementAccessibility,
Types_d_ObservedElementAsyncRequest as ObservedElementAsyncRequest,
Types_d_ObservedElementAPI as ObservedElementAPI,
Types_d_CrossOriginElement as CrossOriginElement,
Types_d_CrossOriginSentTo as CrossOriginSentTo,
Types_d_CrossOriginTransactionTypes as CrossOriginTransactionTypes,
Types_d_CrossOriginTransactionType as CrossOriginTransactionType,
Types_d_CrossOriginTransactionData as CrossOriginTransactionData,
Types_d_CrossOriginTransactionSend as CrossOriginTransactionSend,
Types_d_CrossOriginMessage as CrossOriginMessage,
Types_d_CrossOriginFocusedElementState as CrossOriginFocusedElementState,
Types_d_CrossOriginObservedElementState as CrossOriginObservedElementState,
Types_d_CrossOriginAPI as CrossOriginAPI,
Types_d_OutlineProps as OutlineProps,
Types_d_OutlinedElementProps as OutlinedElementProps,
Types_d_OutlineAPI as OutlineAPI,
Types_d_DeloserElementActions as DeloserElementActions,
Types_d_RestoreFocusOrders as RestoreFocusOrders,
Types_d_RestoreFocusOrder as RestoreFocusOrder,
Types_d_DeloserStrategies as DeloserStrategies,
Types_d_DeloserStrategy as DeloserStrategy,
Types_d_DeloserProps as DeloserProps,
Types_d_Deloser as Deloser,
Types_d_DeloserConstructor as DeloserConstructor,
Types_d_DeloserAPI as DeloserAPI,
Types_d_FocusableProps as FocusableProps,
Types_d_RadioButtonGroup as RadioButtonGroup,
Types_d_FocusableAcceptElementState as FocusableAcceptElementState,
Types_d_FindFocusableProps as FindFocusableProps,
Types_d_FindFocusableOutputProps as FindFocusableOutputProps,
Types_d_FindFirstProps as FindFirstProps,
Types_d_FindNextProps as FindNextProps,
Types_d_FindDefaultProps as FindDefaultProps,
Types_d_FindAllProps as FindAllProps,
Types_d_FindElementCallback as FindElementCallback,
Types_d_FocusableAPI as FocusableAPI,
Types_d_DummyInputManager as DummyInputManager,
Types_d_Visibilities as Visibilities,
Types_d_Visibility as Visibility,
Types_d_MoverElementState as MoverElementState,
Types_d_RestorerTypes as RestorerTypes,
Types_d_RestorerType as RestorerType,
Types_d_MoverDirections as MoverDirections,
Types_d_MoverDirection as MoverDirection,
Types_d_NextTabbable as NextTabbable,
Types_d_MoverProps as MoverProps,
Types_d_Mover as Mover,
Types_d_MoverConstructor as MoverConstructor,
Types_d_MoverKeys as MoverKeys,
Types_d_MoverKey as MoverKey,
Types_d_MoverAPI as MoverAPI,
Types_d_GroupperTabbabilities as GroupperTabbabilities,
Types_d_GroupperTabbability as GroupperTabbability,
Types_d_GroupperProps as GroupperProps,
Types_d_Groupper as Groupper,
Types_d_GroupperConstructor as GroupperConstructor,
Types_d_GroupperAPIInternal as GroupperAPIInternal,
Types_d_GroupperMoveFocusActions as GroupperMoveFocusActions,
Types_d_GroupperMoveFocusAction as GroupperMoveFocusAction,
Types_d_GroupperAPI as GroupperAPI,
Types_d_ModalizerProps as ModalizerProps,
Types_d_Modalizer as Modalizer,
Types_d_ModalizerConstructor as ModalizerConstructor,
Types_d_RootProps as RootProps,
Types_d_Root as Root,
Types_d_RootConstructor as RootConstructor,
Types_d_SysDummyInputsPositions as SysDummyInputsPositions,
Types_d_SysDummyInputsPosition as SysDummyInputsPosition,
Types_d_SysProps as SysProps,
Types_d_GetTabsterContextOptions as GetTabsterContextOptions,
Types_d_TabsterContextMoverGroupper as TabsterContextMoverGroupper,
Types_d_TabsterContext as TabsterContext,
Types_d_RootAPI as RootAPI,
Types_d_UncontrolledAPI as UncontrolledAPI,
Types_d_ModalizerAPI as ModalizerAPI,
Types_d_RestorerAPI as RestorerAPI,
Types_d_Restorer as Restorer,
Types_d_ModalizerElementAccessibleCheck as ModalizerElementAccessibleCheck,
Types_d_UncontrolledProps as UncontrolledProps,
Types_d_DeloserOnElement as DeloserOnElement,
Types_d_RootOnElement as RootOnElement,
Types_d_ModalizerOnElement as ModalizerOnElement,
Types_d_RestorerOnElement as RestorerOnElement,
Types_d_FocusableOnElement as FocusableOnElement,
Types_d_MoverOnElement as MoverOnElement,
Types_d_GroupperOnElement as GroupperOnElement,
Types_d_UncontrolledOnElement as UncontrolledOnElement,
Types_d_ObservedOnElement as ObservedOnElement,
Types_d_OutlineOnElement as OutlineOnElement,
Types_d_SysOnElement as SysOnElement,
Types_d_RestorerProps as RestorerProps,
Types_d_TabsterAttributeProps as TabsterAttributeProps,
Types_d_TabsterAttributeOnElement as TabsterAttributeOnElement,
Types_d_TabsterAugmentedAttributes as TabsterAugmentedAttributes,
Types_d_TabsterOnElement as TabsterOnElement,
Types_d_OutlineElements as OutlineElements,
Types_d_TabsterElementStorageEntry as TabsterElementStorageEntry,
Types_d_TabsterElementStorage as TabsterElementStorage,
Types_d_DisposeFunc as DisposeFunc,
Types_d_InternalAPI as InternalAPI,
Types_d_DummyInputObserver as DummyInputObserver,
Types_d_Tabster as Tabster,
Types_d_TabsterCore as TabsterCore,
Types_d_TabsterCompat as TabsterCompat,
};
}
/*!
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
/**
* If the passed element is Tabster dummy input, returns the container element this dummy input belongs to.
* @param element Element to check for being dummy input.
* @returns Dummy input container element (if the passed element is a dummy input) or null.
*/
declare function getDummyInputContainer(element: HTMLElement | null | undefined): HTMLElement | null;
/*!
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
declare function forceCleanup(tabster: Tabster): void;
/**
* Creates an instance of Tabster, returns the current window instance if it already exists.
*/
declare function createTabster(win: Window, props?: TabsterCoreProps): Tabster;
/**
* Returns an instance of Tabster if it was created before or null.
*/
declare function getTabster(win: Window): Tabster | null;
declare function getShadowDOMAPI(): DOMAPI;
/**
* Creates a new groupper instance or returns an existing one
* @param tabster Tabster instance
*/
declare function getGroupper(tabster: Tabster): GroupperAPI;
/**
* Creates a new mover instance or returns an existing one
* @param tabster Tabster instance
*/
declare function getMover(tabster: Tabster): MoverAPI;
declare function getOutline(tabster: Tabster): OutlineAPI;
/**
* Creates a new new deloser instance or returns an existing one
* @param tabster Tabster instance
* @param props Deloser props
*/
declare function getDeloser(tabster: Tabster, props?: {
autoDeloser: DeloserProps;
}): DeloserAPI;
/**
* Creates a new modalizer instance or returns an existing one
* @param tabster Tabster instance
* @param alwaysAccessibleSelector When Modalizer is active, we put
* aria-hidden to everything else to hide it from screen readers. This CSS
* selector allows to exclude some elements from this behaviour. For example,
* this could be used to exclude aria-live region with the application-wide
* status announcements.
* @param accessibleCheck An optional callback that will be called when
* active Modalizer wants to hide an element that doesn't belong to it from
* the screen readers by setting aria-hidden. Similar to alwaysAccessibleSelector
* but allows to address the elements programmatically rather than with a selector.
* If the callback returns true, the element will not receive aria-hidden.
*/
declare function getModalizer(tabster: Tabster, alwaysAccessibleSelector?: string, accessibleCheck?: ModalizerElementAccessibleCheck): ModalizerAPI;
declare function getObservedElement(tabster: Tabster): ObservedElementAPI;
declare function getCrossOrigin(tabster: Tabster): CrossOriginAPI;
declare function getInternal(tabster: Tabster): InternalAPI;
declare function getRestorer(tabster: Tabster): RestorerAPI;
declare function disposeTabster(tabster: Tabster, allInstances?: boolean): void;
/**
* Allows to make Tabster non operational. Intended for performance debugging (and other
* kinds of debugging), you can switch Tabster off without changing the application code
* that consumes it.
* @param tabster a reference created by createTabster().
* @param noop true if you want to make Tabster noop, false if you want to turn it back.
*/
declare function makeNoOp(tabster: Tabster, noop: boolean): void;
declare function isNoOp(tabster: TabsterCore): boolean;
/*!
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
declare function getTabsterAttribute(props: TabsterAttributeProps): TabsterDOMAttribute;
declare function getTabsterAttribute(props: TabsterAttributeProps, plain: true): string;
/**
* Updates Tabster props object with new props.
* @param element an element to set data-tabster attribute on.
* @param props current Tabster props to update.
* @param newProps new Tabster props to add.
* When the value of a property in newProps is undefined, the property
* will be removed from the attribute.
*/
declare function mergeTabsterProps(props: TabsterAttributeProps, newProps: TabsterAttributeProps): void;
/**
* Sets or updates Tabster attribute of the element.
* @param element an element to set data-tabster attribute on.
* @param newProps new Tabster props to set.
* @param update if true, newProps will be merged with the existing props.
* When true and the value of a property in newProps is undefined, the property
* will be removed from the attribute.
*/
declare function setTabsterAttribute(element: HTMLElement, newProps: TabsterAttributeProps, update?: boolean): void;
/*!
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
interface TabsterMoveFocusEventDetail {
by: "mover" | "groupper" | "modalizer" | "root" | "deloser";
owner: HTMLElement;
next: HTMLElement | null;
relatedEvent?: KeyboardEvent;
}
interface MoverMoveFocusEventDetail {
key: MoverKey;
}
interface MoverMemorizedElementEventDetail {
memorizedElement: HTMLElement | undefined;
}
interface GroupperMoveFocusEventDetail {
action: GroupperMoveFocusAction;
}
interface ModalizerEventDetail {
id: string;
element: HTMLElement;
}
interface RootFocusEventDetail {
element: HTMLElement;
}
type EventsTypes_d_TabsterMoveFocusEventDetail = TabsterMoveFocusEventDetail;
type EventsTypes_d_MoverMoveFocusEventDetail = MoverMoveFocusEventDetail;
type EventsTypes_d_MoverMemorizedElementEventDetail = MoverMemorizedElementEventDetail;
type EventsTypes_d_GroupperMoveFocusEventDetail = GroupperMoveFocusEventDetail;
type EventsTypes_d_ModalizerEventDetail = ModalizerEventDetail;
type EventsTypes_d_RootFocusEventDetail = RootFocusEventDetail;
declare namespace EventsTypes_d {
export {
EventsTypes_d_TabsterMoveFocusEventDetail as TabsterMoveFocusEventDetail,
EventsTypes_d_MoverMoveFocusEventDetail as MoverMoveFocusEventDetail,
EventsTypes_d_MoverMemorizedElementEventDetail as MoverMemorizedElementEventDetail,
EventsTypes_d_GroupperMoveFocusEventDetail as GroupperMoveFocusEventDetail,
EventsTypes_d_ModalizerEventDetail as ModalizerEventDetail,
EventsTypes_d_RootFocusEventDetail as RootFocusEventDetail,
};
}
/*!
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
/**
* Events sent by Tabster.
*/
declare const TabsterFocusInEventName = "tabster:focusin";
declare const TabsterFocusOutEventName = "tabster:focusout";
declare const TabsterMoveFocusEventName = "tabster:movefocus";
/**
* Events sent by Deloser.
*/
declare const DeloserFocusLostEventName = "tabster:deloser:focus-lost";
/**
* Events to be sent to Deloser by the application.
*/
declare const DeloserRestoreFocusEventName = "tabster:deloser:restore-focus";
/**
* Events sent by Modalizer.
*/
declare const ModalizerActiveEventName = "tabster:modalizer:active";
declare const ModalizerInactiveEventName = "tabster:modalizer:inactive";
declare const ModalizerFocusInEventName = "tabster:modalizer:focusin";
declare const ModalizerFocusOutEventName = "tabster:modalizer:focusout";
/**
* Events sent by Mover.
*/
declare const MoverStateEventName = "tabster:mover:state";
/**
* Events to be sent to Mover by the application.
*/
declare const MoverMoveFocusEventName = "tabster:mover:movefocus";
declare const MoverMemorizedElementEventName = "tabster:mover:memorized-element";
/**
* Events sent by Groupper.
*/
/**
* Events to be sent to Groupper by the application.
*/
declare const GroupperMoveFocusEventName = "tabster:groupper:movefocus";
/**
* Events sent by Restorer.
*/
declare const RestorerRestoreFocusEventName = "tabster:restorer:restore-focus";
/**
* Events sent by Root.
*/
declare const RootFocusEventName = "tabster:root:focus";
declare const RootBlurEventName = "tabster:root:blur";
declare const CustomEvent_: {
new <T>(type: string, eventInitDict?: CustomEventInit<T> | undefined): CustomEvent<T>;
prototype: CustomEvent<any>;
};
declare abstract class TabsterCustomEvent<D> extends CustomEvent_<D> {
/**
* @deprecated use `detail`.
*/
details?: D;
constructor(type: string, detail?: D);
}
declare class TabsterFocusInEvent extends TabsterCustomEvent<FocusedElementDetail> {
constructor(detail: FocusedElementDetail);
}
declare class TabsterFocusOutEvent extends TabsterCustomEvent<FocusedElementDetail> {
constructor(detail: FocusedElementDetail);
}
declare class TabsterMoveFocusEvent extends TabsterCustomEvent<TabsterMoveFocusEventDetail> {
constructor(detail: TabsterMoveFocusEventDetail);
}
declare class MoverStateEvent extends TabsterCustomEvent<MoverElementState> {
constructor(detail: MoverElementState);
}
declare class MoverMoveFocusEvent extends TabsterCustomEvent<MoverMoveFocusEventDetail> {
constructor(detail: MoverMoveFocusEventDetail);
}
declare class MoverMemorizedElementEvent extends TabsterCustomEvent<MoverMemorizedElementEventDetail> {
constructor(detail: MoverMemorizedElementEventDetail);
}
declare class GroupperMoveFocusEvent extends TabsterCustomEvent<GroupperMoveFocusEventDetail> {
constructor(detail: GroupperMoveFocusEventDetail);
}
declare class ModalizerActiveEvent extends TabsterCustomEvent<ModalizerEventDetail> {
constructor(detail: ModalizerEventDetail);
}
declare class ModalizerInactiveEvent extends TabsterCustomEvent<ModalizerEventDetail> {
constructor(detail: ModalizerEventDetail);
}
declare class DeloserFocusLostEvent extends TabsterCustomEvent<DeloserElementActions> {
constructor(detail: DeloserElementActions);
}
declare class DeloserRestoreFocusEvent extends TabsterCustomEvent<undefined> {
constructor();
}
declare class RestorerRestoreFocusEvent extends TabsterCustomEvent<undefined> {
constructor();
}
declare class RootFocusEvent extends TabsterCustomEvent<RootFocusEventDetail> {
constructor(detail: RootFocusEventDetail);
}
declare class RootBlurEvent extends TabsterCustomEvent<RootFocusEventDetail> {
constructor(detail: RootFocusEventDetail);
}
declare global {
interface GlobalEventHandlersEventMap {
[TabsterFocusInEventName]: TabsterFocusInEvent;
[TabsterFocusOutEventName]: TabsterFocusOutEvent;
[TabsterMoveFocusEventName]: TabsterMoveFocusEvent;
[MoverStateEventName]: MoverStateEvent;
[MoverMoveFocusEventName]: MoverMoveFocusEvent;
[MoverMemorizedElementEventName]: MoverMemorizedElementEvent;
[GroupperMoveFocusEventName]: GroupperMoveFocusEvent;
[ModalizerActiveEventName]: ModalizerActiveEvent;
[ModalizerInactiveEventName]: ModalizerInactiveEvent;
[DeloserFocusLostEventName]: DeloserFocusLostEvent;
[DeloserRestoreFocusEventName]: DeloserRestoreFocusEvent;
[RestorerRestoreFocusEventName]: RestorerRestoreFocusEvent;
[RootFocusEventName]: RootFocusEvent;
[RootBlurEventName]: RootBlurEvent;
}
}
/*!
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
/** @deprecated This function is obsolete, use native element.dispatchEvent(new GroupperMoveFocusEvent(...)). */
declare function dispatchGroupperMoveFocusEvent(target: HTMLElement, action: GroupperMoveFocusAction): boolean;
/** @deprecated This function is obsolete, use native element.dispatchEvent(new MoverMoveFocusEvent(...)). */
declare function dispatchMoverMoveFocusEvent(target: HTMLElement, key: MoverKey): boolean;
/** @deprecated This function is obsolete, use native element.dispatchEvent(new MoverMemorizedElementEvent(...)). */
declare function dispatchMoverMemorizedElementEvent(target: HTMLElement, memorizedElement: HTMLElement | undefined): boolean;
export { AsyncFocusSources$1 as AsyncFocusSources, DeloserFocusLostEvent, DeloserFocusLostEventName, DeloserRestoreFocusEvent, DeloserRestoreFocusEventName, DeloserStrategies$1 as DeloserStrategies, EventsTypes_d as EventsTypes, FOCUSABLE_SELECTOR, GroupperMoveFocusActions$1 as GroupperMoveFocusActions, GroupperMoveFocusEvent, GroupperMoveFocusEventName, GroupperTabbabilities$1 as GroupperTabbabilities, ModalizerActiveEvent, ModalizerActiveEventName, ModalizerFocusInEventName, ModalizerFocusOutEventName, ModalizerInactiveEvent, ModalizerInactiveEventName, MoverDirections$1 as MoverDirections, MoverKeys$1 as MoverKeys, MoverMemorizedElementEvent, MoverMemorizedElementEventName, MoverMoveFocusEvent, MoverMoveFocusEventName, MoverStateEvent, MoverStateEventName, ObservedElementAccessibilities$1 as ObservedElementAccessibilities, RestoreFocusOrders$1 as RestoreFocusOrders, RestorerRestoreFocusEvent, RestorerRestoreFocusEventName, RestorerTypes$1 as RestorerTypes, RootBlurEvent, RootBlurEventName, RootFocusEvent, RootFocusEventName, SysDummyInputsPositions$1 as SysDummyInputsPositions, TABSTER_ATTRIBUTE_NAME, TABSTER_DUMMY_INPUT_ATTRIBUTE_NAME, TabsterCustomEvent, TabsterFocusInEvent, TabsterFocusInEventName, TabsterFocusOutEvent, TabsterFocusOutEventName, TabsterMoveFocusEvent, TabsterMoveFocusEventName, Types_d as Types, Visibilities$1 as Visibilities, createTabster, dispatchGroupperMoveFocusEvent, dispatchMoverMemorizedElementEvent, dispatchMoverMoveFocusEvent, disposeTabster, forceCleanup, getCrossOrigin, getDeloser, getDummyInputContainer, getGroupper, getInternal, getModalizer, getMover, getObservedElement, getOutline, getRestorer, getShadowDOMAPI, getTabster, getTabsterAttribute, isNoOp, makeNoOp, mergeTabsterProps, setTabsterAttribute };
Reference in New Issue Copy Permalink