@escape-game-over/atlas 0.1.98 → 0.1.99

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@escape-game-over/atlas",
-    "version": "0.1.98",
+    "version": "0.1.99",
     "type": "module",
     "description": "Typed, data-driven machinery for static multi-locale, multi-deployment Astro sites.",
     "private": false,

package/src/hours.ts

@@ -217,6 +217,71 @@ export function formatHours(
 ): readonly FormattedHours[] {
     const between = format.between ?? "–";
     const and = format.and ?? ", ";
+    const { dayName, time } = printer(format);
+
+    return groupHours(hours, format.weekStart).map((group) => ({
+        days: group.runs.map((run) => runName(run, dayName, between)).join(and),
+        weekdays: group.days,
+        times: timesOf(group, format.closed, time, between, and),
+    }));
+}
+
+/**
+ * How to say a week in a sentence: `HoursFormat` without the separators it
+ * picks from `Intl`, plus the one `Intl` has no word for.
+ */
+export interface HoursSentenceFormat extends Omit<HoursFormat, "and"> {
+    /**
+     * Between one group of days and the next: `"; "` in English, `"؛ "` in
+     * Arabic. Copy, so the caller translates it; `Intl` has no list form
+     * for it.
+     */
+    readonly separator: string;
+}
+
+/**
+ * The week as one sentence, for copy that quotes it: `Monday–Thursday and
+ * Sunday 14:00–23:30; Friday–Saturday 14:00–00:45`.
+ *
+ * Days and times join with the locale's own "and" (`Intl.ListFormat`), so a
+ * sentence in Arabic reads `الاثنين–الخميس والأحد` rather than borrowing an
+ * English comma. No closing full stop: the copy around it decides that.
+ */
+export function hoursSentence(
+    hours: WeeklyHours,
+    format: HoursSentenceFormat
+): string {
+    const between = format.between ?? "–";
+    const { dayName, time } = printer(format);
+    const list = new Intl.ListFormat(format.locale, {
+        type: "conjunction",
+        style: "long",
+    });
+    const joined = (parts: readonly string[]) => list.format(parts);
+
+    return groupHours(hours, format.weekStart)
+        .map((group) => {
+            const days = joined(
+                group.runs.map((run) => runName(run, dayName, between))
+            );
+            const times =
+                group.hours === "closed"
+                    ? format.closed
+                    : joined(
+                          group.hours.map(
+                              (range) =>
+                                  `${time(range.opens)}${between}${time(range.closes)}`
+                          )
+                      );
+            return `${days} ${times}`;
+        })
+        .join(format.separator);
+}
+
+/** Day names and times as `format` prints them. */
+function printer(
+    format: Pick<HoursFormat, "locale" | "weekday" | "hourCycle">
+) {
     // 2024-01-01 was a Monday, so `WEEK[i]` falls on the 1st plus `i`.
     const names = new Intl.DateTimeFormat(format.locale, {
         weekday: format.weekday ?? "short",
@@ -247,26 +312,35 @@ export function formatHours(
                       )
                   )
               );
+    return { dayName, time };
+}
 
-    return groupHours(hours, format.weekStart).map((group) => ({
-        days: group.runs
-            .map(([first, last]) =>
-                first === last
-                    ? dayName(first)
-                    : `${dayName(first)}${between}${dayName(last)}`
-            )
-            .join(and),
-        weekdays: group.days,
-        times:
-            group.hours === "closed"
-                ? format.closed
-                : group.hours
-                      .map(
-                          (range) =>
-                              `${time(range.opens)}${between}${time(range.closes)}`
-                      )
-                      .join(and),
-    }));
+/** A run of one day prints as one name — `Sun`, not `Sun–Sun`. */
+function runName(
+    [first, last]: HoursGroup["runs"][number],
+    dayName: (day: Weekday) => string,
+    between: string
+): string {
+    return first === last
+        ? dayName(first)
+        : `${dayName(first)}${between}${dayName(last)}`;
+}
+
+function timesOf(
+    group: HoursGroup,
+    closed: string,
+    time: (at: TimeOfDay) => string,
+    between: string,
+    and: string
+): string {
+    return group.hours === "closed"
+        ? closed
+        : group.hours
+              .map(
+                  (range) =>
+                      `${time(range.opens)}${between}${time(range.closes)}`
+              )
+              .join(and);
 }
 
 /** Minutes since midnight, for comparing two times. */

package/src/index.ts

@@ -123,6 +123,8 @@ export {
     groupHours,
     type HoursFormat,
     type HoursGroup,
+    type HoursSentenceFormat,
+    hoursSentence,
     type OpenStatus,
     openStatus,
     type TimeOfDay,