@tylertech/forge-core 2.0.0

package/typings/custom-elements/component-utils.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Recursively defines a component as a custom elements and all of its dependencies.
+ * @param component The component to import.
+ */
+export declare function defineCustomElement(component: any): void;
+/**
+ * Defines the specified custom element components.
+ * @param {any[]} components The components to register.
+ */
+export declare function defineCustomElements(components: any[]): void;
+/**
+ * Attempts to define the provided custom element name/constructor if not already defined.
+ * @param name The name of the custom element to define.
+ * @param ctor The custom element constructor.
+ */
+export declare function tryDefine(name: string, ctor: CustomElementConstructor, options?: ElementDefinitionOptions | undefined): void;
+/**
+ * Useful when capturing the value of a unupgraded component during the `connectedCallback` upon upgrade.
+ *
+ * More information here:
+ * https://developers.google.com/web/fundamentals/architecture/building-components/best-practices#lazy-properties
+ *
+ * @param property
+ */
+export declare function upgradeProperty<T extends HTMLElement>(instance: T, property: keyof T): void;
+/**
+ * Traverses up the DOM tree starting from the provided component element to find the specified parent.
+ * @param {HTMLElement} component The starting HTMLElement.
+ * @param {string} parentTagName The parent tag name we are searching for.
+ */
+export declare function requireParent<T extends HTMLElement>(component: HTMLElement, parentTagName: string): T | null;
+/**
+ * Creates a template element from a string.
+ * @param template The template HTML string.
+ */
+export declare function parseTemplateString(template: string): HTMLTemplateElement;
+/**
+ * Attaches a template to the given web component instance light DOM.
+ * @param {T} componentInstance A component instance.
+ * @param {string} template The template HTML string.
+ */
+export declare function attachLightTemplate<T extends HTMLElement>(componentInstance: T, template: string): void;
+/**
+ * Attaches a shadow root to the given web component instance.
+ * @param {T} componentInstance A component instance.
+ * @param {string} elementName The name of the element the shadow root is to be attached to.
+ * @param {string} template The shadow root template HTML string.
+ * @param {string | string[]} styles The shadow root styles string to be encapsulated by this shadow root.
+ * @param {boolean} [delegatesFocus=false] Should the component delagate focus.
+ */
+export declare function attachShadowTemplate<T extends HTMLElement>(componentInstance: T, template: string, styles?: string | string[], delegatesFocus?: boolean): void;
+/**
+ * Replaces the template of an existing shadow root with the provided template.
+ * @param {T} componentInstance A component instance.
+ * @param {string} elementName The name of the element the shadow root is to be attached to.
+ * @param {string} template The shadow root template HTML string.
+ * @param {string | string[]} styles The shadow root styles string to be encapsulated by this shadow root.
+ */
+export declare function replaceShadowTemplate<T extends HTMLElement>(componentInstance: T, template: string, styles?: string | string[]): void;
+/**
+ * Creates and prepares an HTML template element for rendering within a shadow root.
+ * @param {string} elementName The name of the element the shadow root is to be attached to.
+ * @param {string} template The shadow root template HTML string.
+ * @param {string | string[]} styles The shadow root styles string to be encapsulated by this shadow root.
+ */
+export declare function prepareShadowTemplate(template: string, styles?: string | string[]): HTMLTemplateElement;
+/**
+ * Appends a template to the provided components shadow root.
+ * @param {T} componentInstance A component instance.
+ * @param {HTMLTemplateElement} templateElement A template element to be cloned.
+ */
+export declare function setShadowTemplate<T extends HTMLElement>(componentInstance: T, templateElement: HTMLTemplateElement): void;
+/**
+ * Copies style rules from the provided document stylesheets collection to the provided shadow root stylesheet.
+ * @param {Document} fromDocument The document to find the style sheets in.
+ * @param {ShadowRoot} shadowRoot The shadow root that contains the stylesheet to copy the rules to.
+ * @param {IStyleSheetDescriptor[]} styleSheetDescriptors A collection of style sheet predicates.
+ * @param {CSSStyleSheet} shadowStyleSheet The shadow root stylesheet to copy the style rules to.
+ */
+export declare function provideDocumentStyles(fromDocument: Document, shadowRoot: ShadowRoot, documentStyleSheets: Array<string | IStyleSheetDescriptor>, shadowStyleSheet: CSSStyleSheet): void;
+/**
+ * Gets an HTML element using a query selector from the provided components` shadow root.
+ * @param {HTMLElement} componentInstance The component instance that contains a shadow root.
+ * @param {string} selector The selector to be passed to `querySelector`.
+ */
+export declare function getShadowElement<T extends HTMLElement>(componentInstance: T, selector: string): HTMLElement;
+/**
+ * Gets an HTML element using a query selector from the provided components` light DOM.
+ * @param {HTMLElement} componentInstance The component instance.
+ * @param {string} selector The selector to be passed to `querySelector`.
+ */
+export declare function getLightElement<T extends HTMLElement>(componentInstance: T, selector: string): HTMLElement;
+/**
+ * Creates and dispatches a cross-browser `CustomEvent` with the provided type and data.
+ * @param {string} type
+ * @param {any} data
+ * @param {boolean=} bubble
+ */
+export declare function emitEvent<T extends HTMLElement>(component: T, type: string, data: any, bubble?: boolean, cancelable?: boolean): boolean;
+/**
+ * Replaces the provided element with a placeholder comment and vice versa.
+ * Useful for hiding and showing elements while retaining their location in the DOM.
+ * @param {boolean} isVisible Whether the element is visible or not.
+ * @param {string} elementName The element tag name.
+ * @param {string} selector The selector used to find the element
+ * @param {Node} element The element
+ * @param {Comment} placeholder The existing placeholder
+ */
+export declare function toggleElementPlaceholder(component: HTMLElement, isVisible: boolean, elementName: string, selector: string, element: Node, placeholder: Comment): Comment;
+/**
+ * Walks up the tree starting a specific node and stops when it finds a shadow root.
+ * @param {Node} node The node to start searching from.
+ * @returns {ShadowRoot | null} The closest shadow root ancestor, or null if not inside a shadow root.
+ */
+export declare function getClosestShadowRoot(node: Node): ShadowRoot | null;
+/**
+ * Finds the closest element up the tree from a starting element across shadow boundaries.
+ * @param selector The CSS selector for the element to find.
+ * @param startElement The element to start finding from.
+ */
+export declare function closestElement(selector: string, startElement: Element): Element | null;
+export interface IStyleSheetDescriptor {
+    name: string;
+    selectorFilter?: string;
+}

