@mittwald/flow-react-components 1.6.0-next.4 → 1.6.0-next.40

package/dist/js/packages/components-base/src/list/filter/dateRange.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"dateRange.mjs","names":[],"sources":["../../../../../../../../components-base/src/list/filter/dateRange.ts"],"sourcesContent":["import { CalendarDate } from \"@internationalized/date\";\nimport type { ColumnDef, Row } from \"@tanstack/table-core\";\nimport { DateTime } from \"luxon\";\n\n/** A calendar date, in whichever shape it reached the filter. */\nexport interface ListDateParts {\n  readonly year: number;\n  readonly month: number;\n  readonly day: number;\n}\n\nexport interface ListDateRange {\n  readonly start?: ListDateParts;\n  readonly end?: ListDateParts;\n}\n\n/** A range needs both ends present to be one, even if either may be unset. */\nexport const isListDateRange = (value: unknown): value is ListDateRange =>\n  !!value && typeof value === \"object\" && \"start\" in value && \"end\" in value;\n\n/*\n * The range's ends are read field by field: they come from the calendar, and\n * after crossing the remote boundary a `CalendarDate` is a plain object.\n */\nconst startOfDay = (date: ListDateParts): DateTime =>\n  DateTime.fromObject({\n    year: date.year,\n    month: date.month,\n    day: date.day,\n  });\n\n/**\n * The cell's value as a point in time, or `undefined` when the filter does not\n * treat it as a date.\n *\n * Three shapes count, each on its own terms: a luxon `DateTime` and an ISO 8601\n * string are compared as the instant they name — a date-only string as the\n * start of its day — and a `CalendarDate` as its day. Anything else, a plain `{\n * year, month, day }` object included, is not a date here.\n */\nconst toDateTime = (value: unknown): DateTime | undefined => {\n  if (value instanceof DateTime) {\n    return value;\n  }\n  if (value instanceof CalendarDate) {\n    return startOfDay(value);\n  }\n  if (typeof value === \"string\") {\n    return DateTime.fromISO(value);\n  }\n  return undefined;\n};\n\n/**\n * Whether a row's date falls inside the selected range.\n *\n * A value that is not a date keeps its row: a filter the data cannot answer\n * should not empty the list. That includes a string luxon cannot parse — the\n * invalid `DateTime` compares as `NaN`, and neither end excludes it.\n */\nexport const dateRangeFilterFn = <T>(\n  row: Row<T>,\n  columnId: string,\n  range?: ListDateRange,\n): boolean => {\n  if (!range) {\n    return true;\n  }\n\n  const dateValue = toDateTime(row.getValue(columnId));\n\n  if (!dateValue) {\n    return true;\n  }\n\n  const startDate = range.start ? startOfDay(range.start) : undefined;\n  /* The whole end day counts, up to its last moment. */\n  const endDate = range.end ? startOfDay(range.end).endOf(\"day\") : undefined;\n\n  if (startDate && dateValue < startDate) {\n    return false;\n  }\n\n  return !(endDate && dateValue > endDate);\n};\n\n/** Turns the column into one a date range filters. */\nexport const applyDateRangeColumnDef = <T>(def: ColumnDef<T>): void => {\n  def.enableColumnFilter = true;\n  def.filterFn = dateRangeFilterFn;\n};\n"],"mappings":";;;;;;AAiBA,IAAa,mBAAmB,UAC9B,CAAC,CAAC,SAAS,OAAO,UAAU,YAAY,WAAW,SAAS,SAAS;AAMvE,IAAM,cAAc,SAClB,SAAS,WAAW;CAClB,MAAM,KAAK;CACX,OAAO,KAAK;CACZ,KAAK,KAAK;AACZ,CAAC;;;;;;;;;;AAWH,IAAM,cAAc,UAAyC;CAC3D,IAAI,iBAAiB,UACnB,OAAO;CAET,IAAI,iBAAiB,cACnB,OAAO,WAAW,KAAK;CAEzB,IAAI,OAAO,UAAU,UACnB,OAAO,SAAS,QAAQ,KAAK;AAGjC;;;;;;;;AASA,IAAa,qBACX,KACA,UACA,UACY;CACZ,IAAI,CAAC,OACH,OAAO;CAGT,MAAM,YAAY,WAAW,IAAI,SAAS,QAAQ,CAAC;CAEnD,IAAI,CAAC,WACH,OAAO;CAGT,MAAM,YAAY,MAAM,QAAQ,WAAW,MAAM,KAAK,IAAI,KAAA;CAE1D,MAAM,UAAU,MAAM,MAAM,WAAW,MAAM,GAAG,CAAC,CAAC,MAAM,KAAK,IAAI,KAAA;CAEjE,IAAI,aAAa,YAAY,WAC3B,OAAO;CAGT,OAAO,EAAE,WAAW,YAAY;AAClC;;AAGA,IAAa,2BAA8B,QAA4B;CACrE,IAAI,qBAAqB;CACzB,IAAI,WAAW;AACjB"}
+{"version":3,"file":"dateRange.mjs","names":[],"sources":["../../../../../../../../components-base/src/list/filter/dateRange.ts"],"sourcesContent":["import {\n  CalendarDate,\n  CalendarDateTime,\n  ZonedDateTime,\n} from \"@internationalized/date\";\nimport type { ColumnDef, Row } from \"@tanstack/table-core\";\nimport { DateTime } from \"luxon\";\n\n/**\n * A calendar date, in whichever shape it reached the filter — with a time of\n * day when the filter narrows down by minute.\n */\nexport interface ListDateParts {\n  readonly year: number;\n  readonly month: number;\n  readonly day: number;\n  readonly hour?: number;\n  readonly minute?: number;\n  readonly second?: number;\n}\n\nexport interface ListDateRange {\n  readonly start?: ListDateParts;\n  readonly end?: ListDateParts;\n}\n\n/** A range needs both ends present to be one, even if either may be unset. */\nexport const isListDateRange = (value: unknown): value is ListDateRange =>\n  !!value && typeof value === \"object\" && \"start\" in value && \"end\" in value;\n\nconst hasTime = (date: ListDateParts) => \"hour\" in date;\n\n/**\n * The date as a local point in time. A `ZonedDateTime` is the instant it names;\n * anything else is read field by field, since after crossing the remote\n * boundary a `CalendarDate` is a plain object.\n */\nexport const listDateToDateTime = (date: ListDateParts): DateTime =>\n  date instanceof ZonedDateTime\n    ? DateTime.fromJSDate(date.toDate())\n    : DateTime.fromObject({\n        year: date.year,\n        month: date.month,\n        day: date.day,\n        ...(hasTime(date)\n          ? { hour: date.hour, minute: date.minute, second: date.second }\n          : {}),\n      });\n\n/**\n * Resolves a range to the instants it spans, for filtering on the server side.\n * Both bounds are inclusive: a date covers its whole day and a date with time\n * its whole minute, in the user's local time zone. A missing side has no\n * bound.\n */\nexport const resolveListDateRange = (\n  range: ListDateRange,\n): { start?: Date; end?: Date } => {\n  const unit = (date: ListDateParts) => (hasTime(date) ? \"minute\" : \"day\");\n\n  return {\n    start: range.start\n      ? listDateToDateTime(range.start).startOf(unit(range.start)).toJSDate()\n      : undefined,\n    end: range.end\n      ? listDateToDateTime(range.end).endOf(unit(range.end)).toJSDate()\n      : undefined,\n  };\n};\n\n/**\n * The cell's value as a point in time, or `undefined` when the filter does not\n * treat it as a date.\n *\n * A luxon `DateTime` and an ISO 8601 string are compared as the instant they\n * name — a date-only string as the start of its day. A `CalendarDate` counts as\n * the start of its day, a `CalendarDateTime` as its local time and a\n * `ZonedDateTime` as its instant. Anything else, a plain `{ year, month, day }`\n * object included, is not a date here.\n */\nconst toDateTime = (value: unknown): DateTime | undefined => {\n  if (value instanceof DateTime) {\n    return value;\n  }\n  if (\n    value instanceof CalendarDate ||\n    value instanceof CalendarDateTime ||\n    value instanceof ZonedDateTime\n  ) {\n    return listDateToDateTime(value);\n  }\n  if (typeof value === \"string\") {\n    return DateTime.fromISO(value);\n  }\n  return undefined;\n};\n\n/**\n * Whether a row's date falls inside the selected range.\n *\n * A value that is not a date keeps its row: a filter the data cannot answer\n * should not empty the list. That includes a string luxon cannot parse — the\n * invalid `DateTime` compares as `NaN`, and neither end excludes it.\n */\nexport const dateRangeFilterFn = <T>(\n  row: Row<T>,\n  columnId: string,\n  range?: ListDateRange,\n): boolean => {\n  if (!range) {\n    return true;\n  }\n\n  const dateValue = toDateTime(row.getValue(columnId));\n\n  if (!dateValue) {\n    return true;\n  }\n\n  const { start, end } = resolveListDateRange(range);\n\n  if (start && dateValue.toMillis() < start.getTime()) {\n    return false;\n  }\n\n  return !(end && dateValue.toMillis() > end.getTime());\n};\n\n/** Turns the column into one a date range filters. */\nexport const applyDateRangeColumnDef = <T>(def: ColumnDef<T>): void => {\n  def.enableColumnFilter = true;\n  def.filterFn = dateRangeFilterFn;\n};\n"],"mappings":";;;;;;AA2BA,IAAa,mBAAmB,UAC9B,CAAC,CAAC,SAAS,OAAO,UAAU,YAAY,WAAW,SAAS,SAAS;AAEvE,IAAM,WAAW,SAAwB,UAAU;;;;;;AAOnD,IAAa,sBAAsB,SACjC,gBAAgB,gBACZ,SAAS,WAAW,KAAK,OAAO,CAAC,IACjC,SAAS,WAAW;CAClB,MAAM,KAAK;CACX,OAAO,KAAK;CACZ,KAAK,KAAK;CACV,GAAI,QAAQ,IAAI,IACZ;EAAE,MAAM,KAAK;EAAM,QAAQ,KAAK;EAAQ,QAAQ,KAAK;CAAO,IAC5D,CAAC;AACP,CAAC;;;;;;;AAQP,IAAa,wBACX,UACiC;CACjC,MAAM,QAAQ,SAAyB,QAAQ,IAAI,IAAI,WAAW;CAElE,OAAO;EACL,OAAO,MAAM,QACT,mBAAmB,MAAM,KAAK,CAAC,CAAC,QAAQ,KAAK,MAAM,KAAK,CAAC,CAAC,CAAC,SAAS,IACpE,KAAA;EACJ,KAAK,MAAM,MACP,mBAAmB,MAAM,GAAG,CAAC,CAAC,MAAM,KAAK,MAAM,GAAG,CAAC,CAAC,CAAC,SAAS,IAC9D,KAAA;CACN;AACF;;;;;;;;;;;AAYA,IAAM,cAAc,UAAyC;CAC3D,IAAI,iBAAiB,UACnB,OAAO;CAET,IACE,iBAAiB,gBACjB,iBAAiB,oBACjB,iBAAiB,eAEjB,OAAO,mBAAmB,KAAK;CAEjC,IAAI,OAAO,UAAU,UACnB,OAAO,SAAS,QAAQ,KAAK;AAGjC;;;;;;;;AASA,IAAa,qBACX,KACA,UACA,UACY;CACZ,IAAI,CAAC,OACH,OAAO;CAGT,MAAM,YAAY,WAAW,IAAI,SAAS,QAAQ,CAAC;CAEnD,IAAI,CAAC,WACH,OAAO;CAGT,MAAM,EAAE,OAAO,QAAQ,qBAAqB,KAAK;CAEjD,IAAI,SAAS,UAAU,SAAS,IAAI,MAAM,QAAQ,GAChD,OAAO;CAGT,OAAO,EAAE,OAAO,UAAU,SAAS,IAAI,IAAI,QAAQ;AACrD;;AAGA,IAAa,2BAA8B,QAA4B;CACrE,IAAI,qBAAqB;CACzB,IAAI,WAAW;AACjB"}

