@odx/foundation 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/i18n/lib/config.d.ts

@@ -0,0 +1,29 @@
+import { LocaleInput, SingleUnitIdentifier } from './models.js';
+export interface DateTimeFormatOptions extends Omit<Intl.DateTimeFormatOptions, 'dateStyle'> {
+    locale?: LocaleInput;
+    dateStyle?: 'iso8601' | Intl.DateTimeFormatOptions['dateStyle'];
+}
+export interface NumberFormatOptions extends Intl.NumberFormatOptions {
+    locale?: LocaleInput;
+    unit?: SingleUnitIdentifier;
+}
+export interface ListFormatOptions extends Intl.ListFormatOptions {
+    locale?: LocaleInput;
+}
+export interface RelativeTimeFormatOptions extends Intl.RelativeTimeFormatOptions {
+    locale?: LocaleInput;
+    minUnit?: Intl.RelativeTimeFormatUnit;
+}
+export interface FormatOptions {
+    dateTimeFormatOptions?: DateTimeFormatOptions;
+    numberFormatOptions?: NumberFormatOptions;
+    listFormatOptions?: ListFormatOptions;
+    relativeTimeFormatOptions?: RelativeTimeFormatOptions;
+}
+export interface LocalizationOptions {
+    defaultLocale: () => LocaleInput;
+}
+export type I18nOptions = LocalizationOptions & FormatOptions;
+export declare function setI18nOptions(options?: Partial<I18nOptions> | null): void;
+export declare function getI18nOptions(options?: Partial<I18nOptions> | null): I18nOptions;
+//# sourceMappingURL=config.d.ts.map

package/dist/i18n/lib/format.d.ts

@@ -0,0 +1,6 @@
+import { DateTimeFormatOptions, ListFormatOptions, NumberFormatOptions, RelativeTimeFormatOptions } from './config.js';
+export declare function formatDate(input: number | string | Date, options?: DateTimeFormatOptions): string;
+export declare function formatNumber(input: number | string, options?: NumberFormatOptions): string;
+export declare function formatList(input: string[], options?: ListFormatOptions): string;
+export declare function formatRelativeTime(input: number | string | Date, options?: RelativeTimeFormatOptions): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/i18n/lib/is-localized.mixin.d.ts

@@ -0,0 +1,15 @@
+import { ReadonlySignal } from '@lit-labs/preact-signals';
+import { Constructor, CustomElement } from '../../lib/main.js';
+import { formatDate, formatList, formatNumber, formatRelativeTime } from './format.js';
+import { getLocale } from './localization.js';
+import { translate } from './translate.js';
+export interface IsLocalized {
+    readonly locale: ReadonlySignal<ReturnType<typeof getLocale>>;
+    t: (...args: Parameters<typeof translate>) => string;
+    formatDate: typeof formatDate;
+    formatNumber: typeof formatNumber;
+    formatList: typeof formatList;
+    formatRelativeTime: typeof formatRelativeTime;
+}
+export declare const IsLocalized: <T extends Constructor<CustomElement>>(superClass: T) => Constructor<IsLocalized> & T;
+//# sourceMappingURL=is-localized.mixin.d.ts.map

package/dist/i18n/lib/localization.d.ts

@@ -0,0 +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;
+//# sourceMappingURL=localization.d.ts.map

package/dist/{lib/models/single-unit-identifier.d.ts → i18n/lib/models.d.ts}