package/typings/custom-elements/decorators/custom-element.d.ts

@@ -0,0 +1,21 @@
+declare global {
+    interface Window {
+        __forgeFlags__autoDefine: any;
+    }
+}
+export interface ICustomElementConfig {
+    /** The name of the custom element tag. */
+    name: string;
+    /** Components that are dependencies of this component */
+    dependencies?: any[];
+    /** Configures if the element will be automatically defined in the custom element registry. Default is `true` */
+    define?: boolean;
+}
+export declare const CUSTOM_ELEMENT_NAME_PROPERTY = "_customElementName";
+export declare const CUSTOM_ELEMENT_DEPENDENCIES_PROPERTY = "_customElementDependencies";
+/**
+ * This decorator is intended to be used on classes that extend `HTMLElement` to
+ * extend/modify the behavior of a custom element.
+ * @param {ICustomElementConfig} [config={}] The custom element configuration.
+ */
+export declare function CustomElement({ name, dependencies, define }: ICustomElementConfig): any;

package/typings/custom-elements/decorators/foundation-property.d.ts

@@ -0,0 +1,20 @@
+export interface IFoundationPropertyOptions<T> {
+    /**
+     * Allow Binding to a different naming convention in the foundation
+     * @example FoundationProperty({name: '_foo'}) foo;
+     */
+    name?: string;
+    /**
+     * When false, skips calling the foundation property setter
+     * @default true
+     * @example FoundationProperty({set: true}) foo;
+     */
+    set?: boolean;
+    /**
+     * When false, skips calling the foundation property getter
+     * @default true
+     * @example FoundationProperty({get: true}) foo;
+     */
+    get?: boolean;
+}
+export declare function FoundationProperty<T>(options?: IFoundationPropertyOptions<T>): any;