package/dist/js/packages/components-base/src/list/filter/dateTimeRangeFields.mjs

@@ -0,0 +1,55 @@
+"use client"
+/* */
+import { resolveListDateRange } from "./dateRange.mjs";
+import { CalendarDate, Time, toCalendarDateTime } from "@internationalized/date";
+//#region ../components-base/src/list/filter/dateTimeRangeFields.ts
+var toListCalendarDate = (value) => value ? new CalendarDate(value.year, value.month, value.day) : null;
+var toListTime = (value) => value && "hour" in value ? new Time(value.hour, value.minute) : null;
+var listDateTimeRangeFieldsFromValue = (value) => ({
+	startDate: toListCalendarDate(value?.start),
+	startTime: toListTime(value?.start),
+	endDate: toListCalendarDate(value?.end),
+	endTime: toListTime(value?.end)
+});
+var toBound = (date, time) => date ? time ? toCalendarDateTime(date, time) : date : void 0;
+var boundKey = (bound) => bound && [
+	bound.year,
+	bound.month,
+	bound.day,
+	bound.hour,
+	bound.minute
+].join("-");
+var isYearComplete = (date) => !!date && date.year >= 1e3;
+/** Not while a year is still being typed: "2" would read as an early end. */
+var isListDateTimeRangeEndBeforeStart = (fields) => {
+	if (!isYearComplete(fields.startDate) || !isYearComplete(fields.endDate)) return false;
+	const { start, end } = resolveListDateRange({
+		start: toBound(fields.startDate, fields.startTime),
+		end: toBound(fields.endDate, fields.endTime)
+	});
+	return !!start && !!end && end < start;
+};
+var isListDateValid = (date, limits = {}) => {
+	const minValue = toListCalendarDate(limits.minValue);
+	const maxValue = toListCalendarDate(limits.maxValue);
+	return !date || !(!isYearComplete(date) || minValue && date.compare(minValue) < 0 || maxValue && date.compare(maxValue) > 0 || limits.isDateUnavailable?.(date));
+};
+/**
+* The range the fields stand for, or `undefined` while it must not be applied:
+* an invalid input keeps the last valid range, and an unchanged one needs no
+* update. `null` clears the filter.
+*/
+var getListDateTimeRangeUpdate = (fields, applied, limits) => {
+	if (!isListDateValid(fields.startDate, limits) || !isListDateValid(fields.endDate, limits) || isListDateTimeRangeEndBeforeStart(fields)) return;
+	const start = toBound(fields.startDate, fields.startTime);
+	const end = toBound(fields.endDate, fields.endTime);
+	if (boundKey(start) === boundKey(applied?.start) && boundKey(end) === boundKey(applied?.end)) return;
+	return start || end ? {
+		start,
+		end
+	} : null;
+};
+//#endregion
+export { getListDateTimeRangeUpdate, isListDateTimeRangeEndBeforeStart, isListDateValid, listDateTimeRangeFieldsFromValue, toListCalendarDate, toListTime };
+
+//# sourceMappingURL=dateTimeRangeFields.mjs.map

