@typed/id 1.0.0-beta.0 → 1.0.0-beta.10

package/src/Id.test.ts

@@ -1,217 +0,0 @@
-import * as Effect from "effect/Effect";
-import { assert, describe, expect, it } from "vitest";
-import * as Cuid from "./Cuid.js";
-import { Ids } from "./Ids.js";
-import * as Ksuid from "./Ksuid.js";
-import * as NanoId from "./NanoId.js";
-import * as Ulid from "./Ulid.js";
-import * as Uuid4 from "./Uuid4.js";
-import * as Uuid5 from "./Uuid5.js";
-import * as Uuid7 from "./Uuid7.js";
-import { Random } from "effect";
-import { TestClock } from "effect/testing";
-
-const run = <A, E>(effect: Effect.Effect<A, E, Ids>) =>
-  Effect.runPromise(Effect.provide(effect, Ids.Test()));
-
-describe("@typed/id", () => {
-  describe("type guards", () => {
-    describe("isUuid4", () => {
-      it("accepts valid UUID v4", () => {
-        expect(Uuid4.isUuid4("f47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(true);
-        expect(Uuid4.isUuid4("550e8400-e29b-41d4-a716-446655440000")).toBe(true);
-      });
-      it("rejects invalid formats", () => {
-        expect(Uuid4.isUuid4("")).toBe(false);
-        expect(Uuid4.isUuid4("not-a-uuid")).toBe(false);
-        expect(Uuid4.isUuid4("f47ac10b-58cc-4372-a567-0e02b2c3d479".replace(/-/g, ""))).toBe(false);
-        expect(Uuid4.isUuid4("g47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(false); // invalid hex
-      });
-      it("rejects UUID v5 as UUID v4", () => {
-        expect(Uuid4.isUuid4("886313e1-3b8a-5372-9b90-0c9aee199e5d")).toBe(false);
-      });
-    });
-
-    describe("isUuid5", () => {
-      it("accepts valid UUID v5", () => {
-        expect(Uuid5.isUuid5("886313e1-3b8a-5372-9b90-0c9aee199e5d")).toBe(true);
-        expect(Uuid5.isUuid5("c2ee5f2e-5b2e-5f2e-8b2e-5b2e5f2e8b2e")).toBe(true);
-      });
-      it("rejects invalid formats", () => {
-        expect(Uuid5.isUuid5("")).toBe(false);
-        expect(Uuid5.isUuid5("f47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(false); // v4
-      });
-    });
-
-    describe("isUuid7", () => {
-      it("accepts valid UUID v7", () => {
-        expect(Uuid7.isUuid7("018eebb4-1f2c-7c3a-8b4d-123456789abc")).toBe(true);
-      });
-      it("rejects invalid formats", () => {
-        expect(Uuid7.isUuid7("")).toBe(false);
-        expect(Uuid7.isUuid7("f47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(false); // v4
-      });
-    });
-
-    describe("isCuid", () => {
-      it("accepts valid CUID-like strings (lowercase letter + base36)", () => {
-        expect(Cuid.isCuid("c1234567890abcdefghijklmn")).toBe(true);
-        expect(Cuid.isCuid("a0")).toBe(true);
-      });
-      it("rejects invalid formats", () => {
-        expect(Cuid.isCuid("")).toBe(false);
-        expect(Cuid.isCuid("A123")).toBe(false); // must start with lowercase
-        expect(Cuid.isCuid("1abc")).toBe(false); // must start with letter
-        expect(Cuid.isCuid("c123-456")).toBe(false); // no hyphen
-      });
-    });
-
-    describe("isKsuid", () => {
-      it("accepts 27-char base62 strings", () => {
-        assert(Ksuid.isKsuid("0123456789ABCDEFGHIJKLMNOPQ"));
-        assert(Ksuid.isKsuid("000000000000000000000000000"));
-      });
-      it("rejects invalid formats", () => {
-        expect(Ksuid.isKsuid("")).toBe(false);
-        expect(Ksuid.isKsuid("short")).toBe(false);
-        expect(Ksuid.isKsuid("0ujsszwN8NRYtYaMBZrYCVp4O1!")).toBe(false); // 28 chars, invalid char
-      });
-    });
-
-    describe("isNanoId", () => {
-      it("accepts strings with only 0-9a-zA-Z_-", () => {
-        assert(NanoId.isNanoId("V1StGXR8_Z5jdHi6B-myT"));
-        assert(NanoId.isNanoId("abc123"));
-        assert(NanoId.isNanoId("_-_"));
-      });
-      it("rejects invalid characters", () => {
-        expect(NanoId.isNanoId("")).toBe(false);
-        expect(NanoId.isNanoId("   ")).toBe(false);
-        expect(NanoId.isNanoId("!@#$%")).toBe(false);
-      });
-    });
-
-    describe("isUlid", () => {
-      it("accepts valid ULIDs (26 chars, Effect alphabet 0-9A-HJKMNP-TV-Z)", () => {
-        expect(Ulid.isUlid("01D78XYFJ1PRM1WPBCBT3VHMNV")).toBe(true);
-      });
-      it("rejects invalid formats", () => {
-        expect(Ulid.isUlid("")).toBe(false);
-        expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FA")).toBe(false); // wrong length
-        expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FAV0")).toBe(false); // wrong length
-        expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FAI")).toBe(false); // I not in Crockford base32
-      });
-    });
-  });
-
-  describe("Ids service", () => {
-    it("uuid4 produces valid UUID v4", async () => {
-      const id = await run(Ids.uuid4);
-      expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
-      expect(Uuid4.isUuid4(id)).toBe(true);
-    });
-
-    it("uuid5 produces valid UUID v5", async () => {
-      const id = await run(Ids.uuid5("hello", Uuid5.Uuid5Namespace.DNS));
-      expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
-      expect(Uuid5.isUuid5(id)).toBe(true);
-    });
-
-    it("uuid5 is deterministic for same name and namespace", async () => {
-      const a = await run(Ids.uuid5("test", Uuid5.Uuid5Namespace.URL));
-      const b = await run(Ids.uuid5("test", Uuid5.Uuid5Namespace.URL));
-      expect(a).toBe(b);
-    });
-
-    it("uuid5 differs for different names", async () => {
-      const a = await run(Ids.uuid5("a", Uuid5.Uuid5Namespace.DNS));
-      const b = await run(Ids.uuid5("b", Uuid5.Uuid5Namespace.DNS));
-      expect(a).not.toBe(b);
-    });
-
-    it("uuid5 predefined namespaces work", async () => {
-      const dns = await run(Ids.uuid5.dns("example.com"));
-      const url = await run(Ids.uuid5.url("https://example.com"));
-      const oid = await run(Ids.uuid5.oid("1.2.3"));
-      const x500 = await run(Ids.uuid5.x500("cn=test"));
-      expect(Uuid5.isUuid5(dns)).toBe(true);
-      expect(Uuid5.isUuid5(url)).toBe(true);
-      expect(Uuid5.isUuid5(oid)).toBe(true);
-      expect(Uuid5.isUuid5(x500)).toBe(true);
-      expect(new Set([dns, url, oid, x500]).size).toBe(4);
-    });
-
-    it("uuid7 produces valid UUID v7", async () => {
-      const id = await run(Ids.uuid7);
-      expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
-      expect(Uuid7.isUuid7(id)).toBe(true);
-    });
-
-    it("cuid produces valid CUID", async () => {
-      const id = await run(Ids.cuid);
-      expect(Cuid.isCuid(id)).toBe(true);
-      expect(id).toMatch(/^[a-z][0-9a-z]+$/);
-    });
-
-    it("ksuid produces valid KSUID", async () => {
-      const id = await run(Ids.ksuid);
-      expect(Ksuid.isKsuid(id)).toBe(true);
-      expect(id).toHaveLength(27);
-      expect(id).toMatch(/^[0-9a-zA-Z]{27}$/);
-    });
-
-    it("nanoId produces valid NanoId", async () => {
-      const id = await run(Ids.nanoId);
-      expect(NanoId.isNanoId(id)).toBe(true);
-      expect(id).toMatch(/^[0-9a-zA-Z_-]+$/);
-      expect(id).toHaveLength(21);
-    });
-
-    it("ulid produces valid ULID", async () => {
-      const id = await run(Ids.ulid);
-      expect(Ulid.isUlid(id)).toBe(true);
-      expect(id).toHaveLength(26);
-      expect(id).toMatch(/^[0-9A-HJKMNP-TV-Z]{26}$/);
-    });
-
-    it("Ids.Test with fixed time yields deterministic time-based prefixes", async () => {
-      const runFixed = <A, E>(effect: Effect.Effect<A, E, Ids>) =>
-        effect.pipe(
-          Effect.provide(Ids.Test({})),
-          Effect.provide(TestClock.layer({})),
-          Random.withSeed(42),
-          Effect.runPromise,
-        );
-
-      const [ulid1, ulid2, ksuid1, ksuid2] = await runFixed(
-        Effect.all([Ids.ulid, Ids.ulid, Ids.ksuid, Ids.ksuid], { concurrency: "unbounded" }),
-      );
-      expect(ulid1.slice(0, 10)).toBe(ulid2.slice(0, 10));
-      expect(ksuid1.slice(0, 5)).toBe(ksuid2.slice(0, 5));
-    });
-  });
-
-  describe("Ids.Default", () => {
-    it("runs all generators with default layer", async () => {
-      const program = Effect.gen(function* () {
-        const ids = yield* Ids;
-        const u4 = yield* ids.uuid4;
-        const u5 = yield* ids.uuid5("default-test", Uuid5.Uuid5Namespace.DNS);
-        const u7 = yield* ids.uuid7;
-        const c = yield* ids.cuid;
-        const k = yield* ids.ksuid;
-        const n = yield* ids.nanoId;
-        const u = yield* ids.ulid;
-        return { u4, u5, u7, c, k, n, u };
-      });
-      const result = await Effect.runPromise(Effect.provide(program, Ids.Default));
-      expect(Uuid4.isUuid4(result.u4)).toBe(true);
-      expect(Uuid5.isUuid5(result.u5)).toBe(true);
-      expect(Uuid7.isUuid7(result.u7)).toBe(true);
-      expect(Cuid.isCuid(result.c)).toBe(true);
-      expect(Ksuid.isKsuid(result.k)).toBe(true);
-      expect(NanoId.isNanoId(result.n)).toBe(true);
-      expect(Ulid.isUlid(result.u)).toBe(true);
-    });
-  });
-});

package/src/Ids.ts

@@ -1,124 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as ServiceMap from "effect/ServiceMap";
-import type { Cuid } from "./Cuid.js";
-import { cuid, CuidState } from "./Cuid.js";
-import { DateTimes } from "./DateTimes.js";
-import type { Ksuid } from "./Ksuid.js";
-import { ksuid } from "./Ksuid.js";
-import type { NanoId } from "./NanoId.js";
-import { nanoId } from "./NanoId.js";
-import { RandomValues } from "./RandomValues.js";
-import type { Ulid } from "./Ulid.js";
-import { ulid } from "./Ulid.js";
-import type { Uuid4 } from "./Uuid4.js";
-import { uuid4 } from "./Uuid4.js";
-import { type Uuid5, uuid5, Uuid5Namespace } from "./Uuid5.js";
-import type { Uuid7 } from "./Uuid7.js";
-import { uuid7, Uuid7State } from "./Uuid7.js";
-
-export class Ids extends ServiceMap.Service<Ids>()("@typed/id/Ids", {
-  make: Effect.gen(function* () {
-    const services = yield* Effect.services<DateTimes | RandomValues | CuidState | Uuid7State>();
-
-    const uuid5_: {
-      (namespace: Uuid5Namespace): (name: string) => Effect.Effect<Uuid5>;
-      (name: string, namespace: Uuid5Namespace): Effect.Effect<Uuid5>;
-      readonly dns: (name: string) => Effect.Effect<Uuid5>;
-      readonly url: (name: string) => Effect.Effect<Uuid5>;
-      readonly oid: (name: string) => Effect.Effect<Uuid5>;
-      readonly x500: (name: string) => Effect.Effect<Uuid5>;
-    } = Object.assign(
-      dual(2, (name: string, namespace: Uuid5Namespace) =>
-        Effect.provide(uuid5(name, namespace), services),
-      ),
-      {
-        dns: uuid5(Uuid5Namespace.DNS),
-        url: uuid5(Uuid5Namespace.URL),
-        oid: uuid5(Uuid5Namespace.OID),
-        x500: uuid5(Uuid5Namespace.X500),
-      },
-    );
-
-    return {
-      cuid: Effect.provide(cuid, services),
-      ksuid: Effect.provide(ksuid, services),
-      nanoId: Effect.provide(nanoId, services),
-      ulid: Effect.provide(ulid, services),
-      uuid4: Effect.provide(uuid4, services),
-      uuid5: uuid5_,
-      uuid7: Effect.provide(uuid7, services),
-    };
-  }),
-}) {
-  static readonly cuid: Effect.Effect<Cuid, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ cuid }) => cuid,
-  );
-
-  static readonly ksuid: Effect.Effect<Ksuid, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ ksuid }) => ksuid,
-  );
-
-  static readonly nanoId: Effect.Effect<NanoId, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ nanoId }) => nanoId,
-  );
-
-  static readonly ulid: Effect.Effect<Ulid, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ ulid }) => ulid,
-  );
-
-  static readonly uuid4: Effect.Effect<Uuid4, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ uuid4 }) => uuid4,
-  );
-
-  static readonly uuid5: {
-    (namespace: Uuid5Namespace): (name: string) => Effect.Effect<Uuid5, never, Ids>;
-    (name: string, namespace: Uuid5Namespace): Effect.Effect<Uuid5, never, Ids>;
-    readonly dns: (name: string) => Effect.Effect<Uuid5, never, Ids>;
-    readonly url: (name: string) => Effect.Effect<Uuid5, never, Ids>;
-    readonly oid: (name: string) => Effect.Effect<Uuid5, never, Ids>;
-    readonly x500: (name: string) => Effect.Effect<Uuid5, never, Ids>;
-  } = Object.assign(
-    dual(2, (name: string, namespace: Uuid5Namespace) =>
-      Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5(name, namespace)),
-    ),
-    {
-      dns: (name: string) => Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5.dns(name)),
-      url: (name: string) => Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5.url(name)),
-      oid: (name: string) => Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5.oid(name)),
-      x500: (name: string) => Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5.x500(name)),
-    },
-  );
-  static readonly uuid7: Effect.Effect<Uuid7, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ uuid7 }) => uuid7,
-  );
-
-  static readonly Default: Layer.Layer<Ids | DateTimes | RandomValues, never, never> = Layer.effect(
-    Ids,
-    Ids.make,
-  ).pipe(
-    Layer.provide([CuidState.Default, Uuid7State.Default]),
-    Layer.provideMerge([DateTimes.Default, RandomValues.Default]),
-  );
-
-  static readonly Test = (options?: TestOptions): Layer.Layer<Ids | DateTimes | RandomValues> =>
-    Layer.effect(Ids, Ids.make).pipe(
-      Layer.provide([
-        Layer.effect(CuidState, CuidState.make(options?.envData ?? "node")),
-        Uuid7State.Default,
-      ]),
-      Layer.provideMerge([DateTimes.Fixed(options?.currentTime ?? 0), RandomValues.Random]),
-    );
-}
-
-export type TestOptions = {
-  readonly currentTime?: number | string | Date;
-  readonly envData?: string;
-};

