✨ Added Valibot Support

Author: max-programming

README.md

@@ -11,6 +11,7 @@ A lightweight, type-safe TypeScript library for generating prefixed IDs with cus
 - ⚙️ **Highly Customizable** - Configure separators, length, and character sets
 - 📦 **Lightweight** - Minimal dependencies (only `nanoid`)
 - 🔍 **Zod Integration** - Built-in Zod validation schemas (optional)
+- ✅ **Valibot Integration** - Built-in Valibot validation schemas (optional)
 - 🧪 **Well Tested** - Comprehensive test coverage
 - 📚 **Modern ESM** - ES modules with CommonJS support
 
@@ -34,6 +35,12 @@ For Zod validation support:
 npm install zod
 ```
 
+For Valibot validation support:
+
+```bash
+npm install valibot
+```
+
 ## 📖 Usage
 
 ### Basic Usage
@@ -136,6 +143,33 @@ const userSchema = z.object({
 });
 ```
 
+## ✅ Valibot Integration
+
+If you're using Valibot for validation, typed-id provides built-in schema creators:
+
+```typescript
+import { IdHelper } from "typed-id";
+import { createValibotIdSchema } from "typed-id/validators/validbot";
+import { safeParse } from "valibot";
+
+const userIdHelper = new IdHelper("user");
+const userIdSchema = createValibotIdSchema(userIdHelper);
+
+// Validate IDs
+const validId = userIdHelper.generate();
+console.log(safeParse(userIdSchema, validId).success); // true
+console.log(safeParse(userIdSchema, "invalid_id").success); // false
+
+// Use in your Valibot schemas
+import { object, string, email } from "valibot";
+
+const userSchema = object({
+  id: userIdSchema,
+  name: string(),
+  email: string([email()]),
+});
+```
+
 ## ⚙️ Configuration Options
 
 | Option            | Type     | Default                                                            | Description                        |
@@ -265,6 +299,7 @@ This library has comprehensive test coverage including:
 - ID generation with default options
 - ID generation with custom options
 - Zod validation schemas
+- Valibot validation schemas
 - Type safety verification
 
 Run tests:

bun.lock

@@ -16,9 +16,11 @@
       },
       "peerDependencies": {
         "typescript": "^5",
+        "valibot": "^1.1.0",
         "zod": "^4.0.17",
       },
       "optionalPeers": [
+        "valibot",
         "zod",
       ],
     },

package.json