@@ -1,6 +1,7 @@
+export type LocaleInput = Intl.UnicodeBCP47LocaleIdentifier | Intl.Locale;
 /**
  * Single units sanctioned for use in ECMAScript.
  * See: https://tc39.es/ecma402/#table-sanctioned-single-unit-identifiers
  */
 export type SingleUnitIdentifier = 'acre' | 'bit' | 'byte' | 'celsius' | 'centimeter' | 'day' | 'degree' | 'fahrenheit' | 'fluid-ounce' | 'foot' | 'gallon' | 'gigabit' | 'gigabyte' | 'gram' | 'hectare' | 'hour' | 'inch' | 'kilobit' | 'kilobyte' | 'kilogram' | 'kilometer' | 'liter' | 'megabit' | 'megabyte' | 'meter' | 'microsecond' | 'mile' | 'mile-scandinavian' | 'milliliter' | 'millimeter' | 'millisecond' | 'minute' | 'month' | 'nanosecond' | 'ounce' | 'percent' | 'petabyte' | 'pound' | 'second' | 'stone' | 'terabit' | 'terabyte' | 'week' | 'yard' | 'year';
-//# sourceMappingURL=single-unit-identifier.d.ts.map
+//# sourceMappingURL=models.d.ts.map

package/dist/i18n/lib/translate.d.ts

@@ -0,0 +1,11 @@
+import { ReadonlySignal } from '@lit-labs/preact-signals';
+import { LocaleInput } from './models.js';
+export type TranslateContext = Record<string, string | number | boolean> | string | number | boolean | null;
+type Translation = {
+    [key: string]: Translation | string;
+};
+export declare function interpolate(value: string, context: Record<string, string | number>): string;
+export declare function setTranslation(locale: LocaleInput, translation: Translation): void;
+export declare function translate(key: string, contextInput?: TranslateContext, locale?: LocaleInput | null): ReadonlySignal<string>;
+export {};
+//# sourceMappingURL=translate.d.ts.map

package/dist/i18n/main.d.ts

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

package/dist/i18n.js