package/src/Ksuid.ts

@@ -1,74 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { DateTimes } from "./DateTimes.js";
-import { RandomValues } from "./RandomValues.js";
-
-// Constants
-const EPOCH = 14e11; // 2014-03-01T00:00:00Z
-const TIMESTAMP_BYTES = 4;
-const PAYLOAD_BYTES = 16;
-const TOTAL_BYTES = TIMESTAMP_BYTES + PAYLOAD_BYTES;
-const STRING_LENGTH = 27;
-
-// Schema
-export const Ksuid = Schema.String.pipe(
-  Schema.check(Schema.isPattern(/^[0-9a-zA-Z]{27}$/)),
-  Schema.brand("@typed/id/KSUID"),
-);
-export type Ksuid = typeof Ksuid.Type;
-
-export const isKsuid: (value: string) => value is Ksuid = Schema.is(Ksuid);
-
-// Types
-type KsuidSeed = Uint8Array & { length: 16 };
-
-// Public API
-export const ksuid: Effect.Effect<Ksuid, never, DateTimes | RandomValues> = Effect.zipWith(
-  DateTimes.now,
-  RandomValues.call<KsuidSeed>(PAYLOAD_BYTES),
-  (timestamp, payload) => {
-    // Create the combined bytes
-    const bytes = new Uint8Array(TOTAL_BYTES);
-
-    // Support for timestamps before the epoch, usually for testing
-    if (timestamp < EPOCH) {
-      timestamp += EPOCH;
-    }
-
-    // Write timestamp (4 bytes, big-endian)
-    const seconds = Math.floor((timestamp - EPOCH) / 1000);
-    bytes[0] = (seconds >>> 24) & 0xff;
-    bytes[1] = (seconds >>> 16) & 0xff;
-    bytes[2] = (seconds >>> 8) & 0xff;
-    bytes[3] = seconds & 0xff;
-
-    // Copy payload
-    bytes.set(payload, TIMESTAMP_BYTES);
-
-    // Encode as base62
-    return Ksuid.makeUnsafe(base62Encode(bytes));
-  },
-);
-
-// Utilities
-const base62Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-const base = BigInt(base62Chars.length);
-
-function base62Encode(bytes: Uint8Array): string {
-  let number = 0n;
-  for (const byte of bytes) {
-    number = (number << 8n) + BigInt(byte);
-  }
-
-  const chars: Array<string> = Array(STRING_LENGTH);
-  let i = chars.length;
-
-  while (i > 0) {
-    i--;
-    const remainder = Number(number % base);
-    chars[i] = base62Chars[remainder];
-    number = number / base;
-  }
-
-  return chars.join("");
-}

