@oscarpalmer/oui 0.31.0 → 0.33.0

package/dist/js/index.d.mts

@@ -1,14 +1,643 @@
-import { OuiComboboxElement } from "./combobox.mjs";
-import { d as OuiSortable, f as createSortable, g as createMovable, h as OuiMovable, t as CreateOuiDraggableOptions } from "./draggable-a6w0J1OD.mjs";
-import "./movable/movable.standalone.mjs";
-import { a as createResizable, n as OuiResizable, t as CreateOuiResizableOptions } from "./resizable.embedded-3qoR0Bjm.mjs";
-import "./resizable/resizable.standalone.mjs";
-import { OuiDialog, getDialog } from "./dialog.mjs";
-import { a as OuiFloatablePosition, n as CreateOuiFloatableOptions, r as OuiFloatable, s as createFloatable } from "./floatable.embedded-Bct4U5Dm.mjs";
-import "./floatable/floatable.standalone.mjs";
-import { a as OuiFocusTrapOptions, i as OuiFocusTrap, o as createFocusTrap } from "./focus-trap.embedded-DR8NpZfr.mjs";
-import { OuiPopover, getPopover } from "./popover.mjs";
-import "./sortable/sortable.standalone.mjs";
-import { OuiSplitterElement } from "./splitter.mjs";
-import { OuiTooltip, getTooltip, setTooltipDelay } from "./tooltip.mjs";
-export { type CreateOuiFloatableOptions, type CreateOuiDraggableOptions as CreateOuiMovableOptions, type CreateOuiDraggableOptions as CreateOuiSortableOptions, type CreateOuiResizableOptions, OuiComboboxElement, type OuiDialog, type OuiFloatable, type OuiFloatablePosition, type OuiFocusTrap, type OuiFocusTrapOptions, type OuiMovable, type OuiPopover, type OuiResizable, type OuiSortable, OuiSplitterElement, type OuiTooltip, createFloatable, createFocusTrap, createMovable, createResizable as createOuiResizable, createSortable, getDialog, getPopover, getTooltip, setTooltipDelay };
+//#region src/js/combobox.d.ts
+declare global {
+  interface HTMLElementTagNameMap {
+    [TAGNAME$1]: OuiComboboxElement;
+  }
+}
+declare class OuiComboboxElement extends HTMLElement {
+  #private;
+  static formAssociated: boolean;
+  static observedAttributes: string[];
+  /**
+   * Is the combobox disabled?
+   */
+  get disabled(): boolean;
+  /**
+   * Should the combobox be disabled?
+   */
+  set disabled(value: boolean);
+  /**
+   * Current filter value
+   */
+  get filter(): string;
+  /**
+   * Set the filter value
+   */
+  set filter(value: string);
+  /**
+   * Maximum number of selected options
+   */
+  get max(): number | undefined;
+  /**
+   * Set the maximum number of selected options
+   */
+  set max(value: number);
+  /**
+   * Minimum number of selected options
+   */
+  get min(): number | undefined;
+  /**
+   * Set the minimum number of selected options
+   */
+  set min(value: number);
+  /**
+   * Does the combobox allow multiple values?
+   */
+  get multiple(): boolean;
+  /**
+   * Name of the combobox
+   */
+  get name(): string;
+  /**
+   * Is the combobox readonly?
+   */
+  get readonly(): boolean;
+  /**
+   * Should the combobox be readonly?
+   */
+  set readonly(value: boolean);
+  /**
+   * Is the combobox required?
+   */
+  get required(): boolean;
+  /**
+   * Should the combobox be required?
+   */
+  set required(value: boolean);
+  /**
+   * Selected options
+   */
+  get selected(): HTMLElement[];
+  /**
+   * Type of combobox
+   */
+  get type(): OuiComboboxType;
+  /**
+   * Current value
+   */
+  get value(): string;
+  /**
+   * Set the value
+   */
+  set value(value: unknown);
+  /**
+   * Current values
+   */
+  get values(): string[];
+  /**
+   * Set the values
+   */
+  set values(value: unknown[]);
+  constructor();
+  attributeChangedCallback(name: string, _: string | null, value: string | null): void;
+  /**
+   * Clear all selected options
+   */
+  clear(): void;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  formDisabledCallback(disabled: boolean): void;
+  formResetCallback(): void;
+  formStateRestoreCallback(state: string | File | FormData, reason: unknown): void;
+  /**
+   * Set combobox localizations for a specific language
+   *
+   * @param language Language code
+   * @param localizations Localizations for language
+   */
+  setLocalizations(language: string, localizations: Partial<OuiComboboxLocalizations>): void;
+  /**
+   * Set combobox localizations for one or more languages
+   *
+   * @param localizations Localizations for one or more languages
+   */
+  setLocalizations(localizations: Record<string, Partial<OuiComboboxLocalizations>>): void;
+}
+type OuiComboboxLocalizations = {
+  empty: string | (() => string);
+  input: string | (() => string);
+  invalid: string | (() => string);
+  max: string | ((max: number) => string);
+  min: string | ((min: number) => string);
+  remove: string | ((label: string, value: string) => string);
+  results: string | ((amount: number) => string);
+  selected: string | ((amount: number) => string);
+};
+type OuiComboboxType = 'autocomplete' | 'select';
+/**
+ * Set combobox localizations for a specific language
+ *
+ * @param language Language code
+ * @param localizations Localizations for language
+ */
+declare function setLocalizations(language: string, localizations: Partial<OuiComboboxLocalizations>): void;
+/**
+ * Set combobox localizations for one or more languages
+ *
+ * @param localizations Localizations for one or more languages
+ */
+declare function setLocalizations(localizations: Record<string, Partial<OuiComboboxLocalizations>>): void;
+declare const TAGNAME$1 = "oui-combobox";
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/models.d.mts
+/**
+ * Event listener that can be removed
+ */
+type RemovableEventListener = () => void;
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/models.d.mts
+/**
+ * Position of an event
+ */
+type EventPosition = {
+  x: number;
+  y: number;
+};
+/**
+ * A generic object
+ */
+type PlainObject = Record<PropertyKey, unknown>;
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/style.d.mts
+//#region src/style.d.ts
+type StyleToggler = {
+  /**
+   * Set the provided styles on the element
+   */
+  set(): void;
+  /**
+   * Remove the provided styles from the element _(and sets any previous styles)_
+   */
+  remove(): void;
+};
+//#endregion
+//#region src/js/movable/movable.embedded.d.ts
+declare class OuiMovable extends OuiDraggable<OuiMovableState> {
+  #private;
+  constructor(element: HTMLElement, options?: CreateOuiDraggableOptions);
+  /**
+   * Destroys the _Movable_
+   */
+  destroy(): void;
+}
+type OuiMovableState = {
+  hasHandles?: boolean;
+  moved: boolean;
+  offset?: Partial<EventPosition>;
+  style: OuiMovableStyle;
+};
+type OuiMovableStyle = {
+  inset: string | undefined;
+  position: string | undefined;
+};
+/**
+ * Creates _(or retrieves)_ a _OuiMovable_ instance for an element
+ *
+ * @param element Element to make movable
+ * @returns _OuiMovable_ instance
+ */
+declare function createMovable(element: HTMLElement, options?: CreateOuiDraggableOptions): OuiMovable;
+//#endregion
+//#region src/js/sortable/sortable.embedded.d.ts
+declare class OuiSortable extends OuiDraggable<OuiSortableState> {
+  constructor(element: HTMLElement, options?: CreateOuiDraggableOptions);
+}
+type OuiSortableState = {
+  connections: string | null | undefined;
+  origin?: HTMLElement;
+};
+/**
+ * Creates _(or retrieves)_ a _OuiSortable_ instance for an element
+ *
+ * @param element Element to make sortable
+ * @returns _OuiSortable_ instance
+ */
+declare function createSortable(element: HTMLElement, options?: CreateOuiDraggableOptions): OuiSortable;
+//#endregion
+//#region src/js/internal/draggable.d.ts
+type CreateOuiDraggableOptions = {
+  /**
+   * Container to hold the draggable element and restrict its movement within. Can be `body`, `document`, `window`, a _CSS_ selector, or an element. _(If not provided, the draggable element will not have any constraints)_
+   */
+  container?: string | HTMLElement;
+  /**
+   * Direction in which the element can be dragged. _(If not provided, the element can be dragged in any direction)_
+   */
+  direction?: OuiDraggableDirection;
+};
+type OuiDraggableDirection = 'horizontal' | 'vertical' | 'x' | 'y';
+declare abstract class OuiDraggable<ExtraState extends PlainObject = PlainObject> {
+  #private;
+  get element(): HTMLElement;
+  constructor(name: keyof OuiDraggableStates, event: string, attribute: string, element: HTMLElement, options: OuiDraggableOptions<ExtraState>, extras: ExtraState);
+  destroy(): void;
+}
+type OuiDragBegin<State extends PlainObject = PlainObject> = (event: MouseEvent | TouchEvent, globals: OuiDraggableGlobals, item: OuiDraggableItem<State>, element: HTMLElement, handle: HTMLElement, position: EventPosition) => void;
+type OuiDragCancel<State extends PlainObject = PlainObject> = (globals: OuiDraggableGlobals, item: OuiDraggableItem<State>) => void;
+type OuiDragEnd<State extends PlainObject = PlainObject> = (event: MouseEvent | TouchEvent, globals: OuiDraggableGlobals, item: OuiDraggableItem<State>, reset: () => void) => void;
+type OuiDragMove<State extends PlainObject = PlainObject> = (event: MouseEvent | TouchEvent, globals: OuiDraggableGlobals, item: OuiDraggableItem<State>, position: OuiDragMovePosition) => PlainObject | undefined;
+type OuiDragMovePosition = {
+  calculated: EventPosition;
+  original: EventPosition;
+};
+type OuiDraggableGlobals = {
+  container?: DOMRect;
+  element?: OuiDraggableGlobalsElement;
+  instances: WeakMap<HTMLElement, OuiDraggableInstances>;
+  offset?: EventPosition;
+  original?: EventPosition;
+  states: WeakMap<HTMLElement, OuiDraggableStates>;
+};
+type OuiDraggableGlobalsElement = {
+  node: HTMLElement;
+  rectangle: DOMRect;
+};
+type OuiDraggableInstances = {
+  movable?: OuiMovable;
+  sortable?: OuiSortable;
+};
+type OuiDraggableItem<ExtraState extends PlainObject = PlainObject> = {
+  instance: OuiDraggable<ExtraState>;
+  state: OuiDraggableState & ExtraState;
+};
+type OuiDraggableOptions<ExtraState extends PlainObject = PlainObject> = {
+  container: OuiDraggableOptionsContainer<ExtraState>;
+  direction: OuiDraggableOptionsDirection<ExtraState>;
+  drag: OuiDraggableOptionsDrag<ExtraState>;
+  input?: CreateOuiDraggableOptions;
+  position: OuiDraggableOptionsPosition<ExtraState>;
+  getDragged(): HTMLElement;
+  getOrigin(): HTMLElement | undefined;
+};
+type OuiDraggableOptionsContainer<ExtraState extends PlainObject = PlainObject> = {
+  attribute: string;
+  map: Map<HTMLElement, Set<OuiDraggable>>;
+  onDestroy?: OuiDraggableOptionsContainerOnDestroy<ExtraState>;
+  onInitialize?: OuiDraggableOptionsContainerOnInitialize;
+};
+type OuiDraggableOptionsContainerOnDestroy<ExtraState extends PlainObject = PlainObject> = (item: OuiDraggableItem<ExtraState>, container: HTMLElement, empty: boolean) => void;
+type OuiDraggableOptionsContainerOnInitialize<ExtraState extends PlainObject = PlainObject> = (item: OuiDraggableItem<ExtraState>) => void;
+type OuiDraggableOptionsDirection<ExtraState extends PlainObject = PlainObject> = {
+  attribute: string;
+  onAfter?: OuiDraggableOptionsDirectionOnAfter<ExtraState>;
+};
+type OuiDraggableOptionsDirectionOnAfter<ExtraState extends PlainObject = PlainObject> = (item: OuiDraggableItem<ExtraState>) => void;
+type OuiDraggableOptionsDrag<ExtraState extends PlainObject = PlainObject> = {
+  onBegin: OuiDragBegin<ExtraState>;
+  onCancel: OuiDragCancel<ExtraState>;
+  onEnd: OuiDragEnd<ExtraState>;
+  onMove: OuiDragMove<ExtraState>;
+};
+type OuiDraggableOptionsPosition<ExtraState extends PlainObject = PlainObject> = {
+  getOffset: OuiDraggableOptionsPositionGetOffset<ExtraState>;
+  getOriginal: OuiDraggableOptionsPositionGetOriginal<ExtraState>;
+};
+type OuiDraggableOptionsPositionGetOffset<ExtraState extends PlainObject = PlainObject> = (globals: OuiDraggableGlobals, item: OuiDraggableItem<ExtraState>, element: HTMLElement, position: EventPosition) => EventPosition;
+type OuiDraggableOptionsPositionGetOriginal<ExtraState extends PlainObject = PlainObject> = (globals: OuiDraggableGlobals, item: OuiDraggableItem<ExtraState>, position: EventPosition) => EventPosition;
+type OuiDraggableState = {
+  attribute: string;
+  container?: HTMLElement;
+  element: HTMLElement;
+  hasHandles?: boolean;
+  horizontal: boolean;
+  name: keyof OuiDraggableStates;
+  options: OuiDraggableOptions;
+  styling: StyleToggler;
+  vertical: boolean;
+};
+type OuiDraggableStates = {
+  movable?: OuiDraggableState;
+  sortable?: OuiDraggableState;
+};
+//#endregion
+//#region src/js/resizable/resizable.embedded.d.ts
+type CreateOuiResizableOptions = {
+  maximumHeight?: number;
+  maximumWidth?: number;
+  minimumHeight?: number;
+  minimumWidth?: number;
+};
+declare class OuiResizable {
+  #private;
+  constructor(state: OuiResizableState);
+  destroy(): void;
+  set(): void;
+  reset(): void;
+}
+type OuiResizableState = {
+  element: HTMLElement;
+  handle: HTMLElement;
+  height: number;
+  options: Required<CreateOuiResizableOptions>;
+  styles: StyleToggler;
+  width: number;
+};
+/**
+ * Creates _(or retrieves)_ a _OuiResizable_ instance for an element
+ *
+ * @param element Element to make resizable
+ * @returns _OuiResizable_ instance
+ */
+declare function createResizable(element: HTMLElement, options?: CreateOuiResizableOptions): OuiResizable;
+//#endregion
+//#region src/js/dialog.d.ts
+declare class OuiDialog {
+  #private;
+  /**
+   * Is the dialog open?
+   */
+  get open(): boolean;
+  /**
+   * Open or close the dialog
+   */
+  set open(value: boolean);
+  constructor(state: OuiDialogState);
+  /**
+   * Closes the dialog by request
+   */
+  hide(request: true, value?: string): void;
+  /**
+   * Closes the dialog
+   */
+  hide(value?: string): void;
+  /**
+   * Opens the dialog
+   */
+  show(modal?: boolean): void;
+}
+type OuiDialogState = {
+  dialog: OuiDialog;
+  element: HTMLDialogElement;
+  listeners: RemovableEventListener[];
+  modal: boolean;
+  movable?: OuiMovable;
+  resizable?: OuiResizable;
+};
+/**
+ * Get the _OuiDialog_ for an element
+ *
+ * @param element Element to get _OuiDialog_ for
+ * @returns _OuiDialog_ instance
+ */
+declare function getDialog(element: HTMLDialogElement): OuiDialog | undefined;
+//#endregion
+//#region src/js/floatable/floatable.embedded.d.ts
+type CreateOuiFloatableOptions = {
+  /**
+   * Open the floatable when created? _(defaults to `true`)_
+   */
+  open?: boolean;
+  /**
+   * Position of the floatable _(defaults to `below`)_
+   */
+  position?: OuiFloatablePosition;
+};
+declare class OuiFloatable {
+  #private;
+  /**
+   * Is the floatable open?
+   */
+  get open(): boolean;
+  /**
+   * Open or close the floatable
+   */
+  set open(value: boolean);
+  constructor(state: OuiFloatableState, standalone: boolean);
+  /**
+   * Destroy the floatable, removing it from the DOM and cleaning up references
+   */
+  destroy(): void;
+  /**
+   * Closes the floatable
+   */
+  hide(): void;
+  /**
+   * Opens the floatable
+   */
+  show(): void;
+  /**
+   * Update the position of the floatable, with an optional new position
+   *
+   * @param position Optional new position
+   */
+  update(position?: OuiFloatablePosition): void;
+}
+type OuiFloatableOptions = {
+  attribute?: string;
+  position: OuiFloatablePosition;
+  reusable: boolean;
+};
+type OuiFloatablePosition = 'above' | 'above-end' | 'above-start' | 'below' | 'below-end' | 'below-start' | 'end' | 'end-bottom' | 'end-top' | 'start' | 'start-bottom' | 'start-top';
+type OuiFloatableState = {
+  anchor: HTMLElement;
+  content: HTMLElement;
+  name: string;
+  options: OuiFloatableOptions;
+};
+/**
+ * Create a _OuiFloatable_ for an anchor and content element
+ *
+ * @param anchor Anchor element
+ * @param content Content element
+ * @param options _OuiFloatable_ options
+ * @returns _OuiFloatable_ instance
+ */
+declare function createFloatable(anchor: HTMLElement, content: HTMLElement, options?: CreateOuiFloatableOptions): OuiFloatable;
+//#endregion
+//#region src/js/focus-trap/focus-trap.embedded.d.ts
+declare class OuiFocusTrap {
+  #private;
+  /**
+   * Is focused maintained within the _focus trap_ when clicking outside of it?
+   */
+  get contain(): boolean;
+  /**
+   * Should focus be maintained within the _focus trap_ when clicking outside of it?
+   */
+  set contain(value: boolean);
+  /**
+   * Is the _focus trap_ disabled?
+   */
+  get disabled(): boolean;
+  /**
+   * Should the _focus trap_ be disabled?
+   */
+  set disabled(value: boolean);
+  /**
+   * Is focus allowed to escape when pressing _Escape_ within the _focus trap_?
+   */
+  get noescape(): boolean;
+  /**
+   * Should the _focus trap_ allow focus to escape when pressing _Escape_?
+   */
+  set noescape(value: boolean);
+  constructor(state: OuiFocusTrapState);
+  /**
+   * Destroys the _focus trap_
+   */
+  destroy(): void;
+  /**
+   * Disables the _focus trap_
+   */
+  disable(): void;
+  /**
+   * Enables the _focus trap_
+   */
+  enable(): void;
+  /**
+   * Focuses the _focus trap_
+   *
+   * @param last When `true`, focuses the last focusable element within the _focus trap_ instead of the first
+   */
+  focus(last: boolean): void;
+}
+type OuiFocusTrapOptions = {
+  /**
+   * Should focus be maintained within the _focus trap_ when clicking outside of it?
+   */
+  contain?: boolean;
+  /**
+   * Should the _focus trap_ allow focus to escape when pressing _Escape_?
+   */
+  noescape?: boolean;
+};
+type OuiFocusTrapState = {
+  disabled: boolean;
+  element: HTMLElement;
+  options: Required<OuiFocusTrapOptions>;
+};
+/**
+ * Creates _(or retrieves)_ a _focus trap_ for an element
+ *
+ * @param element Element to trap focus within
+ * @param options _Focus trap_ options
+ * @returns _Focus trap_ instance
+ */
+declare function createFocusTrap(element: HTMLElement, options?: OuiFocusTrapOptions): OuiFocusTrap;
+//#endregion
+//#region src/js/popover.d.ts
+declare class OuiPopover {
+  #private;
+  /**
+   * Is the popover open?
+   */
+  get open(): boolean;
+  set open(value: boolean);
+  constructor(state: OuiPopoverState);
+  /**
+   * Closes the popover
+   */
+  hide(): void;
+  /**
+   * Opens the popover
+   */
+  show(): void;
+}
+type OuiPopoverState = {
+  anchor: HTMLElement;
+  content: HTMLElement;
+  floatable: OuiFloatable;
+  focusTrap?: OuiFocusTrap;
+  listeners: RemovableEventListener[];
+  popover: OuiPopover;
+};
+/**
+ * Get the _OuiPopover_ for an element
+ *
+ * @param element Element to get _OuiPopover_ for
+ * @returns _OuiPopover_ instance
+ */
+declare function getPopover(element: HTMLElement): OuiPopover | undefined;
+//#endregion
+//#region src/js/splitter.d.ts
+declare global {
+  interface HTMLElementTagNameMap {
+    [TAGNAME]: OuiSplitterElement;
+  }
+}
+declare class OuiSplitterElement extends HTMLElement {
+  #private;
+  static readonly observedAttributes: string[];
+  /**
+   * Maximum size for the first panel
+   */
+  get max(): number;
+  /**
+   * Maximum size for the first panel
+   */
+  set max(value: number);
+  /**
+   * Minimum size for the first panel
+   */
+  get min(): number;
+  /**
+   * Minimum size for the first panel
+   */
+  set min(value: number);
+  /**
+   * Current size for the first panel
+   */
+  get size(): number;
+  /**
+   * Current size for the first panel
+   */
+  set size(value: number);
+  /**
+   * Orientation of the splitter
+   */
+  get type(): string;
+  /**
+   * Orientation of the splitter
+   */
+  set type(value: string);
+  constructor();
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  attributeChangedCallback(name: string): void;
+}
+declare const TAGNAME = "oui-splitter";
+//#endregion
+//#region src/js/tooltip.d.ts
+declare class OuiTooltip {
+  #private;
+  /**
+   * Is the tooltip open?
+   */
+  get open(): boolean;
+  /**
+   * Open or close the tooltip
+   */
+  set open(value: boolean);
+  constructor(state: OuiTooltipState);
+  /**
+   * Closes the tooltip
+   */
+  hide(): void;
+  /**
+   * Opens the tooltip
+   */
+  show(): void;
+}
+type OuiTooltipState = {
+  anchor: HTMLElement;
+  elements: HTMLElement[];
+  floatable: OuiFloatable;
+  timer?: number;
+  tooltip: OuiTooltip;
+};
+/**
+ * Get the _OuiTooltip_ for an element
+ *
+ * @param element Element to get _OuiTooltip_ for
+ * @returns _OuiTooltip_ instance
+ */
+declare function getTooltip(element: HTMLElement): OuiTooltip | undefined;
+/**
+ * Set the delay before showing the tooltip, in milliseconds
+ *
+ * _(Default delay is half a second, or 500 milliseconds)_
+ * @param value Delay in milliseconds
+ */
+declare function setTooltipDelay(value: number): void;
+//#endregion
+export { type CreateOuiFloatableOptions, type CreateOuiDraggableOptions as CreateOuiMovableOptions, type CreateOuiDraggableOptions as CreateOuiSortableOptions, type CreateOuiResizableOptions, OuiComboboxElement, type OuiDialog, type OuiFloatable, type OuiFloatablePosition, type OuiFocusTrap, type OuiFocusTrapOptions, type OuiMovable, type OuiPopover, type OuiResizable, type OuiSortable, OuiSplitterElement, type OuiTooltip, createFloatable, createFocusTrap, createMovable, createResizable as createOuiResizable, createSortable, getDialog, getPopover, getTooltip, setLocalizations, setTooltipDelay };