@rr0/cms 0.3.68 → 0.3.70

package/dist/time/RR0TimeMessages.d.ts

@@ -27,6 +27,11 @@ export type RR0TimeMessages = {
         };
     };
     fromTo(startReplacement: string, endReplacement: string): string;
+    /**
+     * The word that, written right before an interval, asks for it to be rendered as `betweenAnd` ("between", "entre").
+     */
+    between: RegExp;
+    betweenAnd(startReplacement: string, endReplacement: string): string;
     on(approximate: boolean): string;
     in(approximate: boolean): string;
     starting(approximate: boolean): string;

package/dist/time/RR0TimeMessages_en.d.ts

@@ -30,5 +30,7 @@ export declare class RR0TimeMessages_en implements RR0TimeMessages {
     on: (approximate: boolean) => string;
     in: (approximate: boolean) => string;
     fromTo: (startReplacement: string, endReplacement: string) => string;
+    between: RegExp;
+    betweenAnd: (startReplacement: string, endReplacement: string) => string;
     starting: (approximate: boolean) => string;
 }

package/dist/time/RR0TimeMessages_en.js

@@ -33,6 +33,8 @@ export class RR0TimeMessages_en {
         };
         this.in = (approximate) => (approximate ? "around " : "");
         this.fromTo = (startReplacement, endReplacement) => startReplacement + " to " + endReplacement;
+        this.between = /\bbetween\s*$/i;
+        this.betweenAnd = (startReplacement, endReplacement) => startReplacement + " and " + endReplacement;
         this.starting = (approximate) => "starting " + (approximate ? "" : "the ");
     }
 }

package/dist/time/RR0TimeMessages_fr.d.ts

@@ -30,5 +30,7 @@ export declare class RR0TimeMessages_fr implements RR0TimeMessages {
     on: (approximate: boolean) => string;
     in: (approximate: boolean) => string;
     fromTo: (startReplacement: string, endReplacement: string) => string;
+    between: RegExp;
+    betweenAnd: (startReplacement: string, endReplacement: string) => string;
     starting: (approximate: boolean) => string;
 }

package/dist/time/RR0TimeMessages_fr.js

@@ -33,6 +33,8 @@ export class RR0TimeMessages_fr {
         };
         this.in = (approximate) => (approximate ? "vers " : "en ");
         this.fromTo = (startReplacement, endReplacement) => `${startReplacement} à ${endReplacement}`;
+        this.between = /\bentre\s*$/i;
+        this.betweenAnd = (startReplacement, endReplacement) => `${startReplacement} et ${endReplacement}`;
         this.starting = (approximate) => "à partir " + (approximate ? "de " : "du ");
     }
 }

package/dist/time/TimeContext.mjs