package/dist/js/packages/components-base/src/list/filter/dateTimeRangeFields.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateTimeRangeFields.mjs","names":[],"sources":["../../../../../../../../components-base/src/list/filter/dateTimeRangeFields.ts"],"sourcesContent":["import {\n  CalendarDate,\n  type CalendarDateTime,\n  Time,\n  toCalendarDateTime,\n} from \"@internationalized/date\";\nimport {\n  resolveListDateRange,\n  type ListDateParts,\n  type ListDateRange,\n} from \"./dateRange\";\n\n/*\n * The rules of the date and time fields a range filter shows with\n * `granularity: \"minute\"`. Which input is valid and when it applies is the same\n * in every binding; the fields and the state holding their input are not.\n */\n\nexport interface ListDateTimeRangeFields {\n  readonly startDate: CalendarDate | null;\n  readonly startTime: Time | null;\n  readonly endDate: CalendarDate | null;\n  readonly endTime: Time | null;\n}\n\nexport interface ListDateTimeRangeLimits {\n  readonly minValue?: ListDateParts | null;\n  readonly maxValue?: ListDateParts | null;\n  readonly isDateUnavailable?: (date: CalendarDate) => boolean;\n}\n\ntype Bound = CalendarDate | CalendarDateTime;\n\nexport interface ListDateTimeRange {\n  readonly start?: Bound;\n  readonly end?: Bound;\n}\n\n/* Field by field: a value from the host of a remote connection is a plain object. */\nexport const toListCalendarDate = (\n  value?: ListDateParts | null,\n): CalendarDate | null =>\n  value ? new CalendarDate(value.year, value.month, value.day) : null;\n\nexport const toListTime = (\n  value?: { readonly hour?: number; readonly minute?: number } | null,\n): Time | null =>\n  value && \"hour\" in value ? new Time(value.hour, value.minute) : null;\n\nexport const listDateTimeRangeFieldsFromValue = (\n  value: ListDateRange | null,\n): ListDateTimeRangeFields => ({\n  startDate: toListCalendarDate(value?.start),\n  startTime: toListTime(value?.start),\n  endDate: toListCalendarDate(value?.end),\n  endTime: toListTime(value?.end),\n});\n\nconst toBound = (date: CalendarDate | null, time: Time | null) =>\n  date ? (time ? toCalendarDateTime(date, time) : date) : undefined;\n\nconst boundKey = (bound?: ListDateParts) =>\n  bound &&\n  [bound.year, bound.month, bound.day, bound.hour, bound.minute].join(\"-\");\n\n// react-aria reports a typed year digit by digit (2, 20, 202, 2026)\nconst isYearComplete = (date: CalendarDate | null) =>\n  !!date && date.year >= 1000;\n\n/** Not while a year is still being typed: \"2\" would read as an early end. */\nexport const isListDateTimeRangeEndBeforeStart = (\n  fields: ListDateTimeRangeFields,\n): boolean => {\n  if (!isYearComplete(fields.startDate) || !isYearComplete(fields.endDate)) {\n    return false;\n  }\n  const { start, end } = resolveListDateRange({\n    start: toBound(fields.startDate, fields.startTime),\n    end: toBound(fields.endDate, fields.endTime),\n  });\n  return !!start && !!end && end < start;\n};\n\nexport const isListDateValid = (\n  date: CalendarDate | null,\n  limits: ListDateTimeRangeLimits = {},\n): boolean => {\n  const minValue = toListCalendarDate(limits.minValue);\n  const maxValue = toListCalendarDate(limits.maxValue);\n\n  return (\n    !date ||\n    !(\n      !isYearComplete(date) ||\n      (minValue && date.compare(minValue) < 0) ||\n      (maxValue && date.compare(maxValue) > 0) ||\n      limits.isDateUnavailable?.(date)\n    )\n  );\n};\n\n/**\n * The range the fields stand for, or `undefined` while it must not be applied:\n * an invalid input keeps the last valid range, and an unchanged one needs no\n * update. `null` clears the filter.\n */\nexport const getListDateTimeRangeUpdate = (\n  fields: ListDateTimeRangeFields,\n  applied: ListDateRange | null,\n  limits?: ListDateTimeRangeLimits,\n): ListDateTimeRange | null | undefined => {\n  if (\n    !isListDateValid(fields.startDate, limits) ||\n    !isListDateValid(fields.endDate, limits) ||\n    isListDateTimeRangeEndBeforeStart(fields)\n  ) {\n    return undefined;\n  }\n\n  const start = toBound(fields.startDate, fields.startTime);\n  const end = toBound(fields.endDate, fields.endTime);\n\n  if (\n    boundKey(start) === boundKey(applied?.start) &&\n    boundKey(end) === boundKey(applied?.end)\n  ) {\n    return undefined;\n  }\n\n  return start || end ? { start, end } : null;\n};\n"],"mappings":";;;;;AAuCA,IAAa,sBACX,UAEA,QAAQ,IAAI,aAAa,MAAM,MAAM,MAAM,OAAO,MAAM,GAAG,IAAI;AAEjE,IAAa,cACX,UAEA,SAAS,UAAU,QAAQ,IAAI,KAAK,MAAM,MAAM,MAAM,MAAM,IAAI;AAElE,IAAa,oCACX,WAC6B;CAC7B,WAAW,mBAAmB,OAAO,KAAK;CAC1C,WAAW,WAAW,OAAO,KAAK;CAClC,SAAS,mBAAmB,OAAO,GAAG;CACtC,SAAS,WAAW,OAAO,GAAG;AAChC;AAEA,IAAM,WAAW,MAA2B,SAC1C,OAAQ,OAAO,mBAAmB,MAAM,IAAI,IAAI,OAAQ,KAAA;AAE1D,IAAM,YAAY,UAChB,SACA;CAAC,MAAM;CAAM,MAAM;CAAO,MAAM;CAAK,MAAM;CAAM,MAAM;AAAM,CAAC,CAAC,KAAK,GAAG;AAGzE,IAAM,kBAAkB,SACtB,CAAC,CAAC,QAAQ,KAAK,QAAQ;;AAGzB,IAAa,qCACX,WACY;CACZ,IAAI,CAAC,eAAe,OAAO,SAAS,KAAK,CAAC,eAAe,OAAO,OAAO,GACrE,OAAO;CAET,MAAM,EAAE,OAAO,QAAQ,qBAAqB;EAC1C,OAAO,QAAQ,OAAO,WAAW,OAAO,SAAS;EACjD,KAAK,QAAQ,OAAO,SAAS,OAAO,OAAO;CAC7C,CAAC;CACD,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,MAAM;AACnC;AAEA,IAAa,mBACX,MACA,SAAkC,CAAC,MACvB;CACZ,MAAM,WAAW,mBAAmB,OAAO,QAAQ;CACnD,MAAM,WAAW,mBAAmB,OAAO,QAAQ;CAEnD,OACE,CAAC,QACD,EACE,CAAC,eAAe,IAAI,KACnB,YAAY,KAAK,QAAQ,QAAQ,IAAI,KACrC,YAAY,KAAK,QAAQ,QAAQ,IAAI,KACtC,OAAO,oBAAoB,IAAI;AAGrC;;;;;;AAOA,IAAa,8BACX,QACA,SACA,WACyC;CACzC,IACE,CAAC,gBAAgB,OAAO,WAAW,MAAM,KACzC,CAAC,gBAAgB,OAAO,SAAS,MAAM,KACvC,kCAAkC,MAAM,GAExC;CAGF,MAAM,QAAQ,QAAQ,OAAO,WAAW,OAAO,SAAS;CACxD,MAAM,MAAM,QAAQ,OAAO,SAAS,OAAO,OAAO;CAElD,IACE,SAAS,KAAK,MAAM,SAAS,SAAS,KAAK,KAC3C,SAAS,GAAG,MAAM,SAAS,SAAS,GAAG,GAEvC;CAGF,OAAO,SAAS,MAAM;EAAE;EAAO;CAAI,IAAI;AACzC"}

