@wirekyt/dom 0.0.1 → 0.0.2

package/dist/index-3tNJficI.d.ts

@@ -0,0 +1,117 @@
+import { AutoUpdateOptions, Boundary, ComputePositionReturn, Placement, Placement as Placement$1, VirtualElement } from "@floating-ui/dom";
+//#region src/common/popper/types.d.ts
+type MaybeRectElement = HTMLElement | VirtualElement | null;
+type MaybeElement = HTMLElement | null;
+type MaybeFn<T> = T | (() => T);
+type PlacementSide = "top" | "right" | "bottom" | "left";
+type PlacementAlign = "start" | "center" | "end";
+interface AnchorRect {
+  x?: number | undefined;
+  y?: number | undefined;
+  width?: number | undefined;
+  height?: number | undefined;
+}
+interface PositioningOptions {
+  restoreStyles?: boolean | undefined;
+  hideWhenDetached?: boolean | undefined;
+  strategy?: "absolute" | "fixed" | undefined;
+  placement?: Placement$1 | undefined;
+  offset?: {
+    mainAxis?: number | undefined;
+    crossAxis?: number | undefined;
+  } | undefined;
+  gutter?: number | undefined;
+  shift?: number | undefined;
+  overflowPadding?: number | undefined;
+  arrowPadding?: number | undefined;
+  flip?: boolean | Placement$1[] | undefined;
+  slide?: boolean | undefined;
+  overlap?: boolean | undefined;
+  sameWidth?: boolean | undefined;
+  fitViewport?: boolean | undefined;
+  sizeMiddleware?: boolean | undefined;
+  boundary?: (() => Boundary) | Boundary | "clipping-ancestors" | undefined;
+  listeners?: boolean | AutoUpdateOptions | undefined;
+  onComplete?: ((data: ComputePositionReturn) => void) | undefined;
+  onPositioned?: ((data: {
+    placed: boolean;
+  }) => void) | undefined;
+  getAnchorElement?: (() => HTMLElement | VirtualElement | null) | undefined;
+  getAnchorRect?: ((element: HTMLElement | VirtualElement | null) => AnchorRect | null) | undefined;
+  updatePosition?: ((data: {
+    updatePosition: () => Promise<void>;
+    floatingElement: HTMLElement | null;
+  }) => void | Promise<void>) | undefined;
+}
+//#endregion
+//#region src/common/popper/get-placement.d.ts
+declare function getPlacement(referenceOrFn: MaybeFn<MaybeRectElement>, floatingOrFn: MaybeFn<MaybeElement>, opts?: PositioningOptions & {
+  defer?: boolean | undefined;
+}): () => void;
+//#endregion
+//#region src/common/popper/middleware.d.ts
+declare const cssVars: {
+  arrowSize: {
+    variable: string;
+    reference: string;
+  };
+  arrowSizeHalf: {
+    variable: string;
+    reference: string;
+  };
+  arrowBg: {
+    variable: string;
+    reference: string;
+  };
+  transformOrigin: {
+    variable: string;
+    reference: string;
+  };
+  arrowOffset: {
+    variable: string;
+    reference: string;
+  };
+};
+//#endregion
+//#region src/common/popper/get-styles.d.ts
+interface GetPlacementStylesOptions {
+  placement?: Placement | undefined;
+}
+declare function getPlacementStyles(options?: Pick<PositioningOptions, "placement" | "sameWidth" | "fitViewport" | "strategy">): {
+  arrow: {
+    readonly [cssVars.arrowSizeHalf.variable]: `calc(${string} / 2)`;
+    readonly [cssVars.arrowOffset.variable]: `calc(${string} * -1)`;
+    readonly position: "absolute";
+    readonly width: string;
+    readonly height: string;
+  };
+  arrowTip: {
+    readonly transform: any;
+    readonly background: string;
+    readonly top: "0";
+    readonly left: "0";
+    readonly width: "100%";
+    readonly height: "100%";
+    readonly position: "absolute";
+    readonly zIndex: "inherit";
+  };
+  floating: {
+    readonly position: "absolute" | "fixed";
+    readonly isolation: "isolate";
+    readonly minWidth: "max-content" | undefined;
+    readonly width: "var(--reference-width)" | undefined;
+    readonly maxWidth: "var(--available-width)" | undefined;
+    readonly maxHeight: "var(--available-height)" | undefined;
+    readonly pointerEvents: "none" | undefined;
+    readonly top: "0px";
+    readonly left: "0px";
+    readonly transform: "translate3d(var(--x), var(--y), 0)" | "translate3d(0, -100vh, 0)";
+    readonly zIndex: "var(--z-index)";
+  };
+};
+//#endregion
+//#region src/common/popper/placement.d.ts
+declare function isValidPlacement(v: string): v is Placement;
+declare function getPlacementSide(placement: Placement): PlacementSide;
+//#endregion
+export { getPlacement as a, Boundary as c, PlacementAlign as d, PlacementSide as f, getPlacementStyles as i, ComputePositionReturn as l, isValidPlacement as n, AnchorRect as o, PositioningOptions as p, GetPlacementStylesOptions as r, AutoUpdateOptions as s, getPlacementSide as t, Placement$1 as u };

