Implement UUID v1 (#4758)

std/uuid/_common.ts

+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+export function bytesToUuid(bytes: number[] | Uint8Array): string {
+  const bits: string[] = [...bytes].map((bit): string => {
+    const s: string = bit.toString(16);
+    return bit < 0x10 ? "0" + s : s;
+  });
+  return [
+    ...bits.slice(0, 4),
+    "-",
+    ...bits.slice(4, 6),
+    "-",
+    ...bits.slice(6, 8),
+    "-",
+    ...bits.slice(8, 10),
+    "-",
+    ...bits.slice(10),
+  ].join("");
+}

std/uuid/mod.ts

 // Based on https://github.com/kelektiv/node-uuid
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import * as v1 from "./v1.ts";
 import * as v4 from "./v4.ts";
 
 export const NIL_UUID = "00000000-0000-0000-0000-000000000000";
@@ -17,12 +18,10 @@ const NOT_IMPLEMENTED = {
   },
 };
 
-// TODO Implement
-export const v1 = NOT_IMPLEMENTED;
 // TODO Implement
 export const v3 = NOT_IMPLEMENTED;
 
-export { v4 };
+export { v1, v4 };
 
 // TODO Implement
 export const v5 = NOT_IMPLEMENTED;

std/uuid/test.ts

@@ -4,6 +4,10 @@
 // Generic Tests
 import "./tests/isNil.ts";
 
+// V1 Tests
+import "./tests/v1/validate.ts";
+import "./tests/v1/generate.ts";
+
 // V4 Tests
 import "./tests/v4/validate.ts";
 import "./tests/v4/generate.ts";

std/uuid/tests/v1/generate.ts

+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { assert, assertEquals } from "../../../testing/asserts.ts";
+const { test } = Deno;
+import { generate, validate } from "../../v1.ts";
+
+test({
+  name: "[UUID] test_uuid_v1",
+  fn(): void {
+    const u = generate();
+    assertEquals(typeof u, "string", "returns a string");
+    assert(u !== "", "return string is not empty");
+  },
+});
+
+test({
+  name: "[UUID] test_uuid_v1_format",
+  fn(): void {
+    for (let i = 0; i < 10000; i++) {
+      const u = generate() as string;
+      assert(validate(u), `${u} is not a valid uuid v1`);
+    }
+  },
+});
+
+test({
+  name: "[UUID] test_uuid_v1_static",
+  fn(): void {
+    const v1options = {
+      node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
+      clockseq: 0x1234,
+      msecs: new Date("2011-11-01").getTime(),
+      nsecs: 5678,
+    };
+    const u = generate(v1options);
+    assertEquals(u, "710b962e-041c-11e1-9234-0123456789ab");
+  },
+});

std/uuid/tests/v1/validate.ts

+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { assert } from "../../../testing/asserts.ts";
+import { generate, validate } from "../../v1.ts";
+
+Deno.test({
+  name: "[UUID] is_valid_uuid_v1",
+  fn(): void {
+    const u = generate();
+    const t = "63655efa-7ee6-11ea-bc55-0242ac130003";
+    const n = "63655efa-7ee6-11eg-bc55-0242ac130003";
+
+    assert(validate(u as string), `generated ${u} should be valid`);
+    assert(validate(t), `${t} should be valid`);
+    assert(!validate(n), `${n} should not be valid`);
+  },
+});

std/uuid/v1.ts

+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+import { bytesToUuid } from "./_common.ts";
+
+const UUID_RE = new RegExp(
+  "^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$",
+  "i"
+);
+
+export function validate(id: string): boolean {
+  return UUID_RE.test(id);
+}
+
+let _nodeId: number[];
+let _clockseq: number;
+
+let _lastMSecs = 0;
+let _lastNSecs = 0;
+
+type V1Options = {
+  node?: number[];
+  clockseq?: number;
+  msecs?: number;
+  nsecs?: number;
+  random?: number[];
+  rng?: () => number[];
+};
+
+export function generate(
+  options?: V1Options | null,
+  buf?: number[],
+  offset?: number
+): string | number[] {
+  let i = (buf && offset) || 0;
+  const b = buf || [];
+
+  options = options || {};
+  let node = options.node || _nodeId;
+  let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;
+
+  if (node == null || clockseq == null) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const seedBytes: any =
+      options.random ||
+      options.rng ||
+      crypto.getRandomValues(new Uint8Array(16));
+    if (node == null) {
+      node = _nodeId = [
+        seedBytes[0] | 0x01,
+        seedBytes[1],
+        seedBytes[2],
+        seedBytes[3],
+        seedBytes[4],
+        seedBytes[5],
+      ];
+    }
+    if (clockseq == null) {
+      clockseq = _clockseq = ((seedBytes[6] << 8) | seedBytes[7]) & 0x3fff;
+    }
+  }
+  let msecs =
+    options.msecs !== undefined ? options.msecs : new Date().getTime();
+
+  let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;
+
+  const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000;
+
+  if (dt < 0 && options.clockseq === undefined) {
+    clockseq = (clockseq + 1) & 0x3fff;
+  }
+
+  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
+    nsecs = 0;
+  }
+
+  if (nsecs >= 10000) {
+    throw new Error("Can't create more than 10M uuids/sec");
+  }
+
+  _lastMSecs = msecs;
+  _lastNSecs = nsecs;
+  _clockseq = clockseq;
+
+  msecs += 12219292800000;
+
+  const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+  b[i++] = (tl >>> 24) & 0xff;
+  b[i++] = (tl >>> 16) & 0xff;
+  b[i++] = (tl >>> 8) & 0xff;
+  b[i++] = tl & 0xff;
+
+  const tmh = ((msecs / 0x100000000) * 10000) & 0xfffffff;
+  b[i++] = (tmh >>> 8) & 0xff;
+  b[i++] = tmh & 0xff;
+
+  b[i++] = ((tmh >>> 24) & 0xf) | 0x10;
+  b[i++] = (tmh >>> 16) & 0xff;
+
+  b[i++] = (clockseq >>> 8) | 0x80;
+
+  b[i++] = clockseq & 0xff;
+
+  for (let n = 0; n < 6; ++n) {
+    b[i + n] = node[n];
+  }
+
+  return buf ? buf : bytesToUuid(b);
+}

std/uuid/v4.ts

 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 
+import { bytesToUuid } from "./_common.ts";
+
 const UUID_RE = new RegExp(
   "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$",
   "i"
@@ -15,19 +17,5 @@ export function generate(): string {
   rnds[6] = (rnds[6] & 0x0f) | 0x40; // Version 4
   rnds[8] = (rnds[8] & 0x3f) | 0x80; // Variant 10
 
-  const bits: string[] = [...rnds].map((bit): string => {
-    const s: string = bit.toString(16);
-    return bit < 0x10 ? "0" + s : s;
-  });
-  return [
-    ...bits.slice(0, 4),
-    "-",
-    ...bits.slice(4, 6),
-    "-",
-    ...bits.slice(6, 8),
-    "-",
-    ...bits.slice(8, 10),
-    "-",
-    ...bits.slice(10),
-  ].join("");
+  return bytesToUuid(rnds);
 }