Time

1import { type Writer, Sink } from "./core.js";
2import { type ScaledTicks, type Seconds } from "../readers/time.js";
3import { writeInt32, writeInt64 } from "./integers.js";
4
5/**
6 * Write a `Time`: 4-byte signed `Int32` seconds-of-day. The inverse of `readTime`;
7 * pair with {@link parseTime} to start from an "[-]HH:MM:SS" string.
8 */
9export function writeTime(sink: Sink, value: Seconds): void {
10  writeInt32(sink, value);
11}
12
13/**
14 * Write a `Time64(P)`: 8-byte signed `Int64` count of `10^-P`-second ticks, from
15 * a {@link ScaledTicks} `[ticks, precision]`. The inverse of `readTime64`; the
16 * precision lives in the type, so only `ticks` is written. Pair with
17 * {@link parseTime64} to start from a string.
18 */
19export const writeTime64: Writer<ScaledTicks> = (sink, [ticks]) =>
20  writeInt64(sink, ticks);
21
22/**
23 * Parse an "[-]HH:MM:SS" string into signed seconds-of-day — the inverse of
24 * `formatTime`. The hour field may exceed two digits (range ±999:59:59).
25 */
26export function parseTime(text: string): Seconds {
27  const neg = text.startsWith("-");
28  const body = neg ? text.slice(1) : text;
29  const [hh, mm, ss] = body.split(":");
30  const seconds = Number(hh) * 3600 + Number(mm) * 60 + Number(ss);
31  return neg ? -seconds : seconds;
32}
33
34/**
35 * Parse an "[-]HH:MM:SS[.fff]" string into a {@link ScaledTicks} at the given
36 * `precision` — the inverse of `formatTime64`. A shorter fraction is right-padded
37 * with zeros to `precision`; a longer one is truncated.
38 */
39export function parseTime64(text: string, precision: number): ScaledTicks {
40  const neg = text.startsWith("-");
41  const body = neg ? text.slice(1) : text;
42  const dot = body.indexOf(".");
43  const timePart = dot < 0 ? body : body.slice(0, dot);
44  const fracPart = dot < 0 ? "" : body.slice(dot + 1);
45  const [hh, mm, ss] = timePart.split(":");
46  const scale = 10n ** BigInt(precision);
47  const wholeSeconds =
48    BigInt(Number(hh) * 3600 + Number(mm) * 60 + Number(ss)) * scale;
49  const frac = BigInt(
50    (fracPart + "0".repeat(precision)).slice(0, precision) || "0",
51  );
52  const ticks = wholeSeconds + frac;
53  return [neg ? -ticks : ticks, precision];
54}