@kubun/hlc 0.10.1 → 0.12.0

package/lib/index.js

@@ -1 +1,87 @@
-export class HLC{#t;#e=0;#l=0;#i;constructor(t){this.#t=t.nodeID,this.#i=Math.min(t.counterCeiling??1e8,1e8)}get nodeID(){return this.#t}#n(t){t>=this.#i?(this.#e+=1,this.#l=0):this.#l=t}now(){let t=Date.now();return t>this.#e?(this.#e=t,this.#l=0):this.#n(this.#l+1),{wallTime:this.#e,counter:this.#l,nodeID:this.#t}}receive(t){let e=Date.now();return e>this.#e&&e>t.wallTime?(this.#e=e,this.#l=0):t.wallTime>this.#e?(this.#e=t.wallTime,this.#n(t.counter+1)):this.#e>t.wallTime?this.#n(this.#l+1):this.#n(Math.max(this.#l,t.counter)+1),{wallTime:this.#e,counter:this.#l,nodeID:this.#t}}static serialize(t){let e=new Date(t.wallTime).toISOString(),l=t.counter.toString().padStart(8,"0");return`${e}:${l}:${t.nodeID}`}static parse(t){let e=t.indexOf("Z"),l=new Date(t.slice(0,e+1)).getTime(),i=t.slice(e+2),n=i.indexOf(":");return{wallTime:l,counter:Number.parseInt(i.slice(0,n),10),nodeID:i.slice(n+1)}}static compare(t,e){return t.wallTime!==e.wallTime?t.wallTime-e.wallTime:t.counter!==e.counter?t.counter-e.counter:t.nodeID<e.nodeID?-1:+(t.nodeID>e.nodeID)}}
+// The serialized counter is fixed-width zero-padded so that lexicographic string
+// order matches numeric order. The pad width therefore caps the counter: any value
+// reaching this ceiling would emit an extra digit and silently break that ordering.
+const COUNTER_PAD = 8;
+const COUNTER_CEILING = 1e8;
+export class HLC {
+    #nodeID;
+    #lastWallTime = 0;
+    #lastCounter = 0;
+    #counterCeiling;
+    constructor(params){
+        this.#nodeID = params.nodeID;
+        this.#counterCeiling = Math.min(params.counterCeiling ?? COUNTER_CEILING, COUNTER_CEILING);
+    }
+    get nodeID() {
+        return this.#nodeID;
+    }
+    // Apply a candidate counter at the current wall time. If it would reach the
+    // serialization ceiling, advance the wall time by 1ms and reset the counter to 0
+    // instead of emitting a 9th digit. This keeps the result strictly greater than the
+    // previous timestamp (counter ceiling < a +1ms wall time) while preserving the
+    // lexicographic == numeric ordering invariant.
+    #applyCounter(candidate) {
+        if (candidate >= this.#counterCeiling) {
+            this.#lastWallTime += 1;
+            this.#lastCounter = 0;
+        } else {
+            this.#lastCounter = candidate;
+        }
+    }
+    now() {
+        const physicalTime = Date.now();
+        if (physicalTime > this.#lastWallTime) {
+            this.#lastWallTime = physicalTime;
+            this.#lastCounter = 0;
+        } else {
+            this.#applyCounter(this.#lastCounter + 1);
+        }
+        return {
+            wallTime: this.#lastWallTime,
+            counter: this.#lastCounter,
+            nodeID: this.#nodeID
+        };
+    }
+    receive(remote) {
+        const physicalTime = Date.now();
+        if (physicalTime > this.#lastWallTime && physicalTime > remote.wallTime) {
+            this.#lastWallTime = physicalTime;
+            this.#lastCounter = 0;
+        } else if (remote.wallTime > this.#lastWallTime) {
+            this.#lastWallTime = remote.wallTime;
+            this.#applyCounter(remote.counter + 1);
+        } else if (this.#lastWallTime > remote.wallTime) {
+            this.#applyCounter(this.#lastCounter + 1);
+        } else {
+            this.#applyCounter(Math.max(this.#lastCounter, remote.counter) + 1);
+        }
+        return {
+            wallTime: this.#lastWallTime,
+            counter: this.#lastCounter,
+            nodeID: this.#nodeID
+        };
+    }
+    static serialize(ts) {
+        const iso = new Date(ts.wallTime).toISOString();
+        const counter = ts.counter.toString().padStart(COUNTER_PAD, '0');
+        return `${iso}:${counter}:${ts.nodeID}`;
+    }
+    static parse(s) {
+        const zIndex = s.indexOf('Z');
+        const wallTime = new Date(s.slice(0, zIndex + 1)).getTime();
+        const rest = s.slice(zIndex + 2);
+        const colonIndex = rest.indexOf(':');
+        const counter = Number.parseInt(rest.slice(0, colonIndex), 10);
+        const nodeID = rest.slice(colonIndex + 1);
+        return {
+            wallTime,
+            counter,
+            nodeID
+        };
+    }
+    static compare(a, b) {
+        if (a.wallTime !== b.wallTime) return a.wallTime - b.wallTime;
+        if (a.counter !== b.counter) return a.counter - b.counter;
+        return a.nodeID < b.nodeID ? -1 : a.nodeID > b.nodeID ? 1 : 0;
+    }
+}

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@kubun/hlc",
-  "version": "0.10.1",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }