@rr0/cms 0.3.71 → 0.3.73

package/dist/time/TimeContext.mjs

@@ -287,10 +287,15 @@ export class TimeContext {
      * @return {TimeContext}
      */
     clone() {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g;
         const date = this.date;
         const interval = this.interval;
-        return new TimeContext((_a = date === null || date === void 0 ? void 0 : date.year) === null || _a === void 0 ? void 0 : _a.value, (_b = date === null || date === void 0 ? void 0 : date.month) === null || _b === void 0 ? void 0 : _b.value, (_c = date === null || date === void 0 ? void 0 : date.day) === null || _c === void 0 ? void 0 : _c.value, (_d = date === null || date === void 0 ? void 0 : date.hour) === null || _d === void 0 ? void 0 : _d.value, (_e = date === null || date === void 0 ? void 0 : date.minute) === null || _e === void 0 ? void 0 : _e.value, (_f = date === null || date === void 0 ? void 0 : date.timeshift) === null || _f === void 0 ? void 0 : _f.value, this.approximate, this.approximateTime, interval === null || interval === void 0 ? void 0 : interval.from, interval === null || interval === void 0 ? void 0 : interval.to, this.duration);
+        const season = ((_a = date === null || date === void 0 ? void 0 : date.month) === null || _a === void 0 ? void 0 : _a.value) > 12; // "1954-23": EdtfDate's constructor rejects it, only its parser accepts it
+        const clone = new TimeContext((_b = date === null || date === void 0 ? void 0 : date.year) === null || _b === void 0 ? void 0 : _b.value, season ? undefined : (_c = date === null || date === void 0 ? void 0 : date.month) === null || _c === void 0 ? void 0 : _c.value, (_d = date === null || date === void 0 ? void 0 : date.day) === null || _d === void 0 ? void 0 : _d.value, (_e = date === null || date === void 0 ? void 0 : date.hour) === null || _e === void 0 ? void 0 : _e.value, (_f = date === null || date === void 0 ? void 0 : date.minute) === null || _f === void 0 ? void 0 : _f.value, (_g = date === null || date === void 0 ? void 0 : date.timeshift) === null || _g === void 0 ? void 0 : _g.value, this.approximate, this.approximateTime, interval === null || interval === void 0 ? void 0 : interval.from, interval === null || interval === void 0 ? void 0 : interval.to, this.duration);
+        if (season) {
+            clone.date = EdtfDate.fromString(date.toString());
+        }
+        return clone;
     }
     /**
      *

package/dist/time/html/TimeElementFactory.d.ts

@@ -7,7 +7,7 @@ export declare class TimeElementFactory {
     readonly renderer: TimeRenderer;
     constructor(renderer: TimeRenderer);
     create(context: HtmlRR0Context, previousContext: HtmlRR0Context | undefined, options: TimeRenderOptions): HTMLElement | undefined;
-    protected createInterval(fromContext: HtmlRR0Context, toContext: HtmlRR0Context, previousContext: HtmlRR0Context, options: TimeRenderOptions): HTMLElement | undefined;
+    createInterval(fromContext: HtmlRR0Context, toContext: HtmlRR0Context, previousContext: HtmlRR0Context, options: TimeRenderOptions): HTMLElement | undefined;
     protected createStarting(fromContext: HtmlRR0Context, previousContext: HtmlRR0Context, options: TimeRenderOptions): HTMLElement | undefined;
     protected valueReplacement(context: HtmlRR0Context, previousContext: RR0Context | undefined, options?: TimeRenderOptions): HTMLElement | undefined;
     protected durationReplacement(context: HtmlRR0Context): HTMLTimeElement | undefined;

package/dist/time/html/TimeElementFactory.js

@@ -31,9 +31,16 @@ export class TimeElementFactory {
     }
     createInterval(fromContext, toContext, previousContext, options) {
         let replacement;
+        options = { ...options, relativeWords: false }; // "the day after at 22 h" can't start or end an interval
         const startReplacement = this.valueReplacement(fromContext, previousContext, options);
         if (startReplacement) {
-            const endReplacement = this.valueReplacement(toContext, previousContext, options);
+            const from = fromContext.time;
+            const to = toContext.time;
+            const sameDay = from.getDayOfMonth() && from.getYear() === to.getYear() && from.getMonth() === to.getMonth()
+                && from.getDayOfMonth() === to.getDayOfMonth();
+            const endReplacement = sameDay // "21:00/22:00" ends at "22 h", not at "Tuesday 22 May 1517 at 22 h"
+                ? this.valueReplacement(toContext, fromContext, options)
+                : this.valueReplacement(toContext, previousContext, options);
             if (endReplacement && endReplacement.outerHTML !== startReplacement.outerHTML) {
                 replacement = fromContext.file.document.createElement("span");
                 replacement.className = "time-interval";

package/dist/time/html/TimeRenderer.d.ts

@@ -9,6 +9,10 @@ export interface TimeRenderOptions {
      * The text says "between" right before this interval, so it reads "between X and Y" rather than "between X to Y".
      */
     between?: boolean;
+    /**
+     * If a wording like "the day after" may replace the time. Defaults to true.
+     */
+    relativeWords?: boolean;
 }
 export declare class TimeRenderer {
     readonly urlBuilder: TimeUrlBuilder;

package/dist/time/html/TimeRenderer.js

@@ -23,7 +23,7 @@ export class TimeRenderer {
         const date = time.date;
         const absoluteTimeUrl = this.urlBuilder.fromEdtf(date);
         const title = this.textBuilder.build(context, renderOptions);
-        const text = (previousContext ? this.relativeTextBuilder.build(previousContext, context) : undefined) || title;
+        const text = (previousContext ? this.relativeTextBuilder.build(previousContext, context, options.relativeWords !== false) : undefined) || title;
         const file = context.file;
         const currentFileName = file.name;
         const doc = file.document;

package/dist/time/html/TimeReplacer.d.ts

@@ -1,6 +1,8 @@
 import { HtmlRR0Context } from "../../RR0Context.js";
 import { DomReplacement } from "../DomReplacement.js";
 import { TimeElementFactory } from "./TimeElementFactory.js";
+import { TimeRenderOptions } from "./TimeRenderer.js";
+import { TimeStringCompleter } from "./TimeStringCompleter.js";
 /**
  * Replaces a <time> tag.
  */
@@ -11,6 +13,7 @@ export declare class TimeReplacer implements DomReplacement<HtmlRR0Context, HTML
      * ("between <strong><time>1989/1994</time></strong>").
      */
     static readonly inlineTags: string[];
+    protected readonly completer: TimeStringCompleter;
     constructor(factory: TimeElementFactory);
     static resolvedTime(context: HtmlRR0Context, dateTime: string): HTMLTimeElement;
     /**
@@ -18,4 +21,8 @@ export declare class TimeReplacer implements DomReplacement<HtmlRR0Context, HTML
      */
     static precedingText(el: Element): string;
     replacement(context: HtmlRR0Context, origEl: HTMLTimeElement): Promise<HTMLElement>;
+    /**
+     * Renders a range of durations ("P10M/12M") as "from 10 to 12 minutes".
+     */
+    protected durationRange(context: HtmlRR0Context, previousContext: HtmlRR0Context | undefined, durations: RegExpExecArray, options: TimeRenderOptions): HTMLElement | undefined;
 }

package/dist/time/html/TimeReplacer.js

@@ -1,10 +1,12 @@
 import { ObjectUtils } from "@rr0/common";
+import { TimeStringCompleter } from "./TimeStringCompleter.js";
 /**
  * Replaces a <time> tag.
  */
 export class TimeReplacer {
     constructor(factory) {
         this.factory = factory;
+        this.completer = new TimeStringCompleter();
     }
     static resolvedTime(context, dateTime) {
         const replacement = context.file.document.createElement("time");
@@ -24,23 +26,64 @@ export class TimeReplacer {
     }
     async replacement(context, origEl) {
         let replacement;
-        if (origEl.dateTime) { // Already done?
+        if (origEl.dateTime || origEl.dataset.format === "none") { // Already done, or not to be interpreted
             replacement = origEl;
         }
         else {
             const previousContext = origEl.dataset.context === "none" ? undefined : context.clone();
             const timeStr = origEl.textContent;
-            const valid = context.time.updateFromStr(timeStr);
-            const between = context.messages.context.time.between.test(TimeReplacer.precedingText(origEl));
-            replacement = valid && this.factory.create(context, previousContext, { url: true, contentOnly: true, between });
+            const { prefix, value, suffix } = this.completer.split(timeStr);
+            const between = context.messages.context.time.between.test(TimeReplacer.precedingText(origEl) + prefix);
+            const options = { url: true, contentOnly: true, between };
+            try {
+                const durations = /^(~?)P([^/]+)\/P?([^/]+)$/.exec(value.trim()); // "P10M/12M"
+                if (durations) {
+                    replacement = this.durationRange(context, previousContext, durations, options);
+                }
+                else {
+                    const completed = this.completer.complete(value.trim(), context.time);
+                    if (!this.completer.isInterpretable(completed)) {
+                        context.warn("Could not interpret time", timeStr);
+                    }
+                    else if (this.completer.isDayless(completed)) {
+                        context.warn("Could not resolve the day of time", timeStr);
+                    }
+                    else if (context.time.updateFromStr(completed)) {
+                        replacement = this.factory.create(context, previousContext, options);
+                    }
+                }
+            }
+            catch (e) { // One unrenderable time must not stop the others of the page
+                context.warn("Could not render time", timeStr, e.message);
+                replacement = undefined;
+            }
             if (!replacement) {
                 replacement = origEl;
-                // replacement.setAttribute("datetime", context.time.toString())
+            }
+            else if (prefix || suffix) { // Keep the words written around the time ("vers", "le soir")
+                const wrapper = context.file.document.createElement("span");
+                wrapper.className = "time-described";
+                wrapper.append(prefix, replacement, suffix);
+                replacement = wrapper;
             }
             context.debug("\tReplacing time", origEl.outerHTML, "with", ObjectUtils.asSet(replacement).outerHTML);
         }
         return replacement;
     }
+    /**
+     * Renders a range of durations ("P10M/12M") as "from 10 to 12 minutes".
+     */
+    durationRange(context, previousContext, durations, options) {
+        const [, approximate, from, to] = durations;
+        const fromContext = context.clone();
+        const toContext = context.clone();
+        let replacement;
+        if (fromContext.time.updateFromStr(`${approximate}P${from.toUpperCase()}`)
+            && toContext.time.updateFromStr(`${approximate}P${to.toUpperCase()}`)) {
+            replacement = this.factory.createInterval(fromContext, toContext, previousContext, options);
+        }
+        return replacement;
+    }
 }
 /**
  * Elements that don't break a sentence, so that the text before them is the text before the <time> they contain

package/dist/time/html/TimeReplacer.test.js

@@ -102,6 +102,36 @@ describe("TimeReplacer", async () => {
             expect(await renderIn("en", "from <time>1951/1955</time>")).toBe("1951 to 1955");
         });
     });
+    describe("renders an EDTF season", () => {
+        async function render(locale, value) {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "", locale);
+            const el = context.file.document.createElement("time");
+            el.textContent = value;
+            return (await replacer.replacement(context, el)).textContent;
+        }
+        test("in French and English, instead of failing on month 23", async () => {
+            expect(await render("fr", "1954-23")).toBe("automne 1954");
+            expect(await render("en", "1954-22")).toBe("summer 1954");
+        });
+        test("after another date", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            const previous = context.file.document.createElement("time");
+            previous.textContent = "1954-10-16";
+            await replacer.replacement(context, previous);
+            const season = context.file.document.createElement("time");
+            season.textContent = "1954-24";
+            expect((await replacer.replacement(context, season)).textContent).toBe("hiver 1954");
+        });
+    });
+    test("leaves a time with data-format=\"none\" as written", async () => {
+        const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+        const el = context.file.document.createElement("time");
+        el.dataset.format = "none";
+        el.textContent = "Dans la nuit";
+        const replaced = await replacer.replacement(context, el);
+        expect(replaced).toBe(el);
+        expect(replaced.outerHTML).toBe(`<time data-format="none">Dans la nuit</time>`);
+    });
     test("parses unsupported", async () => {
         const interval = "moi";
         const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
@@ -252,4 +282,69 @@ describe("TimeReplacer", async () => {
         test("with approximation", async () => {
         });
     });
+    describe("partial values", () => {
+        async function render(context, str) {
+            const timeEl = context.file.document.createElement("time");
+            timeEl.textContent = str;
+            const replacement = await replacer.replacement(context, timeEl);
+            return replacement.textContent;
+        }
+        test("day of the current month", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            expect(await render(context, "19")).toBe("dimanche 19");
+            expect(context.time.toString()).toBe("1990-08-19");
+        });
+        test("hour of the current day", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            await render(context, "12");
+            expect(await render(context, "21:00")).toBe("21 h");
+            expect(context.time.getDayOfMonth()).toBe(12);
+            expect(context.time.getHour()).toBe(21);
+            expect(await render(context, "23T~01:45")).toBe("jeudi 23 01:45");
+            expect(await render(context, "00:19/00:30")).toBe("00:19 à 00:30");
+            expect(context.time.getYear()).toBe(1990);
+        });
+        test("hour of an unknown day is not read as a year", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/index.html", "");
+            expect(await render(context, "07:30")).toBe("07:30");
+            expect(context.time.getYear()).toBe(1990);
+        });
+        test("interval end relative to its start", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            expect(await render(context, "1517-05-22 21:00/22:00")).toBe("mardi 22 mai 1517 à 21 h à 22 h");
+            expect(await render(context, "02 20:00/03 05:00")).toBe("mercredi 2 20 h à jeudi 3 05 h");
+            expect(await render(context, "27 23:00/03:00")).toBe("dimanche 27 23 h à lundi 28 03 h");
+        });
+        test("date without hour after an hour of the previous day", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            await render(context, "1998-08-09 22:00");
+            expect(await render(context, "1998-08-10")).toBe("lundi 10");
+        });
+        test("range of durations", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            expect(await render(context, "P10M/12M")).toBe("10 minutes à 12 minutes");
+            expect(await render(context, "P15S/20s")).toBe("15 secondes à 20 secondes");
+        });
+        test("words around the value are kept", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            expect(await render(context, "1964-04-27Tle soir")).toBe("lundi 27 avril 1964 le soir");
+            expect(await render(context, "28Tpeu après minuit")).toBe("le lendemain peu après minuit");
+            expect(await render(context, "vers\u00a010:50")).toBe("vers\u00a010:50");
+        });
+        test("words are not read as a time", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            expect(await render(context, "1 h après le coucher du soleil")).toBe("1 h après le coucher du soleil");
+            expect(await render(context, "12 mars 1977")).toBe("12 mars 1977");
+            expect(context.time.toString()).toBe("1990-08");
+        });
+        test("time zone is part of the value", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            expect(await render(context, "1947-06-24 21:45PST")).toBe("mardi 24 juin 1947 à 21:45");
+        });
+        test("season does not break the next time", async () => {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            expect(await render(context, "1990-21")).toBe("printemps 1990");
+            expect(await render(context, "-0033")).toBe("33 av. J.-C.");
+        });
+    });
 });

package/dist/time/html/TimeStringCompleter.d.ts

@@ -0,0 +1,55 @@
+import { TimeContext } from "../TimeContext.mjs";
+/**
+ * A <time> string split into the time value itself and the free text around it ("vers 10:50", "03Tla nuit").
+ */
+export interface TimeStringParts {
+    prefix: string;
+    value: string;
+    suffix: string;
+}
+/**
+ * Prepares a <time> string for EDTF parsing.
+ *
+ * RR0 pages write times relative to the page and to the previous time: "19" is the 19th of the current month,
+ * "21:00" an hour of the current day, "1517-05-22 21:00/22:00" ends at 22:00 the same day. EDTF alone reads "19"
+ * as the year 19 and "07:30" as the year 7, so such partial values are completed from the current time context
+ * first. Free text written around the value ("le soir", "vers") is set apart so that it can be kept as is.
+ */
+export declare class TimeStringCompleter {
+    /**
+     * A trailing time zone ("PST", "(CDT)", "UTC+1") is part of the value, not free text.
+     */
+    protected static readonly timeZone: RegExp;
+    /**
+     * A duration ("P10M", "~P1H"), or a range of durations ("P10M/12M").
+     */
+    static readonly duration: RegExp;
+    split(str: string): TimeStringParts;
+    /**
+     * @param value A time value, possibly partial ("19", "21:00", "15 22:00/16 05:00").
+     * @param time The current time context, that the partial value is relative to.
+     * @return The completed value, or the value unchanged if it is not partial or cannot be completed.
+     */
+    complete(value: string, time: TimeContext): string;
+    /**
+     * EDTF parsing reads "1 h après le coucher" as the year 1 and ignores the rest: words must not reach it.
+     *
+     * @return If the value only holds characters of a time value (and possibly a trailing time zone).
+     */
+    isInterpretable(value: string): boolean;
+    /**
+     * @return If the value still holds a time of an unknown day ("07:30", "12 05:45"), which EDTF would read as a year.
+     */
+    isDayless(value: string): boolean;
+    protected completeOne(value: string, time: TimeContext): string;
+    protected isTime(value: string): boolean;
+    /**
+     * An end hour before its start hour ("23:00/03:00") is on the next day.
+     *
+     * @param end The end, completed with the day of its start ("1981-10-27 03:00").
+     * @param start The start ("1981-10-27 23:00").
+     */
+    protected dayAfterIfBefore(end: string, start: string): string;
+    protected year(year: number): string;
+    protected pad(n: number | string): string;
+}

package/dist/time/html/TimeStringCompleter.js

@@ -0,0 +1,128 @@
+import { TimeContext } from "../TimeContext.mjs";
+/**
+ * Prepares a <time> string for EDTF parsing.
+ *
+ * RR0 pages write times relative to the page and to the previous time: "19" is the 19th of the current month,
+ * "21:00" an hour of the current day, "1517-05-22 21:00/22:00" ends at 22:00 the same day. EDTF alone reads "19"
+ * as the year 19 and "07:30" as the year 7, so such partial values are completed from the current time context
+ * first. Free text written around the value ("le soir", "vers") is set apart so that it can be kept as is.
+ */
+export class TimeStringCompleter {
+    split(str) {
+        let prefix = "";
+        let value = str.replace(/[ \t\r\n]+/g, " ").trim(); // "1973-10-11\n      21:00/22:00"
+        let suffix = "";
+        if (!TimeStringCompleter.duration.test(value.trim())) {
+            const pre = /^([^\d~-]*[A-Za-zÀ-ÿ][^\d~]*?)(\s+)(~?\d.*)$/s.exec(value); // "vers 10:50", "Environ 00:30"
+            if (pre) {
+                prefix = pre[1] + pre[2];
+                value = pre[3];
+            }
+        }
+        const post = /^(.*?\d)(\s*T\s*|\s+)([^\d\s~].*)$/s.exec(value); // "03Tla nuit", "1976-08-03 le soir"
+        // A bare number followed by a space may be a quantity ("1 h", "30 mn après", "8 jours plus tard"), so a day of the
+        // month needs a T before its text ("18Tla nuit").
+        const quantity = post && /^\d{1,2}$/.test(post[1]) && !post[2].includes("T");
+        if (post && !quantity && !TimeStringCompleter.timeZone.test(post[3].trim())) {
+            value = post[1];
+            suffix = (post[2].includes("T") ? " " : post[2]) + post[3];
+        }
+        return { prefix, value, suffix };
+    }
+    /**
+     * @param value A time value, possibly partial ("19", "21:00", "15 22:00/16 05:00").
+     * @param time The current time context, that the partial value is relative to.
+     * @return The completed value, or the value unchanged if it is not partial or cannot be completed.
+     */
+    complete(value, time) {
+        const slash = value.indexOf("/");
+        if (slash > 0 && !TimeStringCompleter.duration.test(value)) {
+            const start = this.completeOne(value.substring(0, slash).trim(), time);
+            const startTime = new TimeContext();
+            if (!startTime.updateFromStr(start) || !startTime.date) {
+                return value;
+            }
+            let end = value.substring(slash + 1).trim();
+            const endMonth = /^\d{1,2}$/.exec(end);
+            if (endMonth && !startTime.getDayOfMonth() && startTime.getMonth()) { // "1989-05/06": May to June
+                end = `${this.year(startTime.getYear())}-${this.pad(end)}`;
+            }
+            else {
+                const completedEnd = this.completeOne(end, startTime);
+                end = completedEnd !== end && this.isTime(end) ? this.dayAfterIfBefore(completedEnd, start) : completedEnd;
+            }
+            return start + "/" + end;
+        }
+        return this.completeOne(value, time);
+    }
+    /**
+     * EDTF parsing reads "1 h après le coucher" as the year 1 and ignores the rest: words must not reach it.
+     *
+     * @return If the value only holds characters of a time value (and possibly a trailing time zone).
+     */
+    isInterpretable(value) {
+        const withoutZone = value.replace(/\s*\(?(?:[A-Z]{2,5}|UTC[+-]?\d*)\)?\s*(\/|$)/g, "$1"); // "01:00EST/03:00EST"
+        return /^[\d\s\-:/~?%.,+XTZPYMWDHS]+$/.test(withoutZone);
+    }
+    /**
+     * @return If the value still holds a time of an unknown day ("07:30", "12 05:45"), which EDTF would read as a year.
+     */
+    isDayless(value) {
+        return value.split("/").some(part => /^~?\d{1,2}[: T]\d/.test(part.trim()));
+    }
+    completeOne(value, time) {
+        var _a;
+        const year = time.getYear();
+        const month = time.getMonth();
+        const day = time.getDayOfMonth();
+        const knownMonth = year !== undefined && month >= 1 && month <= 12;
+        let m;
+        if ((m = /^(\d{1,2})$/.exec(value)) && knownMonth && Number(m[1]) <= 31) { // "19": a day of the month
+            return `${this.year(year)}-${this.pad(month)}-${this.pad(m[1])}`;
+        }
+        if ((m = /^(\d{1,2})[ T](~?\d{1,2}:\d{2}(?::\d{2})?.*)$/.exec(value)) && knownMonth && Number(m[1]) <= 31) {
+            return `${this.year(year)}-${this.pad(month)}-${this.pad(m[1])} ${m[2]}`; // "12 05:45", "23T~01:45"
+        }
+        if ((m = /^(\d{2})-(\d{2})( .+)?$/.exec(value)) && year !== undefined && Number(m[1]) <= 12) { // "02-11 02:00"
+            return `${this.year(year)}-${m[1]}-${m[2]}${(_a = m[3]) !== null && _a !== void 0 ? _a : ""}`;
+        }
+        if ((m = /^(~?\d{1,2}:\d{2}(?::\d{2})?)(.*)$/.exec(value)) && knownMonth && day) { // "21:00"
+            return `${this.year(year)}-${this.pad(month)}-${this.pad(day)} ${m[1]}${m[2]}`;
+        }
+        return value;
+    }
+    isTime(value) {
+        return /^~?\d{1,2}:\d{2}/.test(value);
+    }
+    /**
+     * An end hour before its start hour ("23:00/03:00") is on the next day.
+     *
+     * @param end The end, completed with the day of its start ("1981-10-27 03:00").
+     * @param start The start ("1981-10-27 23:00").
+     */
+    dayAfterIfBefore(end, start) {
+        const time = /^(-?\d{4})-(\d{2})-(\d{2}) (~?)(\d{1,2}:\d{2})(.*)$/.exec(end);
+        const startTime = /^-?\d{4}-\d{2}-\d{2}[ T]~?(\d{1,2}:\d{2})/.exec(start);
+        if (time && startTime && time[5].padStart(5, "0") < startTime[1].padStart(5, "0")) {
+            const next = new Date(Date.UTC(Number(time[1]), Number(time[2]) - 1, Number(time[3]) + 1));
+            next.setUTCFullYear(Number(time[1]), Number(time[2]) - 1, Number(time[3]) + 1); // Years before 100 too
+            const day = `${this.year(next.getUTCFullYear())}-${this.pad(next.getUTCMonth() + 1)}-${this.pad(next.getUTCDate())}`;
+            end = `${day} ${time[4]}${time[5]}${time[6]}`;
+        }
+        return end;
+    }
+    year(year) {
+        return (year < 0 ? "-" : "") + String(Math.abs(year)).padStart(4, "0");
+    }
+    pad(n) {
+        return String(n).padStart(2, "0");
+    }
+}
+/**
+ * A trailing time zone ("PST", "(CDT)", "UTC+1") is part of the value, not free text.
+ */
+TimeStringCompleter.timeZone = /^\(?(?:[A-Z]{1,5}|UTC[+-]?\d*)\)?$/;
+/**
+ * A duration ("P10M", "~P1H"), or a range of durations ("P10M/12M").
+ */
+TimeStringCompleter.duration = /^~?P\d/;

package/dist/time/text/RelativeTimeTextBuilder.d.ts

@@ -3,5 +3,10 @@ import { RR0Context } from "../../RR0Context.js";
 export declare class RelativeTimeTextBuilder {
     protected timeTextBuilder: TimeTextBuilder;
     constructor(timeTextBuilder: TimeTextBuilder);
-    build(oldContext: RR0Context, newContext: RR0Context): string;
+    /**
+     * @param oldContext The time to render relatively to.
+     * @param newContext The time to render.
+     * @param words If a wording like "the day after" may replace the time.
+     */
+    build(oldContext: RR0Context, newContext: RR0Context, words?: boolean): string;
 }

package/dist/time/text/RelativeTimeTextBuilder.js

@@ -1,14 +1,23 @@
+import { TimeTextBuilder } from "./TimeTextBuilder.js";
 import { Level0Duration } from "@rr0/time";
 export class RelativeTimeTextBuilder {
     constructor(timeTextBuilder) {
         this.timeTextBuilder = timeTextBuilder;
     }
-    build(oldContext, newContext) {
+    /**
+     * @param oldContext The time to render relatively to.
+     * @param newContext The time to render.
+     * @param words If a wording like "the day after" may replace the time.
+     */
+    build(oldContext, newContext, words = true) {
         var _a, _b, _c, _d, _e;
         let text;
         const time = newContext.time;
         const previousTime = time.equals(oldContext === null || oldContext === void 0 ? void 0 : oldContext.time) ? undefined : oldContext.time;
         let options;
+        if (TimeTextBuilder.isSeason(time.getMonth()) || TimeTextBuilder.isSeason(previousTime === null || previousTime === void 0 ? void 0 : previousTime.getMonth())) {
+            return undefined; // A season has no position within a year: always render it in full
+        }
         if (previousTime === null || previousTime === void 0 ? void 0 : previousTime.isDefined()) {
             options = {};
             const deltaMs = time.date.compare(previousTime.date);
@@ -30,7 +39,8 @@ export class RelativeTimeTextBuilder {
             const deltaDurationMonth = (_b = deltaDuration.months) === null || _b === void 0 ? void 0 : _b.value;
             const sameMonth = !deltaDurationMonth || deltaDurationMonth < 1;
             const noMonth = !previousMonth;
-            const shouldSetMonth = deltaDurationMonth || (noMonth || shouldSetYear);
+            // Calendar fields are compared too: 22:00 to the next midnight is less than a day, but another day
+            const shouldSetMonth = deltaDurationMonth || (noMonth || shouldSetYear) || month !== previousMonth;
             if (shouldSetMonth) {
                 deltaTime.setMonth(month);
                 options.month = "long";
@@ -39,7 +49,8 @@ export class RelativeTimeTextBuilder {
             const previousDay = previousTime.getDayOfMonth();
             const dayOfMonthDelta = (_c = deltaDuration.days) === null || _c === void 0 ? void 0 : _c.value;
             const sameDay = !dayOfMonthDelta || dayOfMonthDelta < 1;
-            const shouldSetDay = dayOfMonthDelta || (!sameDay && sameYear && sameMonth);
+            const shouldSetDay = dayOfMonthDelta || (!sameDay && sameYear && sameMonth) || shouldSetMonth
+                || dayOfMonth !== previousDay;
             const noDay = !previousDay;
             if (shouldSetDay) {
                 deltaTime.setDayOfMonth(dayOfMonth);
@@ -48,7 +59,8 @@ export class RelativeTimeTextBuilder {
             }
             const hour = time.getHour();
             const hourDelta = (_d = deltaDuration.hours) === null || _d === void 0 ? void 0 : _d.value;
-            const shouldSetHour = hourDelta || (hour && (noDay || (sameYear && sameMonth && sameDay))) || previousTime.getHour() !== time.getHour();
+            const shouldSetHour = hourDelta || (hour && (noDay || (sameYear && sameMonth && sameDay))) || previousTime.getHour() !== time.getHour()
+                || (shouldSetDay && hour !== undefined); // "12 05:45" after "03 05:00" is not just "45"
             if (shouldSetHour) {
                 deltaTime.setHour(hour);
                 options.hour = "2-digit";
@@ -56,8 +68,13 @@ export class RelativeTimeTextBuilder {
             const minutes = time.getMinutes();
             const minutesDelta = (_e = deltaDuration.minutes) === null || _e === void 0 ? void 0 : _e.value;
             const sameHour = hourDelta === 0;
-            const shouldSetMinutes = minutesDelta || (minutes && (sameYear && sameMonth && sameDay && sameHour));
+            const shouldSetMinutes = minutesDelta || (minutes && (sameYear && sameMonth && sameDay && sameHour))
+                || (shouldSetHour && minutes);
             if (shouldSetMinutes) {
+                if (!shouldSetHour && hour !== undefined) { // Minutes alone ("19") don't tell a time, even at hour 0
+                    deltaTime.setHour(hour);
+                    options.hour = "2-digit";
+                }
                 deltaTime.setMinutes(minutes);
                 options.minute = "2-digit";
             }
@@ -67,7 +84,10 @@ export class RelativeTimeTextBuilder {
             // A relative wording ("the day after", "the month after"...) only makes sense against a previous time
             // that is as precise: a month page (1947-07) is not "the day before" its first entry (1947-07-01).
             const messages = newContext.messages.context.time.relative;
-            if (dayOfMonthDelta && sameYear && sameMonth && !noDay) {
+            if (!words) {
+                // Rendered in full
+            }
+            else if (dayOfMonthDelta && sameYear && sameMonth && !noDay) {
                 switch (dayOfMonthDelta) {
                     case -1:
                         text = messages.day.before;

package/dist/time/text/TimeTextBuilder.d.ts

@@ -1,6 +1,11 @@
 import { RR0Context } from "../../RR0Context.js";
 export declare class TimeTextBuilder {
     readonly options: Intl.DateTimeFormatOptions;
+    /**
+     * EDTF season codes (21-24) and their names, per language.
+     */
+    static readonly seasons: Record<string, Record<number, string>>;
+    static isSeason(month: number | undefined): boolean;
     /**
      * @param options The default date format.to use.
      */

package/dist/time/text/TimeTextBuilder.js

@@ -1,4 +1,7 @@
 export class TimeTextBuilder {
+    static isSeason(month) {
+        return month >= 21 && month <= 24;
+    }
     /**
      * @param options The default date format.to use.
      */
@@ -9,10 +12,16 @@ export class TimeTextBuilder {
      * Build a textual representation of context's time, according to context's locale.
      */
     build(context, options = this.options) {
+        var _a;
         const time = context.time;
         const printOptions = {};
         const date = new Date(undefined, undefined, undefined);
         const year = time.getYear();
+        const season = time.getMonth();
+        if (TimeTextBuilder.isSeason(season)) { // "1954-23": no Date can hold it
+            const names = (_a = TimeTextBuilder.seasons[context.locale]) !== null && _a !== void 0 ? _a : TimeTextBuilder.seasons.en;
+            return year ? `${names[season]} ${year}` : names[season];
+        }
         if (year) {
             date.setFullYear(year);
             printOptions.year = options.year;
@@ -79,3 +88,10 @@ export class TimeTextBuilder {
         return text;
     }
 }
+/**
+ * EDTF season codes (21-24) and their names, per language.
+ */
+TimeTextBuilder.seasons = {
+    fr: { 21: "printemps", 22: "été", 23: "automne", 24: "hiver" },
+    en: { 21: "spring", 22: "summer", 23: "autumn", 24: "winter" }
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@rr0/cms",
   "type": "module",
   "author": "Jérôme Beau <rr0@rr0.org> (https://rr0.org)",
-  "version": "0.3.71",
+  "version": "0.3.73",
   "description": "RR0 Content Management System (CMS)",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -34,7 +34,7 @@
     "@rr0/data": "^0.3.43",
     "@rr0/lang": "^0.1.13",
     "@rr0/place": "^0.5.4",
-    "@rr0/time": "^0.11.2",
+    "@rr0/time": "^0.11.3",
     "canvas": "^3.2.1",
     "csv-parser": "^3.2.0",
     "glob": "^11.0.3",