@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/exslt/dateParse.js

@@ -0,0 +1,265 @@
+/**
+ * Parsing of the XML Schema date/time lexical forms used by the EXSLT
+ * dates-and-times module, ported from libexslt `date.c` (`exsltDateParse`).
+ * Date values are described in `./calendar.js`.
+ */
+
+"use strict";
+
+import { DateType, createDate, isValidDate, isValidTime } from "./calendar.js";
+
+/** Largest integer the parsers accept, the analogue of C `LONG_MAX`. */
+const MAX_NUMBER = Number.MAX_SAFE_INTEGER;
+
+/**
+ * A cursor over the text being parsed, mirroring libexslt's `cur` pointer.
+ */
+class Cursor {
+  /** @param {string} text - The text */
+  constructor(text) {
+    this.text = text;
+    this.at = 0;
+  }
+
+  /** @returns {string} The current character, "" at the end */
+  get char() {
+    return this.text.charAt(this.at);
+  }
+
+  /** @returns {boolean} Whether the current character is a digit */
+  get isDigit() {
+    const char = this.char;
+    return char >= "0" && char <= "9";
+  }
+
+  /**
+   * Read two digits (libexslt `PARSE_2_DIGITS`), advancing past them.
+   *
+   * @param {(value: number) => boolean} valid - Range check
+   * @returns {number|null} The value, null when invalid
+   */
+  twoDigits(valid) {
+    const digits = this.text.substring(this.at, this.at + 2);
+    this.at += 2;
+    if (!/^\d\d$/.test(digits)) return null;
+    const value = Number(digits);
+    return valid(value) ? value : null;
+  }
+}
+
+const inRange = (min, max) => (value) => value >= min && value <= max;
+
+/**
+ * Parse a time zone ("", "Z" or "±hh:mm"); updates `dt` and the cursor only
+ * as far as libexslt does.
+ *
+ * @param {object} dt - Date value
+ * @param {Cursor} cur - Cursor at the time zone
+ * @returns {boolean} True when a time zone was parsed
+ */
+function parseTimeZone(dt, cur) {
+  const sign = cur.char;
+  if (sign === "") {
+    dt.tzFlag = false;
+    dt.tzo = 0;
+    return true;
+  }
+  if (sign === "Z") {
+    dt.tzFlag = true;
+    dt.tzo = 0;
+    cur.at++;
+    return true;
+  }
+  if (sign !== "+" && sign !== "-") return false;
+
+  const probe = new Cursor(cur.text);
+  probe.at = cur.at + 1;
+  const hours = probe.twoDigits(inRange(0, 23));
+  if (hours === null || probe.char !== ":") return false;
+  probe.at++;
+  dt.tzo = hours * 60;
+  const minutes = probe.twoDigits(inRange(0, 59));
+  if (minutes === null) return false;
+  dt.tzo = (dt.tzo + minutes) * (sign === "-" ? -1 : 1);
+  cur.at = probe.at;
+  return true;
+}
+
+/**
+ * Parse "hh:mm:ss(.s+)?" into `dt` (libexslt `_exsltDateParseTime`).
+ *
+ * @param {object} dt - Date value
+ * @param {Cursor} cur - Cursor at the time
+ * @returns {boolean} True when a valid time was parsed
+ */
+function parseTime(dt, cur) {
+  const hour = cur.twoDigits(inRange(0, 23));
+  if (hour === null || cur.char !== ":") return false;
+  cur.at++;
+  dt.hour = hour;
+  const min = cur.twoDigits(inRange(0, 59));
+  if (min === null) return false;
+  dt.min = min;
+  if (cur.char !== ":") return false;
+  cur.at++;
+
+  const seconds = cur.twoDigits(() => true);
+  if (seconds === null) return false;
+  let sec = seconds;
+  if (cur.char === ".") {
+    cur.at++;
+    if (!cur.isDigit) return false;
+    let scale = 1;
+    while (cur.isDigit) {
+      scale /= 10;
+      sec += Number(cur.char) * scale;
+      cur.at++;
+    }
+  }
+  dt.sec = sec;
+  return isValidTime(dt);
+}
+
+/**
+ * Parse a year of at least four digits (libexslt `_exsltDateParseGYear`).
+ *
+ * @param {object} dt - Date value
+ * @param {Cursor} cur - Cursor at the year
+ * @returns {boolean} True when a valid year was parsed
+ */
+function parseYear(dt, cur) {
+  const match = /^(-?)(\d+)/.exec(cur.text.substring(cur.at));
+  if (!match) return false;
+  const digits = match[2];
+  // At least four digits, and no leading zero beyond four
+  const badLength =
+    digits.length < 4 || (digits.length > 4 && digits[0] === "0");
+  if (badLength) return false;
+  const year = Number(digits);
+  if (year === 0 || year >= MAX_NUMBER / 10) return false;
+  dt.year = match[1] ? 1 - year : year;
+  cur.at += match[0].length;
+  return true;
+}
+
+/** Outcomes of {@link typedByTimeZone}. */
+const Ending = Object.freeze({
+  TYPED: "typed",
+  NONE: "none",
+  INVALID: "invalid",
+});
+
+/**
+ * Parse a time zone that must end the text (libexslt `RETURN_TYPE_IF_VALID`).
+ *
+ * @param {object} dt - Date value, typed on success
+ * @param {Cursor} cur - Cursor after the date fields
+ * @param {number} type - Type of the value on success
+ * @returns {string} TYPED when the rest is a time zone, INVALID when a time
+ *   zone is followed by more text, NONE when parsing may go on
+ */
+function typedByTimeZone(dt, cur, type) {
+  if (!["", "Z", "+", "-"].includes(cur.char)) return Ending.NONE;
+  if (!parseTimeZone(dt, cur)) return Ending.NONE;
+  if (cur.at !== cur.text.length) return Ending.INVALID;
+  dt.type = type;
+  return Ending.TYPED;
+}
+
+/**
+ * Finish a form that must end with a time zone.
+ *
+ * @param {object} dt - Date value
+ * @param {Cursor} cur - Cursor after the date fields
+ * @param {number} type - Type of the value on success
+ * @returns {object|null} The typed value, null when invalid
+ */
+function endWithTimeZone(dt, cur, type) {
+  return typedByTimeZone(dt, cur, type) === Ending.TYPED ? dt : null;
+}
+
+/**
+ * Parse "--MM-DD", "--MM--" or "---DD", each followed by a time zone.
+ *
+ * @param {object} dt - Date value
+ * @param {Cursor} cur - Cursor after the leading "--"
+ * @returns {object|null} The date value, null when invalid
+ */
+function parseTruncatedDate(dt, cur) {
+  if (cur.char === "-") {
+    cur.at++;
+    dt.day = cur.twoDigits(inRange(1, 31));
+    return dt.day === null ? null : endWithTimeZone(dt, cur, DateType.GDAY);
+  }
+  dt.mon = cur.twoDigits(inRange(1, 12));
+  if (dt.mon === null || cur.char !== "-") return null;
+  cur.at++;
+  if (cur.char === "-") {
+    cur.at++;
+    return endWithTimeZone(dt, cur, DateType.GMONTH);
+  }
+  dt.day = cur.twoDigits(inRange(1, 31));
+  return dt.day === null ? null : endWithTimeZone(dt, cur, DateType.GMONTHDAY);
+}
+
+/**
+ * Fields after the year, each preceded by "-": the type a time zone after
+ * the previous field gives, and the parser of the field.
+ */
+const DATE_FIELDS = [
+  [
+    DateType.GYEAR,
+    (dt, cur) => {
+      dt.mon = cur.twoDigits(inRange(1, 12));
+      return dt.mon !== null;
+    },
+  ],
+  [
+    DateType.GYEARMONTH,
+    (dt, cur) => {
+      dt.day = cur.twoDigits(inRange(1, 31));
+      return dt.day !== null && isValidDate(dt);
+    },
+  ],
+];
+
+/**
+ * Parse any date/time form libexslt accepts (`exsltDateParse`): xs:dateTime,
+ * xs:date, xs:time, xs:gYearMonth, xs:gYear, xs:gMonthDay, xs:gMonth
+ * ("--MM--") and xs:gDay.
+ *
+ * @param {string} text - The lexical form
+ * @returns {object|null} The date value, null when invalid
+ */
+export function parseDate(text) {
+  const dt = createDate(0);
+  const cur = new Cursor(text);
+
+  if (text.startsWith("--")) {
+    cur.at = 2;
+    return parseTruncatedDate(dt, cur);
+  }
+
+  if (cur.isDigit && parseTime(dt, cur)) {
+    const ending = typedByTimeZone(dt, cur, DateType.TIME);
+    if (ending !== Ending.NONE) return ending === Ending.TYPED ? dt : null;
+  }
+
+  cur.at = 0;
+  if (!parseYear(dt, cur)) return null;
+  for (const [type, parseField] of DATE_FIELDS) {
+    const ending = typedByTimeZone(dt, cur, type);
+    if (ending !== Ending.NONE) return ending === Ending.TYPED ? dt : null;
+    if (cur.char !== "-") return null;
+    cur.at++;
+    if (!parseField(dt, cur)) return null;
+  }
+  const ending = typedByTimeZone(dt, cur, DateType.DATE);
+  if (ending !== Ending.NONE) return ending === Ending.TYPED ? dt : null;
+  if (cur.char !== "T") return null;
+  cur.at++;
+  if (!parseTime(dt, cur) || !parseTimeZone(dt, cur)) return null;
+  if (cur.at !== text.length || !isValidTime(dt)) return null;
+  dt.type = DateType.DATETIME;
+  return dt;
+}