package/dist/js/packages/components-base/src/list/filter/formatDateRange.mjs

@@ -0,0 +1,27 @@
+"use client"
+/* */
+import { listDateToDateTime } from "./dateRange.mjs";
+import { DateFormatter } from "@internationalized/date";
+//#region ../components-base/src/list/filter/formatDateRange.ts
+/** The active filter chip's text: an end with time shows its time. */
+var formatListDateRange = (value, locale, format) => {
+	const formatBound = (bound) => new DateFormatter(locale, {
+		year: "numeric",
+		month: "numeric",
+		day: "numeric",
+		..."hour" in bound ? {
+			hour: "2-digit",
+			minute: "2-digit",
+			hourCycle: "h23"
+		} : {}
+	}).format(listDateToDateTime(bound).toJSDate());
+	const { start, end } = value;
+	if (start && end) return `${formatBound(start)} – ${formatBound(end)}`;
+	if (start) return format("dateRange.from", { date: formatBound(start) });
+	if (end) return format("dateRange.until", { date: formatBound(end) });
+	return "";
+};
+//#endregion
+export { formatListDateRange };
+
+//# sourceMappingURL=formatDateRange.mjs.map

package/dist/js/packages/components-base/src/list/filter/formatDateRange.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatDateRange.mjs","names":[],"sources":["../../../../../../../../components-base/src/list/filter/formatDateRange.ts"],"sourcesContent":["import { DateFormatter } from \"@internationalized/date\";\nimport {\n  listDateToDateTime,\n  type ListDateParts,\n  type ListDateRange,\n} from \"./dateRange\";\n\n/** Formats the text of an open range (\"from {date}\", \"until {date}\"). */\nexport type ListDateRangeTextFormat = (\n  key: \"dateRange.from\" | \"dateRange.until\",\n  values: { date: string },\n) => string;\n\n/** The active filter chip's text: an end with time shows its time. */\nexport const formatListDateRange = (\n  value: ListDateRange,\n  locale: string,\n  format: ListDateRangeTextFormat,\n): string => {\n  const formatBound = (bound: ListDateParts) =>\n    new DateFormatter(locale, {\n      year: \"numeric\",\n      month: \"numeric\",\n      day: \"numeric\",\n      // TimeField always shows 24 hours\n      ...(\"hour\" in bound\n        ? { hour: \"2-digit\", minute: \"2-digit\", hourCycle: \"h23\" }\n        : {}),\n    }).format(listDateToDateTime(bound).toJSDate());\n\n  const { start, end } = value;\n\n  if (start && end) {\n    return `${formatBound(start)} – ${formatBound(end)}`;\n  }\n  if (start) {\n    return format(\"dateRange.from\", { date: formatBound(start) });\n  }\n  if (end) {\n    return format(\"dateRange.until\", { date: formatBound(end) });\n  }\n  return \"\";\n};\n"],"mappings":";;;;;;AAcA,IAAa,uBACX,OACA,QACA,WACW;CACX,MAAM,eAAe,UACnB,IAAI,cAAc,QAAQ;EACxB,MAAM;EACN,OAAO;EACP,KAAK;EAEL,GAAI,UAAU,QACV;GAAE,MAAM;GAAW,QAAQ;GAAW,WAAW;EAAM,IACvD,CAAC;CACP,CAAC,CAAC,CAAC,OAAO,mBAAmB,KAAK,CAAC,CAAC,SAAS,CAAC;CAEhD,MAAM,EAAE,OAAO,QAAQ;CAEvB,IAAI,SAAS,KACX,OAAO,GAAG,YAAY,KAAK,EAAE,KAAK,YAAY,GAAG;CAEnD,IAAI,OACF,OAAO,OAAO,kBAAkB,EAAE,MAAM,YAAY,KAAK,EAAE,CAAC;CAE9D,IAAI,KACF,OAAO,OAAO,mBAAmB,EAAE,MAAM,YAAY,GAAG,EAAE,CAAC;CAE7D,OAAO;AACT"}

package/dist/js/packages/components-base/src/overlay/OverlayState.mjs

