@rr0/cms 0.3.67 → 0.3.69

package/dist/CMSGenerator.test.js

@@ -24,6 +24,15 @@ import { PlaceReplacerFactory } from "./place/PlaceReplacerFactory.js";
 import { IndexedReplacerFactory } from "./index/IndexedReplacerFactory.js";
 import { UnitReplaceCommand } from "./value/UnitReplaceCommand.js";
 import { cmsTestUtil } from "./test/CMSTestUtil.js";
+/**
+ * Chronological order: a period's page comes before the pages of its sub-periods ("1960" before "April 1960"),
+ * which a plain sort does not do since "04/index.html" < "index.html".
+ */
+function periodFirst(a, b) {
+    const dirA = a.substring(0, a.lastIndexOf("/") + 1);
+    const dirB = b.substring(0, b.lastIndexOf("/") + 1);
+    return dirA < dirB ? -1 : dirA > dirB ? 1 : 0;
+}
 export async function getTimeFiles() {
     const minusYearFiles = await glob(cmsTestUtil.filePath("time/-?/?/?/?/index.html"));
     const year1Files = await glob(cmsTestUtil.filePath("time/?/index.html"));
@@ -32,7 +41,7 @@ export async function getTimeFiles() {
     const year4Files = await glob(cmsTestUtil.filePath("time/?/?/?/?/index.html"));
     const monthFiles = await glob(cmsTestUtil.filePath("time/?/?/?/?/??/index.html"));
     const dayFiles = await glob(cmsTestUtil.filePath("time/?/?/?/?/??/??/index.html"));
-    return year1Files.concat(year2Files).concat(year3Files).concat(year4Files).concat(minusYearFiles).concat(monthFiles).concat(dayFiles).sort();
+    return year1Files.concat(year2Files).concat(year3Files).concat(year4Files).concat(minusYearFiles).concat(monthFiles).concat(dayFiles).sort(periodFirst);
 }
 describe("Build", () => {
     console.time("ssg");

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/TimeLinkDefaultHandler.d.ts

@@ -9,9 +9,16 @@ export declare class TimeLinkDefaultHandler implements LinkHandler<HtmlRR0Contex
     protected urlBuilder: TimeUrlBuilder;
     protected timeTextBuilder: TimeTextBuilder;
     constructor(service: TimeService, urlBuilder: TimeUrlBuilder, timeTextBuilder: TimeTextBuilder);
+    /**
+     * The period containing the page (the year of a month, the month of a day...), which lists it.
+     */
     contents(context: HtmlRR0Context): Link | undefined;
     next(context: HtmlRR0Context): Link | undefined;
     prev(context: HtmlRR0Context): Link | undefined;
     start(context: HtmlRR0Context): Link | undefined;
+    /**
+     * A decade, century or millennium cannot be told from a year by its path's date, so its page's own title is used.
+     */
+    protected titleOf(context: HtmlRR0Context, fileName: string): string | undefined;
     protected isTimeFile(fileName: string): boolean;
 }

package/dist/time/TimeLinkDefaultHandler.js

@@ -1,19 +1,25 @@
 import { LinkType } from "ssg-api";
+import { existsSync, readFileSync } from "fs";
 export class TimeLinkDefaultHandler {
     constructor(service, urlBuilder, timeTextBuilder) {
         this.service = service;
         this.urlBuilder = urlBuilder;
         this.timeTextBuilder = timeTextBuilder;
     }
+    /**
+     * The period containing the page (the year of a month, the month of a day...), which lists it.
+     */
     contents(context) {
-        const prevLink = this.prev(context);
-        if (prevLink) {
-            const urlBuilder = this.urlBuilder;
-            let contentUrl = urlBuilder.matchExistingTimeFile(prevLink.url.substring(1));
-            if (contentUrl != urlBuilder.options.rootDir) {
-                const text = this.service.titleFromFile(context, contentUrl, this.timeTextBuilder);
+        const fileName = context.file.name;
+        if (this.isTimeFile(fileName)) {
+            const pageDir = fileName.substring(0, fileName.lastIndexOf("/"));
+            const parentDir = pageDir.substring(0, pageDir.lastIndexOf("/"));
+            const contentUrl = this.urlBuilder.matchExistingTimeFile(parentDir);
+            if (contentUrl) {
+                const contentFile = contentUrl + "/index.html";
+                const text = this.titleOf(context, contentFile);
                 if (text) {
-                    return { type: LinkType.prev, text, url: "/" + contentUrl };
+                    return { type: LinkType.contents, text, url: "/" + contentFile };
                 }
             }
         }
@@ -26,7 +32,7 @@ export class TimeLinkDefaultHandler {
             if (pos >= 0) {
                 const nextFile = service.files[pos + 1];
                 if (nextFile) {
-                    const text = service.titleFromFile(context, nextFile, this.timeTextBuilder);
+                    const text = this.titleOf(context, nextFile);
                     return { type: LinkType.next, text, url: "/" + nextFile };
                 }
             }
@@ -40,7 +46,7 @@ export class TimeLinkDefaultHandler {
             if (pos >= 0) {
                 const prevFile = service.files[pos - 1];
                 if (prevFile) {
-                    const text = service.titleFromFile(context, prevFile, this.timeTextBuilder);
+                    const text = this.titleOf(context, prevFile);
                     if (text) {
                         return { type: LinkType.prev, text, url: "/" + prevFile };
                     }
@@ -51,13 +57,28 @@ export class TimeLinkDefaultHandler {
     start(context) {
         if (this.isTimeFile(context.file.name)) {
             return {
-                type: LinkType.contents,
+                type: LinkType.start,
                 text: "Chronologie",
                 url: "/time/"
             };
         }
     }
+    /**
+     * A decade, century or millennium cannot be told from a year by its path's date, so its page's own title is used.
+     */
+    titleOf(context, fileName) {
+        var _a;
+        const rootDir = this.urlBuilder.options.rootDir;
+        const digits = fileName.substring(rootDir.length + 1).split("/").length - 1;
+        if (digits < 4 && existsSync(fileName)) {
+            const title = (_a = /<title>([^<]*)<\/title>/.exec(readFileSync(fileName, "utf-8"))) === null || _a === void 0 ? void 0 : _a[1].trim();
+            if (title) {
+                return title;
+            }
+        }
+        return this.service.titleFromFile(context, fileName, this.timeTextBuilder);
+    }
     isTimeFile(fileName) {
-        return fileName.startsWith("time/");
+        return fileName.startsWith(this.urlBuilder.options.rootDir + "/");
     }
 }

package/dist/time/TimeLinkDefaultHandler.test.d.ts

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

package/dist/time/TimeLinkDefaultHandler.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "vitest";
+import { LinkType } from "ssg-api";
+import { cmsTestUtil } from "../test/CMSTestUtil.js";
+import { TimeLinkDefaultHandler } from "./TimeLinkDefaultHandler.js";
+describe("TimeLinkDefaultHandler", () => {
+    const rootDir = cmsTestUtil.filePath("time");
+    const files = [
+        "1/9/5/4/10/index.html",
+        "1/9/7/index.html",
+        "1/9/7/0/index.html",
+        "1/9/7/0/03/index.html",
+        "1/9/7/0/11/index.html",
+        "1/9/9/0/index.html"
+    ].map(file => rootDir + "/" + file);
+    const url = (file) => "/" + rootDir + "/" + file;
+    const timeUtil = cmsTestUtil.time;
+    const service = timeUtil.getService({ rootDir, files });
+    const handler = new TimeLinkDefaultHandler(service, timeUtil.urlBuilder, timeUtil.timeTextBuilder);
+    const context = cmsTestUtil.newHtmlContext("time/1/9/7/0/11/index.html", "<html><body></body></html>");
+    test("start is the chronology", () => {
+        expect(handler.start(context)).toEqual({ type: LinkType.start, text: "Chronologie", url: "/time/" });
+    });
+    test("contents is the period containing the page, not the previous page", () => {
+        const contents = handler.contents(context);
+        expect(contents.type).toBe(LinkType.contents);
+        expect(contents.url).toBe(url("1/9/7/0/index.html"));
+        expect(contents.text).toBe("1970");
+    });
+    test("prev and next follow the files order", () => {
+        expect(handler.prev(context).url).toBe(url("1/9/7/0/03/index.html"));
+        expect(handler.next(context).url).toBe(url("1/9/9/0/index.html"));
+    });
+    test("a decade is titled by its page, not as the year its path starts with", () => {
+        const yearContext = cmsTestUtil.newHtmlContext("time/1/9/7/0/index.html", "<html><body></body></html>");
+        const contents = handler.contents(yearContext);
+        expect(contents.url).toBe(url("1/9/7/index.html"));
+        expect(contents.text).toBe("1970s");
+    });
+    test("a page below a period without page is listed by the nearest one", () => {
+        const dayContext = cmsTestUtil.newHtmlContext("time/1/9/5/4/10/01/index.html", "<html><body></body></html>");
+        expect(handler.contents(dayContext).url).toBe(url("1/9/5/4/10/index.html"));
+    });
+});

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.67",
+  "version": "0.3.69",
   "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",