package/src/xslt/exslt/dates.js

@@ -0,0 +1,259 @@
+/**
+ * EXSLT dates-and-times module (http://exslt.org/dates-and-times): the
+ * functions libexslt `date.c` implements. `format-date()`, `parse-date()`
+ * and the `date:date-format` element are not implemented by libexslt either.
+ *
+ * Invalid input yields the empty string for string results and NaN for
+ * numbers (and for `leap-year()`, as in libexslt). Without an argument the
+ * functions use the current local date and time, read from the clock.
+ */
+
+"use strict";
+
+import { expandedFunctionName } from "../../xpath/evaluator.js";
+import { EXSLT_DATES, checkArity, toNodeSet } from "./arguments.js";
+import {
+  DateType,
+  SECS_PER_DAY,
+  createDate,
+  dayInYear,
+  isLeapYear,
+} from "./calendar.js";
+import { parseDate } from "./dateParse.js";
+import {
+  addDuration,
+  dateDifference,
+  dayOfWeek,
+  hasYear,
+  secondsOf,
+  weekInMonth,
+  weekInYear,
+} from "./dateCalc.js";
+import {
+  formatByType,
+  formatDateOnly,
+  formatDateTime,
+  formatTimeOnly,
+} from "./dateFormat.js";
+import {
+  addDurations,
+  createDuration,
+  formatDuration,
+  parseDuration,
+} from "./duration.js";
+
+const MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December",
+];
+const DAY_NAMES = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday",
+];
+
+const { DATETIME, DATE, TIME, GYEAR, GYEARMONTH, GMONTH, GMONTHDAY, GDAY } =
+  DateType;
+
+/**
+ * The default clock: now, or `SOURCE_DATE_EPOCH` (seconds, read as UTC)
+ * when set, as libexslt does for reproducible builds.
+ *
+ * @returns {{getTime: () => number, getTimezoneOffset: () => number}} A Date-like instant
+ */
+export function systemClock() {
+  const epoch = Number.parseInt(
+    globalThis.process?.env?.SOURCE_DATE_EPOCH ?? "",
+    10,
+  );
+  if (Number.isNaN(epoch)) return new Date();
+  return { getTime: () => epoch * 1000, getTimezoneOffset: () => 0 };
+}
+
+/**
+ * The local date and time of an instant as a dateTime value, with the local
+ * offset but no explicit time zone (libexslt `exsltDateCurrent`).
+ *
+ * @param {{getTime: () => number, getTimezoneOffset: () => number}} now - A Date-like instant
+ * @returns {object} The date value
+ */
+export function currentDate(now) {
+  const tzo = -now.getTimezoneOffset();
+  const local = new Date(now.getTime() + tzo * 60000);
+  const dt = createDate(DATETIME);
+  dt.year = local.getUTCFullYear();
+  dt.mon = local.getUTCMonth() + 1;
+  dt.day = local.getUTCDate();
+  dt.hour = local.getUTCHours();
+  dt.min = local.getUTCMinutes();
+  dt.sec = local.getUTCSeconds();
+  dt.tzo = tzo;
+  return dt;
+}
+
+/**
+ * Build the EXSLT dates-and-times functions.
+ *
+ * @param {import('../../xpath/evaluator.js').XPathEvaluator} evaluator - Evaluates the arguments
+ * @param {() => {getTime: () => number, getTimezoneOffset: () => number}} [clock] - Current instant
+ * @returns {Object<string, Function>} Functions keyed by expanded name
+ */
+export function createDatesFunctions(evaluator, clock = systemClock) {
+  const string = (arg, ctx) => evaluator.toString(evaluator.evaluate(arg, ctx));
+  const key = (local) => expandedFunctionName(EXSLT_DATES, local);
+  const functions = {};
+
+  /**
+   * Register a function of an optional date argument.
+   *
+   * @param {string} local - Local name
+   * @param {number[]} types - Types accepted from the argument
+   * @param {(dt: object) => *} compute - Result from the date value
+   * @param {*} invalid - Result for an invalid or unaccepted argument
+   */
+  const define = (local, types, compute, invalid) => {
+    functions[key(local)] = (args, ctx) => {
+      checkArity(`date:${local}`, args, 0, 1);
+      const dt =
+        args.length === 0
+          ? currentDate(clock())
+          : parseDate(string(args[0], ctx));
+      if (dt === null || !types.includes(dt.type)) return invalid;
+      return compute(dt) ?? invalid;
+    };
+  };
+
+  const yearTypes = [DATETIME, DATE, GYEARMONTH, GYEAR];
+  const dayTypes = [DATETIME, DATE];
+  const timeTypes = [DATETIME, TIME];
+  const monthTypes = [DATETIME, DATE, GYEARMONTH, GMONTH, GMONTHDAY];
+  const weekday = (dt) =>
+    dayOfWeek(dayInYear(dt.day, dt.mon, dt.year), dt.year);
+
+  define("date", dayTypes, formatDateOnly, "");
+  define("time", timeTypes, formatTimeOnly, "");
+  define(
+    "year",
+    yearTypes,
+    (dt) => (dt.year <= 0 ? dt.year - 1 : dt.year),
+    Number.NaN,
+  );
+  define("leap-year", yearTypes, (dt) => isLeapYear(dt.year), Number.NaN);
+  define("month-in-year", monthTypes, (dt) => dt.mon, Number.NaN);
+  define("month-name", monthTypes, (dt) => MONTH_NAMES[dt.mon - 1], "");
+  define(
+    "month-abbreviation",
+    monthTypes,
+    (dt) => MONTH_NAMES[dt.mon - 1].substring(0, 3),
+    "",
+  );
+  define("week-in-year", dayTypes, weekInYear, Number.NaN);
+  define("week-in-month", dayTypes, weekInMonth, Number.NaN);
+  define(
+    "day-in-year",
+    dayTypes,
+    (dt) => dayInYear(dt.day, dt.mon, dt.year),
+    Number.NaN,
+  );
+  define(
+    "day-in-month",
+    [DATETIME, DATE, GMONTHDAY, GDAY],
+    (dt) => dt.day,
+    Number.NaN,
+  );
+  define(
+    "day-of-week-in-month",
+    dayTypes,
+    (dt) => Math.trunc((dt.day - 1) / 7) + 1,
+    Number.NaN,
+  );
+  define("day-in-week", dayTypes, (dt) => weekday(dt) + 1, Number.NaN);
+  define("day-name", dayTypes, (dt) => DAY_NAMES[weekday(dt)], "");
+  define(
+    "day-abbreviation",
+    dayTypes,
+    (dt) => DAY_NAMES[weekday(dt)].substring(0, 3),
+    "",
+  );
+  define("hour-in-day", timeTypes, (dt) => dt.hour, Number.NaN);
+  define("minute-in-hour", timeTypes, (dt) => dt.min, Number.NaN);
+  define("second-in-minute", timeTypes, (dt) => dt.sec, Number.NaN);
+
+  functions[key("date-time")] = (args) => {
+    checkArity("date:date-time", args, 0);
+    return formatDateTime(currentDate(clock())) ?? "";
+  };
+
+  functions[key("seconds")] = (args, ctx) => {
+    checkArity("date:seconds", args, 0, 1);
+    return secondsOf(
+      args.length === 0 ? currentDate(clock()) : string(args[0], ctx),
+    );
+  };
+
+  functions[key("duration")] = (args, ctx) => {
+    checkArity("date:duration", args, 0, 1);
+    const secs =
+      args.length === 0
+        ? secondsOf(currentDate(clock()))
+        : evaluator.toNumber(string(args[0], ctx));
+    if (!Number.isFinite(secs)) return "";
+    const dur = createDuration();
+    dur.day = Math.floor(secs / SECS_PER_DAY);
+    dur.sec = secs - dur.day * SECS_PER_DAY;
+    return formatDuration(dur);
+  };
+
+  functions[key("add")] = (args, ctx) => {
+    checkArity("date:add", args, 2);
+    const dt = parseDate(string(args[0], ctx));
+    const dur = parseDuration(string(args[1], ctx));
+    if (dt === null || !hasYear(dt) || dur === null) return "";
+    return formatByType(addDuration(dt, dur)) ?? "";
+  };
+
+  functions[key("add-duration")] = (args, ctx) => {
+    checkArity("date:add-duration", args, 2);
+    const x = parseDuration(string(args[0], ctx));
+    const y = parseDuration(string(args[1], ctx));
+    const sum = x === null || y === null ? null : addDurations(x, y);
+    return sum === null ? "" : formatDuration(sum);
+  };
+
+  functions[key("difference")] = (args, ctx) => {
+    checkArity("date:difference", args, 2);
+    const x = parseDate(string(args[0], ctx));
+    const y = parseDate(string(args[1], ctx));
+    const dur = x === null || y === null ? null : dateDifference(x, y, false);
+    return dur === null ? "" : formatDuration(dur);
+  };
+
+  functions[key("sum")] = (args, ctx) => {
+    checkArity("date:sum", args, 1);
+    const nodes = toNodeSet("date:sum", evaluator.evaluate(args[0], ctx));
+    if (nodes.length === 0) return "";
+    let total = createDuration();
+    for (const node of nodes) {
+      const dur = parseDuration(evaluator.getStringValue(node));
+      total = dur === null ? null : addDurations(total, dur);
+      if (total === null) return "";
+    }
+    return formatDuration(total);
+  };
+
+  return functions;
+}