@rr0/cms 0.1.16 → 0.1.18

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

@@ -0,0 +1,225 @@
+import { TimeReplacer } from "./TimeReplacer.js";
+import { rr0TestUtil } from "../../test";
+import { describe, expect, test } from "@javarome/testscript";
+import { TimeRenderer } from "./TimeRenderer.js";
+import { TimeElementFactory } from "./TimeElementFactory.js";
+import { TimeTextBuilder } from "../text/TimeTextBuilder.js";
+import path from "path";
+describe("TimeReplacer", async () => {
+    const timeRoot = rr0TestUtil.time.timeOptions.root;
+    const timeService = await rr0TestUtil.time.getService({
+        root: timeRoot,
+        files: [
+            path.join(timeRoot, "1/9/4/7/07/02/index.html"),
+            path.join(timeRoot, "2/0/0/3/index.html"),
+            path.join(timeRoot, "2/0/0/3/12/24/index.html"),
+            path.join(timeRoot, "2/0/0/4/index.html"),
+            path.join(timeRoot, "2/0/0/4/09/index.html"),
+            path.join(timeRoot, "2/0/0/5/index.html"),
+            path.join(timeRoot, "2/0/0/5/08/23/index.html"),
+            path.join(timeRoot, "2/0/0/6/index.html"),
+            path.join(timeRoot, "2/0/0/6/07/14/index.html"),
+            path.join(timeRoot, "2/0/0/7/06/15/index.html")
+        ]
+    });
+    const textBuilder = new TimeTextBuilder(rr0TestUtil.intlOptions);
+    const timeRenderer = new TimeRenderer(timeService, textBuilder);
+    const timeElementFactory = new TimeElementFactory(timeRenderer);
+    const replacer = new TimeReplacer(timeElementFactory);
+    function timeUrl(pathStr) {
+        return path.join("/", timeService.root, pathStr, "index.html");
+    }
+    test("parses year", async () => {
+        {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            const timeEl = context.file.document.createElement("time");
+            timeEl.textContent = "2003";
+            const replacement = await replacer.replacement(context, timeEl);
+            expect(replacement.outerHTML).toBe(`<span class="time-resolved">en <a href="${path.join("/", timeService.root, "2/0/0/3/")}"><time datetime="2003">2003</time></a></span>`);
+            expect(context.time.getYear()).toBe(2003);
+            expect(context.time.getMonth()).toBe(undefined);
+            expect(context.time.getDayOfMonth()).toBe(undefined);
+            expect(context.time.getHour()).toBe(undefined);
+            expect(context.time.getMinutes()).toBe(undefined);
+            expect(context.time.getTimeZone()).toBe(undefined);
+        }
+        {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "");
+            const timeEl = context.file.document.createElement("time");
+            timeEl.innerHTML = "2003\n      ";
+            const replacement = await replacer.replacement(context, timeEl);
+            expect(replacement.outerHTML).toBe(`<span class="time-resolved">en <a href="${path.join("/", timeService.root, "2/0/0/3/")}"><time datetime="2003">2003</time></a></span>`);
+            expect(context.time.getYear()).toBe(2003);
+            expect(context.time.getMonth()).toBe(undefined);
+            expect(context.time.getDayOfMonth()).toBe(undefined);
+            expect(context.time.getHour()).toBe(undefined);
+            expect(context.time.getMinutes()).toBe(undefined);
+            expect(context.time.getTimeZone()).toBe(undefined);
+        }
+    });
+    test("parses interval", async () => {
+        const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+        const interval = "2003/2004";
+        const original = context.file.document.createElement("time");
+        original.textContent = interval;
+        const replaced = await replacer.replacement(context, original);
+        expect(replaced.outerHTML)
+            .toBe(`<span class="time-interval"><span class="time-resolved">en <a href="${path.join("/", timeService.root, "2/0/0/3/")}"><time datetime="2003">2003</time></a></span> à <span class="time-resolved">en <a href="${path.join("/", timeService.root, "2/0/0/4/")}"><time datetime="2004">2004</time></a></span></span>`);
+        expect(context.time.getYear()).toBe(2004);
+        expect(context.time.getMonth()).toBe(undefined);
+        expect(context.time.getDayOfMonth()).toBe(undefined);
+        expect(context.time.getHour()).toBe(undefined);
+        expect(context.time.getMinutes()).toBe(undefined);
+        expect(context.time.getTimeZone()).toBe(undefined);
+    });
+    test("parses unsupported", async () => {
+        const interval = "moi";
+        const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+        const original = context.file.document.createElement("time");
+        original.textContent = interval;
+        const replacement = await replacer.replacement(context, original);
+        expect(replacement.outerHTML).toBe(`<time>moi</time>`);
+        expect(context.time.getYear()).toBe(1990);
+        expect(context.time.getMonth()).toBe(8);
+        expect(context.time.getDayOfMonth()).toBe(undefined);
+        expect(context.time.getHour()).toBe(undefined);
+        expect(context.time.getMinutes()).toBe(undefined);
+        expect(context.time.getTimeZone()).toBe(undefined);
+    });
+    test("parses timezone", async () => {
+        {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "");
+            const original = context.file.document.createElement("time");
+            original.textContent = "2003-12-24T10:22CDT";
+            const replacement = await replacer.replacement(context, original);
+            expect(replacement.outerHTML)
+                .toBe(`<span class="time-resolved">le <a href="${path.join("/", timeService.root, "2/0/0/3/12/24/")}"><time datetime="2003-12-24T10:22-05">mercredi 24 décembre 2003 à 10:22</time></a></span>`); // TODO: Text should have timezone info
+            expect(context.time.getYear()).toBe(2003);
+            expect(context.time.getMonth()).toBe(12);
+            expect(context.time.getDayOfMonth()).toBe(24);
+            expect(context.time.getHour()).toBe(10);
+            expect(context.time.getMinutes()).toBe(22);
+            expect(context.time.getTimeshift()).toBe("-05");
+        }
+        /*{
+          const context = rr0TestUtil.newHtmlContext("time/1/9/9/0/08/index.html", "")
+          const interval = "2003-12-24 (CDT)"
+          const replacer = new TimeReplacer(["time/2/0/0/3/12/24"])
+          expect(replacer.replacement(context, `<time>${interval}</time>`, interval))
+            .toBe(`<a href="/time/2/0/0/3/12/24/">mercredi 24 décembre 2003</a>`)  // TODO: Text should have timezone info
+          expect(context.time.getYear()).toBe(2003)
+          expect(context.time.getMonth()).toBe(12)
+          expect(context.time.getDayOfMonth()).toBe(24)
+          expect(context.time.getHour()).toBe(undefined)
+          expect(context.time.getMinutes()).toBe(undefined)
+          expect(context.time.getTimeZone()).toBe("CDT")
+        }*/
+    });
+    test("parses month", async () => {
+        const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "");
+        const original = context.file.document.createElement("time");
+        original.textContent = "2004-09";
+        const replacement = await replacer.replacement(context, original);
+        expect(replacement.outerHTML).toBe(`<span class="time-resolved">en <a href="${path.join("/", timeService.root, "2/0/0/4/09/")}"><time datetime="2004-09">septembre 2004</time></a></span>`);
+        expect(context.time.getYear()).toBe(2004);
+        expect(context.time.getMonth()).toBe(9);
+        expect(context.time.getDayOfMonth()).toBe(undefined);
+        expect(context.time.getHour()).toBe(undefined);
+        expect(context.time.getMinutes()).toBe(undefined);
+    });
+    describe("parses day", () => {
+        test("from full date", async () => {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "");
+            const timeEl = context.file.document.createElement("time");
+            timeEl.textContent = "2005-08-23";
+            const replacement = await replacer.replacement(context, timeEl);
+            expect(replacement.outerHTML).toBe(`<span class="time-resolved">le <a href="${path.join("/", timeService.root, "2/0/0/5/08/23/")}"><time datetime="2005-08-23">mardi 23 août 2005</time></a></span>`);
+            expect(context.time.getYear()).toBe(2005);
+            expect(context.time.getMonth()).toBe(8);
+            expect(context.time.getDayOfMonth()).toBe(23);
+            expect(context.time.getHour()).toBe(undefined);
+            expect(context.time.getMinutes()).toBe(undefined);
+        });
+    });
+    test("reset context", async () => {
+        const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+        const timeEl = context.file.document.createElement("time");
+        timeEl.textContent = "2005";
+        const replacement = await replacer.replacement(context, timeEl);
+        expect(replacement.outerHTML).toBe(`<span class="time-resolved">en <a href="${rr0TestUtil.time.url("2/0/0/5/")}"><time datetime="2005">2005</time></a></span>`);
+        const original = context.file.document.createElement("time");
+        const datetime = "2006";
+        original.textContent = datetime;
+        const replacement2 = await replacer.replacement(context, original);
+        expect(replacement2.outerHTML).toBe(`<span class="time-resolved">en <a href="${rr0TestUtil.time.url("2/0/0/6/")}"><time datetime="${datetime}" title="2006">l'année suivante</time></a></span>`);
+    });
+    test("avoids linking to current file", async () => {
+        const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+        const timeEl = context.file.document.createElement("time");
+        const datetime = "1954-10-01";
+        timeEl.textContent = datetime;
+        const replacement = await replacer.replacement(context, timeEl);
+        expect(replacement.outerHTML)
+            .toBe(`<span class="time-resolved">le <time datetime="${datetime}">vendredi 1 octobre 1954</time></span>`);
+    });
+    describe("parse duration", () => {
+        test("with days, hours, minutes and seconds", async () => {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            const timeEl = context.file.document.createElement("time");
+            const datetime = "P2D10H23M45S";
+            timeEl.textContent = datetime;
+            const replacement = await replacer.replacement(context, timeEl);
+            expect(replacement.outerHTML).toBe(`<time datetime="${datetime}" class="duration">2 jours, 10 heures, 23 minutes et 45 secondes</time>`);
+        });
+        test("with context", async () => {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            {
+                const ctxElement = context.file.document.createElement("time");
+                ctxElement.textContent = "1947-07-02";
+                const replacement1 = await replacer.replacement(context, ctxElement);
+                expect(replacement1.outerHTML).toBe(`<span class="time-resolved">le <a href="${rr0TestUtil.time.url("1/9/4/7/07/02/")}"><time datetime="1947-07-02">mercredi 2 juillet 1947</time></a></span>`);
+            }
+            {
+                const element = context.file.document.createElement("time");
+                element.textContent = "P20M";
+                const replacement = await replacer.replacement(context, element);
+                expect(replacement.outerHTML).toBe(`<time datetime="P20M" class="duration">20 minutes</time>`);
+            }
+        });
+        test("with approximation", async () => {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            const original = context.file.document.createElement("time");
+            original.textContent = "P~2H";
+            const replacement = await replacer.replacement(context, original);
+            expect(replacement.outerHTML).toBe(`<time datetime="P2H" class="duration">environ 2 heures</time>`);
+        });
+    });
+    describe("parses hour", () => {
+        test("with context", async () => {
+            // Empty context
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            const timeEl = context.file.document.createElement("time");
+            timeEl.textContent = "2006-07-14 17:56";
+            const replacement = await replacer.replacement(context, timeEl);
+            expect(replacement.outerHTML).toBe(`<span class="time-resolved">le <a href="${path.join("/", timeService.root, "2/0/0/6/07/14/")}"><time datetime="2006-07-14T17:56">vendredi 14 juillet 2006 à 17:56</time></a></span>`);
+            expect(context.time.getYear()).toBe(2006);
+            expect(context.time.getMonth()).toBe(7);
+            expect(context.time.getDayOfMonth()).toBe(14);
+            expect(context.time.getHour()).toBe(17);
+            expect(context.time.getMinutes()).toBe(56);
+            // Change day + hour
+            const timeEl1 = context.file.document.createElement("time");
+            timeEl1.textContent = "2007-06-15 18:47";
+            const replacement1 = await replacer.replacement(context, timeEl1);
+            expect(replacement1.outerHTML).toBe(`<span class="time-resolved">le <a href="${path.join("/", timeService.root, "2/0/0/7/06/15/")}"><time datetime="2007-06-15T18:47">vendredi 15 juin 2007 à 18:47</time></a></span>`);
+            expect(context.time.getYear()).toBe(2007);
+            expect(context.time.getMonth()).toBe(6);
+            expect(context.time.getDayOfMonth()).toBe(15);
+            expect(context.time.getHour()).toBe(18);
+            expect(context.time.getMinutes()).toBe(47);
+            // TODO: Change hour only
+        });
+        test("with approximation", async () => {
+        });
+    });
+});

