feat!: migrate to arktype

Author: luxass

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+  // allow autocomplete for ArkType expressions like "string | num"
+  "editor.quickSuggestions": {
+    "strings": "on"
+  },
+  // prioritize ArkType's "type" for autoimports
+  "typescript.preferences.autoImportSpecifierExcludeRegexes": [
+    "^(node:)?os$"
+  ]
+}

src/generators/emoji-test.ts

@@ -1,40 +1,38 @@
-import { z } from "zod";
+import { type } from "arktype";
 import bundledFlags from "../bundled-json-files/emoji-test-flags.json" with { type: "json" };
 import bundledSmileys from "../bundled-json-files/emoji-test-smileys.json" with { type: "json" };
 import { createLoom } from "../loom";
 
+// eslint-disable-next-line unused-imports/no-unused-vars
 const VALID_STATUS = [
   "component",
   "fully-qualified",
   "minimally-qualified",
   "unqualified",
 ] as const;
 
-const entry = z.object({
-  codePoints: z.array(z.string()),
+const entrySchema = type({
+  codePoints: "string[]",
   // can't use union of literals since typescript can only infer
   // the status type to a string, and not the union of literals
-  status: z.string().refine(
-    (val) => VALID_STATUS.includes(val as (typeof VALID_STATUS)[number]),
-    {
-      message: `status must be one of: ${VALID_STATUS.join(", ")}`,
-    },
-  ),
-  comment: z.string(),
+  status: "string",
+  comment: "string",
 });
 
-const emojiTestInputSchema = z.object({
-  group: z.string(),
-  subgroups: z.array(z.object({
-    subgroup: z.string(),
-    entries: z.array(entry),
-  })),
+const subgroupEntrySchema = type({
+  subgroup: "string",
+  entries: entrySchema.array(),
 });
 
-const emojiTestOptionsSchema = z.object({
-  separator: z.string(),
-  commentPrefix: z.string(),
-  version: z.string(),
+const emojiTestInputSchema = type({
+  group: "string",
+  subgroups: subgroupEntrySchema.array(),
+});
+
+const emojiTestOptionsSchema = type({
+  separator: "string",
+  commentPrefix: "string",
+  version: "string",
 });
 
 export const emojiTest = createLoom({

src/generators/sequences.ts

@@ -1,23 +1,24 @@
-import { z } from "zod";
+import { type } from "arktype";
 import { createLoom } from "../loom";
 
-const sequencesInputSchema = z.object({
-  codePoints: z.array(z.string()),
-  type: z.string(),
-  description: z.string(),
-  comment: z.string(),
+const ark_sequencesInputSchema = type({
+  codePoints: "string[]",
+  type: "string",
+  description: "string",
+  comment: "string",
 });
 
-const sequencesOptionsSchema = z.object({
-  separator: z.string(),
-  commentPrefix: z.string(),
-  version: z.string(),
+const ark_sequencesOptionsSchema = type({
+  separator: "string",
+  commentPrefix: "string",
+  version: "string",
 });
 
 export const sequences = createLoom({
-  inputSchema: sequencesInputSchema,
-  optionsSchema: sequencesOptionsSchema,
+  inputSchema: ark_sequencesInputSchema,
+  optionsSchema: ark_sequencesOptionsSchema,
   template: (ctx, item) => {
+    //              ^?
     return `${item.codePoints.join(" ")} ${ctx.options.separator} ${item.type} ${ctx.options.separator} ${item.description} ${ctx.options.commentPrefix} ${item.comment}`;
   },
 });

src/generators/zwj-sequences.ts

@@ -1,17 +1,17 @@
-import { z } from "zod";
+import { type } from "arktype";
 import { createLoom } from "../loom";
 
-const zwjSequencesInputSchema = z.object({
-  codePoints: z.array(z.string()),
-  type: z.string(),
-  description: z.string(),
-  comment: z.string(),
+const zwjSequencesInputSchema = type({
+  codePoints: "string[]",
+  type: "string",
+  description: "string",
+  comment: "string",
 });
 
-const zwjSequencesOptionsSchema = z.object({
-  separator: z.string(),
-  commentPrefix: z.string(),
-  version: z.string(),
+const zwjSequencesOptionsSchema = type({
+  separator: "string",
+  commentPrefix: "string",
+  version: "string",
 });
 
 export const zwjSequences = createLoom({

src/loom.ts

@@ -1,22 +1,30 @@
 import type { LoomConfig, LoomContext, LoomInstance } from "./types";
+import { type } from "arktype";
 import { compare } from "compare-versions";
 import { z } from "zod";
 
+function _validate<T extends type.Any>(value: T["infer"], schema: T): T["infer"] {
+  const out = schema(value);
+  if (out instanceof type.errors) {
+    throw new TypeError(out.summary);
+  }
+  return out;
+}
+
 export function createLoom<
-  TInputSchema extends z.ZodType,
-  TOptionsSchema extends z.ZodType,
-  TPresets extends Record<string, TInputSchema["_input"][]>,
+  TInputSchema extends type.Any,
+  TOptionsSchema extends type.Any,
+  TPresets extends Record<string, TInputSchema["infer"][]>,
 >(
   config: LoomConfig<TInputSchema, TOptionsSchema, TPresets>,
 ): LoomInstance<TInputSchema, TOptionsSchema, TPresets> {
   const baseLoomFn = (
-    options: TOptionsSchema["_input"] & { input: TInputSchema["_input"][] },
+    options: TOptionsSchema["infer"] & { input: TInputSchema["infer"][] },
   ): string => {
     // validate options against schema
-    const validatedOptions = config.optionsSchema.parse(options);
+    const validatedOptions = _validate(options, config.optionsSchema);
 
-    // validate input against schema
-    const validatedInput = z.array(config.inputSchema).parse(options.input);
+    const validatedInput = _validate(options.input, config.inputSchema.array());
 
     // create context for template
     const ctx: LoomContext<TOptionsSchema> = Object.freeze(
@@ -49,7 +57,7 @@ export function createLoom<
     ? Object.fromEntries(
         Object.entries(config.presets).map(([key, value]) => [
           key,
-          (options: TOptionsSchema["_input"]) =>
+          (options: TOptionsSchema["infer"]) =>
             baseLoomFn({ ...options, input: value }),
         ]),
       )
@@ -62,8 +70,8 @@ export function createLoom<
   >;
 }
 
-function buildLoomContext<TOptionsSchema extends z.ZodType>(
-  options: TOptionsSchema["_input"],
+function buildLoomContext<TOptionsSchema extends type.Any>(
+  options: TOptionsSchema["infer"],
 ): LoomContext<TOptionsSchema> {
   return {
     options,

src/types.ts

@@ -1,3 +1,4 @@
+import type { type } from "arktype";
 import type { z } from "zod";
 
 export type LoomContextHelperFn = (version: string) => boolean;
@@ -29,17 +30,17 @@ export interface LoomContextHelpers {
   isVersionLessThanOrEqual: LoomContextHelperFn;
 }
 
-export interface LoomContext<TOptionsSchema extends z.ZodType> extends LoomContextHelpers {
+export interface LoomContext<TOptionsSchema extends type.Any> extends LoomContextHelpers {
   /**
    * The options.
    */
-  options: TOptionsSchema["_input"];
+  options: TOptionsSchema["infer"];
 }
 
 export interface LoomConfig<
-  TInputSchema extends z.ZodType,
-  TOptionsSchema extends z.ZodType,
-  TPresets extends Record<string, TInputSchema["_input"][]>,
+  TInputSchema extends type.Any,
+  TOptionsSchema extends type.Any,
+  TPresets extends Record<string, TInputSchema["infer"][]>,
 > {
   /**
    * The schema of the input data.
@@ -56,7 +57,7 @@ export interface LoomConfig<
    */
   template: (
     ctx: LoomContext<TOptionsSchema>,
-    item: TInputSchema["_input"]
+    item: TInputSchema["infer"]
   ) => string;
 
   /**
@@ -67,7 +68,7 @@ export interface LoomConfig<
   /**
    * The predicate function. If provided, the loom will only process items that return true.
    */
-  predicate?: (ctx: LoomContext<TOptionsSchema>, item: TInputSchema["_input"]) => boolean;
+  predicate?: (ctx: LoomContext<TOptionsSchema>, item: TInputSchema["infer"]) => boolean;
 
   /**
    * Attach custom presets to the loom.
@@ -76,11 +77,11 @@ export interface LoomConfig<
 }
 
 export type LoomInstance<
-  TInputSchema extends z.ZodType,
-  TOptionsSchema extends z.ZodType,
-  TPresets extends Record<string, TInputSchema["_input"][]>,
+  TInputSchema extends type.Any,
+  TOptionsSchema extends type.Any,
+  TPresets extends Record<string, TInputSchema["infer"][]>,
 > = {
-  (options: TOptionsSchema["_input"] & { input: TInputSchema["_input"][] }): string;
+  (options: TOptionsSchema["infer"] & { input: TInputSchema["infer"][] }): string;
 } & {
-  [key in keyof TPresets]: (options: TOptionsSchema["_input"]) => string;
+  [key in keyof TPresets]: (options: TOptionsSchema["infer"]) => string;
 };

test/loom.test.ts

@@ -1,15 +1,15 @@
+import { type } from "arktype";
 import { expect, it } from "vitest";
-import { z } from "zod";
 import { createLoom } from "../src/loom";
 
-const testInputSchema = z.object({
-  name: z.string(),
-  value: z.number(),
+const testInputSchema = type({
+  name: "string",
+  value: "number",
 });
 
-const testOptionsSchema = z.object({
-  version: z.string(),
-  prefix: z.string(),
+const testOptionsSchema = type({
+  version: "string",
+  prefix: "string",
 });
 
 it("should create a loom instance that processes input correctly", () => {