@@ -0,0 +1,196 @@
+"use client"
+/* */
+import { action, computed, makeObservable, observable, runInAction } from "mobx";
+//#region ../components-base/src/overlay/OverlayState.ts
+/**
+* Whether an overlay is open, and whether closing it has to be confirmed first.
+* Each binding adds its subscription and its lifecycle: React's
+* `OverlayController` subclasses it, Vue's adapter wraps it in refs.
+*
+* `TCloseOptions` lets a binding pass more on a close than the state reads —
+* React's `overlay`, resolved by `Action` before the close arrives here.
+*/
+var OverlayState = class {
+	isOpen = false;
+	isContentSuspended = false;
+	onOpenHandlers = /* @__PURE__ */ new Set();
+	onCloseHandlers = /* @__PURE__ */ new Set();
+	onOpenChangeHandlers = /* @__PURE__ */ new Set();
+	showConfirmationModal = false;
+	closeIsConfirmed = false;
+	confirmOnCloseFromOptions;
+	/**
+	* Every mounted component that has an opinion on close confirmation
+	* contributes one entry here – e.g. a `Modal` with a `confirmOnClose` prop
+	* and a `Form` tracking its dirty state. Combining them instead of assigning
+	* a single flag keeps them from overwriting each other.
+	*/
+	confirmOnCloseSources = observable.map();
+	/**
+	* Active grants that allow closing without a confirmation. Each entry is
+	* scoped to an ongoing operation that legitimately closes the overlay – e.g.
+	* a `Form` submit – and is dropped again when that operation has finished, so
+	* an operation that does _not_ close the overlay leaves the confirmation
+	* armed.
+	*/
+	closeWithoutConfirmationGrants = /* @__PURE__ */ new Set();
+	/**
+	* The open state a `setOpen` call is currently applying. Handlers run before
+	* `isOpen` is assigned, so a handler that calls `setOpen` again would not be
+	* caught by the equality check at the top and would recurse.
+	*/
+	openStateInFlight;
+	constructor(options = {}) {
+		makeObservable(this, {
+			isOpen: observable,
+			isContentSuspended: observable,
+			showConfirmationModal: observable,
+			confirmOnCloseEnabled: computed,
+			open: action.bound,
+			close: action.bound,
+			toggle: action.bound,
+			setOpen: action.bound,
+			syncOpen: action.bound,
+			setIsContentSuspended: action.bound,
+			confirmClose: action.bound,
+			cancelConfirmation: action.bound
+		});
+		const { isDefaultOpen = false, confirmOnClose = false } = options;
+		this.isOpen = isDefaultOpen;
+		this.confirmOnCloseFromOptions = confirmOnClose;
+	}
+	/** Whether closing this overlay currently requires a confirmation. */
+	get confirmOnCloseEnabled() {
+		if (this.confirmOnCloseSources.size === 0) return this.confirmOnCloseFromOptions;
+		return Array.from(this.confirmOnCloseSources.values()).some(Boolean);
+	}
+	/**
+	* Sets the opinion of one source – any object the caller keeps – on close
+	* confirmation. Remove the source again when its owner goes away.
+	*
+	* @internal Bindings call it from their lifecycle.
+	*/
+	setConfirmOnCloseSource(source, confirmOnClose) {
+		runInAction(() => {
+			this.confirmOnCloseSources.set(source, confirmOnClose);
+			this.withdrawUnneededConfirmation();
+		});
+	}
+	/** @internal Bindings call it from their lifecycle. */
+	removeConfirmOnCloseSource(source) {
+		runInAction(() => {
+			this.confirmOnCloseSources.delete(source);
+			this.withdrawUnneededConfirmation();
+		});
+	}
+	withdrawUnneededConfirmation() {
+		if (!this.confirmOnCloseEnabled) this.showConfirmationModal = false;
+	}
+	addOpenStateHandler(handler, handlersSet) {
+		handlersSet.add(handler);
+		return () => {
+			handlersSet.delete(handler);
+		};
+	}
+	executeHandlers(isOpen, handlers) {
+		return Array.from(handlers).map((handler) => handler(isOpen)).some((result) => result === false);
+	}
+	executeOnClose() {
+		return this.executeHandlers(false, this.onCloseHandlers);
+	}
+	executeOnOpen() {
+		return this.executeHandlers(true, this.onOpenHandlers);
+	}
+	executeOnOpenChange(isOpen) {
+		return this.executeHandlers(isOpen, this.onOpenChangeHandlers);
+	}
+	addOnClose(handler) {
+		return this.addOpenStateHandler(handler, this.onCloseHandlers);
+	}
+	addOnOpen(handler) {
+		return this.addOpenStateHandler(handler, this.onOpenHandlers);
+	}
+	addOnOpenChange(handler) {
+		return this.addOpenStateHandler(handler, this.onOpenChangeHandlers);
+	}
+	open() {
+		this.setOpen(true);
+	}
+	close(options) {
+		this.setOpen(false, options);
+	}
+	toggle() {
+		this.setOpen(!this.isOpen);
+	}
+	setOpen(toOpen, options) {
+		if (this.isOpen === toOpen || this.openStateInFlight === toOpen) return;
+		this.openStateInFlight = toOpen;
+		try {
+			this.applyOpenState(toOpen, options);
+		} finally {
+			this.openStateInFlight = void 0;
+		}
+	}
+	/**
+	* Sets the open state without running any handler. Use it to mirror a
+	* controlled `isOpen` prop, whose change comes from the consumer – notifying
+	* them of their own state would echo it back. Closing this way drops a
+	* pending close confirmation as well.
+	*/
+	syncOpen(toOpen) {
+		this.assignOpenState(toOpen);
+	}
+	/** A closed overlay has no close left to confirm. */
+	assignOpenState(toOpen) {
+		this.isOpen = toOpen;
+		if (!toOpen) {
+			this.showConfirmationModal = false;
+			this.closeIsConfirmed = false;
+		}
+	}
+	applyOpenState(toOpen, options) {
+		const { bypassConfirmation = false } = options ?? {};
+		if (toOpen === false) {
+			const closeIsConfirmed = this.closeIsConfirmed;
+			this.closeIsConfirmed = false;
+			if (this.confirmOnCloseEnabled && !closeIsConfirmed && this.closeWithoutConfirmationGrants.size === 0 && !bypassConfirmation) {
+				this.showConfirmationModal = true;
+				return;
+			}
+		}
+		let aborted;
+		if (toOpen) aborted = this.executeOnOpen();
+		else aborted = this.executeOnClose();
+		if (!aborted) aborted = this.executeOnOpenChange(toOpen);
+		if (!aborted) this.assignOpenState(toOpen);
+	}
+	setIsContentSuspended(to) {
+		this.isContentSuspended = to;
+	}
+	/**
+	* Allows closing this overlay without a confirmation until the returned
+	* disposer is called. Use it around an operation that may legitimately close
+	* the overlay – e.g. a `Form` submit, where a "discard unsaved changes?"
+	* prompt would be nonsense – and dispose it as soon as that operation has
+	* finished. An operation that ends without closing the overlay therefore
+	* leaves the confirmation armed (#2775).
+	*/
+	grantCloseWithoutConfirmation() {
+		const grant = {};
+		this.closeWithoutConfirmationGrants.add(grant);
+		return () => {
+			this.closeWithoutConfirmationGrants.delete(grant);
+		};
+	}
+	confirmClose() {
+		this.closeIsConfirmed = true;
+		this.showConfirmationModal = false;
+	}
+	cancelConfirmation() {
+		this.showConfirmationModal = false;
+	}
+};
+//#endregion
+export { OverlayState };
+
+//# sourceMappingURL=OverlayState.mjs.map

package/dist/js/packages/components-base/src/overlay/OverlayState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverlayState.mjs","names":[],"sources":["../../../../../../../components-base/src/overlay/OverlayState.ts"],"sourcesContent":["import {\n  action,\n  computed,\n  makeObservable,\n  observable,\n  runInAction,\n} from \"mobx\";\n\nexport type OverlayOpenHandler = () => unknown;\nexport type OverlayCloseHandler = () => unknown;\nexport type OverlayOpenStateHandler = (isOpen: boolean) => unknown;\nexport type AnyOverlayOpenStateHandler =\n  OverlayOpenHandler | OverlayCloseHandler | OverlayOpenStateHandler;\n\nexport type DisposerFn = () => void;\n\nexport interface OverlayCloseOptions {\n  /** Close without asking, even when the overlay requires confirmation. */\n  bypassConfirmation?: boolean;\n}\n\nexport interface OverlayStateOptions {\n  isDefaultOpen?: boolean;\n  /**\n   * Whether closing the overlay must be confirmed while no source has an\n   * opinion (`setConfirmOnCloseSource`).\n   */\n  confirmOnClose?: boolean;\n}\n\n/**\n * Whether an overlay is open, and whether closing it has to be confirmed first.\n * Each binding adds its subscription and its lifecycle: React's\n * `OverlayController` subclasses it, Vue's adapter wraps it in refs.\n *\n * `TCloseOptions` lets a binding pass more on a close than the state reads —\n * React's `overlay`, resolved by `Action` before the close arrives here.\n */\nexport class OverlayState<\n  TCloseOptions extends OverlayCloseOptions = OverlayCloseOptions,\n> {\n  public isOpen = false;\n  public isContentSuspended = false;\n  private onOpenHandlers = new Set<OverlayOpenHandler>();\n  private onCloseHandlers = new Set<OverlayCloseHandler>();\n  private onOpenChangeHandlers = new Set<OverlayOpenStateHandler>();\n\n  public showConfirmationModal = false;\n  public closeIsConfirmed = false;\n  private readonly confirmOnCloseFromOptions: boolean;\n  /**\n   * Every mounted component that has an opinion on close confirmation\n   * contributes one entry here – e.g. a `Modal` with a `confirmOnClose` prop\n   * and a `Form` tracking its dirty state. Combining them instead of assigning\n   * a single flag keeps them from overwriting each other.\n   */\n  private confirmOnCloseSources = observable.map<object, boolean>();\n  /**\n   * Active grants that allow closing without a confirmation. Each entry is\n   * scoped to an ongoing operation that legitimately closes the overlay – e.g.\n   * a `Form` submit – and is dropped again when that operation has finished, so\n   * an operation that does _not_ close the overlay leaves the confirmation\n   * armed.\n   */\n  private closeWithoutConfirmationGrants = new Set<object>();\n  /**\n   * The open state a `setOpen` call is currently applying. Handlers run before\n   * `isOpen` is assigned, so a handler that calls `setOpen` again would not be\n   * caught by the equality check at the top and would recurse.\n   */\n  private openStateInFlight: boolean | undefined;\n\n  public constructor(options: OverlayStateOptions = {}) {\n    makeObservable(this, {\n      isOpen: observable,\n      isContentSuspended: observable,\n      showConfirmationModal: observable,\n      confirmOnCloseEnabled: computed,\n      open: action.bound,\n      close: action.bound,\n      toggle: action.bound,\n      setOpen: action.bound,\n      syncOpen: action.bound,\n      setIsContentSuspended: action.bound,\n      confirmClose: action.bound,\n      cancelConfirmation: action.bound,\n    });\n    const { isDefaultOpen = false, confirmOnClose = false } = options;\n    this.isOpen = isDefaultOpen;\n    this.confirmOnCloseFromOptions = confirmOnClose;\n  }\n\n  /** Whether closing this overlay currently requires a confirmation. */\n  public get confirmOnCloseEnabled(): boolean {\n    if (this.confirmOnCloseSources.size === 0) {\n      return this.confirmOnCloseFromOptions;\n    }\n    return Array.from(this.confirmOnCloseSources.values()).some(Boolean);\n  }\n\n  /**\n   * Sets the opinion of one source – any object the caller keeps – on close\n   * confirmation. Remove the source again when its owner goes away.\n   *\n   * @internal Bindings call it from their lifecycle.\n   */\n  public setConfirmOnCloseSource(source: object, confirmOnClose: boolean) {\n    runInAction(() => {\n      this.confirmOnCloseSources.set(source, confirmOnClose);\n      this.withdrawUnneededConfirmation();\n    });\n  }\n\n  /** @internal Bindings call it from their lifecycle. */\n  public removeConfirmOnCloseSource(source: object) {\n    runInAction(() => {\n      this.confirmOnCloseSources.delete(source);\n      this.withdrawUnneededConfirmation();\n    });\n  }\n\n  private withdrawUnneededConfirmation() {\n    if (!this.confirmOnCloseEnabled) {\n      this.showConfirmationModal = false;\n    }\n  }\n\n  private addOpenStateHandler<T extends AnyOverlayOpenStateHandler>(\n    handler: T,\n    handlersSet: Set<T>,\n  ): DisposerFn {\n    handlersSet.add(handler);\n    return () => {\n      handlersSet.delete(handler);\n    };\n  }\n\n  private executeHandlers(\n    isOpen: boolean,\n    handlers: Set<\n      OverlayOpenHandler | OverlayCloseHandler | OverlayOpenStateHandler\n    >,\n  ): boolean {\n    const handlerResult = Array.from(handlers).map((handler) =>\n      handler(isOpen),\n    );\n    return handlerResult.some((result) => result === false);\n  }\n\n  private executeOnClose(): boolean {\n    return this.executeHandlers(false, this.onCloseHandlers);\n  }\n\n  private executeOnOpen(): boolean {\n    return this.executeHandlers(true, this.onOpenHandlers);\n  }\n\n  private executeOnOpenChange(isOpen: boolean): boolean {\n    return this.executeHandlers(isOpen, this.onOpenChangeHandlers);\n  }\n\n  public addOnClose(handler: OverlayCloseHandler) {\n    return this.addOpenStateHandler(handler, this.onCloseHandlers);\n  }\n\n  public addOnOpen(handler: OverlayOpenHandler) {\n    return this.addOpenStateHandler(handler, this.onOpenHandlers);\n  }\n\n  public addOnOpenChange(handler: OverlayOpenStateHandler) {\n    return this.addOpenStateHandler(handler, this.onOpenChangeHandlers);\n  }\n\n  public open(): void {\n    this.setOpen(true);\n  }\n\n  public close(options?: TCloseOptions): void {\n    this.setOpen(false, options);\n  }\n\n  public toggle(): void {\n    this.setOpen(!this.isOpen);\n  }\n\n  public setOpen(toOpen: boolean, options?: TCloseOptions): void {\n    if (this.isOpen === toOpen || this.openStateInFlight === toOpen) {\n      return;\n    }\n\n    this.openStateInFlight = toOpen;\n    try {\n      this.applyOpenState(toOpen, options);\n    } finally {\n      this.openStateInFlight = undefined;\n    }\n  }\n\n  /**\n   * Sets the open state without running any handler. Use it to mirror a\n   * controlled `isOpen` prop, whose change comes from the consumer – notifying\n   * them of their own state would echo it back. Closing this way drops a\n   * pending close confirmation as well.\n   */\n  public syncOpen(toOpen: boolean): void {\n    this.assignOpenState(toOpen);\n  }\n\n  /** A closed overlay has no close left to confirm. */\n  private assignOpenState(toOpen: boolean): void {\n    this.isOpen = toOpen;\n    if (!toOpen) {\n      this.showConfirmationModal = false;\n      this.closeIsConfirmed = false;\n    }\n  }\n\n  private applyOpenState(toOpen: boolean, options?: TCloseOptions): void {\n    const { bypassConfirmation = false } = options ?? {};\n\n    if (toOpen === false) {\n      // The confirmation is a one-shot permission for exactly this close\n      // attempt – consume it here instead of only when a close succeeds, so it\n      // cannot survive an aborted close and disarm later attempts.\n      const closeIsConfirmed = this.closeIsConfirmed;\n      this.closeIsConfirmed = false;\n\n      if (\n        this.confirmOnCloseEnabled &&\n        !closeIsConfirmed &&\n        this.closeWithoutConfirmationGrants.size === 0 &&\n        !bypassConfirmation\n      ) {\n        this.showConfirmationModal = true;\n        return;\n      }\n    }\n\n    let aborted: boolean;\n    if (toOpen) {\n      aborted = this.executeOnOpen();\n    } else {\n      aborted = this.executeOnClose();\n    }\n    if (!aborted) {\n      aborted = this.executeOnOpenChange(toOpen);\n    }\n\n    if (!aborted) {\n      this.assignOpenState(toOpen);\n    }\n  }\n\n  public setIsContentSuspended(to: boolean): void {\n    this.isContentSuspended = to;\n  }\n\n  /**\n   * Allows closing this overlay without a confirmation until the returned\n   * disposer is called. Use it around an operation that may legitimately close\n   * the overlay – e.g. a `Form` submit, where a \"discard unsaved changes?\"\n   * prompt would be nonsense – and dispose it as soon as that operation has\n   * finished. An operation that ends without closing the overlay therefore\n   * leaves the confirmation armed (#2775).\n   */\n  public grantCloseWithoutConfirmation(): DisposerFn {\n    const grant = {};\n    this.closeWithoutConfirmationGrants.add(grant);\n    return () => {\n      this.closeWithoutConfirmationGrants.delete(grant);\n    };\n  }\n\n  public confirmClose(): void {\n    this.closeIsConfirmed = true;\n    this.showConfirmationModal = false;\n  }\n\n  public cancelConfirmation(): void {\n    this.showConfirmationModal = false;\n  }\n}\n"],"mappings":"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"}

package/dist/types/_bundled/flow-components-base/index.d.ts

@@ -2,7 +2,9 @@ export { ActionState, actionStateDurations, type ActionStateValue, } from "./act
 export { toArray, type ItemType } from "./lib/array";
 export { ListFilter } from "./list/filter/ListFilter";
 export { ListDateRangeFilter } from "./list/filter/ListDateRangeFilter";