package/dist/time/text/RelativeTimeTextBuilder.js

@@ -1,106 +1,71 @@
+import { Level0Duration } from "@rr0/time";
 export class RelativeTimeTextBuilder {
     constructor(timeTextBuilder) {
         this.timeTextBuilder = timeTextBuilder;
     }
     build(oldContext, newContext) {
+        var _a, _b, _c, _d, _e;
         let text;
-        let print = true;
-        const previousTime = oldContext === null || oldContext === void 0 ? void 0 : oldContext.time;
+        const time = newContext.time;
+        const previousTime = time.equals(oldContext === null || oldContext === void 0 ? void 0 : oldContext.time) ? undefined : oldContext.time;
+        let options;
         if (previousTime === null || previousTime === void 0 ? void 0 : previousTime.isDefined()) {
+            options = {};
+            const deltaMs = time.date.compare(previousTime.date);
+            const deltaDuration = Level0Duration.toSpec(deltaMs);
             const deltaContext = oldContext.clone();
             const deltaTime = deltaContext.time;
-            let dayOfMonthDelta;
-            let yearDelta;
-            let monthDelta;
-            let hourDelta;
-            let minutesDelta;
-            function shouldSetDay() {
-                return !previousTime.getMonth() || monthDelta === 0;
-            }
-            function shouldSetHour() {
-                return !previousTime.getDayOfMonth() || dayOfMonthDelta === 0;
-            }
-            function shouldSetMinutes() {
-                return !previousTime.getMinutes() || hourDelta === 0;
-            }
-            function setYear(year) {
-                const previousYear = previousTime.getYear();
-                if (previousYear) {
-                    yearDelta = year - previousYear;
-                    if (yearDelta != 0) {
-                        deltaTime.setYear(year);
-                    }
-                }
-            }
-            function setMonth(month) {
-                const previousMonth = previousTime.getMonth();
-                if (yearDelta === 0) {
-                    monthDelta = month - (previousMonth || 0);
-                    if (monthDelta != 0) {
-                        deltaTime.setMonth(month);
-                    }
-                }
-                else if (yearDelta != 0) {
-                    deltaTime.setMonth(month);
-                }
-            }
-            function setDayOfMonth(dayOfMonth) {
-                const sameMonth = yearDelta === 0 && shouldSetDay();
-                if (sameMonth) {
-                    dayOfMonthDelta = dayOfMonth - (previousTime.getDayOfMonth() || 0);
-                    if (dayOfMonthDelta != 0) {
-                        deltaTime.setDayOfMonth(dayOfMonth);
-                    }
-                }
-                else if (monthDelta != 0) {
-                    deltaTime.setDayOfMonth(dayOfMonth);
-                }
-            }
-            function setHour(hour) {
-                const sameDay = yearDelta === 0 && shouldSetDay() && shouldSetHour();
-                if (sameDay) {
-                    hourDelta = hour - (previousTime.getHour() || 0);
-                    if (hourDelta != 0) {
-                        deltaTime.setHour(hour);
-                    }
-                }
-                else if (dayOfMonthDelta != 0) {
-                    deltaTime.setHour(hour);
-                }
-            }
-            function setMinutes(minutes) {
-                const sameHour = yearDelta === 0 && shouldSetDay() && shouldSetHour() && shouldSetMinutes();
-                if (sameHour) {
-                    minutesDelta = minutes - (previousTime.getMinutes() || 0);
-                    if (minutesDelta != 0) {
-                        deltaTime.setMinutes(minutes);
-                    }
-                }
-                deltaTime.setMinutes(minutes);
-            }
-            const time = newContext.time;
             const year = time.getYear();
-            if (year) {
-                setYear(year);
+            const previousYear = previousTime.getYear();
+            const yearDelta = (_a = deltaDuration.years) === null || _a === void 0 ? void 0 : _a.value;
+            const sameYear = !yearDelta || yearDelta < 1;
+            const noYear = !previousYear;
+            const shouldSetYear = yearDelta || (noYear) || previousTime.getYear() !== time.getYear();
+            if (shouldSetYear) {
+                deltaTime.setYear(year);
+                options.year = "numeric";
             }
             const month = time.getMonth();
-            if (month) {
-                setMonth(month);
+            const previousMonth = previousTime.getMonth();
+            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);
+            if (shouldSetMonth) {
+                deltaTime.setMonth(month);
+                options.month = "long";
             }
             const dayOfMonth = time.getDayOfMonth();
-            if (dayOfMonth) {
-                setDayOfMonth(dayOfMonth);
+            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 noDay = !previousDay;
+            if (shouldSetDay) {
+                deltaTime.setDayOfMonth(dayOfMonth);
+                options.day = "numeric";
+                options.weekday = "long";
             }
             const hour = time.getHour();
-            if (hour) {
-                setHour(hour);
+            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();
+            if (shouldSetHour) {
+                deltaTime.setHour(hour);
+                options.hour = "2-digit";
             }
             const minutes = time.getMinutes();
-            if (minutes) {
-                setMinutes(minutes);
+            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));
+            if (shouldSetMinutes) {
+                deltaTime.setMinutes(minutes);
+                options.minute = "2-digit";
+            }
+            if (deltaContext.time.isDefined()) {
+                newContext = deltaContext;
             }
-            let messages = newContext.messages.context.time.relative;
-            if (dayOfMonthDelta) {
+            const messages = newContext.messages.context.time.relative;
+            if (dayOfMonthDelta && sameYear && sameMonth) {
                 switch (dayOfMonthDelta) {
                     case -1:
                         text = messages.day.before;
@@ -111,13 +76,13 @@ export class RelativeTimeTextBuilder {
                 }
             }
             else {
-                if (!dayOfMonth) {
-                    switch (monthDelta) {
+                if (!dayOfMonth && sameYear) {
+                    switch (deltaDurationMonth) {
                         case -1:
                             text = messages.month.before;
                             break;
                         case +1:
-                            text = messages.month.after;
+                            text = time.getMonth() - previousTime.getMonth() === 1 ? messages.month.after : messages.month.later;
                             break;
                     }
                 }
@@ -142,23 +107,9 @@ export class RelativeTimeTextBuilder {
                     }
                 }
             }
-            if (!text) {
-                let defaultContext;
-                if (deltaContext.time.isDefined()) {
-                    defaultContext = deltaContext;
-                    const dayOfMonth = defaultContext.time.getDayOfMonth();
-                    if (dayOfMonth && shouldSetDay()) {
-                        defaultContext.time.setMonth(newContext.time.getMonth() || previousTime.getMonth(), false); // give month
-                        defaultContext.time.setYear(newContext.time.getYear() || previousTime.getYear(), false); // give year
-                        // context for the day but won't
-                        print = false;
-                    }
-                    newContext = defaultContext;
-                }
-            }
         }
         if (!text) {
-            text = this.timeTextBuilder.build(newContext, print);
+            text = this.timeTextBuilder.build(newContext, options);
         }
         return text;
     }

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

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

package/dist/time/text/RelativeTimeTextBuilder.test.js

@@ -0,0 +1,125 @@
+import { RelativeTimeTextBuilder } from "./RelativeTimeTextBuilder.js";
+import { rr0TestUtil } from "../../test";
+import { describe, expect, test } from "@javarome/testscript";
+import { TimeTextBuilder } from "./TimeTextBuilder.js";
+describe("RelativeTimeTextBuilder", () => {
+    const timeTextBuilder = new TimeTextBuilder(rr0TestUtil.intlOptions);
+    const relativeTimeTextBuilder = new RelativeTimeTextBuilder(timeTextBuilder);
+    test("next year", () => {
+        {
+            const previousContext = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "");
+            previousContext.time.setYear(2003);
+            const context = previousContext.clone();
+            context.time.setYear(2004);
+            const s1 = relativeTimeTextBuilder.build(previousContext, context);
+            expect(s1).toBe("l'année suivante");
+            context.time.setMonth(6);
+            const s2 = relativeTimeTextBuilder.build(previousContext, context);
+            expect(s2).toBe("juin 2004");
+        }
+    });
+    test("change year", () => {
+        const previousContext = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "");
+        previousContext.time.setYear(1947);
+        const context = previousContext.clone();
+        context.time.setYear(1990);
+        context.time.setMonth(8);
+        context.time.setDayOfMonth(4);
+        const s = relativeTimeTextBuilder.build(previousContext, context);
+        expect(s).toBe("samedi 4 août 1990");
+    });
+    test("next month", () => {
+        {
+            const context1 = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "");
+            context1.time.setYear(2003);
+            {
+                context1.time.setMonth(2);
+                const next2months = context1.clone();
+                next2months.time.setMonth(context1.time.getMonth() + 2);
+                const s11 = relativeTimeTextBuilder.build(context1, next2months);
+                expect(s11).toBe("avril");
+            }
+            context1.time.setMonth(9);
+            const context2 = context1.clone();
+            context2.time.setMonth(context2.time.getMonth() + 1);
+            const s1 = relativeTimeTextBuilder.build(context1, context2);
+            expect(s1).toBe("le mois suivant");
+            const context3 = context2.clone();
+            context3.time.setDayOfMonth(23); // Resets day of month in context
+            const s2 = relativeTimeTextBuilder.build(context2, context3);
+            expect(s2).toBe("jeudi 23");
+            const context4 = context3.clone();
+            context4.time.setMonth(12);
+            const s3 = relativeTimeTextBuilder.build(context3, context4);
+            expect(s3).toBe("un mois plus tard");
+            const context5 = context4.clone();
+            context5.time.setMonth(1);
+            context5.time.setDayOfMonth(24);
+            const s4 = relativeTimeTextBuilder.build(context4, context5);
+            expect(s4).toBe("vendredi 24 janvier");
+        }
+        {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "<html lang='en'></html>");
+            context.time.setYear(2003);
+            context.time.setMonth(9);
+            const previousContext = context.clone();
+            context.time.setMonth(context.time.getMonth() + 1);
+            const s = relativeTimeTextBuilder.build(previousContext, context);
+            expect(s).toBe("the month after");
+        }
+    });
+    test("next day", () => {
+        {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "");
+            context.time.setYear(2003);
+            context.time.setMonth(9);
+            context.time.setDayOfMonth(23);
+            const previousContext = context.clone();
+            expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("mardi 23 septembre 2003");
+            context.time.setDayOfMonth(24);
+            expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("le lendemain");
+        }
+        {
+            const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "<html lang='en'></html>");
+            context.time.setYear(2003);
+            context.time.setMonth(9);
+            context.time.setDayOfMonth(23);
+            const previousContext = context.clone();
+            expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("Tuesday, September 23, 2003");
+            context.time.setDayOfMonth(context.time.getDayOfMonth() + 1);
+            expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("the day after");
+        }
+    });
+    describe("hour", () => {
+        test("next", () => {
+            {
+                let previousContext = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "");
+                const context = previousContext.clone();
+                context.time.setYear(2003);
+                context.time.setMonth(9);
+                context.time.setDayOfMonth(23);
+                context.time.setHour(16);
+                expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("mardi 23 septembre 2003 à 16 h");
+                previousContext = context.clone();
+                context.time.setHour(17);
+                expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("une heure plus tard");
+                context.time.setMinutes(43);
+                expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("17:43");
+            }
+            {
+                let previousContext = rr0TestUtil.time.newHtmlContext("1/9/9/0/08", "<html lang='en'></html>");
+                const context = previousContext.clone();
+                context.time.setYear(2003);
+                context.time.setMonth(9);
+                context.time.setDayOfMonth(23);
+                context.time.setHour(16);
+                expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("Tuesday, September 23, 2003 at 04 PM");
+                previousContext = context.clone();
+                context.time.setHour(17);
+                expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("one hour later");
+                context.time.setMinutes(43);
+                expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("05:43 PM");
+            }
+        });
+    });
+});

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

