@thi.ng/date 2.3.20 → 2.4.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2022-12-22T21:47:07Z
+- **Last updated**: 2023-01-10T15:20:18Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,18 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [2.4.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/date@2.4.0) (2022-12-29)
+
+#### 🚀 Features
+
+- add formatDuration(), internal restructure ([d610a8a](https://github.com/thi-ng/umbrella/commit/d610a8a))
+  - add formatDuration() & formatDurationParts()
+  - add composeDuration()
+  - refactor formatRelativeParts()
+  - move all formatting fns to format.ts
+  - move decomposeDuration() to duration.ts
+  - add tests
+
 ## [2.3.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/date@2.3.0) (2022-06-15)
 
 #### 🚀 Features

package/README.md

@@ -57,7 +57,7 @@ For Node.js REPL:
 const date = await import("@thi.ng/date");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 5.07 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 5.12 KB
 
 ## Dependencies
 
@@ -296,6 +296,16 @@ withLocale(DE_LONG, () => formatRelativeParts("2020-01-01 12:34"))
 // returns tuple of: [sign, years, months, days, hours, mins, secs, millis]
 decomposeDifference("2020-01-01 12:34", Date.now())
 // [-1, 1, 6, 15, 23, 38, 9, 703]
+
+// format a duration (in ms), optionally with given precision
+formatDuration(45296000)
+// "12 h, 34 min, 56 s"
+
+formatDuration(45296000, "h")
+// "13 h"
+
+formatDuration(45296000,"d")
+// "< 1 d"
 ```
 
 ### Date & time formatters
@@ -449,4 +459,4 @@ If this project contributes to an academic publication, please cite it as:
 
 ## License
 
-&copy; 2020 - 2022 Karsten Schmidt // Apache License 2.0
+&copy; 2020 - 2023 Karsten Schmidt // Apache License 2.0

package/duration.d.ts

@@ -0,0 +1,22 @@
+import { type Precision } from "./api.js";
+/**
+ * Decomposes given duration (in milliseconds) into a tuple of: `[year, month,
+ * day, hour, minute, second, millis]`.
+ *
+ * @param dur -
+ */
+export declare const decomposeDuration: (dur: number) => number[];
+/**
+ * Computes a duration (in milliseconds) from given parts. Also see
+ * {@link decomposeDuration}.
+ *
+ * @example
+ * ```ts
+ * composeDuration({ h: 12, m: 34, s: 56 })
+ * // 45296000
+ * ```
+ *
+ * @param parts
+ */
+export declare const composeDuration: (parts: Partial<Record<Precision, number>>) => number;
+//# sourceMappingURL=duration.d.ts.map

package/duration.js

@@ -0,0 +1,44 @@
+import { YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, } from "./api.js";
+/**
+ * Decomposes given duration (in milliseconds) into a tuple of: `[year, month,
+ * day, hour, minute, second, millis]`.
+ *
+ * @param dur -
+ */
+export const decomposeDuration = (dur) => {
+    const year = (dur / YEAR) | 0;
+    dur -= year * YEAR;
+    const month = (dur / MONTH) | 0;
+    dur -= month * MONTH;
+    const day = (dur / DAY) | 0;
+    dur -= day * DAY;
+    const hour = (dur / HOUR) | 0;
+    dur -= hour * HOUR;
+    const min = (dur / MINUTE) | 0;
+    dur -= min * MINUTE;
+    const sec = (dur / SECOND) | 0;
+    dur -= sec * SECOND;
+    return [year, month, day, hour, min, sec, dur];
+};
+/**
+ * Computes a duration (in milliseconds) from given parts. Also see
+ * {@link decomposeDuration}.
+ *
+ * @example
+ * ```ts
+ * composeDuration({ h: 12, m: 34, s: 56 })
+ * // 45296000
+ * ```
+ *
+ * @param parts
+ */
+export const composeDuration = (parts) => {
+    let dur = (parts.y || 0) * YEAR;
+    dur += (parts.M || 0) * MONTH;
+    dur += (parts.d || 0) * DAY;
+    dur += (parts.h || 0) * HOUR;
+    dur += (parts.m || 0) * MINUTE;
+    dur += (parts.s || 0) * SECOND;
+    dur += parts.t || 0;
+    return dur;
+};

package/format.d.ts

@@ -1,4 +1,4 @@
-import { FormatFn, MaybeDate } from "./api.js";
+import { FormatFn, MaybeDate, Precision } from "./api.js";
 export declare const FORMATTERS: Record<string, FormatFn>;
 /**
  * Returns a new date formatter for given array of format strings (or
@@ -78,4 +78,96 @@ export declare const FMT_ISO_SHORT: (x?: MaybeDate, utc?: boolean) => string;
  * `2020-09-19T17:08:01.123Z`
  */
 export declare const FMT_ISO: (x?: MaybeDate, utc?: boolean) => string;
+/**
+ * Takes a `date` and optional reference `base` date and (also optional
+ * `prec`ision, i.e. number of fractional digits, default: 0). Computes the
+ * difference between given dates and returns it as formatted string.
+ *
+ * @remarks
+ * Returns {@link LOCALE.now} if absolute difference is < `eps` milliseconds
+ * (default: 100).
+ *
+ * @see {@link formatRelativeParts} for alternative output.
+ *
+ *
+ * @example
+ * ```ts
+ * formatRelative("2020-06-01", "2021-07-01")
+ * // "1 year ago"
+ *
+ * formatRelative("2020-08-01", "2021-07-01")
+ * // "11 months ago"
+ *
+ * formatRelative("2021-07-01 13:45", "2021-07-01 12:05")
+ * // "in 2 hours"
+ *
+ * formatRelative("2021-07-01 12:23:24", "2021-07-01 12:05")
+ * // "in 18 minutes"
+ * ```
+ *
+ * @param date -
+ * @param base -
+ * @param prec -
+ * @param eps -
+ */
+export declare const formatRelative: (date: MaybeDate, base?: MaybeDate, prec?: number, eps?: number) => string;
+/**
+ * Similar to {@link formatRelative}, however precision is specified as
+ * {@link Precision} (default: seconds). The result will be formatted as a
+ * string made up of parts of increasing precision (years, months, days, hours,
+ * etc.). Only non-zero parts will be mentioned.
+ *
+ * @remarks
+ * Returns {@link LOCALE.now} if absolute difference is < `eps` milliseconds
+ * (default: 100). In all other cases uses {@link decomposeDifference} for
+ * given dates to extract parts for formatting.
+ *
+ * @example
+ * ```ts
+ * // with default precision (seconds)
+ * formatRelativeParts("2022-09-01 12:23:24", "2021-07-01 12:05")
+ * // "in 1 year, 2 months, 21 hours, 18 minutes, 24 seconds"
+ *
+ * // with day precision
+ * formatRelativeParts("2012-12-25 17:59", "2021-07-01 12:05", "d")
+ * // "8 years, 6 months, 5 days ago"
+ *
+ * formatRelativeParts("2021-07-01 17:59", "2021-07-01 12:05", "d")
+ * // "in less than a day"
+ * ```
+ *
+ * @param date -
+ * @param base -
+ * @param prec -
+ * @param eps -
+ */
+export declare const formatRelativeParts: (date: MaybeDate, base?: MaybeDate, prec?: Precision, eps?: number) => string;
+/**
+ * Formats given duration (in ms) to given precision and using current
+ * {@link LOCALE}.
+ *
+ * @example
+ * ```ts
+ * formatDuration(45296000)
+ * // "12 h, 34 min, 56 s"
+ *
+ * formatDuration(45296000, "h")
+ * // "13 h"
+ *
+ * formatDuration(45296000,"d")
+ * // "< 1 d"
+ * ```
+ *
+ * @param dur
+ * @param prec
+ */
+export declare const formatDuration: (dur: number, prec?: Precision) => string;
+/**
+ * Formats an already decomposed duration (in most case you'll want to use
+ * {@link formatDuration}).
+ *
+ * @param parts
+ * @param prec
+ */
+export declare const formatDurationParts: (parts: number[], prec?: Precision) => string;
 //# sourceMappingURL=format.d.ts.map

package/format.js

@@ -1,9 +1,12 @@
 import { isFunction } from "@thi.ng/checks/is-function";
 import { isString } from "@thi.ng/checks/is-string";
 import { Z2, Z3, Z4 } from "@thi.ng/strings/pad-left";
-import { MINUTE } from "./api.js";
-import { ensureDate } from "./checks.js";
-import { LOCALE } from "./i18n.js";
+import { DAY, HOUR, MINUTE, MONTH, SECOND, YEAR, } from "./api.js";
+import { ensureDate, ensureEpoch } from "./checks.js";
+import { decomposeDuration } from "./duration.js";
+import { LOCALE, tense, units, unitsLessThan } from "./i18n.js";
+import { __idToPrecision, __precisionToID } from "./internal/precision.js";
+import { decomposeDifference, difference } from "./relative.js";
 import { weekInYear } from "./units.js";
 export const FORMATTERS = {
     /**
@@ -239,3 +242,161 @@ export const FMT_ISO_SHORT = defFormat(["yyyy", "-", "MM", "-", "dd", "T", "HH",
  */
 // prettier-ignore
 export const FMT_ISO = defFormat(["yyyy", "-", "MM", "-", "dd", "T", "HH", ":", "mm", ":", "ss", ".", "SS", "ZZ"]);
+/**
+ * Takes a `date` and optional reference `base` date and (also optional
+ * `prec`ision, i.e. number of fractional digits, default: 0). Computes the
+ * difference between given dates and returns it as formatted string.
+ *
+ * @remarks
+ * Returns {@link LOCALE.now} if absolute difference is < `eps` milliseconds
+ * (default: 100).
+ *
+ * @see {@link formatRelativeParts} for alternative output.
+ *
+ *
+ * @example
+ * ```ts
+ * formatRelative("2020-06-01", "2021-07-01")
+ * // "1 year ago"
+ *
+ * formatRelative("2020-08-01", "2021-07-01")
+ * // "11 months ago"
+ *
+ * formatRelative("2021-07-01 13:45", "2021-07-01 12:05")
+ * // "in 2 hours"
+ *
+ * formatRelative("2021-07-01 12:23:24", "2021-07-01 12:05")
+ * // "in 18 minutes"
+ * ```
+ *
+ * @param date -
+ * @param base -
+ * @param prec -
+ * @param eps -
+ */
+export const formatRelative = (date, base = new Date(), prec = 0, eps = 100) => {
+    const delta = difference(date, base);
+    if (Math.abs(delta) < eps)
+        return LOCALE.now;
+    let abs = Math.abs(delta);
+    let unit;
+    if (abs < SECOND) {
+        unit = "t";
+    }
+    else if (abs < MINUTE) {
+        abs /= SECOND;
+        unit = "s";
+    }
+    else if (abs < HOUR) {
+        abs /= MINUTE;
+        unit = "m";
+    }
+    else if (abs < DAY) {
+        abs /= HOUR;
+        unit = "h";
+    }
+    else if (abs < MONTH) {
+        abs /= DAY;
+        unit = "d";
+    }
+    else if (abs < YEAR) {
+        abs /= MONTH;
+        unit = "M";
+    }
+    else {
+        abs /= YEAR;
+        unit = "y";
+    }
+    const exp = 10 ** -prec;
+    abs = Math.round(abs / exp) * exp;
+    return tense(delta, `${abs.toFixed(prec)} ${units(abs, unit, true, true)}`);
+};
+/**
+ * Similar to {@link formatRelative}, however precision is specified as
+ * {@link Precision} (default: seconds). The result will be formatted as a
+ * string made up of parts of increasing precision (years, months, days, hours,
+ * etc.). Only non-zero parts will be mentioned.
+ *
+ * @remarks
+ * Returns {@link LOCALE.now} if absolute difference is < `eps` milliseconds
+ * (default: 100). In all other cases uses {@link decomposeDifference} for
+ * given dates to extract parts for formatting.
+ *
+ * @example
+ * ```ts
+ * // with default precision (seconds)
+ * formatRelativeParts("2022-09-01 12:23:24", "2021-07-01 12:05")
+ * // "in 1 year, 2 months, 21 hours, 18 minutes, 24 seconds"
+ *
+ * // with day precision
+ * formatRelativeParts("2012-12-25 17:59", "2021-07-01 12:05", "d")
+ * // "8 years, 6 months, 5 days ago"
+ *
+ * formatRelativeParts("2021-07-01 17:59", "2021-07-01 12:05", "d")
+ * // "in less than a day"
+ * ```
+ *
+ * @param date -
+ * @param base -
+ * @param prec -
+ * @param eps -
+ */
+export const formatRelativeParts = (date, base = Date.now(), prec = "s", eps = 1000) => {
+    date = ensureEpoch(date);
+    base = ensureEpoch(base);
+    if (Math.abs(date - base) < eps)
+        return LOCALE.now;
+    const [sign, ...parts] = decomposeDifference(date, base);
+    return tense(sign, formatDurationParts(parts, prec));
+};
+/**
+ * Formats given duration (in ms) to given precision and using current
+ * {@link LOCALE}.
+ *
+ * @example
+ * ```ts
+ * formatDuration(45296000)
+ * // "12 h, 34 min, 56 s"
+ *
+ * formatDuration(45296000, "h")
+ * // "13 h"
+ *
+ * formatDuration(45296000,"d")
+ * // "< 1 d"
+ * ```
+ *
+ * @param dur
+ * @param prec
+ */
+export const formatDuration = (dur, prec = "s") => formatDurationParts(decomposeDuration(dur), prec);
+/**
+ * Formats an already decomposed duration (in most case you'll want to use
+ * {@link formatDuration}).
+ *
+ * @param parts
+ * @param prec
+ */
+export const formatDurationParts = (parts, prec = "s") => {
+    const precID = __precisionToID(prec);
+    let maxID = precID;
+    while (!parts[maxID] && maxID > 0)
+        maxID--;
+    let minID = parts.findIndex((x) => x > 0);
+    minID < 0 && (minID = maxID);
+    maxID = Math.min(Math.max(maxID, minID), precID);
+    if (minID <= precID && precID < 6) {
+        parts[maxID] = Math.round(parts[maxID] + parts[maxID + 1] / [12, 31, 24, 60, 60, 1000][maxID]);
+    }
+    return parts
+        .slice(0, maxID + 1)
+        .map((x, i) => {
+        let unit = LOCALE.units[__idToPrecision(i)];
+        return x > 0
+            ? units(x, unit, true)
+            : i === maxID && maxID < 6
+                ? unitsLessThan(1, unit, true)
+                : "";
+    })
+        .filter((x) => !!x)
+        .join(", ");
+};

package/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./api.js";
 export * from "./checks.js";
 export * from "./datetime.js";
+export * from "./duration.js";
 export * from "./format.js";
 export * from "./i18n.js";
 export * from "./iterators.js";

package/index.js

@@ -1,6 +1,7 @@
 export * from "./api.js";
 export * from "./checks.js";
 export * from "./datetime.js";
+export * from "./duration.js";
 export * from "./format.js";
 export * from "./i18n.js";
 export * from "./iterators.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/date",
-  "version": "2.3.20",
+  "version": "2.4.1",
   "description": "Datetime types, relative dates, math, iterators, composable formatters, locales",
   "type": "module",
   "module": "./index.js",
@@ -34,13 +34,13 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.6.2",
-    "@thi.ng/checks": "^3.3.6",
-    "@thi.ng/strings": "^3.3.22"
+    "@thi.ng/api": "^8.6.3",
+    "@thi.ng/checks": "^3.3.7",
+    "@thi.ng/strings": "^3.3.23"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.33.7",
-    "@thi.ng/testament": "^0.3.8",
+    "@thi.ng/testament": "^0.3.9",
     "rimraf": "^3.0.2",
     "tools": "^0.0.1",
     "typedoc": "^0.23.22",
@@ -89,6 +89,9 @@
     "./datetime": {
       "default": "./datetime.js"
     },
+    "./duration": {
+      "default": "./duration.js"
+    },
     "./format": {
       "default": "./format.js"
     },
@@ -129,5 +132,5 @@
   "thi.ng": {
     "year": 2020
   },
-  "gitHead": "bc6f7f5e2765bb96fe64db804eaf4b2443b47fc6\n"
+  "gitHead": "3f0b3e2a7c82aefc7e46fb4338369836b5e1b8cf\n"
 }

package/relative.d.ts

@@ -1,4 +1,4 @@
-import { MaybeDate, Period, Precision } from "./api.js";
+import { MaybeDate, Period } from "./api.js";
 import { DateTime } from "./datetime.js";
 /**
  * Takes a relative time `offset` string in plain english and an optional `base`
@@ -66,67 +66,4 @@ export declare const difference: (a: MaybeDate, b: MaybeDate) => number;
  * @param b -
  */
 export declare const decomposeDifference: (a: MaybeDate, b?: MaybeDate) => number[];
-/**
- * Takes a `date` and optional reference `base` date and (also optional
- * `prec`ision, i.e. number of fractional digits, default: 0). Computes the difference
- * between given dates and returns it as formatted string.
- *
- * @remarks
- * Returns {@link LOCALE.now} if absolute difference is < `eps` milliseconds (default: 100).
- *
- * @see {@link formatRelativeParts} for alternative output.
- *
- *
- * @example
- * ```ts
- * formatRelative("2020-06-01", "2021-07-01")
- * // "1 year ago"
- *
- * formatRelative("2020-08-01", "2021-07-01")
- * // "11 months ago"
- *
- * formatRelative("2021-07-01 13:45", "2021-07-01 12:05")
- * // "in 2 hours"
- *
- * formatRelative("2021-07-01 12:23:24", "2021-07-01 12:05")
- * // "in 18 minutes"
- * ```
- *
- * @param date -
- * @param base -
- * @param prec -
- * @param eps -
- */
-export declare const formatRelative: (date: MaybeDate, base?: MaybeDate, prec?: number, eps?: number) => string;
-/**
- * Similar to {@link formatRelative}, however precision is specified as
- * {@link Precision} (default: seconds). The result will be formatted as a
- * string made up of parts of increasing precision (years, months, days, hours,
- * etc.). Only non-zero parts will be mentioned.
- *
- * @remarks
- * Returns {@link LOCALE.now} if absolute difference is < `eps` milliseconds
- * (default: 100). In all other cases uses {@link decomposeDifference} for
- * given dates to extract parts for formatting.
- *
- * @example
- * ```ts
- * // with default precision (seconds)
- * formatRelativeParts("2022-09-01 12:23:24", "2021-07-01 12:05")
- * // "in 1 year, 2 months, 21 hours, 18 minutes, 24 seconds"
- *
- * // with day precision
- * formatRelativeParts("2012-12-25 17:59", "2021-07-01 12:05", "d")
- * // "8 years, 6 months, 5 days ago"
- *
- * formatRelativeParts("2021-07-01 17:59", "2021-07-01 12:05", "d")
- * // "in less than a day"
- * ```
- *
- * @param date -
- * @param base -
- * @param prec -
- * @param eps -
- */
-export declare const formatRelativeParts: (date: MaybeDate, base?: MaybeDate, prec?: Precision, eps?: number) => string;
 //# sourceMappingURL=relative.d.ts.map

package/relative.js

@@ -1,9 +1,7 @@
-import { DAY, HOUR, MINUTE, MONTH, SECOND, YEAR, } from "./api.js";
+import { DAY, HOUR, MINUTE, SECOND } from "./api.js";
 import { ensureEpoch } from "./checks.js";
 import { dateTime, ensureDateTime } from "./datetime.js";
-import { LOCALE, tense, units, unitsLessThan } from "./i18n.js";
 import { EN_LONG, EN_SHORT } from "./i18n/en.js";
-import { __idToPrecision, __precisionToID } from "./internal/precision.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
@@ -165,131 +163,3 @@ export const decomposeDifference = (a, b = new Date()) => {
     parts[3] = dur < 0 ? days(aa, bb) : days(bb, aa);
     return parts;
 };
-/**
- * Takes a `date` and optional reference `base` date and (also optional
- * `prec`ision, i.e. number of fractional digits, default: 0). Computes the difference
- * between given dates and returns it as formatted string.
- *
- * @remarks
- * Returns {@link LOCALE.now} if absolute difference is < `eps` milliseconds (default: 100).
- *
- * @see {@link formatRelativeParts} for alternative output.
- *
- *
- * @example
- * ```ts
- * formatRelative("2020-06-01", "2021-07-01")
- * // "1 year ago"
- *
- * formatRelative("2020-08-01", "2021-07-01")
- * // "11 months ago"
- *
- * formatRelative("2021-07-01 13:45", "2021-07-01 12:05")
- * // "in 2 hours"
- *
- * formatRelative("2021-07-01 12:23:24", "2021-07-01 12:05")
- * // "in 18 minutes"
- * ```
- *
- * @param date -
- * @param base -
- * @param prec -
- * @param eps -
- */
-export const formatRelative = (date, base = new Date(), prec = 0, eps = 100) => {
-    const delta = difference(date, base);
-    if (Math.abs(delta) < eps)
-        return LOCALE.now;
-    let abs = Math.abs(delta);
-    let unit;
-    if (abs < SECOND) {
-        unit = "t";
-    }
-    else if (abs < MINUTE) {
-        abs /= SECOND;
-        unit = "s";
-    }
-    else if (abs < HOUR) {
-        abs /= MINUTE;
-        unit = "m";
-    }
-    else if (abs < DAY) {
-        abs /= HOUR;
-        unit = "h";
-    }
-    else if (abs < MONTH) {
-        abs /= DAY;
-        unit = "d";
-    }
-    else if (abs < YEAR) {
-        abs /= MONTH;
-        unit = "M";
-    }
-    else {
-        abs /= YEAR;
-        unit = "y";
-    }
-    const exp = 10 ** -prec;
-    abs = Math.round(abs / exp) * exp;
-    return tense(delta, `${abs.toFixed(prec)} ${units(abs, unit, true, true)}`);
-};
-/**
- * Similar to {@link formatRelative}, however precision is specified as
- * {@link Precision} (default: seconds). The result will be formatted as a
- * string made up of parts of increasing precision (years, months, days, hours,
- * etc.). Only non-zero parts will be mentioned.
- *
- * @remarks
- * Returns {@link LOCALE.now} if absolute difference is < `eps` milliseconds
- * (default: 100). In all other cases uses {@link decomposeDifference} for
- * given dates to extract parts for formatting.
- *
- * @example
- * ```ts
- * // with default precision (seconds)
- * formatRelativeParts("2022-09-01 12:23:24", "2021-07-01 12:05")
- * // "in 1 year, 2 months, 21 hours, 18 minutes, 24 seconds"
- *
- * // with day precision
- * formatRelativeParts("2012-12-25 17:59", "2021-07-01 12:05", "d")
- * // "8 years, 6 months, 5 days ago"
- *
- * formatRelativeParts("2021-07-01 17:59", "2021-07-01 12:05", "d")
- * // "in less than a day"
- * ```
- *
- * @param date -
- * @param base -
- * @param prec -
- * @param eps -
- */
-export const formatRelativeParts = (date, base = Date.now(), prec = "s", eps = 1000) => {
-    date = ensureEpoch(date);
-    base = ensureEpoch(base);
-    if (Math.abs(date - base) < eps)
-        return LOCALE.now;
-    const [sign, ...parts] = decomposeDifference(date, base);
-    const precID = __precisionToID(prec);
-    let maxID = precID;
-    while (!parts[maxID] && maxID > 0)
-        maxID--;
-    let minID = parts.findIndex((x) => x > 0);
-    minID < 0 && (minID = maxID);
-    maxID = Math.min(Math.max(maxID, minID), precID);
-    if (minID <= precID && precID < 6) {
-        parts[maxID] = Math.round(parts[maxID] + parts[maxID + 1] / [12, 31, 24, 60, 60, 1000][maxID]);
-    }
-    const res = parts
-        .slice(0, maxID + 1)
-        .map((x, i) => {
-        let unit = LOCALE.units[__idToPrecision(i)];
-        return x > 0
-            ? units(x, unit, true)
-            : i === maxID && maxID < 6
-                ? unitsLessThan(1, unit, true)
-                : "";
-    })
-        .filter((x) => !!x)
-        .join(", ");
-    return tense(sign, res);
-};

package/timecode.d.ts

@@ -26,11 +26,4 @@
  * @param sep -
  */
 export declare const defTimecode: (fps: number, sep?: ArrayLike<string>) => (t: number) => string;
-/**
- * Decomposes given duration (in milliseconds) into a tuple of: `[year, month,
- * day, hour, minute, second, millis]`.
- *
- * @param dur -
- */
-export declare const decomposeDuration: (dur: number) => number[];
 //# sourceMappingURL=timecode.d.ts.map

package/timecode.js

@@ -1,5 +1,5 @@
 import { Z2 } from "@thi.ng/strings/pad-left";
-import { DAY, HOUR, MINUTE, MONTH, SECOND, YEAR } from "./api.js";
+import { decomposeDuration } from "./duration.js";
 /**
  * Returns a time formatter for given FPS (frames / second, in [1..1000] range),
  * e.g. `HH:mm:ss:ff`. The returned function takes a single arg (time in
@@ -44,24 +44,3 @@ export const defTimecode = (fps, sep = "::::") => {
         return parts.join("");
     };
 };
-/**
- * Decomposes given duration (in milliseconds) into a tuple of: `[year, month,
- * day, hour, minute, second, millis]`.
- *
- * @param dur -
- */
-export const decomposeDuration = (dur) => {
-    const year = (dur / YEAR) | 0;
-    dur -= year * YEAR;
-    const month = (dur / MONTH) | 0;
-    dur -= month * MONTH;
-    const day = (dur / DAY) | 0;
-    dur -= day * DAY;
-    const hour = (dur / HOUR) | 0;
-    dur -= hour * HOUR;
-    const min = (dur / MINUTE) | 0;
-    dur -= min * MINUTE;
-    const sec = (dur / SECOND) | 0;
-    dur -= sec * SECOND;
-    return [year, month, day, hour, min, sec, dur];
-};