package/src/NanoId.ts

@@ -1,33 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { RandomValues } from "./RandomValues.js";
-
-export const NanoId = Schema.String.pipe(
-  Schema.check(Schema.isPattern(/^[0-9a-zA-Z_-]+$/)),
-  Schema.brand("@typed/id/NanoId"),
-);
-export type NanoId = typeof NanoId.Type;
-
-export const isNanoId: (value: string) => value is NanoId = Schema.is(NanoId);
-
-type NanoIdSeed = Uint8Array & { length: 21 };
-
-export const nanoId: Effect.Effect<NanoId, never, RandomValues> = Effect.map(
-  RandomValues.call<NanoIdSeed>(21),
-  (seed: NanoIdSeed): NanoId => NanoId.makeUnsafe(Array.from(seed, numToCharacter).join("")),
-);
-
-function numToCharacter(byte: number): string {
-  byte &= 63;
-  if (byte < 36) {
-    // `0-9a-z`
-    return byte.toString(36);
-  } else if (byte < 62) {
-    // `A-Z`
-    return (byte - 26).toString(36).toUpperCase();
-  } else if (byte > 62) {
-    return "-";
-  } else {
-    return "_";
-  }
-}

package/src/RandomValues.ts

@@ -1,33 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Random from "effect/Random";
-import * as ServiceMap from "effect/ServiceMap";
-
-export class RandomValues extends ServiceMap.Service<RandomValues>()("@typed/id/RandomValues", {
-  make: Effect.succeed(
-    <A extends Uint8Array>(length: A["length"]): Effect.Effect<A> =>
-      Effect.sync(() => crypto.getRandomValues(new Uint8Array(length)) as A),
-  ),
-}) {
-  static override readonly call = <A extends Uint8Array>(
-    length: A["length"],
-  ): Effect.Effect<A, never, RandomValues> =>
-    RandomValues.asEffect().pipe(Effect.flatMap((randomValues) => randomValues(length)));
-
-  static readonly Default = Layer.effect(RandomValues, RandomValues.make);
-
-  static readonly Random = Layer.effect(
-    RandomValues,
-    Effect.gen(function* () {
-      const random = yield* Random.Random;
-      return RandomValues.of(
-        <A extends Uint8Array>(length: A["length"]): Effect.Effect<A> =>
-          Effect.sync(() => {
-            const view = new Uint8Array(length);
-            for (let i = 0; i < length; ++i) view[i] = random.nextIntUnsafe();
-            return view as A;
-          }),
-      );
-    }),
-  );
-}

package/src/Ulid.ts

@@ -1,51 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { DateTimes } from "./DateTimes.js";
-import { RandomValues } from "./RandomValues.js";
-
-export const Ulid = Schema.String.pipe(
-  Schema.check(Schema.isULID()),
-  Schema.brand("@typed/id/ULID"),
-);
-export type Ulid = typeof Ulid.Type;
-
-export const isUlid: (value: string) => value is Ulid = Schema.is(Ulid);
-
-type UlidSeed = Uint8Array & { length: 16 };
-
-// Crockford's Base32
-const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-const ENCODING_LEN = ENCODING.length;
-const TIME_MAX = 2 ** 48 - 1;
-const TIME_LEN = 10;
-const RANDOM_LEN = 16;
-
-export const ulid: Effect.Effect<Ulid, never, RandomValues | DateTimes> = Effect.zipWith(
-  DateTimes.now,
-  RandomValues.call<UlidSeed>(16),
-  (now, seed) => {
-    if (now > TIME_MAX) {
-      throw new Error("Cannot generate ULID due to timestamp overflow");
-    }
-
-    return Ulid.makeUnsafe(encodeTime(now, TIME_LEN) + encodeRandom(seed));
-  },
-);
-
-function encodeTime(now: number, len: number): string {
-  let str = "";
-  for (let i = len - 1; i >= 0; i--) {
-    const mod = now % ENCODING_LEN;
-    str = ENCODING.charAt(mod) + str;
-    now = (now - mod) / ENCODING_LEN;
-  }
-  return str;
-}
-
-function encodeRandom(seed: UlidSeed): string {
-  let str = "";
-  for (let i = 0; i < RANDOM_LEN; i++) {
-    str = str + ENCODING.charAt(seed[i] % ENCODING_LEN);
-  }
-  return str;
-}