@@ -71,12 +71,16 @@
   },
   "peerDependencies": {
     "typescript": "^5",
+    "valibot": "^1.1.0",
     "zod": "^4.0.17"
   },
   "dependencies": {
     "nanoid": "^5.1.5"
   },
   "peerDependenciesMeta": {
+    "valibot": {
+      "optional": true
+    },
     "zod": {
       "optional": true
     }

src/utils.ts

@@ -0,0 +1,8 @@
+export function getIdRegex(
+  prefix: string,
+  separator: string,
+  length: number,
+  customAlphabets: string
+): RegExp {
+  return new RegExp(`^${prefix}${separator}[${customAlphabets}]{${length}}$`);
+}

src/validators/validbot.ts

@@ -0,0 +1,26 @@
+import { IdHelper } from "../id-helper";
+import { custom as vCustom } from "valibot";
+import { getIdRegex } from "../utils";
+import type { GeneratedId, SeparatorOrDefault } from "../types";
+
+export function createValibotIdSchema<
+  P extends string,
+  S extends string | undefined = undefined
+>(idHelper: IdHelper<P, S>) {
+  const {
+    separator = IdHelper.DEFAULT_SEPARATOR,
+    length = IdHelper.DEFAULT_LENGTH,
+    customAlphabets = IdHelper.DEFAULT_ALPHABETS,
+  } = idHelper.options;
+
+  const idRegex = getIdRegex(
+    idHelper.prefix,
+    separator,
+    length,
+    customAlphabets
+  );
+
+  return vCustom<GeneratedId<P, SeparatorOrDefault<S>>>(val => {
+    return typeof val === "string" && idRegex.test(val);
+  }, "Invalid ID Format");
+}

tests/validators/validbot.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect } from "vitest";
+import { safeParse } from "valibot";
+import { IdHelper } from "../../src";
+import { createValibotIdSchema } from "../../src/validators/validbot";
+
+describe("Valibot ID Validator", () => {
+  it("should validate ID with default options", () => {
+    const userIdHelper = new IdHelper("user");
+
+    const id = userIdHelper.generate();
+
+    const schema = createValibotIdSchema(userIdHelper);
+
+    // Test that the schema validates the generated ID
+    expect(safeParse(schema, id)).toBe(true);
+
+    // Test that the schema rejects IDs with different prefix
+    expect(safeParse(schema, "person_0123456789")).toBe(false);
+
+    // Test that the schema rejects IDs with different separator
+    expect(safeParse(schema, "user::0123456789")).toBe(false);
+
+    // Test that the schema rejects IDs with different length
+    expect(safeParse(schema, "user_1234")).toBe(false);
+  });
+
+  it("should validate ID with custom options", () => {
+    const userIdHelper = new IdHelper("user", {
+      separator: "::",
+      length: 12,
+      customAlphabets: "abcdefghijklmnopqrstuvwxyz",
+    });
+
+    const id = userIdHelper.generate();
+
+    const schema = createValibotIdSchema(userIdHelper);
+
+    // Test that the schema validates the generated ID
+    expect(safeParse(schema, id)).toBe(true);
+
+    // Test that the schema rejects IDs with different prefix
+    expect(safeParse(schema, "person::abcdefghijkl")).toBe(false);
+
+    // Test that the schema rejects IDs with different separator
+    expect(safeParse(schema, "user_abcdefghijkl")).toBe(false);
+
+    // Test that the schema rejects IDs with different length
+    expect(safeParse(schema, "user::abcdefghijk")).toBe(false);
+
+    // Test that the schema rejects IDs with different alphabets
+    expect(safeParse(schema, "user::0123456789123")).toBe(false);
+  });
+
+  it("should validate ID with custom separator", () => {
+    const userIdHelper = new IdHelper("user", { separator: "::" });
+
+    const id = userIdHelper.generate();
+
+    const schema = createValibotIdSchema(userIdHelper);
+
+    // Test that the schema validates the generated ID
+    expect(safeParse(schema, id)).toBe(true);
+
+    // Test that the schema rejects IDs with different prefix
+    expect(safeParse(schema, "person::0123456789")).toBe(false);
+
+    // Test that the schema rejects IDs with different separator
+    expect(safeParse(schema, "user_0123456789")).toBe(false);
+  });
+
+  it("should validate ID with custom length", () => {
+    const userIdHelper = new IdHelper("user", { length: 12 });
+
+    const id = userIdHelper.generate();
+
+    const schema = createValibotIdSchema(userIdHelper);
+
+    // Test that the schema validates the generated ID
+    expect(safeParse(schema, id)).toBe(true);
+
+    // Test that the schema rejects IDs with different prefix
+    expect(safeParse(schema, "person_0123456789")).toBe(false);
+
+    // Test that the schema rejects IDs with different length
+    expect(safeParse(schema, "user_0123456789")).toBe(false);
+  });
+
+  it("should validate ID with custom alphabets", () => {
+    const userIdHelper = new IdHelper("user", {
+      customAlphabets: "abcdefghijklmnopqrstuvwxyz",
+    });
+
+    const id = userIdHelper.generate();
+
+    const schema = createValibotIdSchema(userIdHelper);
+
+    // Test that the schema validates the generated ID
+    expect(safeParse(schema, id)).toBe(true);
+
+    // Test that the schema rejects IDs with different prefix
+    expect(safeParse(schema, "person_0123456789")).toBe(false);
+
+    // Test that the schema rejects IDs with different alphabets
+    expect(safeParse(schema, "user_0123456789123")).toBe(false);
+  });
+});