@@ -1,13 +1,12 @@
 import { RR0Context } from "../../RR0Context.js";
 export declare class TimeTextBuilder {
     readonly options: Intl.DateTimeFormatOptions;
+    /**
+     * @param options The default date format.to use.
+     */
     constructor(options: Intl.DateTimeFormatOptions);
     /**
      * Build a textual representation of context's time, according to context's locale.
-     *
-     * @param context
-     * @param print
-     * @param options
      */
-    build(context: RR0Context, print: boolean, options?: Intl.DateTimeFormatOptions): string;
+    build(context: RR0Context, options?: Intl.DateTimeFormatOptions): string;
 }

package/dist/time/text/TimeTextBuilder.js

@@ -1,60 +1,47 @@
 export class TimeTextBuilder {
+    /**
+     * @param options The default date format.to use.
+     */
     constructor(options) {
         this.options = options;
     }
     /**
      * Build a textual representation of context's time, according to context's locale.
-     *
-     * @param context
-     * @param print
-     * @param options
      */
-    build(context, print, options = this.options) {
+    build(context, options = this.options) {
         const time = context.time;
         const printOptions = {};
         const date = new Date(undefined, undefined, undefined);
         const year = time.getYear();
         if (year) {
             date.setFullYear(year);
-            if (print) {
-                printOptions.year = options.year;
-            }
+            printOptions.year = options.year;
         }
         const month = time.getMonth();
         if (month) {
             date.setDate(1); // Avoid increasing month if today is > 30
             date.setMonth(month - 1);
-            if (print) {
-                printOptions.month = options.month;
-            }
+            printOptions.month = options.month;
         }
         const dayOfMonth = time.getDayOfMonth();
         if (dayOfMonth) {
             date.setDate(dayOfMonth);
-            // if (print) {
             printOptions.day = options.day;
             printOptions.weekday = options.weekday;
-            //  }
         }
         const hour = time.getHour();
         if (hour) {
             date.setHours(hour);
-            //    if (print) {
             printOptions.hour = options.hour;
-            //     }
         }
         const minutes = time.getMinutes();
         if (minutes) {
             date.setMinutes(minutes);
-            //   if (print) {
             printOptions.minute = options.minute;
-            //   }
         }
         const timeZone = time.getTimeZone();
         if (timeZone) {
-            if (print) {
-                // printOptions.timeZoneName = context.time.options.timeZoneName
-            }
+            // printOptions.timeZoneName = context.time.options.timeZoneName
         }
         let text;
         if (Number.isNaN(date.getTime())) {
@@ -62,7 +49,7 @@ export class TimeTextBuilder {
             // TODO: Handle partial date (month only, etc.)
         }
         else { // Valid date?
-            const locale = context.file.lang.lang || context.locale;
+            const locale = context.locale;
             if (year < 0) {
                 date.setFullYear(date.getFullYear() + 1);
                 printOptions.era = "narrow";

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

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