@odx/foundation 1.0.0-beta.9 → 1.0.0-beta.90

package/dist/i18n/{lib/is-localized.d.ts → is-localized.d.ts}

@@ -1,5 +1,5 @@
-import { ReadonlySignal } from '@lit-labs/preact-signals';
-import { Constructor, CustomElement } from '../../lib/main.js';
+import { Constructor, CustomElement } from '../lib/main.js';
+import { ReadonlySignal } from '@preact/signals-core';
 import { formatDate, formatList, formatNumber, formatRelativeTime } from './format.js';
 import { getLocale } from './localization.js';
 import { translate } from './translate.js';

package/dist/i18n/{lib/localization.d.ts → localization.d.ts}

@@ -1,5 +1,5 @@
 import { LocaleInput } from './models.js';
 export declare function getLocale(localeInput?: LocaleInput | null): Intl.Locale;
 export declare function setLocale(localeInput?: LocaleInput | null): void;
-export declare function syncDocumentLanguage(root?: HTMLElement): () => void;
+export declare function syncDocumentLanguage(root?: HTMLElement): void;
 //# sourceMappingURL=localization.d.ts.map

package/dist/i18n/main.d.ts

@@ -1,7 +1,7 @@
-export * from './lib/config.js';
-export * from './lib/format.js';
-export * from './lib/is-localized.js';
-export * from './lib/localization.js';
-export * from './lib/models.js';
-export * from './lib/translate.js';
+export * from './config.js';
+export * from './format.js';
+export * from './is-localized.js';
+export * from './localization.js';
+export * from './models.js';
+export * from './translate.js';
 //# sourceMappingURL=main.d.ts.map

package/dist/i18n/{lib/translate.d.ts → translate.d.ts}