@@ -112,6 +112,11 @@ export class TimeContext {
             }
             catch (e) {
                 try {
+                    // Only a duration starts with P ("P10M", "~P1H"): otherwise EdtfDuration also accepts a date whose
+                    // time zone contains a P ("21:45PST", "00:38:42PDT") as an empty duration.
+                    if (!/^\s*~?P/.test(timeStr)) {
+                        throw new Error("Not a duration");
+                    }
                     this.duration = EdtfDuration.fromString(timeStr);
                     this.interval = undefined;
                     this.date = undefined;

package/dist/time/TimeContext.test.mjs

@@ -59,6 +59,20 @@ describe("TimeContext", () => {
         expect(timeContext.getHour()).toBe(12);
         expect(timeContext.getMinutes()).toBe(55);
     });
+    test("updateFromStr with a time zone containing a P is a date, not a duration", () => {
+        for (const str of ["1957-02-27 21:45PST", "1991-09-18 00:38:42PDT", "1957-02-27 21:45 (PST)"]) {
+            const context = new TimeContext();
+            expect(context.updateFromStr(str)).toBe(true);
+            expect(context.duration).toBeUndefined();
+            expect(context.getYear()).toBeDefined();
+            expect(context.getHour()).toBeDefined();
+        }
+    });
+    test("updateFromStr duration", () => {
+        const context = new TimeContext();
+        expect(context.updateFromStr("~P1H")).toBe(true);
+        expect(context.duration).toBeDefined();
+    });
     test("fromDate", () => {
         const month = 12;
         const date = new Date(2001, month - 1, 13);

package/dist/time/html/TimeElementFactory.js

@@ -37,7 +37,10 @@ export class TimeElementFactory {
             if (endReplacement && endReplacement.outerHTML !== startReplacement.outerHTML) {
                 replacement = fromContext.file.document.createElement("span");
                 replacement.className = "time-interval";
-                replacement.innerHTML = fromContext.messages.context.time.fromTo(startReplacement.outerHTML, endReplacement.outerHTML);
+                const timeMessages = fromContext.messages.context.time;
+                replacement.innerHTML = options.between
+                    ? timeMessages.betweenAnd(startReplacement.outerHTML, endReplacement.outerHTML)
+                    : timeMessages.fromTo(startReplacement.outerHTML, endReplacement.outerHTML);
             }
         }
         return replacement;

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

@@ -5,6 +5,10 @@ import { TimeUrlBuilder } from "../TimeUrlBuilder.js";
 export interface TimeRenderOptions {
     url: boolean;
     contentOnly: boolean;
+    /**
+     * The text says "between" right before this interval, so it reads "between X and Y" rather than "between X to Y".
+     */
+    between?: boolean;
 }
 export declare class TimeRenderer {
     readonly urlBuilder: TimeUrlBuilder;

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

@@ -6,7 +6,16 @@ import { TimeElementFactory } from "./TimeElementFactory.js";
  */
 export declare class TimeReplacer implements DomReplacement<HtmlRR0Context, HTMLTimeElement> {
     readonly factory: TimeElementFactory;
+    /**
+     * Elements that don't break a sentence, so that the text before them is the text before the <time> they contain
+     * ("between <strong><time>1989/1994</time></strong>").
+     */
+    static readonly inlineTags: string[];
     constructor(factory: TimeElementFactory);
     static resolvedTime(context: HtmlRR0Context, dateTime: string): HTMLTimeElement;
+    /**
+     * @return The text that precedes an element in its sentence.
+     */
+    static precedingText(el: Element): string;
     replacement(context: HtmlRR0Context, origEl: HTMLTimeElement): Promise<HTMLElement>;
 }

package/dist/time/html/TimeReplacer.js

@@ -11,6 +11,17 @@ export class TimeReplacer {
         replacement.dateTime = dateTime;
         return replacement;
     }
+    /**
+     * @return The text that precedes an element in its sentence.
+     */
+    static precedingText(el) {
+        var _a, _b;
+        let node = el;
+        while (!node.previousSibling && node.parentElement && TimeReplacer.inlineTags.includes(node.parentElement.tagName)) {
+            node = node.parentElement;
+        }
+        return (_b = (_a = node.previousSibling) === null || _a === void 0 ? void 0 : _a.textContent) !== null && _b !== void 0 ? _b : "";
+    }
     async replacement(context, origEl) {
         let replacement;
         if (origEl.dateTime) { // Already done?
@@ -20,7 +31,8 @@ export class TimeReplacer {
             const previousContext = origEl.dataset.context === "none" ? undefined : context.clone();
             const timeStr = origEl.textContent;
             const valid = context.time.updateFromStr(timeStr);
-            replacement = valid && this.factory.create(context, previousContext, { url: true, contentOnly: true });
+            const between = context.messages.context.time.between.test(TimeReplacer.precedingText(origEl));
+            replacement = valid && this.factory.create(context, previousContext, { url: true, contentOnly: true, between });
             if (!replacement) {
                 replacement = origEl;
                 // replacement.setAttribute("datetime", context.time.toString())
@@ -30,3 +42,8 @@ export class TimeReplacer {
         return replacement;
     }
 }
+/**
+ * Elements that don't break a sentence, so that the text before them is the text before the <time> they contain
+ * ("between <strong><time>1989/1994</time></strong>").
+ */
+TimeReplacer.inlineTags = ["STRONG", "EM", "B", "I", "U", "SPAN", "A"];

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

@@ -83,6 +83,25 @@ describe("TimeReplacer", async () => {
         const replaced = await replacer.replacement(context, interval);
         expect(replaced.outerHTML).toBe(`<span class="time-interval"><span class="time-resolved"><time datetime="1951">1951</time></span> à <span class="time-resolved"><time datetime="1955">1955</time></span></span>`);
     });
+    describe("renders an interval after \"between\" as \"between X and Y\"", () => {
+        async function renderIn(locale, html) {
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "", locale);
+            const p = context.file.document.createElement("p");
+            p.innerHTML = html;
+            const replaced = await replacer.replacement(context, p.querySelector("time"));
+            return replaced.textContent;
+        }
+        test("in French", async () => {
+            expect(await renderIn("fr", "entre <time>1951/1955</time>")).toBe("1951 et 1955");
+        });
+        test("in English, through an inline element", async () => {
+            expect(await renderIn("en", "anywhere between <strong><time>1951/1955</time></strong>")).toBe("1951 and 1955");
+        });
+        test("but not without the word", async () => {
+            expect(await renderIn("fr", "de <time>1951/1955</time>")).toBe("1951 à 1955");
+            expect(await renderIn("en", "from <time>1951/1955</time>")).toBe("1951 to 1955");
+        });
+    });
     test("parses unsupported", async () => {
         const interval = "moi";
         const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");

package/dist/time/text/RelativeTimeTextBuilder.js

@@ -64,8 +64,10 @@ export class RelativeTimeTextBuilder {
             if (deltaContext.time.isDefined()) {
                 newContext = deltaContext;
             }
+            // 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) {
+            if (dayOfMonthDelta && sameYear && sameMonth && !noDay) {
                 switch (dayOfMonthDelta) {
                     case -1:
                         text = messages.day.before;
@@ -76,7 +78,7 @@ export class RelativeTimeTextBuilder {
                 }
             }
             else {
-                if (!dayOfMonth && sameYear) {
+                if (!dayOfMonth && sameYear && !noMonth) {
                     switch (deltaDurationMonth) {
                         case -1:
                             text = messages.month.before;
@@ -86,7 +88,7 @@ export class RelativeTimeTextBuilder {
                             break;
                     }
                 }
-                if (!month) {
+                if (!month && !noYear) {
                     switch (yearDelta) {
                         case -1:
                             text = messages.year.before;
@@ -96,7 +98,7 @@ export class RelativeTimeTextBuilder {
                             break;
                     }
                 }
-                if (!minutes) {
+                if (!minutes && previousTime.getHour() !== undefined) {
                     switch (hourDelta) {
                         case -1:
                             text = messages.hour.before;

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

@@ -90,6 +90,24 @@ describe("RelativeTimeTextBuilder", () => {
             expect(relativeTimeTextBuilder.build(previousContext, context)).toBe("the day after");
         }
     });
+    test("first day of a month page is not the day after the month", () => {
+        const monthContext = cmsTestUtil.time.newHtmlContext("1/9/4/7/07", "");
+        const firstDay = monthContext.clone();
+        firstDay.time.updateFromStr("1947-07-01");
+        expect(relativeTimeTextBuilder.build(monthContext, firstDay)).toBe("mardi 1");
+        const secondDay = firstDay.clone();
+        secondDay.time.updateFromStr("1947-07-02");
+        expect(relativeTimeTextBuilder.build(firstDay, secondDay)).toBe("le lendemain");
+    });
+    test("first month of a year page is not the month after the year", () => {
+        const yearContext = cmsTestUtil.time.newHtmlContext("1/9/4/7", "");
+        const january = yearContext.clone();
+        january.time.updateFromStr("1947-01");
+        expect(relativeTimeTextBuilder.build(yearContext, january)).toBe("janvier");
+        const february = january.clone();
+        february.time.updateFromStr("1947-02");
+        expect(relativeTimeTextBuilder.build(january, february)).toBe("le mois suivant");
+    });
     describe("hour", () => {
         test("next", () => {
             {

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

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

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

@@ -0,0 +1,27 @@
+import { RelativeTimeTextBuilder } from "./RelativeTimeTextBuilder.js";
+import { cmsTestUtil } from "../../test/CMSTestUtil.js";
+import { test } from "vitest";
+import { TimeTextBuilder } from "./TimeTextBuilder.js";
+import { Level0Duration } from "@rr0/time";
+test("x", () => {
+    const b = new RelativeTimeTextBuilder(new TimeTextBuilder(cmsTestUtil.intlOptions));
+    const prev = cmsTestUtil.time.newHtmlContext("1/9/4/7/07", "");
+    console.log("prev", prev.time.toString(), prev.time.getDayOfMonth());
+    const ctx = prev.clone();
+    ctx.time.updateFromStr("1947-07-01");
+    const ms = ctx.time.date.compare(prev.time.date);
+    console.log("ctx", ctx.time.toString(), ms, JSON.stringify(Level0Duration.toSpec(ms)));
+    console.log(b.build(prev, ctx));
+    const c2 = ctx.clone();
+    c2.time.updateFromStr("1947-07-02");
+    const ms2 = c2.time.date.compare(prev.time.date);
+    console.log(ms2, JSON.stringify(Level0Duration.toSpec(ms2)), b.build(prev, c2));
+});
+test("y", () => {
+    const b = new RelativeTimeTextBuilder(new TimeTextBuilder(cmsTestUtil.intlOptions));
+    const prev = cmsTestUtil.time.newHtmlContext("1/9/4/7", "");
+    const ctx = prev.clone();
+    ctx.time.updateFromStr("1947-01");
+    const ms = ctx.time.date.compare(prev.time.date);
+    console.log("Y", prev.time.toString(), ctx.time.toString(), ms, JSON.stringify(Level0Duration.toSpec(ms)), b.build(prev, ctx));
+});

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.68",
+  "version": "0.3.70",
   "description": "RR0 Content Management System (CMS)",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -29,7 +29,7 @@
     "test-ci": "vitest run"
   },
   "dependencies": {
-    "@javarome/fileutil": "^0.3.7",
+    "@javarome/fileutil": "^0.3.9",
     "@rr0/common": "^1.1.5",
     "@rr0/data": "^0.3.43",
     "@rr0/lang": "^0.1.13",
@@ -41,7 +41,7 @@
     "image-size": "^2.0.2",
     "jsdom": "^27.4.0",
     "selenium-webdriver": "^4.39.0",
-    "ssg-api": "^1.18.2"
+    "ssg-api": "^1.18.3"
   },
   "devDependencies": {
     "@types/jsdom": "^21.1.7",