@@ -0,0 +1,145 @@
+import { signal, effect, computed, SignalWatcher } from '@lit-labs/preact-signals';
+import { createOptions, parseDate, dedupeMixin } from '@odx/foundation';
+import { property } from 'lit/decorators.js';
+import { k as flattenObject, l as isNotNil } from './vendor-C_WVAD3D.js';
+
+const I18nOptions = createOptions({
+  defaultLocale: () => navigator.language,
+  relativeTimeFormatOptions: { minUnit: "minute" }
+});
+const i18nOptions = signal(null);
+function setI18nOptions(options) {
+  i18nOptions.value = getI18nOptions(options);
+}
+function getI18nOptions(options) {
+  return I18nOptions(options ?? i18nOptions.value ?? {});
+}
+
+function formatDate(input, options) {
+  const value = parseDate(input);
+  if (!value) return "";
+  const { dateTimeFormatOptions } = getI18nOptions({ dateTimeFormatOptions: options });
+  if (dateTimeFormatOptions?.dateStyle === "iso8601") {
+    return new Intl.DateTimeFormat("sv-SE", { dateStyle: "short" }).format(value);
+  }
+  return new Intl.DateTimeFormat(options?.locale, dateTimeFormatOptions).format(value);
+}
+function formatNumber(input, options) {
+  const value = Number(input);
+  if (Number.isNaN(value)) return "";
+  const { numberFormatOptions } = getI18nOptions({ numberFormatOptions: options });
+  if (numberFormatOptions?.currency) {
+    numberFormatOptions.style = "currency";
+  }
+  return new Intl.NumberFormat(numberFormatOptions?.locale, numberFormatOptions).format(value);
+}
+function formatList(input, options) {
+  if (input.length === 0) return "";
+  const { listFormatOptions } = getI18nOptions({ listFormatOptions: options });
+  return new Intl.ListFormat(options?.locale, listFormatOptions).format(input);
+}
+const TIME_UNITS = [
+  { max: 59e3, value: 1e3, unit: "second" },
+  // max 59 seconds
+  { max: 276e4, value: 6e4, unit: "minute" },
+  // max 46 minutes
+  { max: 72e6, value: 36e5, unit: "hour" },
+  // max 20 hours
+  { max: 5184e5, value: 864e5, unit: "day" },
+  // max 6 days
+  { max: 24192e5, value: 6048e5, unit: "week" },
+  // max 28 days
+  { max: 28512e6, value: 2592e6, unit: "month" },
+  // max 11 months
+  { max: Number.POSITIVE_INFINITY, value: 31536e6, unit: "year" }
+];
+function findTimeUnit(value, minUnit) {
+  const minTimeUnit = TIME_UNITS.find(({ unit }) => unit === minUnit) ?? TIME_UNITS[0];
+  return TIME_UNITS.find((config) => value < config.max && config.value >= minTimeUnit.value);
+}
+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 timeUnit = findTimeUnit(Math.abs(relativeTime), relativeTimeFormatOptions?.minUnit);
+  return new Intl.RelativeTimeFormat(options?.locale, relativeTimeFormatOptions).format(Math.round(relativeTime / timeUnit.value), timeUnit.unit);
+}
+
+const activeLocale = signal(null);
+function getLocale(localeInput) {
+  return new Intl.Locale(localeInput || activeLocale.value || getI18nOptions().defaultLocale());
+}
+function setLocale(localeInput) {
+  activeLocale.value = localeInput ? getLocale(localeInput) : null;
+}
+function syncDocumentLanguage(root = document.documentElement) {
+  return effect(() => {
+    root.lang = getLocale().toString();
+  });
+}
+
+const fallbackLocale = "en";
+const translations = signal({});
+function interpolate(value, context) {
+  return value.replaceAll(/\{\{\s*([^}\s]+)\s*}}/g, (match, variableName) => {
+    return isNotNil(context[variableName]) ? interpolate(context[variableName].toString(), context) : match;
+  });
+}
+function setTranslation(locale, translation) {
+  const { language } = getLocale(locale);
+  translations.value = { ...translations.value, [language]: { ...translations.value[language], ...flattenObject(translation, { delimiter: "." }) } };
+}
+function translate(key, contextInput, locale) {
+  return computed(() => {
+    const translationRecord = getTranslationRecord(locale);
+    if (!translationRecord) return key;
+    const value = translationRecord?.[key] ?? getTranslationRecord(fallbackLocale)?.[key] ?? "";
+    const context = typeof contextInput === "object" || contextInput === void 0 ? flattenObject(contextInput ?? {}) : { $implicit: contextInput.toString() };
+    return interpolate(value, { ...getTranslationRecord(fallbackLocale), ...translationRecord, ...context });
+  });
+}
+function getTranslationRecord(localeInput) {
+  const locale = getLocale(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) {
+    constructor() {
+      super(...arguments);
+      this.locale = computed(() => getLocale(this.lang));
+    }
+    formatDate(...[input, options]) {
+      return formatDate(input, { ...options, locale: options?.locale ?? this.locale.value });
+    }
+    formatNumber(...[input, options]) {
+      return formatNumber(input, { ...options, locale: options?.locale ?? this.locale.value });
+    }
+    formatList(...[input, options]) {
+      return formatList(input, { ...options, locale: options?.locale ?? this.locale.value });
+    }
+    formatRelativeTime(...[input, options]) {
+      return formatRelativeTime(input, { ...options, locale: options?.locale ?? this.locale.value });
+    }
+    t(...[key, context, locale]) {
+      return translate(key, context, locale ?? this.locale.value).value;
+    }
+  }
+  __decorateClass([
+    property()
+  ], IsLocalizedElement.prototype, "lang", 2);
+  return IsLocalizedElement;
+});
+
+export { IsLocalized, formatDate, formatList, formatNumber, formatRelativeTime, getI18nOptions, getLocale, interpolate, setI18nOptions, setLocale, setTranslation, syncDocumentLanguage, translate };

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

@@ -0,0 +1,10 @@
+import { CSSResultGroup, HTMLTemplateResult, LitElement, TemplateResult } from 'lit';
+export declare function isCustomElementClass(candidate: unknown): candidate is typeof CustomElement;
+export declare function customElement(selector?: keyof HTMLElementTagNameMap, styles?: Array<string | CSSResultGroup>): (target: typeof CustomElement) => void;
+export declare class CustomElement extends LitElement {
+    static selector: string;
+    static define: () => void;
+    protected render(): HTMLTemplateResult | TemplateResult | string;
+    emit(event: string, eventInit?: CustomEventInit): boolean;
+}
+//# sourceMappingURL=custom-element.d.ts.map