package/typings/custom-elements/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './custom-element';
+export * from './foundation-property';

package/typings/custom-elements/index.d.ts

@@ -0,0 +1,13 @@
+export * from './decorators';
+export * from './component-utils';
+export interface ICustomElement extends HTMLElement {
+    initializedCallback?: () => void;
+    connectedCallback?: () => void;
+    disconnectedCallback?: () => void;
+    attributeChangedCallback?: (name: string, oldValue: string, newValue: string) => void;
+}
+export interface ICustomElementFoundation {
+    initialize?: () => void;
+    connect?: () => void;
+    disconnect?: () => void;
+}

package/typings/events/event-aware.d.ts

@@ -0,0 +1,16 @@
+export interface IEvent<T> {
+    type: string;
+    data: T | undefined;
+}
+export interface IEventAware {
+    hasListeners(type?: string): boolean;
+    addListener(type: string, listener: (evt: IEvent<any>) => void): void;
+    removeListener(type: string, listener: (evt: IEvent<any>) => void): void;
+}
+export declare abstract class EventAware implements IEventAware {
+    private _listenerMap;
+    protected _emit<T>(type: string, data?: T): void;
+    hasListeners(type?: string): boolean;
+    addListener(type: string, listener: (evt: IEvent<any>) => void): void;
+    removeListener(type: string, listener: (evt: IEvent<any>) => void): void;
+}

package/typings/events/index.d.ts

@@ -0,0 +1 @@
+export * from './event-aware';

package/typings/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright (c) 2022 Tyler Technologies, Inc.
+ * License: Apache-2.0
+ */
+export * from './a11y';
+export * from './constants';
+export * from './custom-elements';
+export * from './events';
+export * from './message-list';
+export * from './scroll';
+export * from './services';
+export * from './utils';

package/typings/message-list/index.d.ts

@@ -0,0 +1,2 @@
+export * from './message-list-entry';
+export * from './message-list';

package/typings/message-list/message-list-entry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Represents a single message list entry containing a string message and its identifier.
+ */
+export declare class MessageListEntry<T> {
+    message: string;
+    identifier: T;
+    originalMessage: string;
+    constructor(message: string, identifier: T);
+}

package/typings/message-list/message-list.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Represents a message list of any type. This class can be used to attach a string message to
+ * a generic identifier.
+ */
+export declare class MessageList<T> {
+    private _messages;
+    private _useAutoEllipsis;
+    /**
+       * True if ellipsis management occurs automatically. Default is true.
+       */
+    get useAutoEllipsis(): boolean;
+    set useAutoEllipsis(value: boolean);
+    /**
+       * The message that is made up of all messages in the entries.
+       */
+    message: string;
+    constructor(useAutoEllipsis?: boolean);
+    /**
+       * Adds a message to the entry map.
+       * @param {string} message The message string.
+       * @param {T} identifier The message identifier.
+       * @returns {MessageList<T>} A reference to `this` for chaining.
+       */
+    add(message: string, identifier: T): MessageList<T>;
+    /**
+       * Removes a message using the provided identifier.
+       * @param {T} identifier The message identifier.
+       * @returns {MessageList<T>} A reference to `this` for chaining.
+       */
+    remove(identifier: T): MessageList<T>;
+    /**
+       * Updates an existing message value.
+       * @param {string} message The message string.
+       * @param {T} identifier The existing message identifier.
+       * @returns {MessageList<T>} A reference to `this` for chaining.
+       */
+    update(message: string, identifier: T): MessageList<T>;
+    /**
+       * Gets the number of messages in the list.
+       * @returns {number}
+       */
+    get messageCount(): number;
+    /**
+       * Resets the message list to it's original state and removes all messages.
+       */
+    reset(): void;
+    /**
+       * Determines if a message with the provided identifier exists.
+       * @param {T} identifier The message identifier.
+       */
+    hasMessage(identifier: T): boolean;
+    private _updateMessage;
+    private _getMessageIndex;
+}

