@thi.ng/date 2.5.5 → 2.5.6

package/i18n.js

@@ -1,124 +1,53 @@
 import { isString } from "@thi.ng/checks/is-string";
 import { EN_SHORT } from "./i18n/en.js";
 const prepLocale = (spec) => {
-    const locale = {
-        sepED: " ",
-        sepDM: "/",
-        sepMY: "/",
-        sepHM: ":",
-        date: ["E", "/ED", "d", "/DM", "MMM", "/MY", "yyyy"],
-        time: ["H", "/HM", "mm"],
-        ...spec,
-    };
-    !locale.dateTime &&
-        (locale.dateTime = [...locale.date, ", ", ...locale.time]);
-    return locale;
+  const locale = {
+    sepED: " ",
+    sepDM: "/",
+    sepMY: "/",
+    sepHM: ":",
+    date: ["E", "/ED", "d", "/DM", "MMM", "/MY", "yyyy"],
+    time: ["H", "/HM", "mm"],
+    ...spec
+  };
+  !locale.dateTime && (locale.dateTime = [...locale.date, ", ", ...locale.time]);
+  return locale;
 };
-/**
- * Sets {@link LOCALE} for formatting and fills in missing default values.
- * Unless called explicitly, the package uses {@link EN_SHORT} by default.
- *
- * @param locale -
- */
-export const setLocale = (locale) => (LOCALE = prepLocale(locale));
-/**
- * Executes given `fn` with temporarily active `locale`. Returns result of `fn`.
- *
- * @remarks
- * `fn` will be called within a try/catch block and the previous locale will be
- * restored even if `fn` throws an error.
- *
- * @param locale -
- * @param fn -
- */
-export const withLocale = (locale, fn) => {
-    const old = LOCALE;
-    setLocale(locale);
-    try {
-        const res = fn();
-        setLocale(old);
-        return res;
-    }
-    catch (e) {
-        setLocale(old);
-        throw e;
-    }
+const setLocale = (locale) => LOCALE = prepLocale(locale);
+const withLocale = (locale, fn) => {
+  const old = LOCALE;
+  setLocale(locale);
+  try {
+    const res = fn();
+    setLocale(old);
+    return res;
+  } catch (e) {
+    setLocale(old);
+    throw e;
+  }
 };
-export let LOCALE = prepLocale(EN_SHORT);
-/**
- * Returns a copy of current {@link LOCALE}'s weekday names array.
- */
-export const weekdayNames = () => LOCALE.days.slice();
-/**
- * Returns a copy of current {@link LOCALE}'s month names array.
- */
-export const monthNames = () => LOCALE.months.slice();
-/**
- * Returns a suitable version of requested `unit` from current {@link LOCALE},
- * based on quantity `x` and optional dativ grammar form. If `unitsOnly` is true
- * (default false) only the unit (w/o quantity) will be returned.
- *
- * @remarks
- * Also see {@link unitsLessThan}, {@link formatRelative},
- * {@link formatRelativeParts}.
- *
- * @example
- * ```ts
- * withLocale(FR_LONG, () => units(1, "y"));
- * // "1 année"
- *
- * withLocale(FR_LONG, () => units(1, "y", true));
- * // "1 an"
- *
- * withLocale(FR_LONG, () => units(2, "y"));
- * // "2 ans"
- *
- * withLocale(FR_LONG, () => units(2, "y", true));
- * // "2 ans"
- *
- * withLocale(DE_LONG, () => units(2, "y"));
- * // "2 Jahre"
- *
- * withLocale(DE_LONG, () => units(2, "y", true));
- * // "2 Jahren"
- * ```
- *
- * @param x -
- * @param unit -
- * @param isDativ -
- * @param unitsOnly -
- */
-export const units = (x, unit, isDativ = false, unitsOnly = false) => {
-    unit = isString(unit) ? LOCALE.units[unit] : unit;
-    const res = x > 1 || x === 0
-        ? isDativ
-            ? unit.pd || unit.p
-            : unit.p
-        : isDativ
-            ? unit.sd || unit.s
-            : unit.s;
-    return unitsOnly ? res : `${x} ${res}`;
+let LOCALE = prepLocale(EN_SHORT);
+const weekdayNames = () => LOCALE.days.slice();
+const monthNames = () => LOCALE.months.slice();
+const units = (x, unit, isDativ = false, unitsOnly = false) => {
+  unit = isString(unit) ? LOCALE.units[unit] : unit;
+  const res = x > 1 || x === 0 ? isDativ ? unit.pd || unit.p : unit.p : isDativ ? unit.sd || unit.s : unit.s;
+  return unitsOnly ? res : `${x} ${res}`;
+};
+const unitsLessThan = (x, unit, isDativ = false) => `${LOCALE.less.replace("%s", String(x))} ${units(
+  Math.max(x, 1),
+  unit,
+  isDativ,
+  true
+)}`;
+const tense = (sign, res) => (sign < 0 ? LOCALE.past : LOCALE.future).replace("%s", res);
+export {
+  LOCALE,
+  monthNames,
+  setLocale,
+  tense,
+  units,
+  unitsLessThan,
+  weekdayNames,
+  withLocale
 };
-/**
- * Similar to {@link units}, but for cases to express/format the phrase `less
- * than {x} {unit(s)}`.
- *
- * @example
- * ```ts
- * withLocale(DE_LONG, () => unitsLessThan(1, "y"));
- * // "weniger als 1 Jahr"
- * ```
- *
- * @param x -
- * @param unit -
- * @param isDativ -
- */
-export const unitsLessThan = (x, unit, isDativ = false) => `${LOCALE.less.replace("%s", String(x))} ${units(Math.max(x, 1), unit, isDativ, true)}`;
-/**
- * Wraps given (presumably localized) string in current {@link LOCALE}'s `past`
- * or `future` phrases, depending on given `sign`.
- *
- * @param sign -
- * @param res -
- */
-export const tense = (sign, res) => (sign < 0 ? LOCALE.past : LOCALE.future).replace("%s", res);

package/internal/precision.js

@@ -1,16 +1,6 @@
-/**
- * Converts a {@link Precision} into a numeric ID.
- *
- * @param prec -
- *
- * @internal
- */
-export const __precisionToID = (prec) => "yMdhmst".indexOf(prec);
-/**
- * Inverse op of {@link __precisionToID}.
- *
- * @param id -
- *
- * @internal
- */
-export const __idToPrecision = (id) => "yMdhmst".charAt(id);
+const __precisionToID = (prec) => "yMdhmst".indexOf(prec);
+const __idToPrecision = (id) => "yMdhmst".charAt(id);
+export {
+  __idToPrecision,
+  __precisionToID
+};

package/iterators.js

@@ -1,97 +1,45 @@
 import { isString } from "@thi.ng/checks/is-string";
 import { DateTime } from "./datetime.js";
 import { floorQuarter, floorWeek } from "./round.js";
-/**
- * Higher-order epoch iterator factory. Returns iterator with configured
- * precision and `tick` fn.
- *
- * @param prec -
- * @param tick -
- */
-export const defIterator = (prec, tick) => {
-    return function* (...xs) {
-        let [from, to] = (xs.length > 1 ? xs : xs[0]).map((x) => new DateTime(x).getTime());
-        let state = isString(prec) ? new DateTime(from, prec) : prec(from);
-        let epoch = from;
-        while (epoch < to) {
-            epoch = state.getTime();
-            if (epoch >= from && epoch < to)
-                yield epoch;
-            tick(state);
-        }
-    };
+const defIterator = (prec, tick) => {
+  return function* (...xs) {
+    let [from, to] = (xs.length > 1 ? xs : xs[0]).map(
+      (x) => new DateTime(x).getTime()
+    );
+    let state = isString(prec) ? new DateTime(from, prec) : prec(from);
+    let epoch = from;
+    while (epoch < to) {
+      epoch = state.getTime();
+      if (epoch >= from && epoch < to)
+        yield epoch;
+      tick(state);
+    }
+  };
+};
+const years = defIterator("y", (d) => d.incYear());
+const quarters = defIterator(
+  (from) => new DateTime(floorQuarter(from)),
+  (d) => d.incQuarter()
+);
+const months = defIterator("M", (d) => d.incMonth());
+const weeks = defIterator(
+  (from) => new DateTime(floorWeek(from)),
+  (d) => d.incWeek()
+);
+const days = defIterator("d", (d) => d.incDay());
+const hours = defIterator("h", (d) => d.incHour());
+const minutes = defIterator("m", (d) => d.incMinute());
+const seconds = defIterator("s", (d) => d.incSecond());
+const milliseconds = defIterator("t", (d) => d.incMillisecond());
+export {
+  days,
+  defIterator,
+  hours,
+  milliseconds,
+  minutes,
+  months,
+  quarters,
+  seconds,
+  weeks,
+  years
 };
-/**
- * Yields iterator of UTC timestamps in given semi-open interval in yearly
- * precision (each timestamp is at beginning of each year).
- *
- * @param from -
- * @param to -
- */
-export const years = defIterator("y", (d) => d.incYear());
-/**
- * Yields iterator of UTC timestamps in given semi-open interval in monthly
- * precision (each timestamp is at beginning of a month), but spaced at 3 month
- * intervals.
- *
- * @param from -
- * @param to -
- */
-export const quarters = defIterator((from) => new DateTime(floorQuarter(from)), (d) => d.incQuarter());
-/**
- * Yields iterator of UTC timestamps in given semi-open interval in monthly
- * precision (each timestamp is at beginning of each month).
- *
- * @param from -
- * @param to -
- */
-export const months = defIterator("M", (d) => d.incMonth());
-/**
- * Yields iterator of UTC timestamps in given semi-open interval in daily
- * precision (each timestamp is 7 days apart). As per ISO8601, weeks start on
- * Mondays.
- *
- * @param from -
- * @param to -
- */
-export const weeks = defIterator((from) => new DateTime(floorWeek(from)), (d) => d.incWeek());
-/**
- * Yields iterator of UTC timestamps in given semi-open interval in daily
- * precision (each timestamp is at midnight/beginning of each day).
- *
- * @param from -
- * @param to -
- */
-export const days = defIterator("d", (d) => d.incDay());
-/**
- * Yields iterator of UTC timestamps in given semi-open interval in hourly
- * precision.
- *
- * @param from -
- * @param to -
- */
-export const hours = defIterator("h", (d) => d.incHour());
-/**
- * Yields iterator of UTC timestamps in given semi-open interval in minute
- * precision.
- *
- * @param from -
- * @param to -
- */
-export const minutes = defIterator("m", (d) => d.incMinute());
-/**
- * Yields iterator of UTC timestamps in given semi-open interval in second
- * precision.
- *
- * @param from -
- * @param to -
- */
-export const seconds = defIterator("s", (d) => d.incSecond());
-/**
- * Yields iterator of UTC timestamps in given semi-open interval in millisecond
- * precision.
- *
- * @param from -
- * @param to -
- */
-export const milliseconds = defIterator("t", (d) => d.incMillisecond());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/date",
-  "version": "2.5.5",
+  "version": "2.5.6",
   "description": "Datetime types, relative dates, math, iterators, composable formatters, locales",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc internal i18n",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,12 +35,13 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/strings": "^3.7.2"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/strings": "^3.7.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -130,5 +133,5 @@
   "thi.ng": {
     "year": 2020
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/relative.js

@@ -1,178 +1,118 @@
-import { DAY, HOUR, MINUTE, SECOND, } from "./api.js";
+import {
+  DAY,
+  HOUR,
+  MINUTE,
+  SECOND
+} from "./api.js";
 import { ensureEpoch } from "./checks.js";
 import { dateTime, ensureDateTime } from "./datetime.js";
 import { EN_LONG, EN_SHORT } from "./i18n/en.js";
-/**
- * Takes a relative time `offset` string in plain english and an optional `base`
- * date (default: now). Parses `offset` and returns new date with relative
- * offset applied. Returns `undefined` if parsing failed.
- *
- * @remarks
- * This function only handles the parsing and input normalization aspect for
- * {@link relative}. The latter function applies the actual offset.
- *
- * The following input formats are supported:
- *
- * - `"tomorrow"` / `"yesterday"` - ±1 day
- * - any weekday names in {@link EN_SHORT} and {@link EN_LONG} (always in future)
- * - `<"-"|"+">?<num><period><" ago">?"` - ±num periods (if prefixed with "-" or
- *   if the `" ago"` suffix is given, the offset will be applied towards the
- *   past)
- *
- * (Note: If both negative offset and "ago" is given, the suffix will, like a
- * double-negative, flip the direction back towards the future).
- *
- * If using the latter form:
- *
- * - `<num>` can be a positve integer or strings: `"next "`, `"a "` or `"an "`
- * - `<period>` can be:
- *   - `ms` / `millis` / `millisecond` / `milliseconds`
- *   - `s` / `sec` / `secs` / `second` / `seconds`
- *   - `min` / `mins` / `minute` / `minutes`
- *   - `h` / `hour` / `hours`
- *   - `d` / `day` / `days`
- *   - `w` / `week` / `weeks`
- *   - `mo` / `month` / `months`
- *   - `q` / `quarter` / `quarters`
- *   - `y` / `year` / `years`
- *
- * @param offset -
- * @param base -
- */
-export const parseRelative = (offset, base) => {
-    offset = offset.toLowerCase();
-    const epoch = dateTime(base);
-    switch (offset) {
-        case "today":
-            return epoch;
-        case "tomorrow":
-            epoch.incDay();
-            return epoch;
-        case "yesterday":
-            epoch.decDay();
-            return epoch;
-        default: {
-            let idx = findIndex(EN_SHORT.days, offset);
-            if (idx < 0) {
-                idx = findIndex(EN_LONG.days, offset);
-            }
-            if (idx >= 0) {
-                do {
-                    epoch.incDay();
-                } while (epoch.toDate().getDay() != idx);
-                return epoch;
-            }
-            const match = /^(an? |next |[-+]?\d+\s?)((ms|milli(?:(s?|seconds?)))|s(?:(ecs?|econds?))?|min(?:(s|utes?))?|h(?:ours?)?|d(?:ays?)?|w(?:eeks?)?|mo(?:nths?)?|q(?:uarters?)?|y(?:ears?)?)(\s+ago)?$/.exec(offset);
-            return match
-                ? relative(parseNum(match[1], !!match[7]), parsePeriod(match[2]), base)
-                : undefined;
-        }
+const parseRelative = (offset, base) => {
+  offset = offset.toLowerCase();
+  const epoch = dateTime(base);
+  switch (offset) {
+    case "today":
+      return epoch;
+    case "tomorrow":
+      epoch.incDay();
+      return epoch;
+    case "yesterday":
+      epoch.decDay();
+      return epoch;
+    default: {
+      let idx = findIndex(EN_SHORT.days, offset);
+      if (idx < 0) {
+        idx = findIndex(EN_LONG.days, offset);
+      }
+      if (idx >= 0) {
+        do {
+          epoch.incDay();
+        } while (epoch.toDate().getDay() != idx);
+        return epoch;
+      }
+      const match = /^(an? |next |[-+]?\d+\s?)((ms|milli(?:(s?|seconds?)))|s(?:(ecs?|econds?))?|min(?:(s|utes?))?|h(?:ours?)?|d(?:ays?)?|w(?:eeks?)?|mo(?:nths?)?|q(?:uarters?)?|y(?:ears?)?)(\s+ago)?$/.exec(
+        offset
+      );
+      return match ? relative(
+        parseNum(match[1], !!match[7]),
+        parsePeriod(match[2]),
+        base
+      ) : void 0;
     }
+  }
 };
 const findIndex = (items, x) => items.findIndex((y) => y.toLowerCase() === x);
-const parseNum = (x, past) => (x === "next " || x === "a " || x === "an " ? 1 : Number(x)) *
-    (past ? -1 : 1);
+const parseNum = (x, past) => (x === "next " || x === "a " || x === "an " ? 1 : Number(x)) * (past ? -1 : 1);
 const parsePeriod = (x) => {
-    x =
-        x !== "s" && x !== "ms" && x.endsWith("s")
-            ? x.substring(0, x.length - 1)
-            : x;
-    return {
-        ms: "t",
-        milli: "t",
-        millisecond: "t",
-        sec: "s",
-        second: "s",
-        min: "m",
-        minute: "m",
-        hour: "h",
-        day: "d",
-        week: "w",
-        mo: "M",
-        month: "M",
-        quarter: "q",
-        year: "y",
-    }[x] || x;
+  x = x !== "s" && x !== "ms" && x.endsWith("s") ? x.substring(0, x.length - 1) : x;
+  return {
+    ms: "t",
+    milli: "t",
+    millisecond: "t",
+    sec: "s",
+    second: "s",
+    min: "m",
+    minute: "m",
+    hour: "h",
+    day: "d",
+    week: "w",
+    mo: "M",
+    month: "M",
+    quarter: "q",
+    year: "y"
+  }[x] || x;
 };
-/**
- * Applies the given relative offset (defined by `num` and `period`) to the
- * optionally given `base` date (default: now). If `num < 0` the result date
- * will be in the past (relative to `base`).
- *
- * @param num -
- * @param period -
- * @param base -
- */
-export const relative = (num, period, base = dateTime()) => dateTime(base).add(num, period);
-/**
- * Returns the signed difference in milliseconds between given two dates `a` and
- * `b` (as `diff = a - b`).
- *
- * @remarks
- * Also see {@link absDifference}.
- *
- * @param a -
- * @param b -
- */
-export const difference = (a, b) => ensureEpoch(a) - ensureEpoch(b);
-/**
- * Returns the unsigned difference in milliseconds between given dates.
- *
- * @remarks
- * Also see {@link difference} for signed difference.
- *
- * @param a
- * @param b
- */
-export const absDifference = (a, b) => Math.abs(difference(a, b));
-/**
- * Computes and decomposes difference between given dates. Returns tuple of:
- * `[sign, years, months, days, hours, mins, secs, millis]`. The `sign` is used
- * to indicate the relative order of `a` compared to `b`, i.e. same contract as
- * [`ICompare`](https://docs.thi.ng/umbrella/api/interfaces/ICompare.html).
- *
- * @param a -
- * @param b -
- */
-export const decomposeDifference = (a, b = new Date()) => {
-    const dur = ensureEpoch(a) - ensureEpoch(b);
-    let abs = Math.abs(dur);
-    const milli = abs % SECOND;
-    abs -= milli;
-    const sec = abs % MINUTE;
-    abs -= sec;
-    const min = abs % HOUR;
-    abs -= min;
-    const hour = abs % DAY;
-    abs -= hour;
-    const parts = [
-        Math.sign(dur),
-        0, // year
-        0, // month
-        0, // day
-        hour / HOUR,
-        min / MINUTE,
-        sec / SECOND,
-        milli,
-    ];
-    if (!abs)
-        return parts;
-    const diff = (a, b) => {
-        const months = (b.y - a.y) * 12 + (b.M - a.M);
-        const bstart = +a.add(months, "M");
-        let frac = +b - bstart;
-        frac /=
-            frac < 0
-                ? bstart - +a.add(months - 1, "M")
-                : +a.add(months + 1, "M") - bstart;
-        return -(months + frac) || 0;
-    };
-    const aa = ensureDateTime(a, "d");
-    const bb = ensureDateTime(b, "d");
-    const months = Math.abs(aa.d < bb.d ? -diff(bb, aa) : diff(aa, bb)) | 0;
-    const days = (start, end) => Math.abs(+start.withPrecision("d").add(months, "M") - +end.withPrecision("d")) / DAY;
-    parts[1] = (months / 12) | 0;
-    parts[2] = months % 12;
-    parts[3] = dur < 0 ? days(aa, bb) : days(bb, aa);
+const relative = (num, period, base = dateTime()) => dateTime(base).add(num, period);
+const difference = (a, b) => ensureEpoch(a) - ensureEpoch(b);
+const absDifference = (a, b) => Math.abs(difference(a, b));
+const decomposeDifference = (a, b = /* @__PURE__ */ new Date()) => {
+  const dur = ensureEpoch(a) - ensureEpoch(b);
+  let abs = Math.abs(dur);
+  const milli = abs % SECOND;
+  abs -= milli;
+  const sec = abs % MINUTE;
+  abs -= sec;
+  const min = abs % HOUR;
+  abs -= min;
+  const hour = abs % DAY;
+  abs -= hour;
+  const parts = [
+    Math.sign(dur),
+    0,
+    // year
+    0,
+    // month
+    0,
+    // day
+    hour / HOUR,
+    min / MINUTE,
+    sec / SECOND,
+    milli
+  ];
+  if (!abs)
     return parts;
+  const diff = (a2, b2) => {
+    const months2 = (b2.y - a2.y) * 12 + (b2.M - a2.M);
+    const bstart = +a2.add(months2, "M");
+    let frac = +b2 - bstart;
+    frac /= frac < 0 ? bstart - +a2.add(months2 - 1, "M") : +a2.add(months2 + 1, "M") - bstart;
+    return -(months2 + frac) || 0;
+  };
+  const aa = ensureDateTime(a, "d");
+  const bb = ensureDateTime(b, "d");
+  const months = Math.abs(aa.d < bb.d ? -diff(bb, aa) : diff(aa, bb)) | 0;
+  const days = (start, end) => Math.abs(
+    +start.withPrecision("d").add(months, "M") - +end.withPrecision("d")
+  ) / DAY;
+  parts[1] = months / 12 | 0;
+  parts[2] = months % 12;
+  parts[3] = dur < 0 ? days(aa, bb) : days(bb, aa);
+  return parts;
+};
+export {
+  absDifference,
+  decomposeDifference,
+  difference,
+  parseRelative,
+  relative
 };