-export { applyDateRangeColumnDef, dateRangeFilterFn, isListDateRange, type ListDateParts, type ListDateRange, } from "./list/filter/dateRange";
+export { applyDateRangeColumnDef, dateRangeFilterFn, isListDateRange, listDateToDateTime, resolveListDateRange, type ListDateParts, type ListDateRange, } from "./list/filter/dateRange";
+export { formatListDateRange, type ListDateRangeTextFormat, } from "./list/filter/formatDateRange";
+export { getListDateTimeRangeUpdate, isListDateTimeRangeEndBeforeStart, isListDateValid, listDateTimeRangeFieldsFromValue, toListCalendarDate, toListTime, type ListDateTimeRange, type ListDateTimeRangeFields, type ListDateTimeRangeLimits, } from "./list/filter/dateTimeRangeFields";
 export { ListFilterValue } from "./list/filter/ListFilterValue";
 export type { FilterMatcher, FilterMode, FilterUpdatedCallback, ListFilterShape, } from "./list/filter/types";
 export { getListColumn, type ListModelContext } from "./list/ListModelContext";
@@ -21,3 +23,4 @@ export type { ListSortingShape, SortingDefaultMode, SortingFn, } from "./list/so
 export { ListViewMode } from "./list/viewMode/ListViewMode";
 export type { ListViewModeOptions, ListViewModeValue, } from "./list/viewMode/types";
 export { customPropertyPrefix, type CustomPropertyName, type PropertyName, type PropertyValue, type PropertyValueRenderMethod, } from "./list/types";
+export { OverlayState, type AnyOverlayOpenStateHandler, type DisposerFn, type OverlayCloseHandler, type OverlayCloseOptions, type OverlayOpenHandler, type OverlayOpenStateHandler, type OverlayStateOptions, } from "./overlay/OverlayState";

package/dist/types/_bundled/flow-components-base/list/filter/ListFilter.d.ts

@@ -83,6 +83,8 @@ export declare class ListFilter<T = never, TProp extends PropertyName<T> = never
     isActive(): boolean;
     deactivateValue(value: ListFilterValue<TRendered>): void;
     private callOnChangedHandlers;
+    /** Tells the listeners — the list resetting its batches among them. */
+    protected notifyFilterUpdated(values: unknown[]): void;
     hasChanges(): boolean;
     isStoringAvailable(): boolean;
     resetValues(): void;

package/dist/types/_bundled/flow-components-base/list/filter/dateRange.d.ts

@@ -1,9 +1,16 @@
 import type { ColumnDef, Row } from "@tanstack/table-core";
