feat: implement standard schema (#36)

Author: gwansikk

packages/event-tracker/package.json

@@ -51,12 +51,12 @@
     "dist"
   ],
   "devDependencies": {
-    "@types/react": "^19.0.2",
-    "react": "^19.1.1"
+    "@types/react": "^19.1.10",
+    "react": "^19.1.1",
+    "zod": "^4.0.17"
   },
   "peerDependencies": {
-    "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-    "zod": "^3 || ^4"
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
   },
   "publishConfig": {
     "access": "public"

packages/event-tracker/src/tracker/index.tsx

@@ -1,6 +1,5 @@
 import type { ReactNode } from "react";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef } from "react";
-import { z } from "zod";
 
 import { isEventPropsWithSchema } from "../helpers/isEventPropsWithSchema";
 import { isFunction } from "../helpers/isFunction";
@@ -26,6 +25,7 @@ import type {
 } from "../types";
 import { evaluateEnabledCondition } from "../utils/condition";
 import { resolveParams } from "../utils/resolveParams";
+import { isFailureResult } from "../utils/schema";
 
 import { Click as PrimitiveClick } from "./components/Click";
 import { DOMEvent as PrimitiveDOMEvent } from "./components/DOMEvent";
@@ -40,22 +40,21 @@ export function createTracker<
 >(config: TrackerConfig<TContext, TEventParams, TSchemas, TTaskResult>) {
   const TrackerContext = createContext<null | TrackerContextProps<TContext, TEventParams, TSchemas, TTaskResult>>(null);
 
-  const validateZodSchema = <TKey extends keyof TSchemas>(schemaKey: TKey, params: z.infer<TSchemas[TKey]>) => {
+  const validateSchema = <TKey extends keyof TSchemas>(schemaKey: TKey, params: SchemaParams<TSchemas, TKey>) => {
     const schema = config.schema?.schemas?.[schemaKey];
     if (schema === undefined) {
       console.warn(`Schema ${String(schemaKey)} not found`);
       return params;
     }
-    try {
-      schema.parse(params);
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        config.schema?.onSchemaError?.(error);
-        if (config.schema?.abortOnError) {
-          throw error;
-        }
+
+    const result = schema["~standard"].validate(params);
+    if (isFailureResult(result)) {
+      config.schema?.onSchemaError?.(result.issues);
+      if (config.schema?.abortOnError) {
+        throw result;
       }
     }
+
     return;
   };
 
@@ -124,7 +123,7 @@ export function createTracker<
             ? paramsWithSchema.params(_getContext())
             : paramsWithSchema.params;
 
-          validateZodSchema(paramsWithSchema.schema, params);
+          validateSchema(paramsWithSchema.schema, params);
 
           return _schedule(() =>
             domEvents[key]?.(params as TEventParams & SchemaParams<TSchemas, TKey>, _getContext(), _setContext),
@@ -152,11 +151,11 @@ export function createTracker<
         options?: TrackingOptions<TContext, TEventParams>,
       ) => {
         const executeEvent = () => {
-          const params = isFunction<TContext, z.infer<TSchemas[TKey]>>(paramsWithSchema.params)
+          const params = isFunction<TContext, SchemaParams<TSchemas, TKey>>(paramsWithSchema.params)
             ? paramsWithSchema.params(_getContext())
             : paramsWithSchema.params;
 
-          validateZodSchema(paramsWithSchema.schema, params);
+          validateSchema(paramsWithSchema.schema, params);
 
           return _schedule(() =>
             event?.(params as TEventParams & SchemaParams<TSchemas, TKey>, _getContext(), _setContext),

packages/event-tracker/src/types.ts

@@ -1,5 +1,4 @@
 import { BatchConfig } from ".";
-import { type z } from "zod";
 import { DOMAttributes } from "react";
 import type { DebounceConfig } from "./utils/debounce";
 import type { ThrottleConfig } from "./utils/throttle";
@@ -14,9 +13,11 @@ export type SetContext<TContext extends Context = Context> = (
 export type EventNames = "onImpression" | "onPageView" | DOMEventNames;
 
 /** EventParams */
-export type SchemaParams<TSchemas extends Schemas = Schemas, TKey extends keyof TSchemas = keyof TSchemas> = z.infer<
-  TSchemas[TKey]
->;
+export type SchemaParams<
+  TSchemas extends Schemas = Schemas,
+  TKey extends keyof TSchemas = keyof TSchemas,
+> = StandardSchemaV1.InferOutput<TSchemas[TKey]>;
+
 export type EventParams = Record<string, any>;
 export type EventParamsWithSchema<
   TContext extends Context = Context,
@@ -101,12 +102,12 @@ export interface PageViewConfig<
 }
 
 /** Schema */
-export type Schemas = Record<string, z.ZodObject<any>>;
+export type Schemas = Record<string, StandardSchemaV1<any, any>>;
 export interface SchemaConfig<TSchemas extends Schemas = Schemas> {
   /** A record of schemas */
   schemas: TSchemas;
   /** A function to handle schema errors */
-  onSchemaError?: (error: z.ZodError) => void;
+  onSchemaError?: (error: ReadonlyArray<StandardSchemaV1.Issue>) => void;
   /** If true, abort the event execution if a schema error occurs */
   abortOnError?: boolean;
 }
@@ -198,3 +199,69 @@ export type TrackingOptions<TContext extends Context = Context, TEventParams ext
   | { throttle: ThrottleConfig; debounce?: never }
   | { debounce?: never; throttle?: never }
 );
+
+// standard schema
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+
+  /** The Standard Schema types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+
+  /** Infers the input type of a Standard Schema. */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+
+  /** Infers the output type of a Standard Schema. */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}

packages/event-tracker/src/utils/schema.ts

@@ -0,0 +1,15 @@
+import type { StandardSchemaV1 } from "../types";
+
+function isIssue(x: unknown): x is StandardSchemaV1.Issue {
+  return !!x && typeof (x as any).message === "string";
+}
+
+export function isFailureResult(e: unknown): e is StandardSchemaV1.FailureResult {
+  return (
+    !!e &&
+    typeof e === "object" &&
+    "issues" in (e as any) &&
+    Array.isArray((e as any).issues) &&
+    (e as any).issues.every(isIssue)
+  );
+}

packages/event-tracker/tsdown.config.ts

@@ -9,5 +9,5 @@ export default defineConfig({
   sourcemap: true,
   dts: true,
   clean: true,
-  external: ["react", "zod"],
+  external: ["react"],
 });