@tabler/core 1.5.0 → 1.6.0

package/dist/types/src/bootstrap/toast.d.ts

@@ -5,14 +5,22 @@
  * --------------------------------------------------------------------------
  */
 import BaseComponent from './base-component';
-import type { ComponentConfig, ComponentConfigType, ElementSelector } from './types';
+import type { ElementSelector, JQueryCollectionLike } from './types';
+type ComponentConfig = {
+    animation: boolean;
+    autohide: boolean;
+    delay: number;
+};
+type ComponentConfigInput = Partial<ComponentConfig> & Record<string, unknown>;
 declare class Toast extends BaseComponent {
+    _element: HTMLElement;
+    _config: ComponentConfig;
     _timeout: ReturnType<typeof setTimeout> | null;
     _hasMouseInteraction: boolean;
     _hasKeyboardInteraction: boolean;
-    constructor(element: ElementSelector, config?: ComponentConfig);
+    constructor(element: ElementSelector, config?: ComponentConfigInput);
     static get Default(): ComponentConfig;
-    static get DefaultType(): ComponentConfigType;
+    static get DefaultType(): Record<keyof ComponentConfig, string>;
     static get NAME(): string;
     show(): void;
     hide(): void;
@@ -22,5 +30,6 @@ declare class Toast extends BaseComponent {
     _onInteraction(event: Event, isInteracting: boolean): void;
     _setListeners(): void;
     _clearTimeout(): void;
+    static jQueryInterface(this: JQueryCollectionLike, config?: unknown): unknown;
 }
 export default Toast;

package/dist/types/src/bootstrap/tooltip.d.ts

@@ -7,28 +7,61 @@
 import * as Popper from '@popperjs/core';
 import BaseComponent from './base-component';
 import TemplateFactory from './util/template-factory';
-interface ComponentConfig {
-    [key: string]: any;
-}
-interface ComponentConfigType {
-    [key: string]: string;
-}
+import type { AllowList, JQueryCollectionLike, SanitizeFn } from './types';
+type PopperOffsetData = {
+    placement: Popper.Placement;
+    reference: Popper.Rect;
+    popper: Popper.Rect;
+};
+type PopperOffsetFunction = (popperData: PopperOffsetData) => number[];
+type PopperConfigFunction = (defaultConfig: Partial<Popper.Options>) => Partial<Popper.Options>;
+export type TooltipDelay = number | {
+    show: number;
+    hide: number;
+};
+export type TooltipContent = string | HTMLElement | null | ((this: HTMLElement, element: HTMLElement) => string | HTMLElement | null);
+export type TooltipContentMap = Record<string, TooltipContent>;
+export type TooltipPlacement = string | ((this: Tooltip, tip: HTMLElement, element: HTMLElement) => string);
+export type TooltipConfig = {
+    allowList: AllowList;
+    animation: boolean;
+    boundary: Popper.Boundary;
+    container: HTMLElement | string | false;
+    customClass: string | ((this: HTMLElement, element: HTMLElement) => string);
+    delay: TooltipDelay;
+    fallbackPlacements: string[];
+    html: boolean;
+    offset: number[] | string | ((popperData: PopperOffsetData, element: HTMLElement) => number[]);
+    placement: TooltipPlacement;
+    popperConfig: Partial<Popper.Options> | PopperConfigFunction | null;
+    sanitize: boolean;
+    sanitizeFn: SanitizeFn | null;
+    selector: string | false;
+    template: string;
+    title: TooltipContent;
+    trigger: string;
+};
+type ComponentConfig = TooltipConfig;
+export type TooltipConfigInput = Partial<TooltipConfig> & Record<string, unknown>;
+type ComponentConfigInput = TooltipConfigInput;
 /**
  * Class definition
  */
 declare class Tooltip extends BaseComponent {
+    _element: HTMLElement;
+    _config: ComponentConfig;
     _isEnabled: boolean;
     _timeout: ReturnType<typeof setTimeout> | number;
     _isHovered: boolean | null;
     _activeTrigger: Record<string, boolean>;
     _popper: Popper.Instance | null;
     _templateFactory: TemplateFactory | null;
-    _newContent: Record<string, any> | null;
+    _newContent: TooltipContentMap | null;
     tip: HTMLElement | null;
-    _hideModalHandler: (() => void) | null;
-    constructor(element: HTMLElement | string, config?: Partial<ComponentConfig>);
+    _hideModalHandler: () => void;
+    constructor(element: HTMLElement | string, config?: ComponentConfigInput);
     static get Default(): ComponentConfig;
-    static get DefaultType(): ComponentConfigType;
+    static get DefaultType(): Record<keyof ComponentConfig, string>;
     static get NAME(): string;
     enable(): void;
     disable(): void;
@@ -40,29 +73,34 @@ declare class Tooltip extends BaseComponent {
     update(): void;
     _isWithContent(): boolean;
     _getTipElement(): HTMLElement | null;
-    _createTipElement(content: Record<string, any>): HTMLElement | null;
-    setContent(content: Record<string, any>): void;
-    _getTemplateFactory(content: Record<string, any>): TemplateFactory;
-    _getContentForTemplate(): Record<string, any>;
-    _getTitle(): string;
+    _createTipElement(content: TooltipContentMap): HTMLElement | null;
+    setContent(content: TooltipContentMap): void;
+    _getTemplateFactory(content: TooltipContentMap): TemplateFactory;
+    _getContentForTemplate(): TooltipContentMap;
+    _getTitle(): string | HTMLElement;
     _initializeOnDelegatedTarget(event: Event & {
         delegateTarget?: HTMLElement;
     }): Tooltip;
     _isAnimated(): boolean;
     _isShown(): boolean;
     _createPopper(tip: HTMLElement): Popper.Instance;
-    _getOffset(): number[] | ((popperData: any) => number[]);
-    _resolvePossibleFunction(arg: any): any;
+    _getOffset(): number[] | PopperOffsetFunction;
+    _resolvePossibleFunction<T>(arg: T | ((this: HTMLElement, element: HTMLElement) => T)): T;
     _getPopperConfig(attachment: string): Partial<Popper.Options>;
     _setListeners(): void;
     _fixTitle(): void;
     _enter(): void;
     _leave(): void;
+    _getDelay(): {
+        show: number;
+        hide: number;
+    };
     _setTimeout(handler: () => void, timeout: number): void;
     _isWithActiveTrigger(): boolean;
-    _getConfig(config: Partial<ComponentConfig>): ComponentConfig;
+    _getConfig(config?: ComponentConfigInput): ComponentConfig;
     _configAfterMerge(config: ComponentConfig): ComponentConfig;
-    _getDelegateConfig(): Partial<ComponentConfig>;
+    _getDelegateConfig(): ComponentConfigInput;
     _disposePopper(): void;
+    static jQueryInterface(this: JQueryCollectionLike, config?: unknown): unknown;
 }
 export default Tooltip;

package/dist/types/src/bootstrap/types.d.ts

@@ -4,7 +4,7 @@
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  * --------------------------------------------------------------------------
  */
-export type ComponentConfig = Record<string, any>;
+export type ComponentConfig = Record<string, unknown>;
 export type ComponentConfigType = Record<string, string>;
 export type ElementSelector = string | HTMLElement;
 export interface ConfigStatic {
@@ -18,3 +18,27 @@ export interface BaseComponentStatic extends ConfigStatic {
 }
 export type AllowList = Record<string, (string | RegExp)[]>;
 export type SanitizeFn = (unsafeHtml: string) => string;
+export interface JQueryEventLike {
+    isPropagationStopped(): boolean;
+    isImmediatePropagationStopped(): boolean;
+    isDefaultPrevented(): boolean;
+    preventDefault(): void;
+}
+export interface JQueryCollectionLike {
+    trigger(event: JQueryEventLike): unknown;
+    each(callback: (this: HTMLElement, index: number) => void): unknown;
+}
+export interface JQueryPluginFunction {
+    (this: JQueryCollectionLike, config?: unknown, ...args: unknown[]): unknown;
+    Constructor?: unknown;
+    noConflict?: () => JQueryPluginFunction;
+}
+export interface JQueryStaticLike {
+    fn: Record<string, JQueryPluginFunction>;
+    (selector: EventTarget): JQueryCollectionLike;
+    Event(name: string, args?: Record<string, unknown>): JQueryEventLike;
+}
+export interface JQueryPluginStatic {
+    NAME: string;
+    jQueryInterface: JQueryPluginFunction;
+}

package/dist/types/src/bootstrap/util/backdrop.d.ts

@@ -6,13 +6,13 @@
  */
 import Config from './config';
 import type { ComponentConfig, ComponentConfigType } from '../types';
-interface BackdropConfig {
+type BackdropConfig = {
     className: string;
     clickCallback: (() => void) | null;
     isAnimated: boolean;
     isVisible: boolean;
     rootElement: HTMLElement | string;
-}
+};
 declare class Backdrop extends Config {
     _config: BackdropConfig & ComponentConfig;
     _isAppended: boolean;

package/dist/types/src/bootstrap/util/component-functions.d.ts

@@ -4,10 +4,30 @@
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  * --------------------------------------------------------------------------
  */
+type ComponentInstance = unknown;
+interface PluginComponent {
+    NAME: string;
+    getOrCreateInstance(element: HTMLElement | string | null): ComponentInstance;
+}
+interface EventActionData {
+    targets: HTMLElement[];
+    event: Event;
+}
+interface PluginEventActionData extends EventActionData {
+    instances: ComponentInstance[];
+}
 interface DismissibleComponent {
     EVENT_KEY: string;
     NAME: string;
-    getOrCreateInstance(element: HTMLElement | string | null): any;
+    getOrCreateInstance(element: HTMLElement | string | null): ComponentInstance;
 }
 declare const enableDismissTrigger: (component: DismissibleComponent, method?: string) => void;
-export { enableDismissTrigger };
+declare const eventAction: (onEvent: string, stringSelector: string, callback: (data: EventActionData) => void) => void;
+declare const eventActionOnPlugin: (Plugin: PluginComponent, onEvent: string, stringSelector: string, method: string, callback?: ((data: PluginEventActionData) => void) | null) => void;
+/**
+ * Creates the component for every element that matches on page load. One
+ * element with a broken config must not stop the rest of the bundle, so the
+ * error is logged and the loop goes on.
+ */
+declare const initAll: (selector: string, Plugin: PluginComponent, filter?: ((element: HTMLElement) => boolean) | null) => void;
+export { enableDismissTrigger, eventAction, eventActionOnPlugin, initAll };

package/dist/types/src/bootstrap/util/focustrap.d.ts

@@ -6,10 +6,10 @@
  */
 import Config from './config';
 import type { ComponentConfig, ComponentConfigType } from '../types';
-interface FocusTrapConfig {
+type FocusTrapConfig = {
     autofocus: boolean;
     trapElement: HTMLElement | null;
-}
+};
 declare class FocusTrap extends Config {
     _config: FocusTrapConfig & ComponentConfig;
     _isActive: boolean;

package/dist/types/src/bootstrap/util/index.d.ts

@@ -4,6 +4,7 @@
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  * --------------------------------------------------------------------------
  */
+import type { JQueryPluginStatic, JQueryStaticLike } from '../types';
 declare const parseSelector: (selector: string) => string;
 declare const toType: (object: unknown) => string;
 declare const getUID: (prefix: string) => string;
@@ -22,7 +23,10 @@ declare const noop: () => void;
  */
 declare const reflow: (element: HTMLElement) => void;
 declare const isRTL: () => boolean;
+declare const getjQuery: () => JQueryStaticLike | null;
+declare const onDOMContentLoaded: (callback: () => void) => void;
+declare const defineJQueryPlugin: (plugin: JQueryPluginStatic) => void;
 declare const execute: (possibleCallback: unknown, args?: unknown[], defaultValue?: unknown) => unknown;
 declare const executeAfterTransition: (callback: () => void, transitionElement: HTMLElement, waitForTransition?: boolean) => void;
 declare const getNextActiveElement: <T>(list: T[], activeElement: T, shouldGetNext: boolean, isCycleAllowed: boolean) => T;
-export { execute, executeAfterTransition, findShadowRoot, getElement, getNextActiveElement, getTransitionDurationFromElement, getUID, isDisabled, isElement, isRTL, isVisible, noop, parseSelector, reflow, triggerTransitionEnd, toType };
+export { defineJQueryPlugin, execute, executeAfterTransition, findShadowRoot, getElement, getjQuery, getNextActiveElement, getTransitionDurationFromElement, getUID, isDisabled, isElement, isRTL, isVisible, noop, onDOMContentLoaded, parseSelector, reflow, triggerTransitionEnd, toType };

package/dist/types/src/bootstrap/util/swipe.d.ts

@@ -6,11 +6,11 @@
  */
 import Config from './config';
 import type { ComponentConfig, ComponentConfigType } from '../types';
-interface SwipeConfig {
+type SwipeConfig = {
     endCallback: (() => void) | null;
     leftCallback: (() => void) | null;
     rightCallback: (() => void) | null;
-}
+};
 declare class Swipe extends Config {
     _config: SwipeConfig & ComponentConfig;
     _element: HTMLElement;

package/dist/types/src/bootstrap/util/template-factory.d.ts

@@ -6,7 +6,7 @@
  */
 import Config from './config';
 import type { AllowList, ComponentConfig, ComponentConfigType, SanitizeFn } from '../types';
-interface TemplateFactoryConfig {
+type TemplateFactoryConfig = {
     allowList: AllowList;
     content: Record<string, unknown>;
     extraClass: string | (() => string);
@@ -14,7 +14,7 @@ interface TemplateFactoryConfig {
     sanitize: boolean;
     sanitizeFn: SanitizeFn | null;
     template: string;
-}
+};
 declare class TemplateFactory extends Config {
     _config: TemplateFactoryConfig & ComponentConfig;
     constructor(config?: ComponentConfig);

package/dist/types/src/clipboard.d.ts

@@ -0,0 +1,45 @@
+/**
+ * --------------------------------------------------------------------------
+ * Tabler clipboard.ts
+ * Licensed under MIT (https://github.com/tabler/tabler/blob/dev/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+import BaseComponent from './bootstrap/base-component';
+import type { ElementSelector } from './bootstrap/types';
+type ComponentConfig = {
+    /** selector of the element to read the text from */
+    target: string | null;
+    /** literal text to copy; wins over `target` */
+    text: string | null;
+    /** how long the copied state lasts, in milliseconds */
+    delay: number;
+};
+type ComponentConfigInput = Partial<ComponentConfig> & Record<string, unknown>;
+/**
+ * Class definition
+ *
+ * Copies text to the clipboard when the trigger is clicked, then shows the
+ * copied state for a moment. Every word lives in the markup: the trigger holds
+ * a `clipboard-label` and a `clipboard-feedback`, and the component only swaps
+ * which of them is hidden.
+ *
+ * The browser gives `navigator.clipboard` to secure contexts only, so on plain
+ * http a copy fails and `error.bs.clipboard` fires.
+ */
+declare class Clipboard extends BaseComponent {
+    _element: HTMLElement;
+    _config: ComponentConfig;
+    _labels: Element[];
+    _feedbacks: Element[];
+    _timeout: number;
+    constructor(element: ElementSelector, config?: ComponentConfigInput);
+    static get Default(): ComponentConfig;
+    static get DefaultType(): Record<keyof ComponentConfig, string>;
+    static get NAME(): string;
+    get text(): string;
+    copy(): Promise<void>;
+    dispose(): void;
+    _showCopied(): void;
+    _toggleCopied(copied: boolean): void;
+}
+export default Clipboard;

package/dist/types/src/confetti.d.ts

@@ -0,0 +1,58 @@
+/**
+ * --------------------------------------------------------------------------
+ * Tabler confetti.ts
+ * Licensed under MIT (https://github.com/tabler/tabler/blob/dev/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+import BaseComponent from './bootstrap/base-component';
+import type { ComponentConfig as BaseConfig, ElementSelector } from './bootstrap/types';
+type ComponentConfig = {
+    /** how many pieces one burst pours out */
+    count: number;
+    /** ms during which pieces keep pouring; the first frames get the most */
+    duration: number;
+    /** how fast the pour thins out; higher means a sharper splash at the start */
+    decay: number;
+    /** share of the viewport height at the bottom where pieces fade out */
+    fade: number;
+    /** multiplier for the fall speed */
+    speed: number;
+    /** piece colours; `null` reads the Tabler palette from CSS custom properties */
+    colors: string[] | null;
+};
+type ComponentConfigInput = Partial<Omit<ComponentConfig, 'colors'>> & {
+    colors?: string[] | string | null;
+};
+type Emitter = {
+    element: HTMLElement;
+    config: ComponentConfig;
+    colors: string[];
+    startedAt: number;
+    emitted: number;
+    /** `stop()` was called: nothing new is poured, what is in the air still falls */
+    stopped: boolean;
+    /** every piece has landed and `end` was fired */
+    done: boolean;
+};
+/**
+ * Class definition
+ *
+ * Pours a short shower of confetti over the page, like a bucket emptied from
+ * the top edge: dense at first, then thinning out. Nothing is drawn when the
+ * user prefers reduced motion, but the events still fire.
+ */
+declare class Confetti extends BaseComponent {
+    _element: HTMLElement;
+    _config: ComponentConfig;
+    _emitter: Emitter | null;
+    constructor(element: ElementSelector, config?: ComponentConfigInput);
+    static get Default(): ComponentConfig;
+    static get DefaultType(): Record<keyof ComponentConfig, string>;
+    static get NAME(): string;
+    burst(): void;
+    stop(): void;
+    dispose(): void;
+    _configAfterMerge(config: BaseConfig): BaseConfig;
+    _colors(): string[];
+}
+export default Confetti;

package/dist/types/src/countup.d.ts

@@ -1 +1,64 @@
-declare const countupElements: NodeListOf<HTMLElement>;
+/**
+ * --------------------------------------------------------------------------
+ * Tabler countup.ts
+ * Licensed under MIT (https://github.com/tabler/tabler/blob/dev/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+import BaseComponent from './bootstrap/base-component';
+import type { ElementSelector } from './bootstrap/types';
+type CountUpFormat = 'number' | 'time';
+type ComponentConfig = {
+    /** start when the element scrolls into view; off starts at once */
+    autoAnimate: boolean;
+    startVal: number;
+    /** seconds */
+    duration: number;
+    decimalPlaces: number;
+    useEasing: boolean;
+    useGrouping: boolean;
+    separator: string;
+    decimal: string;
+    prefix: string;
+    suffix: string;
+    /** `number`, or `time` for a value in minutes shown as h:mm */
+    format: CountUpFormat;
+    /** custom rendering of the number, from a JavaScript config only */
+    formatter: ((value: number) => string) | null;
+};
+type ComponentConfigInput = Partial<ComponentConfig> & Record<string, unknown>;
+/**
+ * Class definition
+ *
+ * Animates the number written inside the element from `startVal` to it,
+ * formatted with grouping, decimals, a prefix and a suffix. Options come from
+ * the `data-countup` attribute as JSON, or from the config object.
+ */
+declare class CountUp extends BaseComponent {
+    _element: HTMLElement;
+    _config: ComponentConfig;
+    _endVal: number;
+    _value: number;
+    _frame: number;
+    _observer: IntersectionObserver | null;
+    _from: number;
+    _elapsed: number;
+    _running: boolean;
+    _paused: boolean;
+    constructor(element: ElementSelector, config?: ComponentConfigInput);
+    static get Default(): ComponentConfig;
+    static get DefaultType(): Record<keyof ComponentConfig, string>;
+    static get NAME(): string;
+    start(): void;
+    reset(): void;
+    update(value: number | string): void;
+    pauseResume(): void;
+    dispose(): void;
+    _mergeConfigObj(config?: Record<string, unknown>, element?: HTMLElement): Record<string, unknown>;
+    _animate(from: number, to: number): void;
+    _run(): void;
+    _finish(value: number): void;
+    _stop(): void;
+    _print(value: number): void;
+    _format(value: number): string;
+}
+export default CountUp;

package/dist/types/src/datepicker.d.ts

@@ -0,0 +1,102 @@
+/**
+ * --------------------------------------------------------------------------
+ * Tabler datepicker.ts
+ * Licensed under MIT (https://github.com/tabler/tabler/blob/dev/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+import type { Calendar, DateAny, DateMode, DatesArr, MonthsCount, Options, PositionToInput, WeekDayID } from 'vanilla-calendar-pro';
+import BaseComponent from './bootstrap/base-component';
+import type { ElementSelector } from './bootstrap/types';
+type ComponentConfig = {
+    /** 'light', 'dark' or 'auto' for the popup only; null inherits from the nearest `[data-bs-theme]` */
+    datepickerTheme: string | null;
+    dateMin: DateAny | null;
+    dateMax: DateAny | null;
+    /** `Intl.DateTimeFormat` options, or a function(date, locale) returning the text shown in the field */
+    dateFormat: Intl.DateTimeFormatOptions | ((date: Date, locale: string | undefined) => string) | null;
+    /** element that shows the formatted date; a button uses itself or its `[data-bs-datepicker-display]` child */
+    displayElement: string | HTMLElement | boolean | null;
+    displayMonthsCount: MonthsCount;
+    /** 0 = Sunday, 1 = Monday */
+    firstWeekday: WeekDayID;
+    /** render the calendar in place instead of a popup */
+    inline: boolean;
+    locale: string;
+    /** element the popup is aligned with; defaults to the `.input-icon` / `.input-group` wrapper or the element */
+    positionElement: string | HTMLElement | null;
+    /** preselected dates as `YYYY-MM-DD` */
+    selectedDates: string[];
+    selectionMode: DateMode;
+    placement: PositionToInput;
+    /** pass-through for any Vanilla Calendar Pro option */
+    vcpOptions: Options;
+};
+type ComponentConfigInput = Partial<ComponentConfig> & Record<string, unknown>;
+type ChangeEventArgs = {
+    dates: string[];
+    event: MouseEvent;
+};
+/**
+ * Class definition
+ *
+ * Wraps Vanilla Calendar Pro (https://vanilla-calendar.pro), loaded separately
+ * as `window.VanillaCalendarPro`. Without the plugin the component is inert.
+ * Same options, methods and events as Bootstrap 6's Datepicker, so markup
+ * written for one works with the other.
+ */
+declare class Datepicker extends BaseComponent {
+    _element: HTMLElement & {
+        value: string;
+    };
+    _config: ComponentConfig;
+    _calendar: Calendar | null;
+    _isShown: boolean;
+    _isShowing: boolean;
+    _isHiding: boolean;
+    _isSilent: boolean;
+    _skipPluginShow: boolean;
+    _resolveShown: (() => void) | null;
+    _isInput: boolean;
+    _isInline: boolean;
+    _boundInput: HTMLInputElement | null;
+    _positionElement: HTMLElement | null;
+    _displayElement: HTMLElement | false | null;
+    _themeObserver: MutationObserver | null;
+    _onFocusIn: ((event: Event) => void) | null;
+    _selectedDates: string[];
+    constructor(element: ElementSelector, config?: ComponentConfigInput);
+    static get Default(): ComponentConfig;
+    static get DefaultType(): Record<keyof ComponentConfig, string>;
+    static get NAME(): string;
+    /** The Vanilla Calendar Pro instance, for options the component does not expose. */
+    get calendar(): Calendar | null;
+    toggle(): Promise<void>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    dispose(): void;
+    getSelectedDates(): string[];
+    setSelectedDates(dates: DatesArr): void;
+    _initCalendar(): void;
+    _updateDisplayWithSelectedDates(): void;
+    _writeSelection(selectedDates: string[]): void;
+    _resolvePositionElement(): HTMLElement;
+    _resolveDisplayElement(): HTMLElement | false | null;
+    _alignToPositionElement(): void;
+    _getThemeAncestor(): Element | null;
+    _getEffectiveTheme(): string | null;
+    _syncThemeAttribute(element: HTMLElement | undefined): void;
+    _setupThemeObserver(): void;
+    _setupDismissOnFocus(): void;
+    _silently(callback: () => void): void;
+    _handlePluginShow(): void;
+    _handlePluginHide(): void;
+    _buildCalendarOptions(): Options;
+    _handleDateClick(self: Calendar, event: MouseEvent): void;
+    _maybeHideAfterSelection(selectedDates: string[]): void;
+    _parseDate(dateStr: string): Date;
+    _formatDate(dateStr: string): string;
+    _formatDateForInput(dates: string[]): string;
+    _parseInputValue(): void;
+}
+export default Datepicker;
+export type { ComponentConfig as DatepickerConfig, ChangeEventArgs as DatepickerChangeEventArgs };

package/dist/types/src/deprecated.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Helpers kept only so that projects written for an older 1.x release keep
+ * working. They are exported as the `tabler` namespace: `tabler.tabler.getColor()`
+ * from the bundle, `import { tabler } from '@tabler/core'` from the module.
+ *
+ * Removed in 2.0, together with this file. Read the custom property yourself,
+ * and mix the opacity in with `color-mix()`.
+ */
+export declare const prefix: string;
+export declare const hexToRgba: (hex: string, opacity: number) => string | null;
+export declare const getColor: (color: string, opacity?: number) => string | null;

package/dist/types/src/input-mask.d.ts

@@ -1 +1,42 @@
-declare const maskElementList: HTMLElement[];
+/**
+ * --------------------------------------------------------------------------
+ * Tabler input-mask.ts
+ * Licensed under MIT (https://github.com/tabler/tabler/blob/dev/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+import BaseComponent from './bootstrap/base-component';
+import type { ElementSelector } from './bootstrap/types';
+interface IMaskInstance {
+    value: string;
+    unmaskedValue: string;
+    updateValue(): void;
+    updateOptions(options: Record<string, unknown>): void;
+    destroy(): void;
+}
+type ComponentConfig = {
+    mask: string;
+    lazy: boolean;
+};
+type ComponentConfigInput = Partial<ComponentConfig> & Record<string, unknown>;
+/**
+ * Class definition
+ *
+ * Wraps the IMask plugin (https://imask.js.org), loaded separately as
+ * `window.IMask`. Without the plugin the component is inert.
+ */
+declare class InputMask extends BaseComponent {
+    _element: HTMLInputElement;
+    _config: ComponentConfig;
+    _mask: IMaskInstance | null;
+    constructor(element: ElementSelector, config?: ComponentConfigInput);
+    static get Default(): ComponentConfig;
+    static get DefaultType(): Record<keyof ComponentConfig, string>;
+    static get NAME(): string;
+    /** The IMask instance, for options the component does not expose. */
+    get mask(): IMaskInstance | null;
+    update(): void;
+    dispose(): void;
+    _mergeConfigObj(config?: Record<string, unknown>, element?: HTMLElement): Record<string, unknown>;
+}
+export default InputMask;
+export type { IMaskInstance };