package/typings/scroll/index.d.ts

@@ -0,0 +1,2 @@
+export * from './scroll-axis-observer';
+export * from './scroll-types';

package/typings/scroll/scroll-axis-observer.d.ts

@@ -0,0 +1,44 @@
+import { EventAware, IEventAware } from '../events/event-aware';
+import { IScrollObserverConfiguration } from './scroll-types';
+export interface IScrollAxisObserver extends IEventAware {
+    scrollPosition: number;
+    isScrolled: boolean;
+    isScrolledStart: boolean;
+    isScrolledEnd: boolean;
+    isScrollable: boolean;
+    scrollSize: number;
+    elementSize: number;
+    setScrollPosition(position: number): void;
+    destroy(): void;
+    start(): void;
+    stop(): void;
+}
+/**
+ * Provides facilties for observing and reacting to scroll events and information on a given element.
+ */
+export declare class ScrollAxisObserver extends EventAware implements IScrollAxisObserver {
+    private _element;
+    private _config;
+    private _axis;
+    private _scrollThreshold;
+    private _lastScrollPosition;
+    private _lastScrollTop;
+    private _lastScrollLeft;
+    private _isListening;
+    private _scrollListener;
+    constructor(_element: HTMLElement, _config?: IScrollObserverConfiguration);
+    destroy(): void;
+    start(): void;
+    stop(): void;
+    private _initialize;
+    private _isScrollAxis;
+    private _onScroll;
+    get scrollPosition(): number;
+    get isScrolled(): boolean;
+    get isScrolledStart(): boolean;
+    get isScrolledEnd(): boolean;
+    get isScrollable(): boolean;
+    get scrollSize(): number;
+    get elementSize(): number;
+    setScrollPosition(position: number): void;
+}

package/typings/scroll/scroll-types.d.ts

@@ -0,0 +1,28 @@
+export declare enum ScrollDirection {
+    Up = "up",
+    Down = "down",
+    Left = "left",
+    Right = "right"
+}
+export declare enum ScrollEvents {
+    Scroll = "scroll",
+    Scrolled = "scrolled",
+    ScrolledStart = "scrolled-start",
+    ScrolledEnd = "scrolled-end"
+}
+export declare type ScrollAxis = 'vertical' | 'horizontal';
+export interface IScrollInfo {
+    direction: ScrollDirection;
+    position: number;
+}
+export interface IScrolledInfo {
+    axis: ScrollAxis;
+    isScrolled: boolean;
+}
+export interface IScrollObserverConfiguration {
+    axis?: ScrollAxis;
+    scrollThreshold?: number;
+    paused?: boolean;
+    throttle?: boolean;
+    throttleTime?: number;
+}

package/typings/services/index.d.ts

@@ -0,0 +1 @@
+export * from './service-adapter';

package/typings/services/service-adapter.d.ts

@@ -0,0 +1,25 @@
+export interface IServiceRequestParameter {
+    type: ServiceRequestMethod;
+    path: string;
+    data?: any;
+}
+export interface IServiceAdapter {
+    request: ServiceRequestCallback;
+    cancel: ServiceCancelCallback;
+}
+export declare enum ServiceRequestMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    HEAD = "HEAD",
+    CONNECT = "CONNECT",
+    OPTIONS = "OPTIONS",
+    TRACE = "TRACE"
+}
+export declare type ServiceRequestCallback = (param: IServiceRequestParameter) => Promise<any>;
+export declare type ServiceCancelCallback = (path: string) => Promise<void>;
+export interface IServiceAware {
+    serviceAdapter: IServiceAdapter;
+}

package/typings/utils/a11y.d.ts

