Initial commit

build/dev/javascript/gleam_time/gleam/time/duration.mjs

@@ -0,0 +1,382 @@
+import * as $bool from "../../../gleam_stdlib/gleam/bool.mjs";
+import * as $int from "../../../gleam_stdlib/gleam/int.mjs";
+import * as $order from "../../../gleam_stdlib/gleam/order.mjs";
+import * as $string from "../../../gleam_stdlib/gleam/string.mjs";
+import { CustomType as $CustomType, remainderInt, divideInt, isEqual } from "../../gleam.mjs";
+
+class Duration extends $CustomType {
+  constructor(seconds, nanoseconds) {
+    super();
+    this.seconds = seconds;
+    this.nanoseconds = nanoseconds;
+  }
+}
+
+export class Nanosecond extends $CustomType {}
+export const Unit$Nanosecond = () => new Nanosecond();
+export const Unit$isNanosecond = (value) => value instanceof Nanosecond;
+
+export class Microsecond extends $CustomType {}
+export const Unit$Microsecond = () => new Microsecond();
+export const Unit$isMicrosecond = (value) => value instanceof Microsecond;
+
+export class Millisecond extends $CustomType {}
+export const Unit$Millisecond = () => new Millisecond();
+export const Unit$isMillisecond = (value) => value instanceof Millisecond;
+
+export class Second extends $CustomType {}
+export const Unit$Second = () => new Second();
+export const Unit$isSecond = (value) => value instanceof Second;
+
+export class Minute extends $CustomType {}
+export const Unit$Minute = () => new Minute();
+export const Unit$isMinute = (value) => value instanceof Minute;
+
+export class Hour extends $CustomType {}
+export const Unit$Hour = () => new Hour();
+export const Unit$isHour = (value) => value instanceof Hour;
+
+export class Day extends $CustomType {}
+export const Unit$Day = () => new Day();
+export const Unit$isDay = (value) => value instanceof Day;
+
+export class Week extends $CustomType {}
+export const Unit$Week = () => new Week();
+export const Unit$isWeek = (value) => value instanceof Week;
+
+export class Month extends $CustomType {}
+export const Unit$Month = () => new Month();
+export const Unit$isMonth = (value) => value instanceof Month;
+
+export class Year extends $CustomType {}
+export const Unit$Year = () => new Year();
+export const Unit$isYear = (value) => value instanceof Year;
+
+/**
+ * Ensure the duration is represented with `nanoseconds` being positive and
+ * less than 1 second.
+ *
+ * This function does not change the amount of time that the duratoin refers
+ * to, it only adjusts the values used to represent the time.
+ * 
+ * @ignore
+ */
+function normalise(duration) {
+  let multiplier = 1_000_000_000;
+  let nanoseconds$1 = remainderInt(duration.nanoseconds, multiplier);
+  let overflow = duration.nanoseconds - nanoseconds$1;
+  let seconds$1 = duration.seconds + (divideInt(overflow, multiplier));
+  let $ = nanoseconds$1 >= 0;
+  if ($) {
+    return new Duration(seconds$1, nanoseconds$1);
+  } else {
+    return new Duration(seconds$1 - 1, multiplier + nanoseconds$1);
+  }
+}
+
+/**
+ * Convert a duration to a number of the largest number of a unit, serving as
+ * a rough description of the duration that a human can understand.
+ *
+ * The size used for each unit are described in the documentation for the
+ * `Unit` type.
+ *
+ * ```gleam
+ * seconds(125)
+ * |> approximate
+ * // -> #(2, Minute)
+ * ```
+ *
+ * This function rounds _towards zero_. This means that if a duration is just
+ * short of 2 days then it will approximate to 1 day.
+ *
+ * ```gleam
+ * hours(47)
+ * |> approximate
+ * // -> #(1, Day)
+ * ```
+ */
+export function approximate(duration) {
+  let s;
+  let ns;
+  s = duration.seconds;
+  ns = duration.nanoseconds;
+  let minute = 60;
+  let hour = minute * 60;
+  let day = hour * 24;
+  let week = day * 7;
+  let year = day * 365 + hour * 6;
+  let month = globalThis.Math.trunc(year / 12);
+  let microsecond = 1000;
+  let millisecond = microsecond * 1000;
+  let $ = undefined;
+  if (s < 0) {
+    let _block;
+    let _pipe = new Duration(- s, - ns);
+    let _pipe$1 = normalise(_pipe);
+    _block = approximate(_pipe$1);
+    let $1 = _block;
+    let amount;
+    let unit;
+    amount = $1[0];
+    unit = $1[1];
+    return [- amount, unit];
+  } else if (s >= year) {
+    return [divideInt(s, year), new Year()];
+  } else if (s >= month) {
+    return [divideInt(s, month), new Month()];
+  } else if (s >= week) {
+    return [divideInt(s, week), new Week()];
+  } else if (s >= day) {
+    return [divideInt(s, day), new Day()];
+  } else if (s >= hour) {
+    return [divideInt(s, hour), new Hour()];
+  } else if (s >= minute) {
+    return [divideInt(s, minute), new Minute()];
+  } else if (s > 0) {
+    return [s, new Second()];
+  } else if (ns >= millisecond) {
+    return [divideInt(ns, millisecond), new Millisecond()];
+  } else if (ns >= microsecond) {
+    return [divideInt(ns, microsecond), new Microsecond()];
+  } else {
+    return [ns, new Nanosecond()];
+  }
+}
+
+/**
+ * Compare one duration to another, indicating whether the first spans a
+ * larger amount of time (and so is greater) or smaller amount of time (and so
+ * is lesser) than the second.
+ *
+ * # Examples
+ *
+ * ```gleam
+ * compare(seconds(1), seconds(2))
+ * // -> order.Lt
+ * ```
+ *
+ * Whether a duration is negative or positive doesn't matter for comparing
+ * them, only the amount of time spanned matters.
+ *
+ * ```gleam
+ * compare(seconds(-2), seconds(1))
+ * // -> order.Gt
+ * ```
+ */
+export function compare(left, right) {
+  let parts = (x) => {
+    let $ = x.seconds >= 0;
+    if ($) {
+      return [x.seconds, x.nanoseconds];
+    } else {
+      return [x.seconds * -1 - 1, 1_000_000_000 - x.nanoseconds];
+    }
+  };
+  let $ = parts(left);
+  let ls;
+  let lns;
+  ls = $[0];
+  lns = $[1];
+  let $1 = parts(right);
+  let rs;
+  let rns;
+  rs = $1[0];
+  rns = $1[1];
+  let _pipe = $int.compare(ls, rs);
+  return $order.break_tie(_pipe, $int.compare(lns, rns));
+}
+
+/**
+ * Calculate the difference between two durations.
+ *
+ * This is effectively substracting the first duration from the second.
+ *
+ * # Examples
+ *
+ * ```gleam
+ * difference(seconds(1), seconds(5))
+ * // -> seconds(4)
+ * ```
+ */
+export function difference(left, right) {
+  let _pipe = new Duration(
+    right.seconds - left.seconds,
+    right.nanoseconds - left.nanoseconds,
+  );
+  return normalise(_pipe);
+}
+
+/**
+ * Add two durations together.
+ *
+ * # Examples
+ *
+ * ```gleam
+ * add(seconds(1), seconds(5))
+ * // -> seconds(6)
+ * ```
+ */
+export function add(left, right) {
+  let _pipe = new Duration(
+    left.seconds + right.seconds,
+    left.nanoseconds + right.nanoseconds,
+  );
+  return normalise(_pipe);
+}
+
+function nanosecond_digits(loop$n, loop$position, loop$acc) {
+  while (true) {
+    let n = loop$n;
+    let position = loop$position;
+    let acc = loop$acc;
+    if (position === 9) {
+      return acc;
+    } else if ((acc === "") && ((remainderInt(n, 10)) === 0)) {
+      loop$n = globalThis.Math.trunc(n / 10);
+      loop$position = position + 1;
+      loop$acc = acc;
+    } else {
+      let acc$1 = $int.to_string(n % 10) + acc;
+      loop$n = globalThis.Math.trunc(n / 10);
+      loop$position = position + 1;
+      loop$acc = acc$1;
+    }
+  }
+}
+
+/**
+ * Create a duration of a number of seconds.
+ */
+export function seconds(amount) {
+  return new Duration(amount, 0);
+}
+
+/**
+ * Create a duration of a number of minutes.
+ */
+export function minutes(amount) {
+  return seconds(amount * 60);
+}
+
+/**
+ * Create a duration of a number of hours.
+ */
+export function hours(amount) {
+  return seconds(amount * 60 * 60);
+}
+
+/**
+ * Create a duration of a number of milliseconds.
+ */
+export function milliseconds(amount) {
+  let remainder = amount % 1000;
+  let overflow = amount - remainder;
+  let nanoseconds$1 = remainder * 1_000_000;
+  let seconds$1 = globalThis.Math.trunc(overflow / 1000);
+  let _pipe = new Duration(seconds$1, nanoseconds$1);
+  return normalise(_pipe);
+}
+
+/**
+ * Create a duration of a number of nanoseconds.
+ *
+ * # JavaScript int limitations
+ *
+ * Remember that JavaScript can only perfectly represent ints between positive
+ * and negative 9,007,199,254,740,991! If you use a single call to this
+ * function to create durations larger than that number of nanoseconds then
+ * you will likely not get exactly the value you expect. Use `seconds` and
+ * `milliseconds` as much as possible for large durations.
+ */
+export function nanoseconds(amount) {
+  let _pipe = new Duration(0, amount);
+  return normalise(_pipe);
+}
+
+/**
+ * Convert the duration to a number of seconds.
+ *
+ * There may be some small loss of precision due to `Duration` being
+ * nanosecond accurate and `Float` not being able to represent this.
+ */
+export function to_seconds(duration) {
+  let seconds$1 = $int.to_float(duration.seconds);
+  let nanoseconds$1 = $int.to_float(duration.nanoseconds);
+  return seconds$1 + (nanoseconds$1 / 1_000_000_000.0);
+}
+
+/**
+ * Convert the duration to a number of seconds and nanoseconds. There is no
+ * loss of precision with this conversion on any target.
+ */
+export function to_seconds_and_nanoseconds(duration) {
+  return [duration.seconds, duration.nanoseconds];
+}
+
+export const empty = /* @__PURE__ */ new Duration(0, 0);
+
+/**
+ * Convert the duration to an [ISO8601][1] formatted duration string.
+ *
+ * The ISO8601 duration format is ambiguous without context due to months and
+ * years having different lengths, and because of leap seconds. This function
+ * encodes the duration as days, hours, and seconds without any leap seconds.
+ * Be sure to take this into account when using the duration strings.
+ *
+ * [1]: https://en.wikipedia.org/wiki/ISO_8601#Durations
+ */
+export function to_iso8601_string(duration) {
+  return $bool.guard(
+    isEqual(duration, empty),
+    "PT0S",
+    () => {
+      let split = (total, limit) => {
+        let amount = remainderInt(total, limit);
+        let remainder = divideInt((total - amount), limit);
+        return [amount, remainder];
+      };
+      let $ = split(duration.seconds, 60);
+      let seconds$1;
+      let rest;
+      seconds$1 = $[0];
+      rest = $[1];
+      let $1 = split(rest, 60);
+      let minutes$1;
+      let rest$1;
+      minutes$1 = $1[0];
+      rest$1 = $1[1];
+      let $2 = split(rest$1, 24);
+      let hours$1;
+      let rest$2;
+      hours$1 = $2[0];
+      rest$2 = $2[1];
+      let days = rest$2;
+      let add$1 = (out, value, unit) => {
+        if (value === 0) {
+          return out;
+        } else {
+          return (out + $int.to_string(value)) + unit;
+        }
+      };
+      let _block;
+      let _pipe = "P";
+      let _pipe$1 = add$1(_pipe, days, "D");
+      let _pipe$2 = $string.append(_pipe$1, "T");
+      let _pipe$3 = add$1(_pipe$2, hours$1, "H");
+      _block = add$1(_pipe$3, minutes$1, "M");
+      let output = _block;
+      let $3 = duration.nanoseconds;
+      if ($3 === 0) {
+        if (seconds$1 === 0) {
+          return output;
+        } else {
+          return (output + $int.to_string(seconds$1)) + "S";
+        }
+      } else {
+        let f = nanosecond_digits(duration.nanoseconds, 0, "");
+        return (((output + $int.to_string(seconds$1)) + ".") + f) + "S";
+      }
+    },
+  );
+}