@rr0/cms 0.3.80 → 0.3.81

package/dist/time/TimeContext.test.mjs

@@ -60,7 +60,7 @@ describe("TimeContext", () => {
         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)"]) {
+        for (const str of ["1957-02-27 21:45PST", "1991-09-18 00:38:42PDT"]) {
             const context = new TimeContext();
             expect(context.updateFromStr(str)).toBe(true);
             expect(context.duration).toBeUndefined();

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

@@ -0,0 +1,36 @@
+import { Level2Date, Level2Duration } from "@rr0/time";
+/**
+ * The `datetime` attribute of a <time> and the EDTF it comes from.
+ *
+ * HTML knows its own formats only: a year, month, date, local or global date and time ("2004-06-11T09:12:33.123+01:00"),
+ * and durations in days, hours, minutes and seconds ("P1DT2H30M"). EDTF is richer: qualified values ("2004-~06", "~P2H"),
+ * a time zone written "+01", years and months in durations. So `datetime` holds what HTML can express, and what it cannot
+ * is kept as it was written in `data-edtf`, which is only set when it differs from `datetime`.
+ */
+export declare class HtmlDatetime {
+    /**
+     * Sets the attributes of a <time> element for a time.
+     *
+     * @param el The element to set the attributes of.
+     * @param time The time the element is about.
+     */
+    static apply(el: HTMLElement, time: Level2Date | Level2Duration): void;
+    /**
+     * @return The `datetime` value that HTML can read for a time, or undefined if HTML has no equivalent.
+     */
+    static of(time: Level2Date | Level2Duration): string | undefined;
+    protected static ofDate(date: Level2Date): string | undefined;
+    protected static ofDuration(duration: Level2Duration): string | undefined;
+    /**
+     * @return The numeric value of a component, if it has one (not a range of values, as for unspecified digits) within bounds.
+     */
+    protected static value(comp: {
+        value: unknown;
+    } | undefined, min: number, max?: number): number | undefined;
+    protected static pad(n: number): string;
+    /**
+     * @param minutes The time zone offset, in minutes east of UTC.
+     * @return The time zone offset as HTML writes it ("Z", "+01:00").
+     */
+    protected static offset(minutes: number): string;
+}

package/dist/time/html/HtmlDatetime.js

@@ -0,0 +1,102 @@
+import { Level2Duration } from "@rr0/time";
+/**
+ * The `datetime` attribute of a <time> and the EDTF it comes from.
+ *
+ * HTML knows its own formats only: a year, month, date, local or global date and time ("2004-06-11T09:12:33.123+01:00"),
+ * and durations in days, hours, minutes and seconds ("P1DT2H30M"). EDTF is richer: qualified values ("2004-~06", "~P2H"),
+ * a time zone written "+01", years and months in durations. So `datetime` holds what HTML can express, and what it cannot
+ * is kept as it was written in `data-edtf`, which is only set when it differs from `datetime`.
+ */
+export class HtmlDatetime {
+    /**
+     * Sets the attributes of a <time> element for a time.
+     *
+     * @param el The element to set the attributes of.
+     * @param time The time the element is about.
+     */
+    static apply(el, time) {
+        const datetime = HtmlDatetime.of(time);
+        if (datetime !== undefined) {
+            el.dateTime = datetime;
+        }
+        const edtf = time.toString();
+        if (edtf !== datetime) {
+            el.dataset.edtf = edtf;
+        }
+    }
+    /**
+     * @return The `datetime` value that HTML can read for a time, or undefined if HTML has no equivalent.
+     */
+    static of(time) {
+        return time instanceof Level2Duration ? HtmlDatetime.ofDuration(time) : HtmlDatetime.ofDate(time);
+    }
+    static ofDate(date) {
+        var _a;
+        const year = HtmlDatetime.value(date.year, 1);
+        if (year === undefined) {
+            return undefined;
+        }
+        let str = String(year).padStart(4, "0");
+        const month = HtmlDatetime.value(date.month, 1, 12); // Seasons (21 to 24) are no month
+        if (month === undefined) {
+            return str;
+        }
+        str += "-" + HtmlDatetime.pad(month);
+        const day = HtmlDatetime.value(date.day, 1, 31);
+        if (day === undefined) {
+            return str;
+        }
+        str += "-" + HtmlDatetime.pad(day);
+        const hour = HtmlDatetime.value(date.hour, 0, 23);
+        const minute = HtmlDatetime.value(date.minute, 0, 59);
+        if (hour === undefined || minute === undefined) { // HTML has no time without minutes
+            return str;
+        }
+        str += "T" + HtmlDatetime.pad(hour) + ":" + HtmlDatetime.pad(minute);
+        const second = HtmlDatetime.value(date.second, 0, 59);
+        if (second !== undefined) {
+            str += ":" + HtmlDatetime.pad(second);
+            const millisecond = HtmlDatetime.value(date.millisecond, 0, 999); // @rr0/time 1.1.0
+            if (millisecond !== undefined) {
+                str += "." + String(millisecond).padStart(3, "0");
+            }
+        }
+        const timeshift = (_a = date.timeshift) === null || _a === void 0 ? void 0 : _a.value;
+        if (typeof timeshift === "number" && Number.isInteger(timeshift)) {
+            str += HtmlDatetime.offset(timeshift);
+        }
+        return str;
+    }
+    static ofDuration(duration) {
+        const spec = duration.toSpec();
+        if (spec.years || spec.months) { // HTML durations have no years nor months, whose length depends on the date
+            return undefined;
+        }
+        const numbers = [spec.days, spec.hours, spec.minutes, spec.seconds].map(comp => HtmlDatetime.value(comp, 0));
+        const [days, hours, minutes, seconds] = numbers;
+        const time = (hours ? hours + "H" : "") + (minutes ? minutes + "M" : "") + (seconds ? seconds + "S" : "");
+        const str = (days ? days + "D" : "") + (time ? "T" + time : "");
+        return str ? "P" + str : undefined;
+    }
+    /**
+     * @return The numeric value of a component, if it has one (not a range of values, as for unspecified digits) within bounds.
+     */
+    static value(comp, min, max = Number.MAX_SAFE_INTEGER) {
+        const value = comp === null || comp === void 0 ? void 0 : comp.value;
+        return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max ? value : undefined;
+    }
+    static pad(n) {
+        return String(n).padStart(2, "0");
+    }
+    /**
+     * @param minutes The time zone offset, in minutes east of UTC.
+     * @return The time zone offset as HTML writes it ("Z", "+01:00").
+     */
+    static offset(minutes) {
+        if (minutes === 0) {
+            return "Z";
+        }
+        const abs = Math.abs(minutes);
+        return (minutes < 0 ? "-" : "+") + HtmlDatetime.pad(Math.floor(abs / 60)) + ":" + HtmlDatetime.pad(abs % 60);
+    }
+}

package/dist/time/html/HtmlDatetime.test.d.ts

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

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

@@ -0,0 +1,80 @@
+import { describe, expect, test } from "vitest";
+import { Level2Date, Level2Duration } from "@rr0/time";
+import { HtmlDatetime } from "./HtmlDatetime.js";
+import { cmsTestUtil } from "../../test/CMSTestUtil.js";
+describe("HtmlDatetime", () => {
+    describe("date", () => {
+        test.each([
+            ["2004", "2004"],
+            ["0033", "0033"],
+            ["2004-06", "2004-06"],
+            ["2004-06-11", "2004-06-11"],
+            ["2004-06-11T09:12", "2004-06-11T09:12"],
+            ["2004-06-11T09:12:33", "2004-06-11T09:12:33"],
+            ["2004-06-11 09:12", "2004-06-11T09:12"],
+            ["2004-06-11T09:12:33Z", "2004-06-11T09:12:33Z"],
+            ["2004-06-11T09:12:33+01", "2004-06-11T09:12:33+01:00"],
+            ["2004-06-11T09:12-05", "2004-06-11T09:12-05:00"],
+            ["1947-06-24 21:45PST", "1947-06-24T21:45-08:00"]
+        ])("%s is %s", (edtf, expected) => {
+            expect(HtmlDatetime.of(Level2Date.fromString(edtf))).toBe(expected);
+        });
+        test("qualification is not part of the HTML value", () => {
+            expect(HtmlDatetime.of(Level2Date.fromString("2004-~06"))).toBe("2004-06");
+            expect(HtmlDatetime.of(Level2Date.fromString("2004-06~"))).toBe("2004-06");
+            expect(HtmlDatetime.of(Level2Date.fromString("?2004-06-11"))).toBe("2004-06-11");
+        });
+        test("an hour without minutes has no HTML equivalent, the date remains", () => {
+            expect(HtmlDatetime.of(new Level2Date({ year: 2004, month: 6, day: 11, hour: 9 }))).toBe("2004-06-11");
+        });
+        test("a season is no month", () => {
+            expect(HtmlDatetime.of(Level2Date.fromString("2004-21"))).toBe("2004");
+        });
+        test("a year before 1 has no HTML equivalent", () => {
+            expect(HtmlDatetime.of(Level2Date.fromString("-0033"))).toBeUndefined();
+        });
+    });
+    describe("duration", () => {
+        test.each([
+            ["P2D", "P2D"],
+            ["P20H", "PT20H"],
+            ["P90S", "PT1M30S"],
+            ["P2D10H23M45S", "P2DT10H23M45S"],
+            ["PT30M", "PT30M"]
+        ])("%s is %s", (edtf, expected) => {
+            expect(HtmlDatetime.of(Level2Duration.fromString(edtf))).toBe(expected);
+        });
+        test("months are written MM in the former notation, and have no HTML equivalent", () => {
+            expect(HtmlDatetime.of(Level2Duration.fromString("P2MM"))).toBeUndefined();
+        });
+        test("years have no HTML equivalent", () => {
+            expect(HtmlDatetime.of(Level2Duration.fromString("P1Y"))).toBeUndefined();
+        });
+        test("qualification is not part of the HTML value", () => {
+            expect(HtmlDatetime.of(Level2Duration.fromString("~P20H"))).toBe("PT20H");
+        });
+    });
+    describe("element", () => {
+        const newTimeEl = () => cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "").file.document.createElement("time");
+        test("data-edtf is not set when HTML reads the same value", () => {
+            const timeEl = newTimeEl();
+            HtmlDatetime.apply(timeEl, Level2Date.fromString("2004-06-11"));
+            expect(timeEl.getAttribute("datetime")).toBe("2004-06-11");
+            expect(timeEl.hasAttribute("data-edtf")).toBe(false);
+        });
+        test("data-edtf holds the EDTF when HTML reads it differently", () => {
+            const timeEl = newTimeEl();
+            const date = Level2Date.fromString("2004-06-11T09:12+01");
+            HtmlDatetime.apply(timeEl, date);
+            expect(timeEl.getAttribute("datetime")).toBe("2004-06-11T09:12+01:00");
+            expect(timeEl.getAttribute("data-edtf")).toBe(date.toString());
+        });
+        test("data-edtf holds the EDTF when HTML has no equivalent, and then datetime is not set", () => {
+            const timeEl = newTimeEl();
+            const duration = Level2Duration.fromString("P2MM");
+            HtmlDatetime.apply(timeEl, duration);
+            expect(timeEl.hasAttribute("datetime")).toBe(false);
+            expect(timeEl.getAttribute("data-edtf")).toBe(duration.toString());
+        });
+    });
+});

package/dist/time/html/TimeElementFactory.js

@@ -77,7 +77,6 @@ export class TimeElementFactory {
         const duration = context.time.duration;
         const items = [];
         const messages = context.messages.context.time.duration;
-        const datetime = duration.toString();
         const spec = duration.toSpec();
         const days = spec.days;
         if (days) {
@@ -105,7 +104,7 @@ export class TimeElementFactory {
             if (context.time.approximate) {
                 replacementStr = messages.approximate(replacementStr);
             }
-            replacement = TimeReplacer.resolvedTime(context, datetime);
+            replacement = TimeReplacer.resolvedTime(context, duration);
             replacement.classList.add("duration");
             replacement.textContent = replacementStr;
         }

package/dist/time/html/TimeRenderer.js

@@ -28,7 +28,7 @@ export class TimeRenderer {
         const currentFileName = file.name;
         const doc = file.document;
         let replacement;
-        const timeEl = TimeReplacer.resolvedTime(context, date.toString());
+        const timeEl = TimeReplacer.resolvedTime(context, date);
         if (title !== text) {
             timeEl.title = title;
         }

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

@@ -1,5 +1,6 @@
 import { HtmlRR0Context } from "../../RR0Context.js";
 import { DomReplacement } from "../DomReplacement.js";
+import { Level2Date, Level2Duration } from "@rr0/time";
 import { TimeElementFactory } from "./TimeElementFactory.js";
 import { TimeRenderOptions } from "./TimeRenderer.js";
 import { TimeStringCompleter } from "./TimeStringCompleter.js";
@@ -15,7 +16,11 @@ export declare class TimeReplacer implements DomReplacement<HtmlRR0Context, HTML
     static readonly inlineTags: string[];
     protected readonly completer: TimeStringCompleter;
     constructor(factory: TimeElementFactory);
-    static resolvedTime(context: HtmlRR0Context, dateTime: string): HTMLTimeElement;
+    /**
+     * @param context The context to create the element in.
+     * @param time The time the element is about, which `datetime` and `data-edtf` are set from.
+     */
+    static resolvedTime(context: HtmlRR0Context, time: Level2Date | Level2Duration): HTMLTimeElement;
     /**
      * @return The text that precedes an element in its sentence.
      */

package/dist/time/html/TimeReplacer.js

@@ -1,4 +1,5 @@
 import { ObjectUtils } from "@rr0/common";
+import { HtmlDatetime } from "./HtmlDatetime.js";
 import { TimeStringCompleter } from "./TimeStringCompleter.js";
 /**
  * Replaces a <time> tag.
@@ -8,9 +9,13 @@ export class TimeReplacer {
         this.factory = factory;
         this.completer = new TimeStringCompleter();
     }
-    static resolvedTime(context, dateTime) {
+    /**
+     * @param context The context to create the element in.
+     * @param time The time the element is about, which `datetime` and `data-edtf` are set from.
+     */
+    static resolvedTime(context, time) {
         const replacement = context.file.document.createElement("time");
-        replacement.dateTime = dateTime;
+        HtmlDatetime.apply(replacement, time);
         return replacement;
     }
     /**
@@ -34,7 +39,7 @@ export class TimeReplacer {
     }
     async replacement(pageContext, origEl) {
         let replacement;
-        if (origEl.dateTime || origEl.dataset.format === "none") { // Already done, or not to be interpreted
+        if (origEl.dateTime || origEl.dataset.edtf || origEl.dataset.format === "none") { // Already done, or not to be interpreted
             replacement = origEl;
         }
         else {

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

@@ -153,7 +153,7 @@ describe("TimeReplacer", async () => {
             original.textContent = "2003-12-24T10:22CDT";
             const replacement = await replacer.replacement(context, original);
             expect(replacement.outerHTML)
-                .toBe(`<span class="time-resolved"><a href="${path.join("/", timeOptions.rootDir, "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
+                .toBe(`<span class="time-resolved"><a href="${path.join("/", timeOptions.rootDir, "2/0/0/3/12/24/")}"><time datetime="2003-12-24T10:22-05:00" data-edtf="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);
@@ -262,7 +262,7 @@ describe("TimeReplacer", async () => {
             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>`);
+            expect(replacement.outerHTML).toBe(`<time datetime="P2DT10H23M45S" data-edtf="${datetime}" class="duration">2 jours, 10 heures, 23 minutes et 45 secondes</time>`);
         });
         test("with context", async () => {
             const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
@@ -276,7 +276,7 @@ describe("TimeReplacer", async () => {
                 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>`);
+                expect(replacement.outerHTML).toBe(`<time datetime="PT20M" data-edtf="P20M" class="duration">20 minutes</time>`);
             }
         });
         test("with approximation", async () => {
@@ -284,7 +284,7 @@ describe("TimeReplacer", async () => {
             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>`);
+            expect(replacement.outerHTML).toBe(`<time datetime="PT2H" data-edtf="P~2H" class="duration">environ 2 heures</time>`);
         });
     });
     describe("parses hour", () => {
@@ -374,6 +374,20 @@ describe("TimeReplacer", 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("a time zone in parentheses, as pages write it, is read as a time zone", async () => {
+            var _a, _b;
+            for (const str of ["1947-06-24 21:45 (PST)", "1947-06-24 21:45 PST"]) {
+                const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+                expect(await render(context, str)).toBe("mardi 24 juin 1947 à 21:45");
+                expect((_b = (_a = context.time.date) === null || _a === void 0 ? void 0 : _a.timeshift) === null || _b === void 0 ? void 0 : _b.value, str).toBe(-480);
+            }
+        });
+        test("a sidereal time is not a time zone, and is kept as text", async () => {
+            var _a;
+            const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+            expect(await render(context, "1967-05-13 15:40 (LST)")).toBe("samedi 13 mai 1967 à 15:40 (LST)");
+            expect((_a = context.time.date) === null || _a === void 0 ? void 0 : _a.timeshift).toBeUndefined();
+        });
         test("time inside a link gets no link of its own", async () => {
             const context = cmsTestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
             const doc = context.file.document;

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

@@ -20,6 +20,12 @@ 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;
+    /**
+     * @param str A word following a time.
+     * @return The time zone it names, as EDTF writes it right after the time ("EST" for "(EST)"), or undefined if it is not a time zone
+     * EDTF knows ("(LST)" is a local sidereal time, whose offset is unknown, so it remains free text).
+     */
+    protected static zone(str: string): string | undefined;
     /**
      * A duration ("P10M", "~P1H"), or a range of durations ("P10M/12M").
      */

package/dist/time/html/TimeStringCompleter.js

@@ -1,3 +1,4 @@
+import { timeZones } from "@rr0/time";
 import { TimeContext } from "../TimeContext.mjs";
 /**
  * Prepares a <time> string for EDTF parsing.
@@ -8,6 +9,16 @@ import { TimeContext } from "../TimeContext.mjs";
  * first. Free text written around the value ("le soir", "vers") is set apart so that it can be kept as is.
  */
 export class TimeStringCompleter {
+    /**
+     * @param str A word following a time.
+     * @return The time zone it names, as EDTF writes it right after the time ("EST" for "(EST)"), or undefined if it is not a time zone
+     * EDTF knows ("(LST)" is a local sidereal time, whose offset is unknown, so it remains free text).
+     */
+    static zone(str) {
+        var _a;
+        const name = (_a = TimeStringCompleter.timeZone.exec(str)) === null || _a === void 0 ? void 0 : _a[1];
+        return name && (/^UTC[+-]?\d*$/.test(name) || timeZones.some(zone => zone.name === name && zone.timeshift !== "?")) ? name : undefined;
+    }
     split(str) {
         let prefix = "";
         let value = str.replace(/[ \t\r\n]+/g, " ").trim(); // "1973-10-11\n      21:00/22:00"
@@ -23,9 +34,15 @@ export class TimeStringCompleter {
         // 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];
+        if (post && !quantity) {
+            const zone = TimeStringCompleter.zone(post[3].trim());
+            if (zone) {
+                value = post[1] + zone; // EDTF reads "21:45EST", not "21:45 EST" nor "21:45 (EST)"
+            }
+            else {
+                value = post[1];
+                suffix = (post[2].includes("T") ? " " : post[2]) + post[3];
+            }
         }
         return { prefix, value, suffix };
     }
@@ -121,7 +138,7 @@ export class TimeStringCompleter {
 /**
  * A trailing time zone ("PST", "(CDT)", "UTC+1") is part of the value, not free text.
  */
-TimeStringCompleter.timeZone = /^\(?(?:[A-Z]{1,5}|UTC[+-]?\d*)\)?$/;
+TimeStringCompleter.timeZone = /^\(?([A-Z]{1,5}|UTC[+-]?\d*)\)?$/;
 /**
  * A duration ("P10M", "~P1H"), or a range of durations ("P10M/12M").
  */

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.80",
+  "version": "0.3.81",
   "description": "RR0 Content Management System (CMS)",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -31,10 +31,10 @@
   "dependencies": {
     "@javarome/fileutil": "^0.3.9",
     "@rr0/common": "^1.1.5",
-    "@rr0/data": "^0.3.47",
+    "@rr0/data": "^0.3.48",
     "@rr0/lang": "^0.1.13",
     "@rr0/place": "^0.5.4",
-    "@rr0/time": "^1.0.0",
+    "@rr0/time": "^2.0.0",
     "canvas": "^3.2.1",
     "csv-parser": "^3.2.0",
     "glob": "^11.0.3",