-/** A calendar date, in whichever shape it reached the filter. */
+import { DateTime } from "luxon";
+/**
+ * A calendar date, in whichever shape it reached the filter — with a time of
+ * day when the filter narrows down by minute.
+ */
 export interface ListDateParts {
     readonly year: number;
     readonly month: number;
     readonly day: number;
+    readonly hour?: number;
+    readonly minute?: number;
+    readonly second?: number;
 }
 export interface ListDateRange {
     readonly start?: ListDateParts;
@@ -11,6 +18,22 @@ export interface ListDateRange {
 }
 /** A range needs both ends present to be one, even if either may be unset. */
 export declare const isListDateRange: (value: unknown) => value is ListDateRange;
+/**
+ * The date as a local point in time. A `ZonedDateTime` is the instant it names;
+ * anything else is read field by field, since after crossing the remote
+ * boundary a `CalendarDate` is a plain object.
+ */
+export declare const listDateToDateTime: (date: ListDateParts) => DateTime;
+/**
+ * Resolves a range to the instants it spans, for filtering on the server side.
+ * Both bounds are inclusive: a date covers its whole day and a date with time
+ * its whole minute, in the user's local time zone. A missing side has no
+ * bound.
+ */
+export declare const resolveListDateRange: (range: ListDateRange) => {
+    start?: Date;
+    end?: Date;
+};
 /**
  * Whether a row's date falls inside the selected range.
  *

package/dist/types/_bundled/flow-components-base/list/filter/dateTimeRangeFields.d.ts

@@ -0,0 +1,34 @@
+import { CalendarDate, type CalendarDateTime, Time } from "@internationalized/date";
+import { type ListDateParts, type ListDateRange } from "./dateRange";
+export interface ListDateTimeRangeFields {
+    readonly startDate: CalendarDate | null;
+    readonly startTime: Time | null;
+    readonly endDate: CalendarDate | null;
+    readonly endTime: Time | null;
+}
+export interface ListDateTimeRangeLimits {
+    readonly minValue?: ListDateParts | null;
+    readonly maxValue?: ListDateParts | null;
+    readonly isDateUnavailable?: (date: CalendarDate) => boolean;
+}
+type Bound = CalendarDate | CalendarDateTime;
+export interface ListDateTimeRange {
+    readonly start?: Bound;
+    readonly end?: Bound;
+}
+export declare const toListCalendarDate: (value?: ListDateParts | null) => CalendarDate | null;
+export declare const toListTime: (value?: {
+    readonly hour?: number;
+    readonly minute?: number;
+} | null) => Time | null;
+export declare const listDateTimeRangeFieldsFromValue: (value: ListDateRange | null) => ListDateTimeRangeFields;
+/** Not while a year is still being typed: "2" would read as an early end. */
+export declare const isListDateTimeRangeEndBeforeStart: (fields: ListDateTimeRangeFields) => boolean;
+export declare const isListDateValid: (date: CalendarDate | null, limits?: ListDateTimeRangeLimits) => boolean;
+/**
+ * The range the fields stand for, or `undefined` while it must not be applied:
+ * an invalid input keeps the last valid range, and an unchanged one needs no
+ * update. `null` clears the filter.
+ */
+export declare const getListDateTimeRangeUpdate: (fields: ListDateTimeRangeFields, applied: ListDateRange | null, limits?: ListDateTimeRangeLimits) => ListDateTimeRange | null | undefined;
+export {};

package/dist/types/_bundled/flow-components-base/list/filter/formatDateRange.d.ts

@@ -0,0 +1,7 @@
+import { type ListDateRange } from "./dateRange";
+/** Formats the text of an open range ("from {date}", "until {date}"). */
+export type ListDateRangeTextFormat = (key: "dateRange.from" | "dateRange.until", values: {
+    date: string;
+}) => string;
+/** The active filter chip's text: an end with time shows its time. */
+export declare const formatListDateRange: (value: ListDateRange, locale: string, format: ListDateRangeTextFormat) => string;

package/dist/types/_bundled/flow-components-base/overlay/OverlayState.d.ts

@@ -0,0 +1,94 @@
+export type OverlayOpenHandler = () => unknown;
+export type OverlayCloseHandler = () => unknown;
+export type OverlayOpenStateHandler = (isOpen: boolean) => unknown;
+export type AnyOverlayOpenStateHandler = OverlayOpenHandler | OverlayCloseHandler | OverlayOpenStateHandler;
+export type DisposerFn = () => void;
+export interface OverlayCloseOptions {
+    /** Close without asking, even when the overlay requires confirmation. */
+    bypassConfirmation?: boolean;
+}
+export interface OverlayStateOptions {
+    isDefaultOpen?: boolean;
+    /**
+     * Whether closing the overlay must be confirmed while no source has an
+     * opinion (`setConfirmOnCloseSource`).
+     */
+    confirmOnClose?: boolean;
+}
+/**
+ * Whether an overlay is open, and whether closing it has to be confirmed first.
+ * Each binding adds its subscription and its lifecycle: React's
+ * `OverlayController` subclasses it, Vue's adapter wraps it in refs.
+ *
+ * `TCloseOptions` lets a binding pass more on a close than the state reads —
+ * React's `overlay`, resolved by `Action` before the close arrives here.
+ */
+export declare class OverlayState<TCloseOptions extends OverlayCloseOptions = OverlayCloseOptions> {
+    isOpen: boolean;
+    isContentSuspended: boolean;
+    private onOpenHandlers;
+    private onCloseHandlers;
+    private onOpenChangeHandlers;
+    showConfirmationModal: boolean;
+    closeIsConfirmed: boolean;
+    private readonly confirmOnCloseFromOptions;
+    /**
+     * Every mounted component that has an opinion on close confirmation
+     * contributes one entry here – e.g. a `Modal` with a `confirmOnClose` prop
+     * and a `Form` tracking its dirty state. Combining them instead of assigning
+     * a single flag keeps them from overwriting each other.
+     */
+    private confirmOnCloseSources;
+    /**
+     * Active grants that allow closing without a confirmation. Each entry is
+     * scoped to an ongoing operation that legitimately closes the overlay – e.g.
+     * a `Form` submit – and is dropped again when that operation has finished, so
+     * an operation that does _not_ close the overlay leaves the confirmation
+     * armed.
+     */
+    private closeWithoutConfirmationGrants;
+    /**
+     * The open state a `setOpen` call is currently applying. Handlers run before
+     * `isOpen` is assigned, so a handler that calls `setOpen` again would not be
+     * caught by the equality check at the top and would recurse.
+     */
+    private openStateInFlight;
+    constructor(options?: OverlayStateOptions);
+    /** Whether closing this overlay currently requires a confirmation. */
+    get confirmOnCloseEnabled(): boolean;
+    private withdrawUnneededConfirmation;
+    private addOpenStateHandler;
+    private executeHandlers;
+    private executeOnClose;
+    private executeOnOpen;
+    private executeOnOpenChange;
+    addOnClose(handler: OverlayCloseHandler): DisposerFn;
+    addOnOpen(handler: OverlayOpenHandler): DisposerFn;
+    addOnOpenChange(handler: OverlayOpenStateHandler): DisposerFn;
+    open(): void;
+    close(options?: TCloseOptions): void;
+    toggle(): void;
+    setOpen(toOpen: boolean, options?: TCloseOptions): void;
+    /**
+     * Sets the open state without running any handler. Use it to mirror a
+     * controlled `isOpen` prop, whose change comes from the consumer – notifying
+     * them of their own state would echo it back. Closing this way drops a
+     * pending close confirmation as well.
+     */
+    syncOpen(toOpen: boolean): void;
+    /** A closed overlay has no close left to confirm. */
+    private assignOpenState;
+    private applyOpenState;
+    setIsContentSuspended(to: boolean): void;
+    /**
+     * Allows closing this overlay without a confirmation until the returned
+     * disposer is called. Use it around an operation that may legitimately close
+     * the overlay – e.g. a `Form` submit, where a "discard unsaved changes?"
+     * prompt would be nonsense – and dispose it as soon as that operation has
+     * finished. An operation that ends without closing the overlay therefore
+     * leaves the confirmation armed (#2775).
+     */
+    grantCloseWithoutConfirmation(): DisposerFn;
+    confirmClose(): void;
+    cancelConfirmation(): void;
+}

package/dist/types/components/AlertBadge/AlertBadge.d.ts

@@ -1,8 +1,8 @@
 import { PropsWithChildren } from 'react';
 import { PropsWithStatus, PropsWithClassName } from '../../lib/types/props';
 import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
-export interface AlertBadgeProps extends PropsWithChildren, PropsWithStatus, FlowComponentProps, PropsWithClassName {
+export interface AlertBadgeProps extends PropsWithChildren, PropsWithStatus, FlowComponentProps<HTMLSpanElement>, PropsWithClassName {
 }
 /** @flr-generate all */
-export declare const AlertBadge: import('react').FunctionComponent<AlertBadgeProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const AlertBadge: import('react').FunctionComponent<AlertBadgeProps & import('react').RefAttributes<HTMLSpanElement>>;
 export default AlertBadge;

package/dist/types/components/Badge/Badge.d.ts

@@ -4,7 +4,7 @@ import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
 import { PressEvent } from '@react-types/shared';
 export declare const badgeColors: readonly ["neutral", "blue", "navy", "violet", "teal", "lilac", "green", "orange", "red", "dark", "light", "dark-static", "light-static"];
 export type BadgeColors = (typeof badgeColors)[number];
-export interface BadgeProps extends PropsWithChildren, FlowComponentProps, PropsWithClassName {
+export interface BadgeProps extends PropsWithChildren, FlowComponentProps<HTMLSpanElement>, PropsWithClassName {
     /** Handler that is called when the badge is pressed. */
     onPress?: (e: PressEvent) => void;
     /** Handler that is called when the badges close icon is pressed. */
@@ -15,5 +15,5 @@ export interface BadgeProps extends PropsWithChildren, FlowComponentProps, Props
     isDisabled?: boolean;
 }
 /** @flr-generate all */
-export declare const Badge: import('react').FunctionComponent<BadgeProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const Badge: import('react').FunctionComponent<BadgeProps & import('react').RefAttributes<HTMLSpanElement>>;
 export default Badge;

package/dist/types/components/CartesianChart/hooks/useTickLabelWidth.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/CodeBlock/CodeBlock.d.ts

@@ -8,7 +8,7 @@ export interface CodeBlockProps extends PropsWithClassName, PropsWithChildren, P
      * Controls truncation of long code blocks. `false` disables it, `true`
      * truncates after 8 lines, and a number sets the maximum line count.
      *
-     * @default: false
+     * @default false
      */
     truncateLines?: boolean | number;
 }

package/dist/types/components/DonutChart/DonutChart.d.ts

@@ -15,10 +15,7 @@ export interface DonutChartProps extends Omit<Aria.ProgressBarProps, "children"
     size?: "m" | "l";
     /** Divides the fill of the donut chart into segments */
     segments?: DonutChartSegment[];
-    /**
-     * Whether the legend component is shown when segments are used. @default:
-     * true
-     */
+    /** Whether the legend component is shown when segments are used. @default true */
     showLegend?: boolean;
     /** The position of the legend. @default "right" */
     legendPosition?: "top" | "left" | "bottom" | "right";

package/dist/types/components/Link/Link.d.ts

@@ -2,7 +2,7 @@ import { ComponentProps, ComponentType, CSSProperties, PropsWithChildren } from
 import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
 import { AlphaColor, PropsWithClassName } from '../../lib/types/props';
 import * as Aria from "react-aria-components";
-export interface LinkProps extends PropsWithChildren<Omit<Aria.LinkProps, "children" | "slot" | "className">>, FlowComponentProps<HTMLAnchorElement>, PropsWithClassName {
+export interface LinkProps extends PropsWithChildren<Omit<Aria.LinkProps, "children" | "slot" | "className" | "aria-current">>, FlowComponentProps<HTMLAnchorElement>, PropsWithClassName {
     /** Whether the link should be styled for being displayed inside a text. */
     inline?: boolean;
     /** An alternative link component. */

package/dist/types/components/List/components/Header/components/DateTimeRangeFields/DateTimeRangeFields.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { AnyDateRangeFilter } from '../../../../model/filter/types';
+interface Props {
+    filter: AnyDateRangeFilter;
+    className?: string;
+}
+export declare const DateTimeRangeFields: FC<Props>;
+export default DateTimeRangeFields;