feat: version 2 beta

libraries/hlc.ts

@@ -0,0 +1,122 @@
+import { HLCClockOffsetError, HLCForwardJumpError, HLCWallTimeOverflowError } from "./errors.ts";
+import { Timestamp } from "./timestamp.ts";
+
+export class HLC {
+  time: typeof getTime;
+
+  maxTime: number;
+  maxOffset: number;
+
+  timeUpperBound: number;
+  toleratedForwardClockJump: number;
+
+  last: Timestamp;
+
+  constructor(
+    { time = getTime, maxOffset = 0, timeUpperBound = 0, toleratedForwardClockJump = 0, last }: Options = {},
+  ) {
+    this.time = time;
+    this.maxTime = timeUpperBound > 0 ? timeUpperBound : Number.MAX_SAFE_INTEGER;
+    this.maxOffset = maxOffset;
+    this.timeUpperBound = timeUpperBound;
+    this.toleratedForwardClockJump = toleratedForwardClockJump;
+    this.last = new Timestamp(this.time());
+    if (last) {
+      this.last = Timestamp.bigger(new Timestamp(last.time), this.last);
+    }
+  }
+
+  now(): Timestamp {
+    return this.update(this.last);
+  }
+
+  update(other: Timestamp): Timestamp {
+    this.last = this.#getTimestamp(other);
+    return this.last;
+  }
+
+  #getTimestamp(other: Timestamp): Timestamp {
+    const [time, logical] = this.#getTimeAndLogicalValue(other);
+    if (!this.#validUpperBound(time)) {
+      throw new HLCWallTimeOverflowError(time, logical);
+    }
+    return new Timestamp(time, logical);
+  }
+
+  #getTimeAndLogicalValue(other: Timestamp): [number, number] {
+    const last = Timestamp.bigger(other, this.last);
+    const time = this.time();
+    if (this.#validOffset(last, time)) {
+      return [time, 0];
+    }
+    return [last.time, last.logical + 1];
+  }
+
+  #validOffset(last: Timestamp, time: number): boolean {
+    const offset = last.time - time;
+    if (!this.#validForwardClockJump(offset)) {
+      throw new HLCForwardJumpError(-offset, this.toleratedForwardClockJump);
+    }
+    if (!this.#validMaxOffset(offset)) {
+      throw new HLCClockOffsetError(offset, this.maxOffset);
+    }
+    if (offset < 0) {
+      return true;
+    }
+    return false;
+  }
+
+  #validForwardClockJump(offset: number): boolean {
+    if (this.toleratedForwardClockJump > 0 && -offset > this.toleratedForwardClockJump) {
+      return false;
+    }
+    return true;
+  }
+
+  #validMaxOffset(offset: number): boolean {
+    if (this.maxOffset > 0 && offset > this.maxOffset) {
+      return false;
+    }
+    return true;
+  }
+
+  #validUpperBound(time: number): boolean {
+    return time < this.maxTime;
+  }
+
+  toJSON() {
+    return Object.freeze({
+      maxOffset: this.maxOffset,
+      timeUpperBound: this.timeUpperBound,
+      toleratedForwardClockJump: this.toleratedForwardClockJump,
+      last: this.last.toJSON(),
+    });
+  }
+}
+
+/*
+ |--------------------------------------------------------------------------------
+ | Utilities
+ |--------------------------------------------------------------------------------
+ */
+
+export function getTime(): number {
+  return Date.now();
+}
+
+/*
+ |--------------------------------------------------------------------------------
+ | Types
+ |--------------------------------------------------------------------------------
+ */
+
+export type Options = {
+  time?: typeof getTime;
+  maxOffset?: number;
+  timeUpperBound?: number;
+  toleratedForwardClockJump?: number;
+  last?: {
+    time: number;
+    logical: number;
+  };
+};