@@ -1,4 +1,4 @@
-import { ReadonlySignal } from '@lit-labs/preact-signals';
+import { ReadonlySignal } from '@preact/signals-core';
 import { LocaleInput } from './models.js';
 type Translation = {
     [key: string]: Translation | string;

package/dist/i18n.js

@@ -1,7 +1,9 @@
-import { signal, effect, computed, SignalWatcher } from '@lit-labs/preact-signals';
-import { parseDate, dedupeMixin } from '@odx/foundation';
+import { signal, effect, computed } from '@preact/signals-core';
+import { parseDate } from '@odx/foundation';
+import { _ as __decorateClass } from './_virtual_class-decorator-runtime.js';
+import { k as flattenObject, e } from './vendor.js';
+import 'lit/html.js';
 import { property } from 'lit/decorators.js';
-import { f as flattenObject } from './vendor-dJxQG085.js';
 
 const I18nConfig = (config) => ({
   defaultLocale: () => navigator.language,
@@ -67,7 +69,7 @@ function formatRelativeTime(input, options) {
   const value = parseDate(input);
   if (!value) return "";
   const { relativeTimeFormatOptions } = getI18nOptions({ relativeTimeFormatOptions: options });
-  const relativeTime = value.getTime() - (/* @__PURE__ */ new Date()).getTime();
+  const relativeTime = value.getTime() - Date.now();
   const timeUnit = findTimeUnit(Math.abs(relativeTime), relativeTimeFormatOptions?.minUnit);
   return new Intl.RelativeTimeFormat(options?.locale, relativeTimeFormatOptions).format(Math.round(relativeTime / timeUnit.value), timeUnit.unit);
 }
@@ -80,9 +82,10 @@ function setLocale(localeInput) {
   activeLocale.value = localeInput ? getLocale(localeInput) : null;
 }
 function syncDocumentLanguage(root = document.documentElement) {
-  return effect(() => {
+  const cleanup = effect(() => {
     root.lang = getLocale().toString();
   });
+  window.addEventListener("unload", cleanup);
 }
 
 const translations = signal({});
@@ -111,18 +114,8 @@ function getTranslationRecord(localeInput) {
   return translations.value[locale.toString()] ?? translations.value[locale.language] ?? null;
 }
 
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-const IsLocalized = dedupeMixin((superClass) => {
-  class IsLocalizedElement extends SignalWatcher(superClass) {
+const IsLocalized = (superClass) => {
+  class IsLocalizedElement extends e(superClass) {
     constructor() {
       super(...arguments);
       this.locale = computed(() => getLocale(this.lang));
@@ -147,6 +140,6 @@ const IsLocalized = dedupeMixin((superClass) => {
     property()
   ], IsLocalizedElement.prototype, "lang", 2);
   return IsLocalizedElement;
-});
+};
 
 export { I18nConfig, IsLocalized, formatDate, formatList, formatNumber, formatRelativeTime, getI18nOptions, getLocale, interpolate, setI18nOptions, setLocale, setTranslation, syncDocumentLanguage, translate };

package/dist/lib/{facade → control}/checkbox-form-control.d.ts

@@ -1,15 +1,15 @@
-import { CustomElement } from '../custom-element.js';
-declare const CheckboxFormControl_base: import('../main.js').Constructor<import('../mixins/form-control.js').IsFormControl<string>> & typeof CustomElement;
-export declare abstract class CheckboxFormControl extends CheckboxFormControl_base {
+import { FormControl } from './form-control.js';
+export declare abstract class CheckboxFormControl extends FormControl<string> {
     #private;
+    /** @internal */
     static shadowRootOptions: ShadowRootInit;
     role: 'checkbox' | 'menuitemcheckbox' | 'menuitemradio' | 'option' | 'radio' | 'switch' | null;
     checked: boolean;
+    value: string;
     constructor();
     toFormValue(): string | File | FormData | null;
     toggle(state?: boolean, emitEvent?: boolean): void;
     connectedCallback(): void;
     updateAriaAttributes(): void;
 }
-export {};
 //# sourceMappingURL=checkbox-form-control.d.ts.map

package/dist/lib/control/checkbox-group-form-control.d.ts

@@ -0,0 +1,22 @@
+import { PropertyValues } from 'lit';
+import { CheckboxFormControl } from './checkbox-form-control.js';
+import { FormControl } from './form-control.js';
+export declare abstract class CheckboxGroupFormControl extends FormControl<string[]> {
+    #private;
+    private elements;
+    protected get childGroups(): CheckboxGroupFormControl[];
+    get controls(): CheckboxFormControl[];
+    get selectedControls(): CheckboxFormControl[];
+    get groupControl(): CheckboxFormControl | null;
+    value: string[];
+    constructor();
+    protected firstUpdated(_changedProperties: PropertyValues): Promise<void>;
+    toFormValue(): FormData;
+    protected isControl(element: unknown): element is CheckboxFormControl;
+    protected isGroupControl(element: unknown): element is CheckboxFormControl;
+    protected isControlChecked(control: CheckboxFormControl): boolean;
+    protected updated(props: PropertyValues<this>): void;
+    protected updateControls(updateFn: (control: CheckboxFormControl, index: number) => void): void;
+    protected updateValue(value: string[], dispatchEvent?: boolean): void;
+}
+//# sourceMappingURL=checkbox-group-form-control.d.ts.map

package/dist/lib/control/form-control.d.ts

@@ -0,0 +1,29 @@
+import { PropertyValues } from 'lit';
+import { CustomElement } from '../custom-element.js';
+import { CanBeDisabled } from '../mixins/can-be-disabled.js';
+declare const FormControl_base: import('../main.js').Constructor<CanBeDisabled> & typeof CustomElement;
+export declare class FormControl<V extends string | number | string[] = string> extends FormControl_base {
+    /** @internal */
+    static readonly formAssociated = true;
+    /** @internal */
+    static shadowRootOptions: ShadowRootInit;
+    /** @internal */
+    readonly internals: ElementInternals;
+    name: string;
+    value: V;
+    readonly: boolean;
+    required: boolean;
+    get form(): HTMLFormElement | null;
+    get validity(): ValidityState;
+    get validationMessage(): string;
+    get willValidate(): boolean;
+    constructor();
+    updateAriaAttributes?(): void;
+    toFormValue(): string | File | FormData | null;
+    checkValidity(): boolean;
+    setValidity(flags?: ValidityStateFlags, target?: HTMLElement): void;
+    reportValidity(): void;
+    protected willUpdate(props: PropertyValues<this>): void;
+}
+export {};
+//# sourceMappingURL=form-control.d.ts.map

package/dist/lib/control/listbox-form-control.d.ts

@@ -0,0 +1,25 @@
+import { PropertyValues } from 'lit';
+import { ActiveDescendantsController } from '../controllers/active-descendants-controller.js';
+import { FormControl } from './form-control.js';
+import { OptionControl } from './option-control.js';
+export declare abstract class ListboxFormControl<Option extends OptionControl> extends FormControl<string | string[]> {
+    #private;
+    protected readonly activeDescendants: ActiveDescendantsController<Option>;
+    protected abstract options: Option[];
+    autoSelect: boolean;
+    multiple: boolean;
+    placeholder: string;
+    value: string[] | string;
+    get selectedOptions(): Option[];
+    get selectedIndices(): number[];
+    constructor();
+    protected canAutoSelect(option: Option): boolean;
+    protected canSelect(option: Option): boolean;
+    toggleOption(option: Option, state?: boolean): void;
+    connectedCallback(): void;
+    protected handleSlotChange(): void;
+    protected updateValue(option?: Option): void;
+    protected willUpdate(props: PropertyValues<this>): void;
+    protected updateSelection(): void;
+}
+//# sourceMappingURL=listbox-form-control.d.ts.map

package/dist/lib/control/number-form-control.d.ts

@@ -0,0 +1,12 @@
+import { PropertyValues } from 'lit';
+import { FormControl } from './form-control.js';
+export declare class NumberFormControl extends FormControl<number> {
+    min: number;
+    max: number;
+    step: number;
+    value: number;
+    getValueText(): string;
+    protected willUpdate(props: PropertyValues<this>): void;
+    toFormValue(): string;
+}
+//# sourceMappingURL=number-form-control.d.ts.map

package/dist/lib/control/option-control.d.ts

@@ -0,0 +1,23 @@
+import { PropertyValues } from 'lit';
+import { ActiveDescendant } from '../controllers/active-descendants-controller.js';
+import { CustomElement } from '../custom-element.js';
+import { CanBeDisabled } from '../mixins/can-be-disabled.js';
+declare const OptionControl_base: import('../main.js').Constructor<CanBeDisabled> & typeof CustomElement;
+export declare abstract class OptionControl extends OptionControl_base implements ActiveDescendant {
+    #private;
+    role: 'option' | 'gridcell' | 'row' | 'tab' | null;
+    set label(value: string);
+    get label(): string;
+    value: string;
+    selected: boolean;
+    type?: 'checkbox' | null;
+    canActivate(): boolean;
+    canSelect(): boolean;
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    connectedCallback(): void;
+    protected willUpdate(props: PropertyValues<this>): void;
+}
+export {};
+//# sourceMappingURL=option-control.d.ts.map

package/dist/lib/control/radio-group-form-control.d.ts

@@ -0,0 +1,22 @@
+import { PropertyValues } from 'lit';
+import { CheckboxFormControl } from './checkbox-form-control.js';
+import { FormControl } from './form-control.js';
+export declare abstract class RadioGroupFormControl extends FormControl<string> {
+    #private;
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    private elements;
+    value: string;
+    constructor();
+    getControls(): CheckboxFormControl[];
+    connectedCallback(): void;
+    protected isControl(element: unknown): element is CheckboxFormControl;
+    protected isControlChecked(control: CheckboxFormControl): boolean;
+    protected willUpdate(changes: PropertyValues<this>): void;
+    protected updateControls(updateFn: (control: CheckboxFormControl, index: number) => void): void;
+}
+//# sourceMappingURL=radio-group-form-control.d.ts.map

package/dist/lib/controllers/active-descendants-controller.d.ts

@@ -0,0 +1,29 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export interface ActiveDescendant {
+    canActivate(): boolean;
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+}
+export interface ActiveDescendantsControllerOptions<T extends ActiveDescendant & Element> {
+    getItems: () => T[];
+    onChange?: (previousActiveDescendant: T | undefined, activeDescendant: T | undefined, firstChange: boolean) => void;
+}
+export declare const ActiveDescendantsControllerOptions: <T extends ActiveDescendant & Element>(options?: Partial<ActiveDescendantsControllerOptions<T>>) => ActiveDescendantsControllerOptions<T>;
+export declare class ActiveDescendantsController<T extends ActiveDescendant & Element> implements ReactiveController {
+    #private;
+    get activeIndex(): number;
+    get activeItem(): T | undefined;
+    get items(): T[];
+    constructor(host: ReactiveElement, options?: Partial<ActiveDescendantsControllerOptions<T>>);
+    hostConnected?(): void;
+    activate(initialActiveIndex?: number): void;
+    deactivate(): void;
+    previous(): void;
+    next(): void;
+    first(): void;
+    last(): void;
+    select(item: T): void;
+    update(index?: number, force?: boolean): void;
+}
+//# sourceMappingURL=active-descendants-controller.d.ts.map

package/dist/{cdk/drag-drop → lib/controllers}/drag.controller.d.ts

@@ -1,5 +1,6 @@
 import { ReactiveController, ReactiveElement } from 'lit';
-import { DraggableElement } from './is-draggable.js';
+import { IsDraggable } from '../mixins/is-draggable.js';
+export type DraggableElement = IsDraggable & HTMLElement;
 export interface DragControllerOptions<T extends DraggableElement = DraggableElement> {
     getDraggableElements: () => T[];
     getContainer?: () => HTMLElement;

package/dist/lib/controllers/expandable-controller.d.ts

@@ -3,7 +3,6 @@ import { CanBeExpanded } from '../mixins/can-be-expanded.js';
 export type ExpandableItem = CanBeExpanded & HTMLElement;
 export interface ExpandableItemManagerHost extends ReactiveElement {
     multiple?: boolean;
-    toggleAll?: (force?: boolean, ...exclude: ExpandableItem[]) => void;
 }
 export interface ExpandableItemManagerOptions<T extends ExpandableItem = ExpandableItem> {
     getItems?: () => T[];
@@ -11,7 +10,7 @@ export interface ExpandableItemManagerOptions<T extends ExpandableItem = Expanda
 export declare const ExpandableItemManagerOptions: (options?: Partial<ExpandableItemManagerOptions>) => ExpandableItemManagerOptions;
 export declare class ExpandableItemManager<T extends ExpandableItem> implements ReactiveController {
     #private;
-    get expandableItems(): T[];
+    get items(): T[];
     constructor(host: ExpandableItemManagerHost, options?: ExpandableItemManagerOptions);
     hostConnected?(): void;
 }

package/dist/lib/custom-element.d.ts

@@ -1,9 +1,16 @@
-import { CSSResultGroup, HTMLTemplateResult, LitElement, TemplateResult } from 'lit';
-export declare function customElement(selector?: keyof HTMLElementTagNameMap, styles?: Array<string | CSSResultGroup>): (target: typeof CustomElement) => void;
+import { LitElement, TemplateResult } from 'lit';
+type CustomElementTag = keyof HTMLElementTagNameMap & `odx-${string}`;
+/** @internal */
+export declare function customElement(tagName: CustomElementTag, ...styles: string[]): (target: typeof CustomElement) => void;
+/** @internal */
 export declare class CustomElement extends LitElement {
-    static selector: string;
-    static define: () => void;
-    protected render(): HTMLTemplateResult | TemplateResult | string;
+    /** @internal */
+    static tagName: string;
+    /** @internal */
+    static define?: () => void;
+    protected render(): TemplateResult | string;
+    /** @internal */
     emit(event: string | Event, eventInit?: CustomEventInit): boolean;
 }
+export {};
 //# sourceMappingURL=custom-element.d.ts.map

package/dist/lib/interactive/interactive-element.d.ts

@@ -0,0 +1,23 @@
+import { TemplateResult } from 'lit';
+import { InteractiveLink } from './interactive-link.js';
+/**
+ * @csspart base
+ * @csspart loader
+ * @csspart label
+ *
+ * @slot prefix - Prefix slot
+ * @slot suffix - Suffix slot
+ * @slot - Default slot
+ */
+export declare class InteractiveElement extends InteractiveLink {
+    #private;
+    static readonly styles: import('lit').CSSResult;
+    /** @internal */
+    protected loaderSlot?: 'prefix' | 'suffix' | 'default';
+    loading: boolean;
+    lineClamp: number;
+    protected render(): TemplateResult;
+    protected renderContent(withSpinner?: boolean): TemplateResult;
+    protected renderLoader(): TemplateResult;
+}
+//# sourceMappingURL=interactive-element.d.ts.map

package/dist/lib/interactive/interactive-link.d.ts

@@ -0,0 +1,21 @@
+import { TemplateResult } from 'lit';
+import { CustomElement } from '../custom-element.js';
+import { CanBeDisabled } from '../mixins/can-be-disabled.js';
+declare const InteractiveLink_base: import('../utils/types.js').Constructor<CanBeDisabled> & typeof CustomElement;
+/**
+ * @attr {boolean} disabled
+ */
+export declare class InteractiveLink extends InteractiveLink_base {
+    /** @internal */
+    static shadowRootOptions: ShadowRootInit;
+    /** @internal */
+    readonly nativeElement: HTMLLinkElement | HTMLButtonElement;
+    href: string;
+    target: '_blank' | '_parent' | '_self' | '_top' | '';
+    rel: string;
+    download?: string;
+    protected render(): TemplateResult;
+    protected renderContent(): TemplateResult;
+}
+export {};
+//# sourceMappingURL=interactive-link.d.ts.map

package/dist/lib/main.d.ts

@@ -1,33 +1,28 @@
-import { ExtractAssetName } from '@odx/assets-utils';
+export * from './control/checkbox-form-control.js';
+export * from './control/checkbox-group-form-control.js';
+export * from './control/form-control.js';
+export * from './control/listbox-form-control.js';
+export * from './control/number-form-control.js';
+export * from './control/option-control.js';
+export * from './control/radio-group-form-control.js';
+export * from './controllers/active-descendants-controller.js';
+export * from './controllers/drag.controller.js';
 export * from './controllers/expandable-controller.js';
-export * from './controllers/focus-trap.controller.js';
-export * from './facade/checkbox-form-control.js';
-export * from './facade/checkbox-group-form-control.js';
-export * from './facade/option-control.js';
-export * from './facade/radio-group-form-control.js';
-export * from './facade/select-form-control.js';
+export * from './custom-element.js';
+export * from './interactive/interactive-element.js';
+export * from './interactive/interactive-link.js';
 export * from './mixins/can-be-disabled.js';
 export * from './mixins/can-be-expanded.js';
-export * from './mixins/can-be-readonly.js';
-export * from './mixins/can-be-required.js';
-export * from './mixins/can-be-selected.js';
-export * from './mixins/can-be-validated.js';
-export * from './mixins/form-control.js';
-export * from './mixins/number-control.js';
-export * from './mixins/with-loading-state.js';
-export * from './utils/a11y.js';
-export * from './utils/date.js';
-export * from './utils/dedupe-mixin.js';
+export * from './mixins/is-draggable.js';
+export * from './models/drag-event.js';
+export * from './models/placement.js';
+export * from './models/shape.js';
+export * from './models/size.js';
+export * from './models/variant.js';
+export * from './utils/compute-popover-placement.js';
 export * from './utils/dom.js';
-export * from './utils/empty-slot-fallback-fix.js';
 export * from './utils/get-unique-id.js';
-export * from './utils/keyboard-events.js';
 export * from './utils/lit.js';
-export * from './utils/search-text-content.js';
-export * from './utils/shared-intersection-observer.js';
 export * from './utils/shared-resize-observer.js';
-export * from './utils/transformers.js';
-export * from './custom-element.js';
-export { effect } from '@lit-labs/preact-signals';
-export type AvailableIcons = keyof _OdxIcon | ExtractAssetName<keyof _OdxIcon>;
+export * from './utils/types.js';
 //# sourceMappingURL=main.d.ts.map

package/dist/lib/mixins/can-be-disabled.d.ts

@@ -1,15 +1,7 @@
-import { ContextProvider } from '@lit/context';
 import { CustomElement } from '../custom-element.js';
-import { Constructor } from '../utils/dedupe-mixin.js';
+import { Constructor } from '../utils/types.js';
 export interface CanBeDisabled {
     disabled: boolean;
 }
-export declare const DisabledContext: {
-    __context__: boolean;
-};
-export declare class DisabledContextProvider extends ContextProvider<typeof DisabledContext, CanBeDisabled & CustomElement> {
-    constructor(host: CanBeDisabled & CustomElement);
-    hostUpdated(): void;
-}
 export declare const CanBeDisabled: <T extends Constructor<CustomElement>>(superClass: T) => Constructor<CanBeDisabled> & T;
 //# sourceMappingURL=can-be-disabled.d.ts.map

package/dist/lib/mixins/can-be-expanded.d.ts

@@ -1,12 +1,10 @@
 import { CustomElement } from '../custom-element.js';
-import { Constructor } from '../utils/dedupe-mixin.js';
+import { Constructor } from '../utils/types.js';
 import { CanBeDisabled } from './can-be-disabled.js';
-export interface CanBeExpanded extends CanBeDisabled {
+export interface CanBeExpanded {
     expanded: boolean;
-    expandable: boolean;
-    collapse(emitEvent?: boolean): void;
-    expand(emitEvent?: boolean): void;
-    toggle(force?: boolean, emitEvent?: boolean): void;
+    toggle(state?: boolean, emitEvent?: boolean): void;
+    getExpandControl(): HTMLElement | null;
 }
-export declare const CanBeExpanded: <T extends Constructor<CustomElement>>(superClass: T) => Constructor<CanBeExpanded> & T;
+export declare const CanBeExpanded: <T extends Constructor<CustomElement & CanBeDisabled>>(superClass: T) => Constructor<CanBeExpanded> & T;
 //# sourceMappingURL=can-be-expanded.d.ts.map

package/dist/lib/mixins/is-draggable.d.ts

@@ -0,0 +1,16 @@
+import { CustomElement } from '../custom-element.js';
+import { DragEvent, Position } from '../models/drag-event.js';
+import { Constructor } from '../utils/types.js';
+export declare const IS_DRAG_ACTIVE_ATTRIBUTE = "odx-drag-active";
+export interface IsDraggable {
+    dragDisabled: boolean;
+    get isDragActive(): boolean;
+    beforeDragStart?(event: DragEvent): void;
+    dragStart?(event: DragEvent): void;
+    dragMove?(event: DragEvent): void;
+    dragEnd?(event: DragEvent): void;
+    afterDragEnd?(event: DragEvent): void;
+    getDistance?(container: HTMLElement, position: Position): number;
+}
+export declare const IsDraggable: <T extends Constructor<CustomElement>>(superClass: T) => Constructor<IsDraggable & HTMLElement> & T;
+//# sourceMappingURL=is-draggable.d.ts.map

package/dist/{cdk/drag-drop/drag-events.d.ts → lib/models/drag-event.d.ts}

@@ -6,4 +6,4 @@ export interface DragEvent {
     event: PointerEvent;
     position: Position;
 }
-//# sourceMappingURL=drag-events.d.ts.map
+//# sourceMappingURL=drag-event.d.ts.map

package/dist/lib/models/placement.d.ts

@@ -0,0 +1,17 @@
+import { ValuesOf } from '../utils/types.js';
+export type Placement = ValuesOf<typeof Placement>;
+export declare const Placement: {
+    readonly TOP: "top";
+    readonly TOP_START: "top-start";
+    readonly TOP_END: "top-end";
+    readonly RIGHT: "right";
+    readonly RIGHT_START: "right-start";
+    readonly RIGHT_END: "right-end";
+    readonly BOTTOM: "bottom";
+    readonly BOTTOM_START: "bottom-start";
+    readonly BOTTOM_END: "bottom-end";
+    readonly LEFT: "left";
+    readonly LEFT_START: "left-start";
+    readonly LEFT_END: "left-end";
+};
+//# sourceMappingURL=placement.d.ts.map

package/dist/lib/models/shape.d.ts

@@ -0,0 +1,7 @@
+import { ValuesOf } from '../utils/types.js';
+export type Shape = ValuesOf<typeof Shape>;
+export declare const Shape: {
+    readonly CIRCLE: "circle";
+    readonly RECTANGLE: "rectangle";
+};
+//# sourceMappingURL=shape.d.ts.map

package/dist/lib/models/size.d.ts

@@ -0,0 +1,11 @@
+import { ValuesOf } from '../utils/types.js';
+export type Size = ValuesOf<typeof Size>;
+export declare const Size: {
+    readonly XS: "xs";
+    readonly SM: "sm";
+    readonly MD: "md";
+    readonly LG: "lg";
+    readonly XL: "xl";
+    readonly XXL: "xxl";
+};
+//# sourceMappingURL=size.d.ts.map

package/dist/lib/models/variant.d.ts

@@ -0,0 +1,12 @@
+import { ValuesOf } from '../utils/types.js';
+export type Variant = ValuesOf<typeof Variant>;
+export declare const Variant: {
+    readonly NEUTRAL: "neutral";
+    readonly PRIMARY: "primary";
+    readonly ACCENT: "accent";
+    readonly SUCCESS: "success";
+    readonly WARNING: "warning";
+    readonly DANGER: "danger";
+    readonly GHOST: "ghost";
+};
+//# sourceMappingURL=variant.d.ts.map

package/dist/lib/utils/compute-popover-placement.d.ts

@@ -0,0 +1,14 @@
+import { Placement, ReferenceElement } from '@floating-ui/dom';
+export interface PopoverPlacementOptions {
+    placement: Placement;
+    arrowElement?: HTMLElement | null;
+    enableFallback: boolean;
+    fallbackAxisSideDirection: 'start' | 'end';
+    matchReferenceWidth: boolean;
+    minHeight?: number | null;
+    offset: number;
+}
+export declare function PopoverPlacementOptions(options?: Partial<PopoverPlacementOptions>): PopoverPlacementOptions;
+export declare function computePopoverPlacement(referenceElement: ReferenceElement, floatingElement: HTMLElement, options: PopoverPlacementOptions): Promise<void>;
+export declare function positionUpdater(referenceElement: ReferenceElement, floatingElement: HTMLElement, options: PopoverPlacementOptions): () => void;
+//# sourceMappingURL=compute-popover-placement.d.ts.map

package/dist/lib/utils/dom.d.ts

@@ -1,17 +1,27 @@
-export type CSSDimensionUnit = 'px' | 'em' | 'rem' | 'vh' | 'vw' | 'vmin' | 'vmax' | '%' | 'fr' | 'auto' | 'inherit' | 'initial' | 'unset';
-export type CSSDimensionValue = `${number}${CSSDimensionUnit}`;
-/**
- * Creates a new MutationObserver instance.
- *
- * @param {MutationCallback} callback - The callback to execute when a mutation occurs.
- * @returns {MutationObserver} A MutationObserver instance or a dummy object with no-op methods if unsupported.
- */
-export declare function createMutationObserver(callback: MutationCallback): MutationObserver;
-export declare function toggleAttribute(element: Element | null | undefined, name: string, value?: string | number | boolean | null): void;
-export declare function getElementFromEvent<T>(event: Event, filterFn: (node: Element) => boolean): T;
-export declare function findClosestDocument(node: Node): ShadowRoot | Document | null;
-export declare function toPx(value?: string | number | null): string | null;
-export declare function getAssignedElements<T extends HTMLElement = HTMLElement>(host: HTMLElement, ...slots: string[]): T[];
-export declare function waitForAnimations(element?: Element | null, subtree?: boolean): Promise<Animation[]>;
+export declare function parseDate(value: number | string | Date): Date | null;
+export declare function findClosestDocument(node: Node): ShadowRoot | Document;
 export declare function forwardEvent(target: HTMLElement, eventInit?: EventInit): EventListener;
+export declare function getElementFromEvent<T = HTMLElement>(event: Event, filterFn: (node: Element) => boolean): T;
+export declare function waitForAnimations(element?: Element | null, subtree?: boolean): Promise<Animation[]>;
+export declare function toAriaBooleanAttribute(value: boolean, removeOnFalse?: boolean): 'true' | 'false';
+export declare function toPx(value?: number | null): string | null;
+export interface GetAssignedElementOptions {
+    slot?: string;
+    selector?: string;
+    flatten?: boolean;
+}
+export declare function getAssignedElement<T = HTMLElement>(root: Element | ShadowRoot | null, options?: GetAssignedElementOptions): T | undefined;
+export declare function getKeyInfo(event: KeyboardEvent): {
+    up: boolean;
+    right: boolean;
+    down: boolean;
+    left: boolean;
+    enter: boolean;
+    escape: boolean;
+    space: boolean;
+    tab: boolean;
+    backTab: boolean;
+    start: boolean;
+    end: boolean;
+};
 //# sourceMappingURL=dom.d.ts.map