package/dist/index-BEfvdGE2.d.cts

@@ -0,0 +1,116 @@
+import { Calendar, CalendarDate, CalendarDateTime, DateDuration, DateFormatter, DateValue, ZonedDateTime } from "@internationalized/date";
+//#region src/common/date-utils/types.d.ts
+type DateValue$1 = CalendarDate | CalendarDateTime | ZonedDateTime;
+type DateGranularity = "day" | "hour" | "minute" | "second";
+type DateAlignment = "start" | "end" | "center";
+type DateAvailableFn = (date: DateValue$1, locale: string) => boolean;
+type DateAdjustFn = (options: {
+  startDate: DateValue$1;
+  focusedDate: DateValue$1;
+}) => {
+  startDate: DateValue$1;
+  focusedDate: DateValue$1;
+  endDate: DateValue$1;
+};
+type DateRangePreset = "thisWeek" | "lastWeek" | "thisMonth" | "lastMonth" | "thisQuarter" | "lastQuarter" | "thisYear" | "lastYear" | "last3Days" | "last7Days" | "last14Days" | "last30Days" | "last90Days";
+//#endregion
+//#region src/common/date-utils/align.d.ts
+declare function alignDate(date: DateValue$1, alignment: DateAlignment, duration: DateDuration, locale: string, min?: DateValue$1 | undefined, max?: DateValue$1 | undefined): import("@internationalized/date").DateValue;
+declare function alignStartDate(date: DateValue$1, startDate: DateValue$1, endDate: DateValue$1, duration: DateDuration, locale: string, min?: DateValue$1 | undefined, max?: DateValue$1 | undefined): import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+//#endregion
+//#region src/common/date-utils/assertion.d.ts
+declare function isDateEqual(dateA: DateValue$1 | null | undefined, dateB?: DateValue$1 | null): boolean;
+declare function isDateUnavailable(date: DateValue$1 | null, isUnavailable: DateAvailableFn | undefined, locale: string, minValue?: DateValue$1 | null, maxValue?: DateValue$1 | null): boolean;
+declare function isDateOutsideRange(date: DateValue$1, startDate?: DateValue$1 | null, endDate?: DateValue$1 | null): boolean;
+declare function isPreviousRangeInvalid(startDate: DateValue$1, minValue?: DateValue$1 | null, maxValue?: DateValue$1 | null): boolean;
+declare function isNextRangeInvalid(endDate: DateValue$1, minValue?: DateValue$1 | null, maxValue?: DateValue$1 | null): boolean;
+//#endregion
+//#region src/common/date-utils/constrain.d.ts
+declare function alignCenter(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignStart(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignEnd(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainStart(date: DateValue, aligned: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainValue<T extends DateValue>(date: T, minValue?: DateValue, maxValue?: DateValue): T;
+declare function constrainSegments<T extends DateValue>(date: T, minValue?: DateValue, maxValue?: DateValue): T;
+//#endregion
+//#region src/common/date-utils/duration.d.ts
+declare function getUnitDuration(duration: DateDuration): {
+  years?: number;
+  months?: number;
+  weeks?: number;
+  days?: number;
+};
+declare function getEndDate(startDate: DateValue$1, duration: DateDuration): import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+//#endregion
+//#region src/common/date-utils/format.d.ts
+declare function formatRange(startDate: DateValue$1, endDate: DateValue$1, formatter: DateFormatter, toString: (start: string, end: string) => string, timeZone: string): string;
+declare function formatSelectedDate(startDate: DateValue$1 | null | undefined, endDate: DateValue$1 | null, locale: string, timeZone: string): string;
+declare function formatVisibleRange(startDate: DateValue$1, endDate: DateValue$1 | null, locale: string, timeZone: string): string;
+//#endregion
+//#region src/common/date-utils/formatter.d.ts
+declare function getDayFormatter(locale: string, timeZone: string, referenceDate?: DateValue): DateFormatter;
+declare function getMonthFormatter(locale: string, timeZone: string, referenceDate?: DateValue): DateFormatter;
+//#endregion
+//#region src/common/date-utils/date-month.d.ts
+declare function getStartOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getEndOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getDaysInWeek(weekIndex: number, from: DateValue, locale: string, firstDayOfWeek?: number): DateValue[];
+declare function getMonthDays(from: DateValue, locale: string, numOfWeeks?: number, firstDayOfWeek?: number): DateValue[][];
+declare function getWeekdayFormats(locale: string, timeZone: string): <T extends DateValue | Date>(value: T) => {
+  value: T;
+  short: string;
+  long: string;
+  narrow: string;
+};
+declare function getWeekDays(date: DateValue, startOfWeekProp: number | undefined, timeZone: string, locale: string): {
+  value: import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+  short: string;
+  long: string;
+  narrow: string;
+}[];
+declare function getMonthNames(locale: string, format?: Intl.DateTimeFormatOptions["month"], referenceDate?: DateValue): string[];
+declare function getWeekOfYear(date: DateValue, locale: string): number;
+//#endregion
+//#region src/common/date-utils/date-year.d.ts
+interface YearsRange {
+  from: number;
+  to: number;
+}
+declare function getYearsRange(range: YearsRange): number[];
+declare function getDefaultYearRange(referenceDate: DateValue, min?: DateValue, max?: DateValue): YearsRange;
+declare function normalizeYear(year: string | null | undefined): string | undefined;
+declare function getDecadeRange(year: number, opts?: {
+  strict?: boolean;
+}): number[];
+//#endregion
+//#region src/common/date-utils/mutation.d.ts
+declare function getTodayDate(timeZone?: string, calendar?: Calendar): import("@internationalized/date").CalendarDate;
+declare function setCalendar(date: DateValue, calendar: Calendar): import("@internationalized/date").CalendarDateTime;
+declare function setDate(date: DateValue, startDate: DateValue, isDateUnavailable: DateAvailableFn, locale: string, minValue: DateValue, maxValue: DateValue): DateValue | undefined;
+declare function getPreviousAvailableDate(date: DateValue, minValue: DateValue, locale: string, isDateUnavailable?: DateAvailableFn): DateValue | undefined;
+//#endregion
+//#region src/common/date-utils/pagination.d.ts
+interface AdjustDateParams {
+  startDate: DateValue$1;
+  focusedDate: DateValue$1;
+}
+interface AdjustDateReturn extends AdjustDateParams {
+  endDate: DateValue$1;
+}
+declare function getAdjustedDateFn(visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): (options: AdjustDateParams) => AdjustDateReturn;
+declare function getNextPage(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn;
+declare function getPreviousPage(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn;
+declare function getNextRow(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getPreviousRow(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getSectionStart(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getSectionEnd(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getNextSection(focusedDate: DateValue$1, startDate: DateValue$1, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getPreviousSection(focusedDate: DateValue$1, startDate: DateValue$1, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+//#endregion
+//#region src/common/date-utils/parse-date.d.ts
+declare function parseDateString(date: string, locale: string, timeZone: string): DateValue$1 | undefined;
+//#endregion
+//#region src/common/date-utils/preset.d.ts
+declare function getDateRangePreset(preset: DateRangePreset, locale: string, timeZone: string): [DateValue, DateValue];
+//#endregion
+export { DateRangePreset as $, getWeekdayFormats as A, alignStart as B, getDaysInWeek as C, getStartOfWeek as D, getMonthNames as E, formatVisibleRange as F, isDateOutsideRange as G, constrainStart as H, getEndDate as I, isPreviousRangeInvalid as J, isDateUnavailable as K, getUnitDuration as L, getMonthFormatter as M, formatRange as N, getWeekDays as O, formatSelectedDate as P, DateGranularity as Q, alignCenter as R, normalizeYear as S, getMonthDays as T, constrainValue as U, constrainSegments as V, isDateEqual as W, alignStartDate as X, alignDate as Y, DateAdjustFn as Z, setDate as _, getAdjustedDateFn as a, getDefaultYearRange as b, getNextSection as c, getPreviousSection as d, DateValue$1 as et, getSectionEnd as f, setCalendar as g, getTodayDate as h, AdjustDateReturn as i, getDayFormatter as j, getWeekOfYear as k, getPreviousPage as l, getPreviousAvailableDate as m, parseDateString as n, getNextPage as o, getSectionStart as p, isNextRangeInvalid as q, AdjustDateParams as r, getNextRow as s, getDateRangePreset as t, getPreviousRow as u, YearsRange as v, getEndOfWeek as w, getYearsRange as x, getDecadeRange as y, alignEnd as z };

package/dist/index-BEfvdGE2.d.ts

@@ -0,0 +1,116 @@
+import { Calendar, CalendarDate, CalendarDateTime, DateDuration, DateFormatter, DateValue, ZonedDateTime } from "@internationalized/date";
+//#region src/common/date-utils/types.d.ts
+type DateValue$1 = CalendarDate | CalendarDateTime | ZonedDateTime;
+type DateGranularity = "day" | "hour" | "minute" | "second";
+type DateAlignment = "start" | "end" | "center";
+type DateAvailableFn = (date: DateValue$1, locale: string) => boolean;
+type DateAdjustFn = (options: {
+  startDate: DateValue$1;
+  focusedDate: DateValue$1;
+}) => {
+  startDate: DateValue$1;
+  focusedDate: DateValue$1;
+  endDate: DateValue$1;
+};
+type DateRangePreset = "thisWeek" | "lastWeek" | "thisMonth" | "lastMonth" | "thisQuarter" | "lastQuarter" | "thisYear" | "lastYear" | "last3Days" | "last7Days" | "last14Days" | "last30Days" | "last90Days";
+//#endregion
+//#region src/common/date-utils/align.d.ts
+declare function alignDate(date: DateValue$1, alignment: DateAlignment, duration: DateDuration, locale: string, min?: DateValue$1 | undefined, max?: DateValue$1 | undefined): import("@internationalized/date").DateValue;
+declare function alignStartDate(date: DateValue$1, startDate: DateValue$1, endDate: DateValue$1, duration: DateDuration, locale: string, min?: DateValue$1 | undefined, max?: DateValue$1 | undefined): import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+//#endregion
+//#region src/common/date-utils/assertion.d.ts
+declare function isDateEqual(dateA: DateValue$1 | null | undefined, dateB?: DateValue$1 | null): boolean;
+declare function isDateUnavailable(date: DateValue$1 | null, isUnavailable: DateAvailableFn | undefined, locale: string, minValue?: DateValue$1 | null, maxValue?: DateValue$1 | null): boolean;
+declare function isDateOutsideRange(date: DateValue$1, startDate?: DateValue$1 | null, endDate?: DateValue$1 | null): boolean;
+declare function isPreviousRangeInvalid(startDate: DateValue$1, minValue?: DateValue$1 | null, maxValue?: DateValue$1 | null): boolean;
+declare function isNextRangeInvalid(endDate: DateValue$1, minValue?: DateValue$1 | null, maxValue?: DateValue$1 | null): boolean;
+//#endregion
+//#region src/common/date-utils/constrain.d.ts
+declare function alignCenter(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignStart(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignEnd(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainStart(date: DateValue, aligned: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainValue<T extends DateValue>(date: T, minValue?: DateValue, maxValue?: DateValue): T;
+declare function constrainSegments<T extends DateValue>(date: T, minValue?: DateValue, maxValue?: DateValue): T;
+//#endregion
+//#region src/common/date-utils/duration.d.ts
+declare function getUnitDuration(duration: DateDuration): {
+  years?: number;
+  months?: number;
+  weeks?: number;
+  days?: number;
+};
+declare function getEndDate(startDate: DateValue$1, duration: DateDuration): import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+//#endregion
+//#region src/common/date-utils/format.d.ts
+declare function formatRange(startDate: DateValue$1, endDate: DateValue$1, formatter: DateFormatter, toString: (start: string, end: string) => string, timeZone: string): string;
+declare function formatSelectedDate(startDate: DateValue$1 | null | undefined, endDate: DateValue$1 | null, locale: string, timeZone: string): string;
+declare function formatVisibleRange(startDate: DateValue$1, endDate: DateValue$1 | null, locale: string, timeZone: string): string;
+//#endregion
+//#region src/common/date-utils/formatter.d.ts
+declare function getDayFormatter(locale: string, timeZone: string, referenceDate?: DateValue): DateFormatter;
+declare function getMonthFormatter(locale: string, timeZone: string, referenceDate?: DateValue): DateFormatter;
+//#endregion
+//#region src/common/date-utils/date-month.d.ts
+declare function getStartOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getEndOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getDaysInWeek(weekIndex: number, from: DateValue, locale: string, firstDayOfWeek?: number): DateValue[];
+declare function getMonthDays(from: DateValue, locale: string, numOfWeeks?: number, firstDayOfWeek?: number): DateValue[][];
+declare function getWeekdayFormats(locale: string, timeZone: string): <T extends DateValue | Date>(value: T) => {
+  value: T;
+  short: string;
+  long: string;
+  narrow: string;
+};
+declare function getWeekDays(date: DateValue, startOfWeekProp: number | undefined, timeZone: string, locale: string): {
+  value: import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+  short: string;
+  long: string;
+  narrow: string;
+}[];
+declare function getMonthNames(locale: string, format?: Intl.DateTimeFormatOptions["month"], referenceDate?: DateValue): string[];
+declare function getWeekOfYear(date: DateValue, locale: string): number;
+//#endregion
+//#region src/common/date-utils/date-year.d.ts
+interface YearsRange {
+  from: number;
+  to: number;
+}
+declare function getYearsRange(range: YearsRange): number[];
+declare function getDefaultYearRange(referenceDate: DateValue, min?: DateValue, max?: DateValue): YearsRange;
+declare function normalizeYear(year: string | null | undefined): string | undefined;
+declare function getDecadeRange(year: number, opts?: {
+  strict?: boolean;
+}): number[];
+//#endregion
+//#region src/common/date-utils/mutation.d.ts
+declare function getTodayDate(timeZone?: string, calendar?: Calendar): import("@internationalized/date").CalendarDate;
+declare function setCalendar(date: DateValue, calendar: Calendar): import("@internationalized/date").CalendarDateTime;
+declare function setDate(date: DateValue, startDate: DateValue, isDateUnavailable: DateAvailableFn, locale: string, minValue: DateValue, maxValue: DateValue): DateValue | undefined;
+declare function getPreviousAvailableDate(date: DateValue, minValue: DateValue, locale: string, isDateUnavailable?: DateAvailableFn): DateValue | undefined;
+//#endregion
+//#region src/common/date-utils/pagination.d.ts
+interface AdjustDateParams {
+  startDate: DateValue$1;
+  focusedDate: DateValue$1;
+}
+interface AdjustDateReturn extends AdjustDateParams {
+  endDate: DateValue$1;
+}
+declare function getAdjustedDateFn(visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): (options: AdjustDateParams) => AdjustDateReturn;
+declare function getNextPage(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn;
+declare function getPreviousPage(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn;
+declare function getNextRow(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getPreviousRow(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getSectionStart(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getSectionEnd(focusedDate: DateValue$1, startDate: DateValue$1, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getNextSection(focusedDate: DateValue$1, startDate: DateValue$1, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+declare function getPreviousSection(focusedDate: DateValue$1, startDate: DateValue$1, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue$1, maxValue?: DateValue$1): AdjustDateReturn | undefined;
+//#endregion
+//#region src/common/date-utils/parse-date.d.ts
+declare function parseDateString(date: string, locale: string, timeZone: string): DateValue$1 | undefined;
+//#endregion
+//#region src/common/date-utils/preset.d.ts
+declare function getDateRangePreset(preset: DateRangePreset, locale: string, timeZone: string): [DateValue, DateValue];
+//#endregion
+export { DateRangePreset as $, getWeekdayFormats as A, alignStart as B, getDaysInWeek as C, getStartOfWeek as D, getMonthNames as E, formatVisibleRange as F, isDateOutsideRange as G, constrainStart as H, getEndDate as I, isPreviousRangeInvalid as J, isDateUnavailable as K, getUnitDuration as L, getMonthFormatter as M, formatRange as N, getWeekDays as O, formatSelectedDate as P, DateGranularity as Q, alignCenter as R, normalizeYear as S, getMonthDays as T, constrainValue as U, constrainSegments as V, isDateEqual as W, alignStartDate as X, alignDate as Y, DateAdjustFn as Z, setDate as _, getAdjustedDateFn as a, getDefaultYearRange as b, getNextSection as c, getPreviousSection as d, DateValue$1 as et, getSectionEnd as f, setCalendar as g, getTodayDate as h, AdjustDateReturn as i, getDayFormatter as j, getWeekOfYear as k, getPreviousPage as l, getPreviousAvailableDate as m, parseDateString as n, getNextPage as o, getSectionStart as p, isNextRangeInvalid as q, AdjustDateParams as r, getNextRow as s, getDateRangePreset as t, getPreviousRow as u, YearsRange as v, getEndOfWeek as w, getYearsRange as x, getDecadeRange as y, alignEnd as z };

package/dist/index-BF6G2RiC.d.cts

@@ -0,0 +1 @@
+import "./index-BKgxIVbE.cjs";

package/dist/index-BKgxIVbE.d.cts

@@ -0,0 +1,285 @@
+import { B as isActiveElement } from "./index-BWiYePx8.cjs";
+//#region src/common/core/merge-props.d.ts
+interface Props {
+  [key: string | symbol]: any;
+}
+type TupleTypes<T extends any[]> = T[number];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+declare function mergeProps<T extends Props>(...args: Array<T | undefined>): UnionToIntersection<TupleTypes<T[]>>;
+//#endregion
+//#region src/common/core/memo.d.ts
+type NoInfer<T> = [T][T extends any ? 0 : never];
+declare function memo<TDeps extends any[], TDepArgs, TResult>(getDeps: (depArgs: TDepArgs) => [...TDeps], fn: (args: NoInfer<[...TDeps]>, deps: TDepArgs) => TResult, opts?: {
+  onChange?: ((result: TResult) => void) | undefined;
+}): (depArgs: TDepArgs) => TResult;
+//#endregion
+//#region src/common/core/types.d.ts
+type Dict = Record<string, any>;
+interface ComputedParams<T extends Dict> {
+  context: BindableContext<T>;
+  event: EventType<T["event"]>;
+  prop: PropFn<T>;
+  refs: BindableRefs<T>;
+  scope: Scope;
+  computed: ComputedFn<T>;
+}
+interface ContextParams<T extends Dict> {
+  prop: PropFn<T>;
+  bindable: BindableFn;
+  scope: Scope;
+  getContext: () => BindableContext<T>;
+  getComputed: () => ComputedFn<T>;
+  getRefs: () => BindableRefs<T>;
+  getEvent: () => EventType<T["event"]>;
+  flush: (fn: VoidFunction) => void;
+}
+interface PropFn<T extends Dict> {
+  <K extends keyof T["props"]>(key: K): T["props"][K];
+}
+interface ComputedFn<T extends Dict> {
+  <K extends keyof T["computed"]>(key: K): T["computed"][K];
+}
+type AnyFunction = () => string | number | boolean | null | undefined;
+type TrackFn = (deps: AnyFunction[], fn: VoidFunction) => void;
+interface BindableParams<T> {
+  defaultValue?: T | undefined;
+  value?: T | undefined;
+  hash?: ((a: T) => string) | undefined;
+  isEqual?: ((a: T, b: T | undefined) => boolean) | undefined;
+  onChange?: ((value: T, prev: T | undefined) => void) | undefined;
+  debug?: string | undefined;
+  sync?: boolean | undefined;
+}
+type ValueOrFn<T> = T | ((prev: T) => T);
+interface Bindable<T> {
+  initial: T | undefined;
+  ref: any;
+  get: () => T;
+  set(value: ValueOrFn<T>): void;
+  invoke(nextValue: T, prevValue: T): void;
+  hash(value: T): string;
+}
+interface BindableRefs<T extends Dict> {
+  set<K extends keyof T["refs"]>(key: K, value: T["refs"][K]): void;
+  get<K extends keyof T["refs"]>(key: K): T["refs"][K];
+}
+interface BindableContext<T extends Dict> {
+  set<K extends keyof T["context"]>(key: K, value: ValueOrFn<T["context"][K]>): void;
+  get<K extends keyof T["context"]>(key: K): T["context"][K];
+  initial<K extends keyof T["context"]>(key: K): T["context"][K];
+  hash<K extends keyof T["context"]>(key: K): string;
+}
+interface BindableRef<T> {
+  get: () => T;
+  set: (next: T) => void;
+}
+interface BindableFn {
+  <K>(params: () => BindableParams<K>): Bindable<K>;
+  cleanup: (fn: VoidFunction) => void;
+  ref: <T>(defaultValue: T) => BindableRef<T>;
+}
+interface Scope {
+  id?: string | undefined;
+  ids?: Record<string, any> | undefined;
+  getRootNode: () => ShadowRoot | Document | Element;
+  getById: <T extends Element = HTMLElement>(id: string) => T | null;
+  getActiveElement: () => HTMLElement | null;
+  isActiveElement: (elem: HTMLElement | null) => boolean;
+  getDoc: () => typeof document;
+  getWin: () => typeof window;
+}
+type EventType<T = any> = T & {
+  previousEvent?: (T & {
+    [key: string]: any;
+  }) | undefined;
+  src?: string | undefined;
+  [key: string]: any;
+};
+type EventObject = EventType<{
+  type: string;
+}>;
+interface Params<T extends Dict> {
+  prop: PropFn<T>;
+  action: (action: T["action"][]) => void;
+  context: BindableContext<T>;
+  refs: BindableRefs<T>;
+  track: TrackFn;
+  flush: (fn: VoidFunction) => void;
+  event: EventType<T["event"]> & {
+    current: () => EventType<T["event"]>;
+    previous: () => EventType<T["event"]>;
+  };
+  send: (event: EventType<T["event"]>) => void;
+  computed: ComputedFn<T>;
+  scope: Scope;
+  state: Bindable<T["state"]> & {
+    matches: (...values: T["state"][]) => boolean;
+    hasTag: (tag: T["tag"]) => boolean;
+  };
+  choose: ChooseFn<T>;
+  guard: (key: T["guard"] | GuardFn<T>) => boolean | undefined;
+}
+type GuardFn<T extends Dict> = (params: Params<T>) => boolean;
+type TopLevelState<S extends string> = S extends `${infer Top}.${string}` ? Top : S;
+type ChildStateKey<S extends string, Parent extends string> = S extends `${Parent}.${infer Rest}` ? Rest extends `${infer Child}.${string}` ? Child : Rest : never;
+type ParentPath<S extends string> = S extends `${infer Parent}.${string}` ? Parent : never;
+type AncestorPaths<S extends string> = S | (ParentPath<S> extends never ? never : AncestorPaths<ParentPath<S>>);
+type StateIdTarget = `#${string}`;
+type SiblingStateTarget<S extends string, Source extends string> = TopLevelState<S> | ChildStateKey<S, Exclude<AncestorPaths<Source>, Source>>;
+type ChildStateTarget<S extends string, Source extends string> = `.${ChildStateKey<S, Source>}`;
+interface Transition<T extends Dict, Source extends string | undefined = string | undefined> {
+  target?: T["state"] | StateIdTarget | (Source extends string ? SiblingStateTarget<T["state"], Source> : never) | (Source extends string ? ChildStateTarget<T["state"], Source> : never) | undefined;
+  actions?: T["action"][] | undefined;
+  guard?: T["guard"] | GuardFn<T> | undefined;
+  reenter?: boolean | undefined;
+}
+type TransitionSet<T extends Dict> = Transition<T> | Transition<T>[] | undefined;
+type TransitionMap<T extends Dict> = Record<string, TransitionSet<T>>;
+type TransitionMatch<T extends Dict> = {
+  transitions: TransitionSet<T>;
+  source: string | undefined;
+};
+type MaybeArray<T> = T | T[];
+type ChooseFn<T extends Dict> = (transitions: MaybeArray<Omit<Transition<T, string>, "target">> | null | undefined) => Transition<T> | undefined;
+interface PropsParams<T extends Dict> {
+  props: Partial<T["props"]>;
+  scope: Scope;
+}
+interface RefsParams<T extends Dict> {
+  prop: PropFn<T>;
+  context: BindableContext<T>;
+}
+type ActionsOrFn<T extends Dict> = T["action"][] | ((params: Params<T>) => T["action"][] | undefined);
+type EffectsOrFn<T extends Dict> = T["effect"][] | ((params: Params<T>) => T["effect"][] | undefined);
+interface MachineState<T extends Dict, Parent extends string = string> {
+  id?: string | undefined;
+  tags?: T["tag"][] | undefined;
+  entry?: ActionsOrFn<T> | undefined;
+  exit?: ActionsOrFn<T> | undefined;
+  effects?: EffectsOrFn<T> | undefined;
+  initial?: ChildStateKey<T["state"], Parent> | undefined;
+  states?: { [K in ChildStateKey<T["state"], Parent>]?: MachineState<T, `${Parent}.${K}`>; } | undefined;
+  on?: { [E in T["event"]["type"]]?: Transition<T, Parent> | Array<Transition<T, Parent>>; } | undefined;
+}
+interface Machine<T extends Dict> {
+  debug?: boolean | undefined;
+  props?: ((params: PropsParams<T>) => T["props"]) | undefined;
+  context?: ((params: ContextParams<T>) => { [K in keyof T["context"]]: Bindable<T["context"][K]>; }) | undefined;
+  computed?: { [K in keyof T["computed"]]: (params: ComputedParams<T>) => T["computed"][K]; } | undefined;
+  initialState: (params: {
+    prop: PropFn<T>;
+  }) => T["state"];
+  entry?: ActionsOrFn<T> | undefined;
+  exit?: ActionsOrFn<T> | undefined;
+  effects?: EffectsOrFn<T> | undefined;
+  refs?: ((params: RefsParams<T>) => T["refs"]) | undefined;
+  watch?: ((params: Params<T>) => void) | undefined;
+  on?: { [E in T["event"]["type"]]?: Transition<T, undefined> | Array<Transition<T, undefined>>; } | undefined;
+  states: { [K in TopLevelState<T["state"]>]: MachineState<T, K>; };
+  implementations?: {
+    guards?: { [K in T["guard"]]: (params: Params<T>) => boolean; } | undefined;
+    actions?: { [K in T["action"]]: (params: Params<T>) => void; } | undefined;
+    effects?: { [K in T["effect"]]: (params: Params<T>) => void | VoidFunction; } | undefined;
+  } | undefined;
+}
+interface MachineBaseProps {
+  id?: string | undefined;
+  ids?: Record<string, any> | undefined;
+  getRootNode?: (() => ShadowRoot | Document | Node) | undefined;
+  [key: string]: any;
+}
+interface MachineSchema {
+  props?: MachineBaseProps | undefined;
+  context?: Record<string, any> | undefined;
+  refs?: Record<string, any> | undefined;
+  computed?: Record<string, any> | undefined;
+  state?: string | undefined;
+  tag?: string | undefined;
+  guard?: string | undefined;
+  action?: string | undefined;
+  effect?: string | undefined;
+  event?: ({
+    type: string;
+  } & Dict) | undefined;
+}
+type State<T extends MachineSchema> = Bindable<T["state"]> & {
+  hasTag: (tag: T["tag"]) => boolean;
+  matches: (...values: T["state"][]) => boolean;
+};
+type Service<T extends MachineSchema> = {
+  getStatus: () => MachineStatus;
+  state: State<T> & {
+    matches: (...values: T["state"][]) => boolean;
+    hasTag: (tag: T["tag"]) => boolean;
+  };
+  context: BindableContext<T>;
+  send: (event: EventType<T["event"]>) => void;
+  prop: PropFn<T>;
+  scope: Scope;
+  computed: ComputedFn<T>;
+  refs: BindableRefs<T>;
+  event: EventType<T["event"]> & {
+    current: () => EventType<T["event"]>;
+    previous: () => EventType<T["event"]>;
+  };
+};
+declare enum MachineStatus {
+  NotStarted = "Not Started",
+  Started = "Started",
+  Stopped = "Stopped"
+}
+declare const INIT_STATE = "__init__";
+//#endregion
+//#region src/common/core/create-machine.d.ts
+declare function createGuards<T extends MachineSchema>(): {
+  and: (...guards: Array<GuardFn<T> | T["guard"]>) => (params: any) => boolean;
+  or: (...guards: Array<GuardFn<T> | T["guard"]>) => (params: any) => boolean;
+  not: (guard: GuardFn<T> | T["guard"]) => (params: any) => boolean;
+};
+declare function createMachine<T extends MachineSchema>(config: Machine<T>): Machine<T>;
+declare function setup<T extends MachineSchema>(): {
+  guards: {
+    and: (...guards: (GuardFn<T> | T["guard"])[]) => (params: any) => boolean;
+    or: (...guards: (GuardFn<T> | T["guard"])[]) => (params: any) => boolean;
+    not: (guard: GuardFn<T> | T["guard"]) => (params: any) => boolean;
+  };
+  createMachine: (config: Machine<T>) => Machine<T>;
+  choose: (transitions: Transition<T> | Transition<T>[]) => ({ choose }: Params<T>) => T["action"][] | undefined;
+};
+//#endregion
+//#region src/common/core/state.d.ts
+declare function ensureStateIndex<T extends MachineSchema>(machine: Machine<T>): Map<string, MachineState<T, string>>;
+type StateChain<T extends MachineSchema> = Array<{
+  path: string;
+  state: MachineState<T>;
+}>;
+declare function getStateChain<T extends MachineSchema>(machine: Machine<T>, state: T["state"] | undefined): StateChain<T>;
+declare function resolveStateValue<T extends MachineSchema>(machine: Machine<T>, value: T["state"] | string, source?: string): T["state"];
+declare function getStateDefinition<T extends MachineSchema>(machine: Machine<T>, state: T["state"]): MachineState<T, string>;
+declare function findTransition<T extends MachineSchema>(machine: Machine<T>, state: T["state"], eventType: string): TransitionMatch<T>;
+declare function getExitEnterStates<T extends MachineSchema>(machine: Machine<T>, prevState: T["state"] | undefined, nextState: T["state"], reenter?: boolean): {
+  exiting: {
+    path: string;
+    state: MachineState<T, string>;
+  }[];
+  entering: {
+    path: string;
+    state: MachineState<T, string>;
+  }[];
+};
+declare function matchesState(current: string | undefined, value: string): boolean;
+declare function hasTag<T extends MachineSchema>(machine: Machine<T>, state: T["state"], tag: T["tag"]): boolean;
+//#endregion
+//#region src/common/core/scope.d.ts
+declare function createScope(props: Pick<Scope, "id" | "ids" | "getRootNode">): {
+  getRootNode: () => Document | ShadowRoot;
+  getDoc: () => Document;
+  getWin: () => Window & typeof globalThis;
+  getActiveElement: () => HTMLElement | null;
+  isActiveElement: typeof isActiveElement;
+  getById: <T extends Element = HTMLElement>(id: string) => T | null;
+  id?: string | undefined | undefined;
+  ids?: Record<string, any> | undefined;
+};
+//#endregion
+export { PropFn as A, GuardFn as C, MachineState as D, MachineSchema as E, TransitionMatch as F, TransitionSet as I, ValueOrFn as L, Service as M, Transition as N, MachineStatus as O, TransitionMap as P, memo as R, EventObject as S, Machine as T, BindableParams as _, getStateChain as a, ComputedFn as b, matchesState as c, createMachine as d, setup as f, BindableFn as g, BindableContext as h, getExitEnterStates as i, Scope as j, Params as k, resolveStateValue as l, Bindable as m, ensureStateIndex as n, getStateDefinition as o, ActionsOrFn as p, findTransition as r, hasTag as s, createScope as t, createGuards as u, BindableRefs as v, INIT_STATE as w, EffectsOrFn as x, ChooseFn as y, mergeProps as z };