package/src/Uuid4.ts

@@ -1,24 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { uuidStringify } from "./_uuid-stringify.js";
-import { RandomValues } from "./RandomValues.js";
-
-export const Uuid4 = Schema.String.pipe(
-  Schema.check(Schema.isUUID(4)),
-  Schema.brand("@typed/id/UUID4"),
-);
-export type Uuid4 = typeof Uuid4.Type;
-
-export const isUuid4: (value: string) => value is Uuid4 = Schema.is(Uuid4);
-
-type Uuid4Seed = Uint8Array & { length: 16 };
-
-export const uuid4: Effect.Effect<Uuid4, never, RandomValues> = Effect.map(
-  RandomValues.call<Uuid4Seed>(16),
-  (seed: Uuid4Seed): Uuid4 => {
-    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-    seed[6] = (seed[6] & 0x0f) | 0x40;
-    seed[8] = (seed[8] & 0x3f) | 0x80;
-    return Uuid4.makeUnsafe(uuidStringify(seed));
-  },
-);

package/src/Uuid5.ts

@@ -1,71 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as Schema from "effect/Schema";
-import { sha1 } from "./_sha.js";
-import { uuidStringify } from "./_uuid-stringify.js";
-
-export const Uuid5 = Schema.String.pipe(
-  Schema.check(Schema.isUUID(5)),
-  Schema.brand("@typed/id/UUID5"),
-);
-export type Uuid5 = typeof Uuid5.Type;
-
-export const isUuid5: (value: string) => value is Uuid5 = Schema.is(Uuid5);
-
-export type Uuid5Namespace = Uint8Array;
-
-const textEncoder = new TextEncoder();
-
-// Pre-defined namespaces from RFC 4122
-export const Uuid5Namespace = {
-  DNS: new Uint8Array([
-    0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8,
-  ]),
-
-  URL: new Uint8Array([
-    0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8,
-  ]),
-
-  OID: new Uint8Array([
-    0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8,
-  ]),
-
-  X500: new Uint8Array([
-    0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8,
-  ]),
-} as const;
-
-export const uuid5: {
-  (namespace: Uuid5Namespace): (name: string) => Effect.Effect<Uuid5>;
-  (name: string, namespace: Uuid5Namespace): Effect.Effect<Uuid5>;
-} = dual(2, function uuid5(name: string, namespace: Uuid5Namespace): Effect.Effect<Uuid5> {
-  return Effect.gen(function* () {
-    // Convert name to UTF-8 bytes
-    const nameBytes = textEncoder.encode(name);
-
-    // Concatenate namespace and name
-    const buffer = new Uint8Array(namespace.length + nameBytes.length);
-    buffer.set(namespace);
-    buffer.set(nameBytes, namespace.length);
-
-    // Hash the concatenated bytes
-    const hash = yield* sha1(buffer);
-
-    // Format as UUID v5
-    const result = new Uint8Array(16);
-
-    // Copy first 16 bytes of the hash
-    result.set(hash.subarray(0, 16));
-
-    // Set version (5) and variant bits
-    result[6] = (result[6] & 0x0f) | 0x50; // version 5
-    result[8] = (result[8] & 0x3f) | 0x80; // variant 1
-
-    return Uuid5.makeUnsafe(uuidStringify(result));
-  });
-});
-
-export const dnsUuid5 = uuid5(Uuid5Namespace.DNS);
-export const urlUuid5 = uuid5(Uuid5Namespace.URL);
-export const oidUuid5 = uuid5(Uuid5Namespace.OID);
-export const x500Uuid5 = uuid5(Uuid5Namespace.X500);