package/dist/lib/decorators/request-update-on-aria-change.d.ts

@@ -0,0 +1,4 @@
+import { ReactiveElement } from 'lit';
+import { ARIAProperty } from '../utils/a11y.js';
+export declare function requestUpdateOnAriaChange(ariaProperties: ARIAProperty[]): (ctor: typeof ReactiveElement) => void;
+//# sourceMappingURL=request-update-on-aria-change.d.ts.map

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

@@ -1,5 +1,5 @@
-import { CustomElement } from '../models';
-declare const CheckboxFormControl_base: import('../mixins').Constructor<import('../mixins').IsFormControl<string>> & typeof CustomElement;
+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 {
     #private;
     static shadowRootOptions: ShadowRootInit;

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

@@ -1,7 +1,7 @@
 import { PropertyValues } from 'lit';
-import { CustomElement } from '../models';
-import { CheckboxFormControl } from './checkbox-form-control';
-declare const CheckboxGroupFormControl_base: import('../mixins').Constructor<import('../mixins').IsFormControl<string[]>> & typeof CustomElement;
+import { CustomElement } from '../custom-element.js';
+import { CheckboxFormControl } from './checkbox-form-control.js';
+declare const CheckboxGroupFormControl_base: import('../main.js').Constructor<import('../mixins/form-control.js').IsFormControl<string[]>> & typeof CustomElement;
 export declare abstract class CheckboxGroupFormControl extends CheckboxGroupFormControl_base {
     #private;
     private elements;

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

@@ -1,7 +1,7 @@
 import { PropertyValueMap } from 'lit';
-import { CanBeDisabled } from '../mixins';
-import { CustomElement } from '../models';
-declare const OptionControl_base: import('../mixins').Constructor<CanBeDisabled> & typeof CustomElement;
+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 {
     role: 'option' | 'gridcell' | 'row' | 'tab' | null;
     selected: boolean;

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

@@ -1,7 +1,7 @@
 import { PropertyValues } from 'lit';
-import { CustomElement } from '../models';
-import { CheckboxFormControl } from './checkbox-form-control';
-declare const RadioGroupFormControl_base: import('../mixins').Constructor<import('../mixins').IsFormControl<string>> & typeof CustomElement;
+import { CustomElement } from '../custom-element.js';
+import { CheckboxFormControl } from './checkbox-form-control.js';
+declare const RadioGroupFormControl_base: import('../main.js').Constructor<import('../mixins/form-control.js').IsFormControl<string>> & typeof CustomElement;
 export declare abstract class RadioGroupFormControl extends RadioGroupFormControl_base {
     #private;
     static shadowRootOptions: {

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

@@ -1,7 +1,7 @@
 import { PropertyValues } from 'lit';
-import { CustomElement } from '../models';
-import { OptionControl } from './option-control';
-declare const SelectFormControl_base: import('../mixins').Constructor<import('../mixins').IsFormControl<string | string[]>> & typeof CustomElement;
+import { CustomElement } from '../custom-element.js';
+import { OptionControl } from './option-control.js';
+declare const SelectFormControl_base: import('../main.js').Constructor<import('../mixins/form-control.js').IsFormControl<string | string[]>> & typeof CustomElement;
 export declare abstract class SelectFormControl<Option extends OptionControl = OptionControl> extends SelectFormControl_base {
     #private;
     protected abstract options: Option[];

package/dist/lib/main.d.ts

@@ -1,8 +1,32 @@
-export * from './controllers';
-export * from './directives';
-export * from './external';
-export * from './facade';
-export * from './mixins';
-export * from './models';
-export * from './utils';
+export * from './controllers/focus-trap.controller.js';
+export * from './decorators/request-update-on-aria-change.js';
+export * from './directives/optional-attr.js';
+export * from './directives/optional-slot.js';
+export * from './directives/slot-fallback.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 './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/dedupe-mixin.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/dom.js';
+export * from './utils/get-unique-id.js';
+export * from './utils/keyboard-events.js';
+export * from './utils/object.js';
+export * from './utils/search-text-content.js';
+export * from './utils/shared-intersection-observer.js';
+export * from './utils/shared-resize-observer.js';
+export * from './custom-element.js';
+export { effect } from '@lit-labs/preact-signals';
 //# sourceMappingURL=main.d.ts.map

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

@@ -1,9 +1,9 @@
-import { CustomElement } from '../models';
-import { Constructor } from './dedupe-mixin';
+import { CustomElement } from '../custom-element.js';
+import { Constructor } from './dedupe-mixin.js';
 export interface CanBeDisabled {
     disabled: boolean;
     _contextDisabled: boolean;
-    onDisabledChanged?(disabled: boolean): void;
+    isContextDisabled(): boolean;
 }
 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

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

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

@@ -1,5 +1,5 @@
-import { CustomElement } from '../models';
-import { Constructor } from './dedupe-mixin';
+import { CustomElement } from '../custom-element.js';
+import { Constructor } from './dedupe-mixin.js';
 export interface CanBeReadonly {
     readonly: boolean;
 }

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

@@ -1,5 +1,5 @@
-import { CustomElement } from '../models';
-import { Constructor } from './dedupe-mixin';
+import { CustomElement } from '../custom-element.js';
+import { Constructor } from './dedupe-mixin.js';
 export interface CanBeRequired {
     required: boolean;
 }

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

@@ -0,0 +1,9 @@
+import { CustomElement } from '../custom-element.js';
+import { ARIAMixinStrict } from '../utils/a11y.js';
+import { Constructor } from './dedupe-mixin.js';
+export interface CanBeSelected {
+    selected: boolean;
+    ariaSelectedValue: ARIAMixinStrict['ariaCurrent'];
+}
+export declare const CanBeSelected: <T extends Constructor<CustomElement>>(superClass: T) => Constructor<CanBeSelected> & T;
+//# sourceMappingURL=can-be-selected.d.ts.map

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

@@ -1,5 +1,5 @@
-import { CustomElement } from '../models';
-import { Constructor } from './dedupe-mixin';
+import { CustomElement } from '../custom-element.js';
+import { Constructor } from './dedupe-mixin.js';
 export interface CanBeValidated {
     readonly internals: ElementInternals;
     get validity(): ValidityState;

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

@@ -1,9 +1,9 @@
-import { CustomElement } from '../models';
-import { CanBeDisabled } from './can-be-disabled';
-import { CanBeReadonly } from './can-be-readonly';
-import { CanBeRequired } from './can-be-required';
-import { CanBeValidated } from './can-be-validated';
-import { Constructor } from './dedupe-mixin';
+import { CustomElement } from '../custom-element.js';
+import { CanBeDisabled } from './can-be-disabled.js';
+import { CanBeReadonly } from './can-be-readonly.js';
+import { CanBeRequired } from './can-be-required.js';
+import { CanBeValidated } from './can-be-validated.js';
+import { Constructor } from './dedupe-mixin.js';
 type ValueType = string | number | boolean | string[] | number[] | boolean[];
 export interface IsFormControl<V extends ValueType = string> extends CanBeDisabled, CanBeReadonly, CanBeRequired, CanBeValidated {
     form: HTMLFormElement | null;

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

@@ -1,6 +1,6 @@
-import { CustomElement } from '../models';
-import { Constructor } from './dedupe-mixin';
-import { IsFormControl } from './form-control';
+import { CustomElement } from '../custom-element.js';
+import { Constructor } from './dedupe-mixin.js';
+import { IsFormControl } from './form-control.js';
 export interface IsNumberControl extends Omit<IsFormControl, 'value'> {
     min: number;
     max: number;

package/dist/lib/mixins/with-loading-state.d.ts

@@ -1,5 +1,5 @@
-import { CustomElement } from '../models';
-import { Constructor } from './dedupe-mixin';
+import { CustomElement } from '../custom-element.js';
+import { Constructor } from './dedupe-mixin.js';
 export interface HasLoadingState {
     loading: boolean;
     get loadingContainer(): HTMLElement;

package/dist/lib/{models/aria-mixin-strict.d.ts → utils/a11y.d.ts}

@@ -59,4 +59,6 @@ export interface ARIAMixinStrict extends ARIAMixin {
     ariaValueText: string | null;
     role: ARIARole | null;
 }
-//# sourceMappingURL=aria-mixin-strict.d.ts.map
+export declare function toAriaBooleanAttribute(value: boolean, removeOnFalse?: boolean): 'true' | 'false';
+export declare function fromAriaBooleanAttribute(value?: string | null): boolean;
+//# sourceMappingURL=a11y.d.ts.map

package/dist/lib/utils/{parse-date.d.ts → date.d.ts}

@@ -1,2 +1,2 @@
 export declare function parseDate(value: number | string | Date): Date | null;
-//# sourceMappingURL=parse-date.d.ts.map
+//# sourceMappingURL=date.d.ts.map

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

@@ -1,6 +1,15 @@
+/**
+ * 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 forwardEvent(this: HTMLElement, event: Event): void;
 //# sourceMappingURL=dom.d.ts.map

package/dist/lib/utils/{create-options.d.ts → object.d.ts}

@@ -1,2 +1,2 @@
 export declare function createOptions<T extends object>(defaultOptions: T): (options?: Partial<T> | null) => T;
-//# sourceMappingURL=create-options.d.ts.map
+//# sourceMappingURL=object.d.ts.map

package/dist/lib/utils/search-text-content.d.ts

@@ -0,0 +1,7 @@
+export interface SearchTextContentOptions {
+    root: Element;
+    query: string;
+    minlength: number;
+}
+export declare function searchTextContent(options: SearchTextContentOptions): Range[];
+//# sourceMappingURL=search-text-content.d.ts.map

package/dist/lib/utils/shared-intersection-observer.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Creates a IntersectionObserver instance safely, falling back to a dummy if the API is not supported.
+ *
+ * @param {IntersectionObserverCallback} callback - The callback to execute when an observed element's size changes.
+ * @returns {IntersectionObserver} A IntersectionObserver instance or a dummy object with no-op methods if unsupported.
+ */
+export declare function createIntersectionObserver(callback: IntersectionObserverCallback, options?: IntersectionObserverInit): IntersectionObserver;
 export interface SharedIntersectionObserverOptions {
     fpsLimit: number;
 }

package/dist/lib/utils/shared-resize-observer.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Creates a ResizeObserver instance safely, falling back to a dummy if the API is not supported.
+ *
+ * @param {ResizeObserverCallback} callback - The callback to execute when an observed element's size changes.
+ * @returns {ResizeObserver} A ResizeObserver instance or a dummy object with no-op methods if unsupported.
+ */
+export declare function createResizeObserver(callback: ResizeObserverCallback): ResizeObserver;
 export interface SharedResizeObserverOptions extends ResizeObserverOptions {
     fpsLimit: number;
 }

package/dist/loader/main.d.ts

@@ -0,0 +1,2 @@
+export declare function defineCustomElements(): Promise<void>;
+//# sourceMappingURL=main.d.ts.map

package/dist/loader.js

@@ -0,0 +1,13 @@
+import { isCustomElementClass } from '@odx/foundation';
+import * as cdkComponents from '@odx/foundation/cdk';
+import * as components from '@odx/foundation/components';
+
+async function defineCustomElements() {
+  for (const entry of Object.values({ ...components, ...cdkComponents })) {
+    if (!isCustomElementClass(entry)) continue;
+    entry.define();
+  }
+}
+defineCustomElements();
+
+export { defineCustomElements };