@astryxdesign/core 0.7.8 → 0.7.9-canary.0200dfe

package/dist/utils/calendarSystem.js

@@ -0,0 +1,569 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file calendarSystem.ts
+ * @input A calendar identifier and Gregorian PlainDates
+ * @output Calendar months located by their Gregorian days, their year and
+ *   month numbers, month and year steps, dates from calendar fields,
+ *   availability of each calendar, and calendar labels and digits
+ * @position Shared date utility; read by the i18n calendar resolution, by
+ *   the date components, and by Calendar's public hooks. Values stay Gregorian PlainDates. Temporal owns the arithmetic of
+ *   every calendar whose months are not Gregorian.
+ */
+
+import { DATE_FORMAT_MONTH_ONLY, dateTimeFormatAtCall, dateTimeFormatFor, plainDateAddDays, plainDateAddMonths, plainDateFormatDayNumber, plainDateFormatStandaloneMonthYear, plainDateFormatToParts, plainDateFromDate, plainDateFromInstant, plainDateIsInRange, getDaysInMonth } from "./plainDate.js";
+
+/**
+ * A calendar system that date components can show: the calendars that
+ * ECMA-402 and Temporal require. Values stay Gregorian ISO dates in every
+ * calendar.
+ */
+
+// A record, so the compiler checks that it lists every calendar exactly once.
+const KNOWN_CALENDARS = {
+  gregory: true,
+  iso8601: true,
+  buddhist: true,
+  roc: true,
+  japanese: true,
+  persian: true,
+  indian: true,
+  hebrew: true,
+  chinese: true,
+  dangi: true,
+  coptic: true,
+  ethiopic: true,
+  ethioaa: true,
+  'islamic-civil': true,
+  'islamic-tbla': true,
+  'islamic-umalqura': true
+};
+export const CALENDAR_SYSTEMS = Object.keys(KNOWN_CALENDARS);
+const GREGORIAN_ALIGNED = new Set(['gregory', 'iso8601', 'buddhist', 'roc', 'japanese']);
+
+/**
+ * Whether `<input type="date">` can show the calendar. The native control is
+ * Gregorian by specification, so only `gregory` and `iso8601` qualify.
+ */
+export function isGregorianCalendar(calendar) {
+  return calendar === 'gregory' || calendar === 'iso8601';
+}
+
+/** Whether the calendar's months and days are the Gregorian ones. */
+export function isGregorianAligned(calendar) {
+  return GREGORIAN_ALIGNED.has(calendar);
+}
+export function isCalendarSystem(value) {
+  return Object.hasOwn(KNOWN_CALENDARS, value);
+}
+
+// The published types must not need the `esnext.temporal` library.
+// This module declares only the Temporal members it reads.
+
+function getTemporal() {
+  const temporal = globalThis.Temporal;
+  return typeof temporal?.PlainDate === 'function' ? temporal : undefined;
+}
+
+// The key is the Temporal object, so a polyfill that loads later gets its
+// own probe.
+const supportedCalendars = new WeakMap();
+
+/**
+ * Whether this runtime can show the calendar. Gregorian-aligned calendars
+ * always can. The others need a `Temporal` that knows the calendar: a
+ * polyfill build without non-ISO calendars throws for them.
+ */
+export function isCalendarSystemAvailable(calendar) {
+  if (isGregorianAligned(calendar)) {
+    return true;
+  }
+  const temporal = getTemporal();
+  if (temporal == null) {
+    return false;
+  }
+  let known = supportedCalendars.get(temporal);
+  if (known == null) {
+    known = new Map();
+    supportedCalendars.set(temporal, known);
+  }
+  let isSupported = known.get(calendar);
+  if (isSupported == null) {
+    try {
+      new temporal.PlainDate(2000, 1, 1, calendar);
+      isSupported = true;
+    } catch {
+      isSupported = false;
+    }
+    known.set(calendar, isSupported);
+  }
+  return isSupported;
+}
+function inCalendar(calendar, pd) {
+  const temporal = getTemporal();
+  if (temporal == null) {
+    throw new Error(`The "${calendar}" calendar needs Temporal.`);
+  }
+  return new temporal.PlainDate(pd.year, pd.month, pd.day, calendar);
+}
+function toGregorian(date) {
+  const iso = date.withCalendar('iso8601');
+  return {
+    year: iso.year,
+    month: iso.month,
+    day: iso.day
+  };
+}
+
+/** A month of a calendar, located by its first and last Gregorian days. */
+
+function makeMonth(start, length) {
+  return {
+    start,
+    end: plainDateAddDays(start, length - 1),
+    length
+  };
+}
+function gregorianMonth(year, month) {
+  return makeMonth({
+    year,
+    month,
+    day: 1
+  }, getDaysInMonth(year, month));
+}
+function temporalMonth(firstDay) {
+  return makeMonth(toGregorian(firstDay), firstDay.daysInMonth);
+}
+
+/** The day of the calendar month that a Gregorian date falls on. */
+export function calendarDayOfMonth(calendar, pd) {
+  return isGregorianAligned(calendar) ? pd.day : inCalendar(calendar, pd).day;
+}
+
+/** The calendar month that contains a Gregorian date. */
+export function calendarMonthOf(calendar, pd) {
+  if (isGregorianAligned(calendar)) {
+    return gregorianMonth(pd.year, pd.month);
+  }
+  return temporalMonth(inCalendar(calendar, pd).with({
+    day: 1
+  }));
+}
+
+/**
+ * A calendar month by its year and its position in that year, as
+ * `Temporal.PlainDate` numbers them: month 13 exists in a Hebrew leap year.
+ */
+
+// Temporal counts the years of these Gregorian-aligned calendars from another
+// epoch: 2026 is 2569 in `buddhist` and 115 in `roc`.
+const GREGORIAN_YEAR_OFFSETS = {
+  buddhist: 543,
+  roc: -1911
+};
+
+/** The year and month numbers of a calendar month. */
+export function calendarYearMonthOf(calendar, month) {
+  if (isGregorianAligned(calendar)) {
+    return {
+      year: month.start.year + (GREGORIAN_YEAR_OFFSETS[calendar] ?? 0),
+      month: month.start.month
+    };
+  }
+  const {
+    year,
+    month: monthOfYear
+  } = inCalendar(calendar, month.start);
+  return {
+    year,
+    month: monthOfYear
+  };
+}
+
+/**
+ * The calendar month with these year and month numbers. A month past the end
+ * of its year becomes the last month of that year, as Temporal constrains it.
+ */
+export function calendarMonthFromYearMonth(calendar, {
+  year,
+  month
+}) {
+  if (isGregorianAligned(calendar)) {
+    return gregorianMonth(year - (GREGORIAN_YEAR_OFFSETS[calendar] ?? 0), month);
+  }
+  // `with` replaces the year and month of any date in the calendar.
+  return temporalMonth(inCalendar(calendar, {
+    year: 2000,
+    month: 1,
+    day: 1
+  }).with({
+    year,
+    month,
+    day: 1
+  }));
+}
+
+/** The calendar month `n` months after `month`, or before it when negative. */
+export function calendarAddMonths(calendar, month, n) {
+  if (n === 0) {
+    return month;
+  }
+  if (isGregorianAligned(calendar)) {
+    const {
+      year,
+      month: monthOfYear
+    } = plainDateAddMonths(month.start, n);
+    return gregorianMonth(year, monthOfYear);
+  }
+  return temporalMonth(inCalendar(calendar, month.start).add({
+    months: n
+  }));
+}
+
+/**
+ * Moves a date by `n` calendar months. It keeps the day of the month and
+ * clamps it to the length of the target month.
+ */
+export function calendarShiftMonths(calendar, pd, n) {
+  if (isGregorianAligned(calendar)) {
+    return plainDateAddMonths(pd, n);
+  }
+  return toGregorian(inCalendar(calendar, pd).add({
+    months: n
+  }));
+}
+
+/**
+ * Moves a date by `n` calendar years, to the same month of the target year.
+ * It clamps the day of the month. A leap month that the target year does not
+ * have becomes its common counterpart, because Temporal keeps the month code
+ * and constrains it.
+ */
+export function calendarShiftYears(calendar, pd, n) {
+  if (isGregorianAligned(calendar)) {
+    return plainDateAddMonths(pd, n * 12);
+  }
+  return toGregorian(inCalendar(calendar, pd).add({
+    years: n
+  }));
+}
+
+/** Whether a Gregorian date falls inside a calendar month. */
+export function isInCalendarMonth(pd, month) {
+  return plainDateIsInRange(pd, [month.start, month.end]);
+}
+
+/**
+ * The day that names a calendar month: its middle day. In the Japanese
+ * calendar an era can start inside a month, and most days of that month then
+ * belong to the era of its middle day.
+ */
+export function calendarMonthLabelDay(month) {
+  return plainDateAddDays(month.start, Math.floor(month.length / 2));
+}
+
+/**
+ * The stand-alone month and year label of a calendar month, such as
+ * "Aban 1405 AP", named by `calendarMonthLabelDay`. When `day` is given and the
+ * month spans an era change, it formats that day instead, clamped to the
+ * month, so January 1989 reads 昭和64年1月 on the 3rd and 平成元年1月 on the
+ * 22nd.
+ */
+export function formatCalendarMonthLabel(calendar, month, locale, day) {
+  const labelDay = day != null && calendarMonthSpansEras(calendar, month, locale) ? plainDateAddDays(month.start, Math.min(Math.max(day, 1), month.length) - 1) : calendarMonthLabelDay(month);
+  return plainDateFormatStandaloneMonthYear(labelDay, locale, labelCalendar(calendar));
+}
+
+/** Whether the first and last days of a calendar month fall in different eras. */
+function calendarMonthSpansEras(calendar, month, locale) {
+  return !isGregorianCalendar(calendar) && eraYearAt(calendar, month.start, locale).era !== eraYearAt(calendar, month.end, locale).era;
+}
+
+// Intl has no month names for `iso8601`. Labels use `gregory`, which has the
+// same months and days.
+function labelCalendar(calendar) {
+  return calendar === 'iso8601' ? 'gregory' : calendar;
+}
+function formatToParts(calendar, pd, options, locale) {
+  return plainDateFormatToParts(pd, {
+    ...options,
+    calendar
+  }, locale);
+}
+const MONTH_PART_TYPES = new Set(['era', 'year', 'relatedYear', 'yearName', 'month']);
+function monthPartsKey(parts) {
+  return parts.filter(part => MONTH_PART_TYPES.has(part.type)).map(part => part.value).join('|');
+}
+
+/**
+ * Formats a Gregorian date in the calendar, such as "Friday, Aban 8, 1405 AP".
+ * The label always names the month and day that the grid shows. Intl and the
+ * runtime's Temporal can disagree on where a month of the Chinese or Dangi
+ * calendar starts; the label then takes its month and year from the middle of
+ * the Temporal month, and its day from Temporal. With `relatedYear`, a
+ * Chinese or Dangi year that the locale names only by its place in the 60-year
+ * cycle becomes the related Gregorian year.
+ */
+export function formatCalendarDate(calendar, pd, options, locale, labelOptions) {
+  return joinParts(formatCalendarDateToParts(calendar, pd, options, locale, labelOptions));
+}
+
+/** The parts of `formatCalendarDate`'s label. */
+export function formatCalendarDateToParts(calendar, pd, options, locale, {
+  relatedYear = false
+} = {}) {
+  const parts = formatToParts(labelCalendar(calendar), pd, options, locale);
+  const fixed = withTemporalDay(calendar, pd, parts, options, locale);
+  return relatedYear ? withRelatedYear(calendar, pd, fixed, options, locale) : fixed;
+}
+function withRelatedYear(calendar, pd, parts, options, locale) {
+  if (calendar !== 'chinese' && calendar !== 'dangi' || !isCalendarSystemAvailable(calendar) || parts.some(part => part.type === 'relatedYear')) {
+    return parts;
+  }
+  const {
+    numberingSystem
+  } = dateTimeFormatFor(locale, {
+    ...options,
+    calendar,
+    timeZone: 'UTC'
+  }).resolvedOptions();
+  const {
+    year
+  } = inCalendar(calendar, pd);
+  const value = plainDateFormatDayNumber(year, locale, numberingSystem);
+  return parts.map(part => /^year(Name)?$/.test(part.type) ? {
+    ...part,
+    value
+  } : part);
+}
+
+// Returns `parts` itself where Intl already names Temporal's month and day.
+function withTemporalDay(calendar, pd, parts, options, locale) {
+  if (isGregorianAligned(calendar) || !isCalendarSystemAvailable(calendar)) {
+    return parts;
+  }
+  const date = inCalendar(calendar, pd);
+  const middle = plainDateAddDays(pd, Math.floor(date.daysInMonth / 2) - (date.day - 1));
+  const middleParts = formatToParts(calendar, middle, options, locale);
+  const intlDay = formatToParts(calendar, pd, {
+    day: 'numeric'
+  }, 'en-u-nu-latn').find(part => part.type === 'day')?.value;
+  if (Number(intlDay) === date.day && monthPartsKey(parts) === monthPartsKey(middleParts)) {
+    return parts;
+  }
+  const {
+    numberingSystem
+  } = dateTimeFormatFor(locale, {
+    ...options,
+    calendar,
+    timeZone: 'UTC'
+  }).resolvedOptions();
+  const middleValues = new Map(middleParts.map(part => [part.type, part.value]));
+  return parts.map(part => part.type === 'day' ? {
+    ...part,
+    value: plainDateFormatDayNumber(date.day, locale, numberingSystem)
+  } : MONTH_PART_TYPES.has(part.type) ? {
+    ...part,
+    value: middleValues.get(part.type) ?? part.value
+  } : part);
+}
+
+/**
+ * Formats an instant as `formatCalendarDate` formats the day it falls on in
+ * `timeZone`, the host's zone when omitted. Intl writes any time of day that
+ * `options` asks for.
+ */
+export function formatCalendarInstant(calendar, instant, options, locale, timeZone) {
+  return instantLabel(calendar, instant, options, locale, timeZone).text;
+}
+
+/**
+ * Formats the range between two instants. Intl writes the fields that both
+ * ends share once. Where Intl names another month or day than Temporal at
+ * either end, the range writes each end in full.
+ */
+export function formatCalendarInstantRange(calendar, start, end, options, locale, timeZone) {
+  const ends = [start, end].map(instant => instantLabel(calendar, instant, options, locale, timeZone));
+  const {
+    format
+  } = ends[0];
+  if (ends.every(({
+    isIntl
+  }) => isIntl)) {
+    return format.formatRange(start, end);
+  }
+  // Intl writes a range of different years as two full dates around its
+  // separator, which gives the separator to put between the two full ends.
+  const far = new Date(start.getTime() + 400 * 86_400_000);
+  const both = format.formatRange(start, far);
+  const [from, to] = [format.format(start), format.format(far)];
+  const separator = both.startsWith(from) && both.endsWith(to) ? both.slice(from.length, both.length - to.length) : ' – ';
+  const [first, last] = ends.map(({
+    text
+  }) => text);
+  return first === last ? first : `${first}${separator}${last}`;
+}
+function instantLabel(calendar, instant, options, locale, timeZone) {
+  const format = dateTimeFormatAtCall(locale, {
+    ...options,
+    ...(timeZone === undefined ? {} : {
+      timeZone
+    }),
+    calendar: labelCalendar(calendar)
+  });
+  const parts = format.formatToParts(instant);
+  const day = timeZone === undefined ? plainDateFromDate(instant) : plainDateFromInstant(instant.getTime(), timeZone);
+  const fixed = withTemporalDay(calendar, day, parts, options, locale);
+  const isIntl = fixed === parts;
+  return {
+    format,
+    isIntl,
+    text: isIntl ? format.format(instant) : joinParts(fixed)
+  };
+}
+function joinParts(parts) {
+  return parts.map(part => part.value).join('');
+}
+
+/**
+ * The fields of a date written in a calendar. A field gives either `year` or
+ * `era` with `eraYear`, and either `monthCode` (such as `M05L` for a leap
+ * month) or `month`, the month's position in its year.
+ */
+
+/**
+ * The Gregorian date for fields written in a calendar that needs Temporal,
+ * or null when the calendar does not have that date. Temporal validates the
+ * fields and never adjusts them: 30 Esfand in a common Persian year is null.
+ */
+export function calendarDateFromFields(calendar, fields) {
+  const temporal = getTemporal();
+  if (temporal == null) {
+    throw new Error(`The "${calendar}" calendar needs Temporal.`);
+  }
+  try {
+    return toGregorian(temporal.PlainDate.from({
+      ...fields,
+      calendar
+    }, {
+      overflow: 'reject'
+    }));
+  } catch (error) {
+    if (error instanceof RangeError || error instanceof TypeError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+/** The number of months in the calendar year that contains a date. */
+export function calendarMonthsInYear(calendar, pd) {
+  return isGregorianAligned(calendar) ? 12 : inCalendar(calendar, pd).monthsInYear;
+}
+
+/**
+ * The number of calendar months from the month `from` to the month `to`:
+ * positive when `to` is later.
+ */
+export function calendarMonthsBetween(calendar, from, to) {
+  if (isGregorianAligned(calendar)) {
+    return (to.start.year - from.start.year) * 12 + (to.start.month - from.start.month);
+  }
+  return inCalendar(calendar, from.start).until(inCalendar(calendar, to.start), {
+    largestUnit: 'months'
+  }).months;
+}
+
+/**
+ * The calendar month at a position in a year of the calendar. A
+ * Gregorian-aligned calendar counts Gregorian years here; the others count
+ * years as {@link calendarYearMonthOf} does.
+ */
+export function calendarMonthOfYear(calendar, year, month) {
+  return isGregorianAligned(calendar) ? gregorianMonth(year, month) : calendarMonthFromYearMonth(calendar, {
+    year,
+    month
+  });
+}
+
+/** The number of months in a year of the calendar. */
+export function calendarMonthsInCalendarYear(calendar, year) {
+  return isGregorianAligned(calendar) ? 12 : calendarMonthsInYear(calendar, calendarMonthOfYear(calendar, year, 1).start);
+}
+
+/**
+ * The name of a calendar month, such as "Adar I". It formats the middle day of
+ * the month, for the reason {@link formatCalendarMonthLabel} gives.
+ */
+export function formatCalendarMonthName(calendar, month, locale) {
+  return formatCalendarDate(calendar, plainDateAddDays(month.start, Math.floor(month.length / 2)), DATE_FORMAT_MONTH_ONLY, locale);
+}
+const YEAR_PART_TYPES = new Set(['era', 'year', 'relatedYear']);
+
+/** The era and year parts of a date, as the locale writes them in a long date. */
+function eraYearAt(calendar, pd, locale) {
+  const parts = formatToParts(calendar, pd, {
+    era: 'short',
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric'
+  }, locale);
+  const era = parts.find(part => part.type === 'era')?.value;
+  const first = parts.findIndex(part => YEAR_PART_TYPES.has(part.type));
+  if (first === -1) {
+    return {
+      era,
+      label: null
+    };
+  }
+  let last = first;
+  parts.forEach((part, index) => {
+    if (YEAR_PART_TYPES.has(part.type)) {
+      last = index;
+    }
+  });
+  const label = parts.slice(first, last + 1).filter(part => YEAR_PART_TYPES.has(part.type) || part.type === 'literal').map(part => part.value).join('').replace(/\s+/g, ' ').trim();
+  return {
+    era,
+    label
+  };
+}
+
+/**
+ * Whether the first and last days of a year of the calendar fall in different
+ * eras, as the Japanese year 2019 does (Heisei, then Reiwa). Only an era change
+ * counts: other parts, such as a Chinese related year, can disagree at the
+ * edges of a year when Intl and Temporal place a month start one day apart.
+ */
+export function calendarYearSpansEras(calendar, year, locale) {
+  if (isGregorianCalendar(calendar)) {
+    return false;
+  }
+  const months = calendarMonthsInCalendarYear(calendar, year);
+  const start = eraYearAt(calendar, calendarMonthOfYear(calendar, year, 1).start, locale);
+  const end = eraYearAt(calendar, calendarMonthOfYear(calendar, year, months).end, locale);
+  return start.era !== end.era && start.label != null && end.label != null;
+}
+
+/**
+ * The label of a year of the calendar, with its era where the locale writes
+ * one in a date, such as "令和8" in `ja-JP` or "1405 AP" in English. It uses the
+ * era and year parts of a long date, in the locale's order and digits, with the
+ * text between them. A year that spans an era change takes its era from `at`,
+ * a month position and a day clamped to that month, so 2019 reads "平成31" in
+ * January and "令和元" in May. Without `at`, and for every other year, the label
+ * comes from the middle of the year. Gregorian years are plain numbers.
+ */
+export function formatCalendarYearLabel(calendar, year, locale, at) {
+  if (isGregorianCalendar(calendar)) {
+    return String(year);
+  }
+  const months = calendarMonthsInCalendarYear(calendar, year);
+  if (at != null && calendarYearSpansEras(calendar, year, locale)) {
+    const month = calendarMonthOfYear(calendar, year, Math.min(Math.max(at.month, 1), months));
+    const day = Math.min(Math.max(at.day, 1), month.length);
+    return eraYearAt(calendar, plainDateAddDays(month.start, day - 1), locale).label ?? String(year);
+  }
+  const middle = eraYearAt(calendar, calendarMonthOfYear(calendar, year, Math.floor(months / 2) + 1).start, locale);
+  return middle.label ?? String(year);
+}

package/dist/utils/coarsePointer.d.ts

@@ -1,5 +1,10 @@
 /** Whether the primary pointer of `view` is coarse now. */
 export declare function isCoarsePointer(view: Window | null | undefined): boolean;
+/**
+ * Call `listener` with the new answer each time `query` starts or stops
+ * matching in `view`, until the returned function is called.
+ */
+export declare function watchMediaQuery(view: Window | null | undefined, query: string, listener: (matches: boolean) => void): () => void;
 /**
  * Call `listener` with the new answer each time the primary pointer of
  * `view` turns coarse or fine, until the returned function is called.

package/dist/utils/coarsePointer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coarsePointer.d.ts","sourceRoot":"","sources":["../../src/utils/coarsePointer.ts"],"names":[],"mappings":"AAsBA,2DAA2D;AAC3D,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAKxE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC/B,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,GACpC,MAAM,IAAI,CAaZ"}
+{"version":3,"file":"coarsePointer.d.ts","sourceRoot":"","sources":["../../src/utils/coarsePointer.ts"],"names":[],"mappings":"AAuBA,2DAA2D;AAC3D,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAKxE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC/B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GACnC,MAAM,IAAI,CAaZ;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC/B,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,GACpC,MAAM,IAAI,CAEZ"}

package/dist/utils/coarsePointer.js

@@ -3,11 +3,12 @@
 /**
  * @file coarsePointer.ts
  * @input A window
- * @output Exports isCoarsePointer and watchCoarsePointer: whether the
- *   primary pointer is coarse (TOUCH_QUERY), and when it changes
+ * @output Exports isCoarsePointer, watchCoarsePointer and watchMediaQuery:
+ *   whether the primary pointer is coarse (TOUCH_QUERY), and when it or any
+ *   media query changes
  * @position The coarse-pointer gate of packages/core/src/gestures and of
  *   the press controller (pressFeedback.ts): touch-only work registers only
- *   while it holds
+ *   while it holds. useMediaQuery watches through watchMediaQuery
  *
  * Under a coarse primary pointer, a phone's touch work stays registered: the
  * gesture host's page listeners, the page hold and the finger scroll. Under a
@@ -26,20 +27,28 @@ export function isCoarsePointer(view) {
 }
 
 /**
- * Call `listener` with the new answer each time the primary pointer of
- * `view` turns coarse or fine, until the returned function is called.
+ * Call `listener` with the new answer each time `query` starts or stops
+ * matching in `view`, until the returned function is called.
  */
-export function watchCoarsePointer(view, listener) {
+export function watchMediaQuery(view, query, listener) {
   if (typeof view?.matchMedia !== 'function') {
     return () => {};
   }
-  const query = view.matchMedia(TOUCH_QUERY);
-  const onChange = () => listener(query.matches);
-  if (typeof query.addEventListener === 'function') {
-    query.addEventListener('change', onChange);
-    return () => query.removeEventListener('change', onChange);
+  const list = view.matchMedia(query);
+  const onChange = () => listener(list.matches);
+  if (typeof list.addEventListener === 'function') {
+    list.addEventListener('change', onChange);
+    return () => list.removeEventListener('change', onChange);
   }
   // Safari before 14 only has the older pair.
-  query.addListener(onChange);
-  return () => query.removeListener(onChange);
+  list.addListener(onChange);
+  return () => list.removeListener(onChange);
+}
+
+/**
+ * Call `listener` with the new answer each time the primary pointer of
+ * `view` turns coarse or fine, until the returned function is called.
+ */
+export function watchCoarsePointer(view, listener) {
+  return watchMediaQuery(view, TOUCH_QUERY, listener);
 }

package/dist/utils/flatTree.d.ts

@@ -1,11 +1,12 @@
 /**
  * @file flatTree.ts
  * @input A DOM node
- * @output Exports parentAcrossShadow, and containsAlongFlatTree, which walks it
+ * @output Exports parentAcrossShadow, containsAlongFlatTree, which walks it,
+ *   and deepActiveElement
  * @position The flat-tree parent the browser scrolls and dispatches
- *   through, shared by the gesture host's native-scroll probe and the
+ *   through, shared by the gesture host's native-scroll probe, the
  *   selection lock (which the press feedback controller uses without the
- *   gesture system)
+ *   gesture system) and the Layer module's input hold
  */
 /** The node's parent, crossing out of shadow roots. */
 export declare function parentAcrossShadow(node: Node): Node | null;
@@ -14,4 +15,6 @@ export declare function parentAcrossShadow(node: Node): Node | null;
  * shadow root to its host, which `Node.contains` does not follow.
  */
 export declare function containsAlongFlatTree(ancestor: Node, node: Node): boolean;
+/** The focused element of `doc`, inside open shadow roots too. */
+export declare function deepActiveElement(doc: Document | null | undefined): Element | null;
 //# sourceMappingURL=flatTree.d.ts.map

package/dist/utils/flatTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flatTree.d.ts","sourceRoot":"","sources":["../../src/utils/flatTree.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,uDAAuD;AACvD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAa1D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAOzE"}
+{"version":3,"file":"flatTree.d.ts","sourceRoot":"","sources":["../../src/utils/flatTree.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,uDAAuD;AACvD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAa1D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAOzE;AAED,kEAAkE;AAClE,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,GAC/B,OAAO,GAAG,IAAI,CAMhB"}