@@ -0,0 +1,2 @@
+/** Constructs a visually hidden element and returns the element instance. */
+export declare function createVisuallyHiddenElement(attr?: string): HTMLElement;

package/typings/utils/clipboard.d.ts

@@ -0,0 +1,2 @@
+/** Copy the text value to the clipboard. */
+export declare function copyToClipboard(text: string): boolean;

package/typings/utils/dom-utils.d.ts

@@ -0,0 +1,254 @@
+export interface IScrollbarVisibility {
+    x: boolean;
+    y: boolean;
+}
+export interface IFontInfo {
+    fontSize?: number;
+    fontFamily?: string;
+}
+/**
+ * Retrieves an element based on the provided root and selector.
+ * @param {Element} root The root element to search within.
+ * @param {string} selector The selector for the child element.
+ * @param {boolean} [allowNull=false] Should the method allow the element to be not found? Default is false.
+ * @returns {HTMLElement}
+ */
+export declare function getElement<T>(root: Element, selector: string, allowNull?: boolean): T;
+/**
+ * Checks if an element is a valid element.
+ * @param {Element} element The node to test
+ * @returns {boolean}
+ */
+export declare function isElement(element: Element): boolean;
+/**
+ * Checks if an element is statically positioned.
+ * @param {Element} element The node to test.
+ * @returns {boolean}
+ */
+export declare function isPositionStatic(element: Element): boolean;
+/**
+ * Parses a style string to a numeric value (removes 'px').
+ * @param {string} value The style string to parse.
+ * @returns {number}
+ */
+export declare function parseStyle(value: string): number;
+/**
+ * Gets the index of an element in the parent element children.
+ * @param {Element} element The element to get the index on.
+ * @returns {number}
+ */
+export declare function elementIndex(element: Element): number;
+/**
+ * Gets an array of parent elements up to the body element.
+ * @param {Element} element The element to get the parents of.
+ * @param {Element=} untilElement Optional element where traversal should stop.
+ * @returns {Array}
+ */
+export declare function elementParents(element: Element, untilElement?: Element): Element[];
+/**
+ * Gets the non-statically positioned parent of an element.
+ * @param element The element to get the offset parent of.
+ * @returns {Element}
+ */
+export declare function offsetParent(element: HTMLElement): HTMLElement;
+/**
+ * Gets the browser scrollbar width.
+ * @returns {number}
+ */
+export declare function scrollbarWidth(): number;
+/**
+ * Checks if an element is scrollable.
+ * @param {Element} element The element to test for scrollability
+ * @returns {boolean}
+ */
+export declare function isScrollable(element: Element): boolean;
+/**
+ * Gets the scroll parent of an element.
+ * @param {Element} element The element to get the scroll parent of.
+ * @param {boolean} [includeSelf=false] Should the element be checked for scrollability.
+ * @returns {Element}
+ */
+export declare function scrollParent(element: Element, includeSelf?: boolean): Element;
+/**
+ * Checks if the elements scroll parent scrollbars are visible.
+ * @param {Element} element The element to check the scroll parent of.
+ * @returns {IScrollbarVisibility}
+ */
+export declare function isScrollbarVisible(element: Element): IScrollbarVisibility;
+/**
+ * Gets the offset from the element to the parent element edges.
+ * If no parentElement is supplied, the documentElement will be used.
+ * @param {Element} element The element to compute the offset for.
+ * @param {Element=} parentElement Optional parent element to measure from.
+ * @returns {DOMRect}
+ */
+export declare function offset(element: Element, parentElement?: Element): Omit<DOMRect, 'x' | 'y' | 'toJSON'>;
+/**
+ * Gets the offset from the element to the parent element viewable edges.
+ * If no parentElement is supplied, the documentElement will be used.
+ * @param {Element} element The element to measure
+ * @param {Element=} parentElement The parent element to measure to.
+ * @returns {DOMRect}
+ */
+export declare function viewportOffset(element: HTMLElement, parentElement?: Element): Omit<DOMRect, 'x' | 'y' | 'toJSON'>;
+/**
+ * Checks if any part of an element is visible in the viewport.
+ * @param {Element} element The element to check.
+ * @returns {boolean}
+ */
+export declare function isElementInViewport(element: Element): boolean;
+/**
+ * Adds an event listener to the document that will call the provided callback function
+ * when an element and it's children no longer have focus.  The blur and touchstart events are used
+ * to evaluate the active element to determine if the callback should be called.
+ *
+ * @param {Element} element The element to add the event listener to.
+ * @param {Function} callback The function to call when the element and children don't have focus.
+ * @param {boolean} [delay=false] Should a RAF cycle occur before the callback is called.
+ * @returns {Function} The function to call to remove the document events.
+ */
+export declare function notChildEventListener(element: HTMLElement, callback: (element: HTMLElement) => void, delay?: boolean): () => void;
+/**
+ * Removes all children from a DOM node.
+ * @param node The DOM node to remove children from.
+ */
+export declare function removeAllChildren(node: Element): void;
+/**
+ * Replaces one child node of the specified node with another.
+ * @param newChild The new node to replace `oldChild`.
+ * @param oldChild The existing node to be replaced.
+ * @returns {Node} The replaced node. Same node as `oldChild`.
+ */
+export declare function replaceElement(newChild: Node, oldChild: Node): Node;
+/**
+ * Adds a class or array of classes to an element.
+ *
+ * @param {string | string[]} name The class(es) to add to the element
+ * @param {Element} element The element to add class(es) to.
+ */
+export declare function addClass(name: string | string[], element: Element): void;
+/**
+ * Removes a class or array of classes to an element.
+ *
+ * @param {string | string[]} name The class(es) to remove from the element
+ * @param {Element} element The element to remove class(es) from.
+ */
+export declare function removeClass(name: string | string[], element: Element): void;
+/** Determines which type of animation event is supported. */
+export declare function getAnimationEvent(): string | undefined;
+/**
+ * A helper method to trigger a keyframe animation via adding a class, and removing the class when the animation completes.
+ * @param {HTMLElement} element The element to play the animation on.
+ * @param {string} className The class to add that triggers the animation.
+ */
+export declare function playKeyframeAnimation(element: HTMLElement, className: string, remove?: boolean): Promise<void>;
+/**
+ * Removes an element from the DOM using the available remove method for that platform.
+ * @param {HTMLElement} element The element to remove.
+ */
+export declare function removeElement(element: HTMLElement): void;
+/**
+ * Returns a width string that is safe for css based on the provided input.
+ * @param {string | number} width
+ * @returns {string | undefined} A width safe for using in CSS.
+ */
+export declare function safeCssWidth(width: string | number): string | undefined;
+/**
+ * Calculates the size of an element that is not attached to the DOM.
+ * @param {HTMLElement} element The element to calc the size of.
+ * @returns {width, height} The size of the element.
+ */
+export declare function calcSizeUnattached(element: HTMLElement): {
+    width: number;
+    height: number;
+};
+/**
+ * Resolves a promise when the provided element has children.
+ * @param {Element} element An element that does or will contain children.
+ */
+export declare function ensureChildren(element: Element): Promise<void>;
+/**
+ * Resolves a promise when the provided element has a child that matches a given selector.
+ * @param {Element} element An element that does or will contain children.
+ * @param {string} selector A CSS selector to use for finding an element.
+ */
+export declare function ensureChild(element: Element, selector: string): Promise<Element>;
+/**
+ * Resolves a promise when the provided host element has an `<input>` element child
+ * @param {HTMLElement} host An element that does or will contain children.
+ */
+export declare function ensureInputElement(host: HTMLElement): Promise<Element>;
+/**
+ * Walks up the tree starting a specific node and stops when the provided matcher function returns true.
+ * @param {Node} node The node to start searching from.
+ * @returns {Node | null} The closest matching ancestor node, or null if not found.
+ */
+export declare function walkUpUntil(node: Node, matcher: (node: Node) => boolean): Node | null;
+/**
+ * Calculates the width of a string given the provided font information.
+ */
+export declare function calculateFontWidth(value: string, info?: IFontInfo): number;
+/**
+ * Generates a CSS text-shadow style value based on the number of iterations and color provided.
+ * @param {number} iterations The number of iterations for how long the shadow should be.
+ * @param {string} color The color of the text shadow. Can be any CSS-safe color format. Ex. hex, rgb, rgba, hsl... etc.
+ */
+export declare function generateTextShadow(iterations: number, color: string): string;
+/**
+ * Checks if an element matches any of the provided selectors.
+ * @param {Element} el The element to match.
+ * @param {string[]} selectors The selectors to check the element against.
+ */
+export declare function matchesSelectors(el: Element | Node, selectors: string | string[]): boolean;
+/**
+ * Walks the DOM tree starting at a root element and checks if any of its children
+ * match the provided selectors. Similar to the native `querySelectorAll` except
+ * that it will traverse the shadow DOM as well as slotted nodes.
+ * @param {Element} rootElement The element to start querying from.
+ * @param {string[]} selectors An array of CSS selectors.
+ * @param {boolean} [checkRootElement] True if the provided root element is to be matched against the selectors.
+ */
+export declare function deepQuerySelectorAll(rootElement: Element, selectors: string | string[], checkRootElement?: boolean): Element[];
+/**
+ * Gets the currently focused element within the document by also traversing shadow roots.
+ * @returns {Element}
+ */
+export declare function getActiveElement(): Element;
+/**
+ * Gets the active element within the provided elements shadow root. If the element
+ * does not have a shadow root, the provided element is returned.
+ * @param {Element} element The active element.
+ */
+export declare function getActiveShadowElement(element: Element): Element;
+/** Toggles a CSS class (or classes) on an element based on a boolean. */
+export declare function toggleClass(el: HTMLElement, hasClass: boolean, className: string | string[]): void;
+/** Toggles a value-less attribute on an element. */
+export declare function toggleAttribute(el: HTMLElement, hasAttribute: boolean, name: string, value?: string): void;
+/** Toggles part of an attribute on an element. */
+export declare function toggleOnAttribute(el: HTMLElement, attribute: string, value: string, force?: boolean): void;
+/** Appends a value to an attribute on an element, first setting it if it doesn't exist. */
+export declare function appendToAttribute(el: HTMLElement, attribute: string, value: string): void;
+/** Removes a value from an attribute on an element, removing the attribute if empty. */
+export declare function removeFromAttribute(el: HTMLElement, attribute: string, value: string): void;
+/**
+ * Attempts to scroll a target element into view within a scrollable parent element, unless already visible within the container.
+ * @param scrollElement The scrollable parent element.
+ * @param targetElement The element to scroll into view.
+ * @param behavior The scroll behavior. Defaults to 'auto'.
+ * @param block The block position to anchor the target element to within the scroll element.
+ */
+export declare function tryScrollIntoView(scrollElement: HTMLElement, targetElement: HTMLElement, behavior?: 'auto' | 'smooth', block?: 'nearest' | 'center'): void;
+/** Calculates the block anchor position for a target element within a scrollable parent element. */
+export declare function calcBlockScroll(block: 'nearest' | 'center', isClippedStart: boolean, targetOffset: number, targetSize: number, scrollOffset: number, scrollSize: number): number;
+/**
+ * Creates an element from an HTML string.
+ */
+export declare function elementFromHTML(html: string): Element | null;
+/**
+ * Observes changes to the provided attributes on a target element and executes a provided callback when changed.
+ * @param element The element to observe.
+ * @param listener The callback to execute when an attribute changes on the element.
+ * @param attributeFilter The attributes to observe.
+ * @returns A `MutationObserver` instasnce.
+ */
+export declare function createElementAttributeObserver(element: HTMLElement, listener: (name: string, value: string | null) => void, attributeFilter: string[] | undefined): MutationObserver;