Initial commit

node_modules/tabster/dist/dts/State/FocusedElement.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "../Types";
+import { Subscribable } from "./Subscribable";
+export declare class FocusedElementState extends Subscribable<HTMLElement | undefined, Types.FocusedElementDetail> implements Types.FocusedElementState {
+    private static _lastResetElement;
+    private static _isTabbingTimer;
+    static isTabbing: boolean;
+    private _tabster;
+    private _win;
+    private _nextVal;
+    private _lastVal;
+    private _asyncFocus?;
+    constructor(tabster: Types.TabsterCore, getWindow: Types.GetWindow);
+    private _init;
+    dispose(): void;
+    static forgetMemorized(instance: Types.FocusedElementState, parent: HTMLElement): void;
+    getFocusedElement(): HTMLElement | undefined;
+    getLastFocusedElement(): HTMLElement | undefined;
+    focus(element: HTMLElement, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean, preventScroll?: boolean): boolean;
+    focusDefault(container: HTMLElement): boolean;
+    getFirstOrLastTabbable(isFirst: boolean, props: Pick<Types.FindFocusableProps, "container" | "ignoreAccessibility">): HTMLElement | undefined;
+    private _focusFirstOrLast;
+    focusFirst(props: Types.FindFirstProps): boolean;
+    focusLast(props: Types.FindFirstProps): boolean;
+    resetFocus(container: HTMLElement): boolean;
+    requestAsyncFocus(source: Types.AsyncFocusSource, callback: () => void, delay: number): void;
+    cancelAsyncFocus(source: Types.AsyncFocusSource): void;
+    private _setOrRemoveAttribute;
+    private _setFocusedElement;
+    protected setVal(val: HTMLElement | undefined, detail: Types.FocusedElementDetail): void;
+    private _onFocusIn;
+    private _onFocusOut;
+    static findNextTabbable(tabster: Types.TabsterCore, ctx: Types.TabsterContext, container?: HTMLElement, currentElement?: HTMLElement, referenceElement?: HTMLElement, isBackward?: boolean, ignoreAccessibility?: boolean): Types.NextTabbable | null;
+    private _validateFocusedElement;
+    private _onKeyDown;
+    _onChanged: (element: HTMLElement | undefined, detail: Types.FocusedElementDetail) => void;
+}

node_modules/tabster/dist/dts/State/KeyboardNavigation.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "../Types";
+import { Subscribable } from "./Subscribable";
+export declare class KeyboardNavigationState extends Subscribable<boolean> implements Types.KeyboardNavigationState {
+    private _keyborg?;
+    constructor(getWindow: Types.GetWindow);
+    dispose(): void;
+    private _onChange;
+    setNavigatingWithKeyboard(isNavigatingWithKeyboard: boolean): void;
+    isNavigatingWithKeyboard(): boolean;
+}

node_modules/tabster/dist/dts/State/ObservedElement.d.ts

@@ -0,0 +1,41 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "../Types";
+import { Subscribable } from "./Subscribable";
+export declare class ObservedElementAPI extends Subscribable<HTMLElement, Types.ObservedElementDetails> implements Types.ObservedElementAPI {
+    private _win;
+    private _tabster;
+    private _waiting;
+    private _lastRequestFocusId;
+    private _observedById;
+    private _observedByName;
+    private _currentRequest;
+    private _currentRequestTimestamp;
+    constructor(tabster: Types.TabsterCore);
+    dispose(): void;
+    private _onFocus;
+    private _rejectWaiting;
+    private _isObservedNamesUpdated;
+    /**
+     * Returns existing element by observed name
+     *
+     * @param observedName An observed name
+     * @param accessibility Optionally, return only if the element is accessible or focusable
+     * @returns HTMLElement | null
+     */
+    getElement(observedName: string, accessibility?: Types.ObservedElementAccessibility): HTMLElement | null;
+    /**
+     * Waits for the element to appear in the DOM and returns it.
+     *
+     * @param observedName An observed name
+     * @param timeout Wait no longer than this timeout
+     * @param accessibility Optionally, wait for the element to also become accessible or focusable before returning it
+     * @returns Promise<HTMLElement | null>
+     */
+    waitElement(observedName: string, timeout: number, accessibility?: Types.ObservedElementAccessibility): Types.ObservedElementAsyncRequest<HTMLElement | null>;
+    requestFocus(observedName: string, timeout: number, options?: Pick<FocusOptions, "preventScroll">): Types.ObservedElementAsyncRequest<boolean>;
+    onObservedElementUpdate: (element: HTMLElement) => void;
+    private _waitConditional;
+}

node_modules/tabster/dist/dts/State/Subscribable.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "../Types";
+export declare abstract class Subscribable<A, B = undefined> implements Types.Subscribable<A, B> {
+    protected _val: A | undefined;
+    private _callbacks;
+    dispose(): void;
+    subscribe(callback: Types.SubscribableCallback<A, B>): void;
+    subscribeFirst(callback: Types.SubscribableCallback<A, B>): void;
+    unsubscribe(callback: Types.SubscribableCallback<A, B>): void;
+    protected setVal(val: A, detail: B): void;
+    protected getVal(): A | undefined;
+    protected trigger(val: A, detail: B): void;
+    private _callCallbacks;
+}